संस्करण संख्या की तुलना करें

26

जब हम कुछ सॉफ़्टवेयर प्रकाशित करते हैं, तो हम उसे एक संस्करण संख्या प्रदान करते हैं। और उपयोगकर्ता कुछ सॉफ़्टवेयर के नवीनतम संस्करण में अपडेट करना चाह सकते हैं। इसलिए, यह पता लगाने का समय है कि कौन सा संस्करण नया होना चाहिए।

इनपुट

तार के रूप में इनपुट दो संस्करण संख्या।

इस चुनौती के संदर्भ में, हम केवल संस्करण संख्याओं का समर्थन करते हैं जो डॉट्स द्वारा शामिल किए गए कुछ अंक हैं।

  • एक संस्करण संख्या एक स्ट्रिंग है जिसमें केवल अंक ( 0~ 9) और बिंदु ( .) हो सकते हैं।
  • डॉट्स किसी संस्करण संख्या का पहला / अंतिम वर्ण नहीं होगा।
  • डॉट्स के बीच कुछ अंक होने चाहिए। कोई भी दो बिंदु लगातार प्रकट नहीं हो सकते हैं।
  • एक संस्करण संख्या में सभी संख्या 2 16 से कम होगी ।

उत्पादन

इनपुट किए गए संस्करण संख्याओं और आउटपुट की तुलना करें कि क्या पहले एक से अधिक / बराबर / दूसरे से कम है। आपको निम्नलिखित प्रस्तुतियों में से एक को चुनने की अनुमति है:

  • सकारात्मक संख्या / शून्य / ऋणात्मक संख्या का उपयोग करें, जबकि शून्य का अर्थ समान है;
  • तीन निरंतर अलग-अलग मूल्यों का उपयोग करें;

की तुलना

आपको इस अनुभाग में वर्णित एल्गोरिदम को लागू करने की आवश्यकता नहीं है। आपका सबमिशन तब तक मान्य है जब तक कि यह इस एल्गोरिदम के साथ एक ही आउटपुट देता है।

  • संस्करण संख्याएँ कुछ दशमलव संख्याएँ हैं जो डॉट्स से जुड़ती हैं। हम पहले संख्याओं के सरणियों के लिए दो संस्करण संख्याओं को विभाजित करते हैं;
  • शून्य के साथ सरणियों के अंत को पैडिंग करना उनकी लंबाई समान करना;
  • पहले आइटम की तुलना पिछले एक से करें:
    • यदि दो ऐरे आइटम अलग-अलग हैं, तो अधिक संख्या का अर्थ है अधिक से अधिक संस्करण संख्या
    • यदि वे समान हैं, तो निम्नलिखित वस्तुओं की तुलना करना जारी रखें;
    • यदि सरणी में सभी आइटम समान हैं, तो दो संस्करण समान हैं।

परीक्षण के मामलों

version1  version2  result
2         1         >
1.0.0     1         =
1.0       1.0.0     =
1.2.42    1.2.41    >
1.1.56789 1.2.0     <
1.10      1.2       >
1.20      1.150     <
18.04     18.4      =
7.010     7.8       >
1.0.0.1.0 1.00.00.2 <
00.00.01  0.0.0.1   >
0.0.1     0.1       <
42.0      4.2.0     >
999.999   999.999.1 <
2018.08.1 2018.08   >
code-golf  string  number 
— TSH
स्रोत
— FryAmTheEggman
.NET में एक संस्करण ऑब्जेक्ट है, लेकिन एक एकल वर्ण इसमें समर्थित नहीं है :(
— ब्रायन जे
@ ब्रायन और कई पात्रों के लिए '.0' लागत? :)
— रोबाऊ
खैर, यह वास्तव में 2, 3 या 4 भागों की अपेक्षा करता है। तो यह 1.0.0.1.0 परीक्षण मामले पर विफल रहता है (हालांकि मैंने शुरू में आपके विचार की कोशिश की :))
— ब्रायन जे
मुझे लगता है कि विंडोज में एक अंतर्निहित है जो यह करेगा: StrCmpLogicalW
— bace1000

जवाबों:

6

05AB1E (विरासत) , 15 14 13 बाइट्स

'.¡0ζε`.S}0K¬

आउटपुट -1 [] 1के लिए < = >क्रमशः।

-1 बाइट @ @ मिग्ना के लिए धन्यवाद ।

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें ।

स्पष्टीकरण:

'.¡              # Split on dots
                 #  i.e. ['1.0.1.1.0','1.00.2.0']
                 #   → [['1','0','1','1','0'],['1','00','2','0']]
   0ζ            # Zip, swapping rows and columns, using '0' as filler
                 #  i.e. [['1','0','1','1','0'],['1','00','2','0']]
                 #   → [['1','1'],['0','00'],['1','2'],['1','0'],['0','0']]
     ε   }       # Map each:
      `          #  Push both values to the stack
       .S        #  And calculate the signum (1 if a>b; -1 if a<b; 0 if a==b)
                 #   i.e. [['1','1'],['0','00'],['1','2'],['1','0'],['0','0']]
                 #    → [0,0,-1,1,0]
          0K     # Remove all zeros
                 #  i.e. [0,0,-1,1,0] → [-1,1]
            ¬    # Then take the head as result
                 #  i.e. [-1,1] → -1
— केविन क्रूज़सेन
स्रोत
1
आप उपयोग कर सकते हैं 0Kके बजाय ʒĀ}।
— एमिगा
@Eignigna आह .. धन्यवाद।
— केविन क्रूज़सेन
5

आर , 32 बाइट्स

rank(numeric_version(scan(,"")))

इसे ऑनलाइन आज़माएं!

एक आर बिलिन का उपयोग करना

आउटपुट 1 2, 1.5 1.5, 2 1कम, बराबर, अधिक से अधिक के लिए।

सर्वश्रेष्ठ अब तक, बिना बिलिन के:

आर , 151 142 125 107 बाइट्स

function(v,L=strsplit(v,'\\.'))Find(c,sign(Reduce('-',Map(as.double,Map(c,L,Map(rep,0,rev(lengths(L))))))))

इसे ऑनलाइन आज़माएं!

स्पष्टीकरण के साथ अनियंत्रित कोड:

function(v){             # character vector of 2 elements as function arg;
  L=strsplit(v,'\\.')    # obtain a list of two character vectors
                         # with the separated version numbers;
  R=rev(lengths(L))      # store in vector R the lengths of the 2 vectors and reverse it;
  M1=Map(rep,0,R)        # create a list of 2 vector containing zeros
                         # repeated R[1] and R[2] times;
  M2=Map(c,L,M1)         # append to the vectors in list L the zeros in M1;
  M3=Map(as.double,M2)   # convert the character vectors in M2 to double;
  w=sign(Reduce('-',M3)  # compute the sign of element by element difference M[[1]] - M[[2]]);
  Find(c,w)            # returns the first non zero element in w, if none return NULL;
}
# N.B. as.double is necessary because "0XX" is interpreted as octal by strtoi unless 
#      we use strtoi(x,10) which is exactly the same length of as.double(x)

आउटपुट -1, NULL, 1कम, बराबर, अधिक से अधिक के लिए।

मूल अवधारणा, का उपयोग कर नीचे गोल्फ sapply, [<-और %*%:

आर , 129 बाइट्स

function(x,y=strsplit(x,"\\."),w=sign(sapply(y,function(x)strtoi("[<-"(rep(0,max(lengths(y))),seq(x),x),10))%*%c(1,-1)))w[!!w][1]

इसे ऑनलाइन आज़माएं!

अब आपके पास पूर्णांक के दो समान लंबाई वाले वैक्टर की एक सूची है। अंत में Reduceमुश्किल छोटे w[!!w][1]रूप का उपयोग करके पहले गैर-शून्य तत्व का उपयोग करके युग्मक अंतरों की गणना करें और आउटपुट करें ।

आउटपुट -1, NA, 1कम, बराबर, अधिक से अधिक के लिए।

— एनजीएम
स्रोत
प्रभावशाली! क्विक गोल्फ: अपने कोड के अंत में अतिरिक्त न्यूलाइन - यह 150 बाइट्स होना चाहिए;)
— जेसीई
नामित चर की संख्या को कम ... । मुझे लगता है कि सूचियों के बजाय मैट्रिक्स का उपयोग करने का एक तरीका है, लेकिन मुझे अभी तक ऐसा करने का तरीका नहीं मिला है।
— JayCe
1
आप 100 बाइट्स को यह नीचे का उपयोग कर प्राप्त कर सकते हैं scan function(a,b,d=scan(t=a,se='.'),e=scan(t=b,se='.'),f=1:max(lengths(list(d,e))),g=d[f]-e[f])g[!!g][1]या 106 अगर तुम वापस जाने के लिए -1 चाहते हैं, (एनए, 1 नहीं (नकारात्मक), एनए, (सकारात्मक)।
— mnel
1
@ 100 बाइट के घोल को थोड़ा काम करने की जरूरत है। यह पिछले दो परीक्षण मामलों में विफल रहता है। पैडिंग होनी है 0और नहीं (प्रत्यय) NA। मैंने उत्तर को एक सामुदायिक विकी बना दिया है, जो कोई भी इसे ठीक कर सकता है, बस इसे जोड़ सकता है।
— एनजीएम
1
@digEmAll ने पहली बार साइन की गणना करके 4 बाइट की, और फिर किया Find(c,x)। मुझे लगता है कि यह एक नई चाल है।
— JayCe
4

एपीएल (डायलॉग यूनिकोड) , 18 17 बाइट्स

1 बाइट ने @ Adám के ⍤1बजाय धन्यवाद का उपयोग करके बचाया ∘↑(...)¨और इनपुट स्वरूप को नेस्टेड सरणी से मैट्रिक्स में बदल दिया

(⍋-⍒)(⍎¨∊∘⎕D⊆⊢)⍤1

इसे ऑनलाइन आज़माएं!

इनपुट को सही तर्क के रूप में मैट्रिक्स के मैट्रिक्स के रूप में लेता है, जहां प्रत्येक संस्करण स्ट्रिंग अपनी पंक्ति में है। आउटपुट ¯1 1, 0 0, 1 ¯1के लिए <, =, >क्रमशः।

(⍎¨∊∘⎕D⊆⊢)⍤1 प्रत्येक पंक्ति पर

  • ∊∘⎕D⊆⊢ अंकों की सभी घटनाओं को समूह, अर्थात् पर विभाजित करें .

  • ⍎¨ और इनमें से प्रत्येक घटना को एक संख्या में परिवर्तित करें

↑एक मैट्रिक्स में कनवर्ट करें, जहां पहला इनपुट शीर्ष पंक्ति पर और दूसरा नीचे में है, 0जहां आवश्यक है

(⍋-⍒) तथा

  • - घटाना
    • ⍒ पंक्तियों में सूचकांक जो उन्हें अवरोही क्रम में क्रमबद्ध करेगा
    • ⍋ शीर्ष के समान लेकिन आरोही क्रम के लिए
— क्रिक्टी लिथोस
स्रोत
4

पर्ल 6 , 63 47 22 बाइट्स

{"v$^a cmp v$^b".EVAL}

इसे ऑनलाइन आज़माएं!

पता चलता है कि पर्ल 6 में एक संस्करण प्रकार है जो वर्णन के लिए बहुत उपयुक्त है। यह एक अनाम कोड ब्लॉक है जो दो वर्जन स्ट्रिंग्स की सूची लेता है और या तो रिटर्न करता है More, Sameया Less।

स्पष्टीकरण:

{                    }  # Anonymous code block
 "             "        # Create a string of code
  v$^a cmp v$^b         # Comparing the two versions
                .EVAL   # And EVAL it

या, 47 बाइट्स के लिए अंतर्निहित प्रकार के बिना:

{first +*,[Z<=>] map *.split('.')[^@_.ords],@_}

इसे ऑनलाइन आज़माएं!

बेनामी कोड ब्लॉक जो दो स्ट्रिंग्स लेता है और Moreयदि दूसरा अधिक है, Lessतो दूसरा छोटा है और Nilयदि वे समान हैं तो रिटर्न करते हैं।

स्पष्टीकरण:

{                                             } # Anonymous code block
                 map *.split('.')          ,@_  # Split both strings by '.'
                                 [^@_.ords]     # Pad the lists by a lot
          [Z<=>]   # Zip the strings with the <=> operator
 first +*,  # Get the first value that when coerced to an int, is not 0
— मजाक कर रहा है
स्रोत
3

ब्रेकीलॉग , 49 40 बाइट्स

+0|{~c[H,".",T]hị;T|ị;0|0}ᵐz{h-0&t↰₀|h-}

... यह अभी भी नहीं बल्कि लंबे समय तक लंबा है।

दो तारों की सूची की अपेक्षा करता है। के positive number / zero / negative number रूप में उपयोग करता है > / = / <।

इसे ऑनलाइन आज़माएं!

व्याख्या

आदानों का विभाजन

एक इनपुट उस के साथ एकजुट नहीं है को देखते हुए [0, 0], जैसे ["1.02.0", "1.2.0.1.0"], खंड आउटपुट, जैसे नीचे, [[1, "02.0"], [1, "2.0.1.0"]]।

                            # unify the input with...
+0                          # : a list whose sum = 0 (output is 0)
  |{                     }ᵐ # : OR a list that when mapped...
    ~c                      # : : if the input string unifies with a list of the form...
      [H,".",T]             # : : : e.g. "1.02.0", H = "1", T = "02.0"
               hị           # : : : coerce the head to an integer
                 ;T         # : : : append the string T
                            # : : : "1.02.0" -> [1, "02.0"]
                   |ị       # : : OR it unifies with an integer
                     ;0     # : : : append 0
                            # : : : "1" -> [1, 0]
                       |0   # : : OR it unifies with 0
                            # : : : 0 -> [0]

इनपुट्स की तुलना

यह देखते हुए, उदाहरण के लिए, [[1, "02.0"], [1, "2.0.1.0"]]उपलेस्ट को ज़िप करता है [[1, 1], ["02.0", "2.0.1.0"]]और सिर में मूल्यों की तुलना करता है ( [1,1])। दूसरी सबलिस्ट पर पुनः प्राप्त करें। ध्यान दें कि विधेय ज़िप zछोटी सूची के माध्यम से चक्र इतना है कि साथ ज़िप करने [0,0]के साथ ज़िप करने के बराबर है [0], इसलिए पिछले चरण जोड़ता 0साथ 0बिना आगे मूल्यों संलग्न।

z             # zip the sublists
 {          } # unify the result (r) with...
  h           # : take the head of the result
   -          # : : subtract the second value from the first
    0         # : : if the difference unifies with 0...
     &t↰₀     # : : recur on the tail of r
         |h-  # : OR unify with the difference of the elements of the head
              # : (equivalent to returning early)
— फालतूपन
स्रोत
3

जावास्क्रिप्ट (ईएस 6), 73 68 बाइट्स

सहेजे गए 5 बाइट्स @redundancy की बदौलत

के रूप में इनपुट लेता है (a)(b)। बराबर के लिए रिटर्न , अधिक से अधिक के लिए एक सकारात्मक पूर्णांक या कम से कम एक नकारात्मक पूर्णांक ।0

a=>b=>(a+[...b].fill`.`).split`.`.some((x,i)=>d=~b.split`.`[i]-~x)*d

इसे ऑनलाइन आज़माएं!

— Arnauld
स्रोत
अच्छा लगा। मैं सही ढंग से समझ लिया है, तो आप प्रतिस्थापन बाइट्स बचा सकता है replaceके साथ fill। -दोनों के लिए परिचालनों की अदला-बदली की जाती है क्योंकि दोनों को अब एक संख्या के लिए बाध्य किया जाना चाहिए। इसे ऑनलाइन आज़माएं!
— अतिरेक
@ बहुत अच्छा विचार! (सुनिश्चित नहीं हैं कि यदि मेरा कार्यान्वयन वास्तव में आपके मन में है, तो क्या होगा।)
— अरनौल्ड
मैंने मान लिया कि आपका इरादा पर्याप्त मानों को 0 से जोड़ने के लिए है, जैसे कि aउन मानों के माध्यम से चक्रों के सबस्ट्रिंग पर मैपिंग करना, जिनमें से bअधिक संख्या खंड हैं a। ऐसा होता है कि यह सुनिश्चित करने का सबसे छोटा तरीका है कि b'की एक- स्ट्रिंग स्ट्रिंग' पर विभाजित किया जाए । लागू मौजूदा विभाजन का लाभ उठाकर a।
— अतिरेक
3

जावा (JDK 10) , 201 96 89 बाइट्स

java.util.Comparator.comparing(java.lang.module.ModuleDescriptor.Version::parse)::compare

इसे ऑनलाइन आज़माएं!

एक नकारात्मक संख्या लौटाता है यदि पहला संस्करण दूसरे से छोटा है, तो एक सकारात्मक यदि पहला संस्करण दूसरे से अधिक है और 0यदि वे समान हैं।

हां, यह एक बिल्ट-इन "कॉल" करने के लिए कुछ भारी काम है!

क्रेडिट

— ओलिवियर ग्रेजायर
स्रोत
1
मैंने कोशिश की, लेकिन मैं केवल तीन बाइट्स निकालने में सक्षम हूं .. 228 बाइट्स
— केविन क्रूज़सेन
1
कुछ और मिला: 217 बाइट्स
— केविन क्रूज़सेन
1
शायद ऐसा ही है .. पहले से ही कोशिश की गई try-finallyहै, अगर आई-चेक को सरल बनाया जा सकता है; लूप के अंदर वापसी की कोशिश की अगर t!=0; का उपयोग करने की कोशिश की Integerऔर i.compare(i.valueOf(...),i.valueOf(...)); इस तरह से जेनरिक का उपयोग करने की कोशिश की <T>T[]g(T s){return(T[])(s+"").replaceAll("(\\.0+)*$","").split("\\.");}; आदि सभी 2-6 बाइट्स लंबे हैं। यदि आप (या कोई और) कुछ और खोजता है, तो कृपया मुझे बताएं। जानने को उत्सुक है। :)
— केविन क्रूज़सेन
1
@KevinCruijssen नहीं, मैं नहीं कर सकता क्योंकि "एक संस्करण संख्या में सभी संख्याएं इससे कम होंगी 2^16।" शॉर्ट रेंज से - (2 ^ 15) से 2 ^ 15-1।
— ओलिवियर ग्रेगोइरे
1
@ केविनक्रूजसेन मैं 105 बाइट निकाल सकता था! कैसे? ठीक है, मुझे एक बिल्ट-इन;) मिला
— ओलिवियर ग्रेजायर
2

रेटिना 0.8.2 , 54 बाइट्स

\d+
$*
+`^(.)(.*=)\1
$2
(.*=|^=.*)1.*
<
.*1.*=.*
>
\.

इसे ऑनलाइन आज़माएं! लिंक में परीक्षण के मामले शामिल हैं। विभाजक मान का उपयोग समानता आउटपुट के रूप में करता है, इसलिए सुविधा के लिए हेडर इनपुट विभाजक को परिवर्तित करता है, =लेकिन यह कुछ भी नहीं हो सकता है [.\d]। स्पष्टीकरण:

\d+
$*

यूनीरी में बदलें।

+`^(.)(.*=)\1
$2

जब तक वे अलग-अलग या एक तरफ से बाहर नहीं निकलते, तब तक प्रत्येक वर्ण से पहले वर्ण को हटा दें। यह उपसर्गों से मेल खाने की तुलना में बहुत तेज है, हालांकि संभवतः गोल्फर नहीं है। इस बिंदु पर, स्ट्रिंग्स कई रूपों में से एक हैं, जिन्हें एक तुलना परिणाम तक डीकोड करने की आवश्यकता होती है।

  1. यदि न तो स्ट्रिंग में शामिल है, 1तो परिणाम है=
  2. यदि बाईं स्ट्रिंग एक 1परिणाम के साथ शुरू होती है तो परिणाम होता है>
  3. यदि दायां स्ट्रिंग शुरू होता है 1तो परिणाम होता है<
  4. यदि बायां तार खाली है तो परिणाम है <
  5. इस बिंदु पर दाहिना स्ट्रिंग खाली है इसलिए परिणाम है >

इसके बारे में सोचने का एक और तरीका यह है कि यदि एक स्ट्रिंग में एक है 1और दूसरा 1तब से शुरू नहीं होता है तो यह स्ट्रिंग अधिक होती है, हालांकि यह लंबे समय तक बाइट के रूप में निकलता है।

(.*=|^=.*)1.*
<

केस 3, या केस 4 बिना केस 1 के चेक करें। 

.*1.*=.*
>

यदि बाएं स्ट्रिंग में अभी भी 1इस बिंदु पर है तो यह अधिक है।

\.

अन्यथा किसी भी बचे हुए को हटाएं .।

फ़ायरफ़ॉक्स ब्राउज़र कंसोल REPL, 19 बाइट्स

Services.vc.compare

मेरा मानना ​​है कि यह आंतरिक कार्य आवश्यक तुलना करता है। यह -1, 0 या 1 देता है।

— नील
स्रोत
1
मेरा सुझाव है कि आप फ़ायरफ़ॉक्स क्रोम कोड को एक अन्य उत्तर के रूप में पोस्ट करें ...
— tsh
btw, मुझे यकीन नहीं है कि फ़ायरफ़ॉक्स क्रोम कोड अपनी बाइट्स कैसे गिनता है। Cu.import("resource://gre/modules/Services.jsm");गिना जाना चाहिए?
— tsh
1
@tsh यही कारण है कि मैंने "ब्राउज़र कंसोल REPL" को जोड़ा ...
— नील
2

PHP , 38 बाइट्स

<?=version_compare($argv[1],$argv[2]);

आउटपुट -1 → < | 0 → = | 1 → >

इसे ऑनलाइन आज़माएं!

— लुइस फेलिप डी जीसस मुनोज
स्रोत
मुझे लगता है कि आपका सबमिशन सिर्फ फंक्शन ही हो सकता है
— जो किंग
1
यह इनपुट के किसी भी जोड़े के लिए गलत परिणाम देता है, जो केवल 1.0.01
— अनुगमन
2

सी (जीसीसी) ,  140  134 बाइट्स

यह कोड एक नकारात्मक , या क्रमशः के 0लिए एक सकारात्मक या आउटपुट देता है ।<=>

i;n;p;q;g(char*s){for(i=n=0;*s&&++n&&*s-46;i=i*10+*s++-48);i=i;}f(char*a,char*b){for(p=q=0;*a+*b&&p==q;b+=n)p=g(a),a+=n,q=g(b);a=p-q;}

इसे ऑनलाइन आज़माएं!

संपादन:

  • छत के लिए धन्यवाद 6 बाइट्स सहेजे गए!
— Annyo
स्रोत
चुनौती बताती है: "तीन निरंतर भिन्न मूल्यों का उपयोग करें;" आपका कोड लगातार नहीं लौटता है।
— ओलिवियर ग्रेगोइरे
1
@Olivier यह बताता है कि मैं "तीन निरंतर भिन्न मूल्यों का उपयोग कर सकता हूं;" या "सकारात्मक संख्या / शून्य / नकारात्मक संख्या का उपयोग करें, जबकि शून्य का मतलब समान है?"
— Annyo
मेरी गलती! तुम सही हो।
— ओलिवियर ग्रेगोइरे
1

जावास्क्रिप्ट (Node.js) , 105 88 80 बाइट्स

-17 बाइट्स से @redundancy। वाह!

-8 बाइट्स Math.sign को हटा रहा है। साभार @tsh

एक नकारात्मक, शून्य या सकारात्मक मूल्य देता है

f=(a,b,r=/(\d*).?(.*)/)=>a+b&&+((a=r.exec(a))[1]-(b=r.exec(b))[1]||f(a[2],b[2]))

इसे ऑनलाइन आज़माएं!

— लुइस फेलिप डी जीसस मुनोज
स्रोत
1
88 बाइट्स execस्ट्रिंग्स को विभाजित करने के लिए उपयोग करते हैं। इसे ऑनलाइन आज़माएं!
— अतिरेक
@redundancy धिक्कार है, धन्यवाद! एक बहुत अच्छी चाल है
— लुइस फेलिप डी जेउस मुनोज़
हो सकता है कि आप सकारात्मक / शून्य / नकारात्मक मूल्यों पर स्विच करके कुछ बाइट्स को बचाने के लिए Math.sign को निकालना चाहते हों। और शायद एक सकारात्मक संकेत की आवश्यकता है।
— tsh
1

जाप , 16 11 बाइट्स

-5 बाइट्स @ झागी से

आउटपुट:

  • के लिए ऋणात्मक संख्या <
  • ( nullया 0) के लिए=
  • के लिए सकारात्मक संख्या >
N®q.Ãy_r-Ãf

इसे ऑनलाइन आज़माएं!

— लुइस फेलिप डी जीसस मुनोज
स्रोत
क्या यह काम करेगा?
— झबरा
@ झागी हां, यह नकारात्मक, अशक्त या 0, क्रमशः के लिए सकारात्मक 10 बाइट्स को छोटा कर सकता है , < = >लेकिन मुझे नहीं पता कि इनपुट को एक सरणी के रूप में लिया जा सकता है
— लुइस फेलिप डी जीसस मुनोज़
0

क्लीन , 116 111 बाइट्स

import StdEnv,Text
?s=map toInt(split"."s)
$a b= @(?a)(?b)
@[h:t][u:v]|h==u= @t v=h-u
@l[]=sum l
@[]l= ~(sum l)

इसे ऑनलाइन आज़माएं!

एक नकारात्मक संख्या को आउटपुट करता है जब पहला तर्क दूसरे से कम होता है, शून्य जब वे समकक्ष होते हैं, और एक सकारात्मक संख्या जब यह दूसरे से अधिक होता है।

— Οurous
स्रोत
0

स्विफ्ट 4 , 155 बाइट्स

शीर्षलेख (गिना नहीं गया: कोड गैर-पुनरावर्ती है):

let f:(String,String)->Bool? =

कोड

{let x:(String)->[Int]={$0.split{$0=="."}.map{Int($0)!}.reversed().drop{$0==0}.reversed()},a=x($0),b=x($1)
return a==b ?nil:a.lexicographicallyPrecedes(b)}

इसे ऑनलाइन आज़माएं!

स्पष्टीकरण

  • हम अनुगामी ट्रिम करते हैं ।0।
  • हम घटकों की संख्यात्मक रूप से तुलना करते हैं।

लौट आए स्थिरांक

  • के लिए nil =
  • सत्य के लिए <
  • झूठे के लिए>
— कोयूर
स्रोत
0

जावास्क्रिप्ट 64 बाइट्स

a=>b=>(e=i=>(g=v=>v.split`.`[i]||0)(a)-g(b)||!a[i]-1&&e(i+1))(0)

इसे ऑनलाइन आज़माएं!

टिप्पणियों के साथ:

a=>b=>(                            // Main function takes arguments like ("1.2.42")("1.2.41")
    e=i=>                          // e(i) compares the ith number, returns >0, <0 or =0.
        (   g=v=>v.split`.`[i]||0  // g() returns the ith string or 0
        )(a)                       // call g(a)
        -g(b)                      // subtracting g(b) from g(a) casts strings to integer
        ||                         // If they are not equal return result now
        !a[i]-1 &&                 // recursion limited to a.length, always sufficient
        e(i+1)                     // next i
    )(0)                           // Start with i = 0
— जेम्स
स्रोत
0

बर्लेस्क - 17 बाइट्स

wd{'.;;)ri}m[^pcm


blsq ) "2018.08.1 2018.08"wd{'.;;)ri}m[^pcm
1
blsq ) "0.0.1 0.1"wd{'.;;)ri}m[^pcm
-1
blsq ) "1.1.56789 1.2.0"wd{'.;;)ri}m[^pcm
-1

यदि आप '> <=' में आउटपुट चाहते हैं तो जोड़ें ?i"<=>"j!!Q।

— mroman
स्रोत
0

पॉवरशेल, 88 बाइट्स

0बराबर positive integerया उससे negative integerकम के लिए , बराबर के लिए रिटर्न ।

param($a,$b)+(($x=$a-split'\.')+($y=$b-split'\.')|%{$x[+$i]-$y[$i++]}|?{$_}|Select -f 1)

कम गोल्फ परीक्षण स्क्रिप्ट:

$f = {

param($a,$b)
$x=$a-split'\.'
$y=$b-split'\.'
$z=$x+$y|%{
    $x[+$i]-$y[$i++]
}|?{$_}|Select -first 1
+$z             # convert $null to 0

}

@(
    ,("2"         ,"1"         , 1)
    ,("1.0.0"     ,"1"         , 0)
    ,("1.0"       ,"1.0.0"     , 0)
    ,("1.2.42"    ,"1.2.41"    , 1)
    ,("1.1.56789" ,"1.2.0"     ,-1)
    ,("1.10"      ,"1.2"       , 1)
    ,("1.20"      ,"1.150"     ,-1)
    ,("18.04"     ,"18.4"      , 0)
    ,("7.010"     ,"7.8"       , 1)
    ,("1.0.0.1.0" ,"1.00.00.2" ,-1)
    ,("00.00.01"  ,"0.0.0.1"   , 1)
    ,("0.0.1"     ,"0.1"       ,-1)
    ,("42.0"      ,"4.2.0"     , 1)
    ,("999.999"   ,"999.999.1" ,-1)
    ,("2018.08.1" ,"2018.08"   , 1)
) | % {
    $v1,$v2,$expected = $_
    $result = &$f $v1 $v2
    "$([Math]::Sign($result)-eq$expected): $result"
}

आउटपुट:

True: 1
True: 0
True: 0
True: 1
True: -1
True: 8
True: -130
True: 0
True: 2
True: -1
True: 1
True: -1
True: 38
True: -1
True: 1
— Mazzy
स्रोत
0

डार्ट , 277 231 बाइट्स

F(s,{t}){t=s.split('.').map(int.parse).toList();while(t.last<1)t.removeLast();return t;}f(a,b,{d,e,f,g,h,i=0}){d=F(b);e=F(a);g=d.length;h=e.length;f=h>g?g:h;for(;i<f;i++)if(e[i]!=d[i])return e[i]>d[i]?1:-1;return h>g?1:(h<g?-1:0);}

इसे ऑनलाइन आज़माएं!

  • लंबाई को स्टोर करने के लिए चर का उपयोग करके और लूप में टर्नरी का उपयोग करके -44 बाइट्स
  • कोष्ठक के लिए निकालकर -2 बाइट्स
— Elcan
स्रोत
0

स्विफ्ट 4 + फाउंडेशन , 160 बाइट्स (142 + 18) , 155 बाइट्स (142 + 13)

आयात ( ;कोड से अलग करने के लिए 13 बाइट्स ):

यह फाउंडेशन आयात करेगा, लेकिन 5 बाइट्स से कम है import Foundation।

import UIKit;

शीर्षलेख (गिना नहीं गया: कोड गैर-पुनरावर्ती है):

let f:(String,String)->ComparisonResult =

कोड (142 बाइट्स):

{var x={($0 as String).split{$0=="."}.count},a=$0,b=$1
while x(a)<x(b){a+=".0"}
while x(b)<x(a){b+=".0"}
return a.compare(b,options:.numeric)}

इसे ऑनलाइन आज़माएं!

स्पष्टीकरण

  1. हम घटकों के समान संख्या के लिए कुछ अनुगामी .0 को जोड़ते हैं।
  2. हम घटकों की संख्यात्मक रूप से तुलना करते हैं।

लौट आए स्थिरांक

  • तुलना .Result.orderedSame = के लिए
  • तुलना के लिए ।Result.orderedAscending <
  • तुलना .Result.orderedDescending के लिए>
— कोयूर
स्रोत
मुझे यकीन नहीं है कि अगर हम importबयान की गिनती करते हैं , तो मैंने एक अलग उत्तर पोस्ट किया है जिसकी आवश्यकता नहीं है Foundationऔर बाइट्स के साथ 142 बाइट्स (काउंटिंग इम्पोर्ट नहीं) और 160 बाइट्स (काउंटिंग इंपोर्ट) की गिनती होती है।
— Cœur
0

Zsh , 54 बाइट्स

eval {autoload,}' is-at-least $'{1\ $2,2\ $1}';<<<$?;'

इसे ऑनलाइन आज़माएं! एक परीक्षण सूट की कोशिश करो!

यह evalनिम्नलिखित आठ कथनों के लिए है:

autoload is-at-least $1 $2     # loads the "is-at-least" function
<<<$?                          # success, prints 0
autoload is-at-least $2 $1     # redundant
<<<$?                          # success, prints 0
is-at-least $1 $2              # exits 1 if $1 < $2
<<<$?
is-at-least $2 $1              # exits 1 if $2 < $1
<<<$?

तो तीन अद्वितीय मूल्य हैं:

 cmp |  value
-----+------------------------------------------
  =  |  0<newline>0<newline>0<newline>0<newline>
  <  |  0<newline>0<newline>1<newline>0<newline>
  >  |  0<newline>0<newline>0<newline>1<newline>
— GammaFunction
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.