c++ - सी++ में ऋणात्मक और धनात्मक दोनों संख्याओं वाले आरेखों को कैसे सॉर्ट करें?




arrays string (2)

एक अन्य उपाय यह है कि आप अपने स्वयं के तुलनात्मक कार्य को कार्यान्वित करें:

  • दोनों तारों के पहले चरित्र की जाँच करें। यदि एक अंक से शुरू होता है और दूसरा - शुरू होता है, तो जो स्ट्रिंग से शुरू होता है - वह छोटी संख्या है।
  • यदि दोनों तार एक अंक से शुरू होते हैं, तो तार की लंबाई की तुलना करें। छोटी स्ट्रिंग छोटी संख्या है। यदि दोनों स्ट्रिंग्स समान लंबाई हैं, तो एक मानक स्ट्रिंग तुलना करें।
  • यदि दोनों तार के साथ शुरू होता है - तो तार की लंबाई की तुलना करें। लंबी स्ट्रिंग छोटी संख्या है। यदि दोनों स्ट्रिंग्स समान लंबाई हैं, तो एक मानक स्ट्रिंग की तुलना करें, लेकिन परिणाम को नकारें।
String str[]={"-123","89","-10","456"};

str तार का एक सरणी है, जिसमें प्रत्येक स्ट्रिंग एक पूर्णांक के प्रारूप में है, और आपको इस सरणी को O(n log n) समय में क्रमबद्ध करना होगा।

str में तार सकारात्मक और नकारात्मक दोनों पूर्णांकों का प्रतिनिधित्व कर सकते हैं। इन तारों की अधिकतम लंबाई 1024 वर्ण है।

मुझे पता है कि इस समस्या का एक समाधान स्ट्रिंग्स को संख्याओं में बदलना है, फिर इसके अलावा उनकी तुलना करें; क्या इस समस्या का कोई और समाधान है?


यहां एक न्यूनतम और संभावित अपर्याप्त है (अग्रणी शून्य, व्हॉट्सएप, आदि को संभालना नहीं है) उदाहरण जो आपको पसंद करता है।

टिप्पणियाँ समझाती हैं कि यह क्या कर रहा है। :)

#include <algorithm>
#include <iostream>
#include <string>
#include <vector>

int main() {
  std::vector<std::string> strings = {
      "-1", "-1", "-20", "-4", "3", "0", "-0", "1", "20", "20", "44020",
  };

  // Assumes everything in "strings" has no whitespace in it.
  // Assumes everything in "strings" does not have leading zeroes.
  // Assumes everything in "strings" is an ascii representaion of an integer.
  // Assumes everything in "strings" is nonempty.
  std::sort(strings.begin(), strings.end(),
            [](const std::string &a, const std::string &b) {
              const bool a_is_negative = a[0] == '-';
              const bool b_is_negative = b[0] == '-';
              if (a_is_negative != b_is_negative) {
                // If they have different signs, then whichever is negative is
                // smaller.
                return a_is_negative;
              } else if (a.length() != b.length()) {
                // If they have the same sign, then whichever has more
                // characters is larger in magnitude. When the sign is negative,
                // the longer (more digits) number is "more negative". When
                // positive, the longer (more digits) number is "more positive".
                return (a.length() < b.length()) != a_is_negative;
              } else {
                // Otherwise a lexicographic comparison of "a" and "b" will
                // determine which string is larger in magnitude. Using the same
                // logic above, we account for the "negative vs. positive"
                // comparison.
                return (a < b) != a_is_negative;
              }
            });

  for (const auto &str : strings) {
    std::cout << str << " ";
  }
  std::cout << std::endl;
}





sorting