Wenn wir eine Software veröffentlichen, weisen wir ihr eine Versionsnummer zu. Benutzer möchten möglicherweise auf die neueste Version einiger Software aktualisieren. Es ist also an der Zeit herauszufinden, welche Version neuer sein soll.

Eingang

Geben Sie zwei Versionsnummern als Zeichenfolgen ein.

Im Rahmen dieser Herausforderung unterstützen wir nur Versionsnummern, bei denen es sich um Ziffern handelt, die durch Punkte verbunden sind.

• Eine Versionsnummer ist eine Zeichenfolge, die nur Ziffern ( 0~ 9) und Punkte ( .) enthalten darf .
• Punkte wären nicht das erste / letzte Zeichen einer Versionsnummer.
• Zwischen den Punkten müssen einige Ziffern stehen. Es dürfen keine zwei Punkte fortlaufend erscheinen.
• Alle Nummern in einer Versionsnummer wären kleiner als 2 ¹⁶ .

Ausgabe

Vergleichen Sie die eingegebenen Versionsnummern und geben Sie aus, ob die erste größer / gleich / kleiner als die zweite ist. Sie können eine der folgenden Präsentationen auswählen:

• Verwenden Sie eine positive Zahl / Null / negative Zahl, während Null gleich bedeutet.
• Verwenden Sie drei verschiedene konstante Werte.

Vergleichen

Sie müssen den in diesem Abschnitt beschriebenen Algorithmus nicht implementieren. Ihre Eingabe ist gültig, solange sie mit diesem Algorithmus dieselbe Ausgabe ergibt.

• Versionsnummern sind Dezimalzahlen, die durch Punkte verbunden sind. Wir teilen zuerst die beiden Versionsnummern in Zahlenfelder auf;
• Das Ende von Arrays mit Nullen auffüllen, damit sie die gleiche Länge haben;
• Vergleichen Sie vom ersten bis zum letzten Artikel:
  • Wenn sich die beiden Array-Elemente unterscheiden, bedeutet die höhere Nummer eine höhere Versionsnummer
  • Wenn sie identisch sind, vergleichen Sie die folgenden Elemente weiter.
  • Wenn alle Elemente im Array gleich sind, sind die beiden Versionen gleich.

Testfälle

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   >

Python 2 , 84 79 76 Bytes

lambda*l:cmp(*map(lambda v:map(int,v.split('.')+[0]*len(`l`))[:len(`l`)],l))

Probieren Sie es online!

Ausgänge -1,0,1für<,=,>

05AB1E (Legacy) , 15 14 13 Byte

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

Ausgänge -1 [] 1für < = >.

-1 Byte dank @Emigna .

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Erläuterung:

'.¡              # 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

R , 32 Bytes

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

Probieren Sie es online!

Verwenden eines eingebauten R

Ausgänge 1 2, 1.5 1.5, 2 1für weniger, gleich, größer.

Am besten bisher, ohne eingebaut zu haben:

R , 151 142 125 107 Bytes

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

Probieren Sie es online!

Abgerollter Code mit Erklärung:

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)

Ausgänge -1, NULL, 1für weniger, gleich, größer.

Ursprüngliches Konzept, das mit Golf gespielt wurde sapply, [<-und %*%:

R , 129 Bytes

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]

Probieren Sie es online!

Nun haben Sie eine Liste von zwei gleichlangen Vektoren von ganzen Zahlen. Berechnen Sie die paarweisen Differenzen mit Reduceund geben Sie das erste Nicht-Null-Element mit der kniffligen kleinen w[!!w][1]Form am Ende aus.

Ausgänge -1, NA, 1für weniger, gleich, größer.

APL (Dyalog Unicode) , 18 bis 17 Bytes

1 Byte gespart dank @ Adám für die Verwendung ⍤1anstelle von ∘↑(...)¨und durch Ändern des Eingabeformats von einem verschachtelten Array in eine Matrix

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

Probieren Sie es online!

Nimmt die Eingabe als Zeichenmatrix als das richtige Argument, wobei sich jeder Versionsstring in einer eigenen Zeile befindet. Ausgänge ¯1 1, 0 0, 1 ¯1für <, =, >jeweils.

(⍎¨∊∘⎕D⊆⊢)⍤1 in jeder Reihe

• ∊∘⎕D⊆⊢ Gruppieren Sie alle Vorkommen von Ziffern, dh teilen Sie sie auf .

• ⍎¨ und konvertieren Sie jedes dieser Vorkommen in eine Zahl

↑In eine Matrix konvertieren, bei der sich die erste Eingabe in der oberen und die zweite in der unteren Zeile befindet und 0bei Bedarf mit s aufgefüllt wird

(⍋-⍒) und

• - subtrahieren
  • ⍒ die Indizes in die Zeilen, die sie in absteigender Reihenfolge sortieren würden
  • ⍋ wie oben, jedoch in aufsteigender Reihenfolge

Perl 6 , 63 47 22 Bytes

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

Probieren Sie es online!

Es stellte sich heraus, dass Perl 6 einen Versionstyp hat , der der Beschreibung ziemlich gut entspricht. Dies ist ein anonymer Codeblock, der eine Liste von zwei Versionsstrings und gibt entweder nimmt More, SameoderLess .

Erläuterung:

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

Oder ohne eingebaute Typen für 47 Bytes:

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

Probieren Sie es online!

Anonymer Codeblock, der zwei Zeichenfolgen akzeptiert und zurückgibt, Morewenn die zweite größer ist, Lesswenn die zweite kleiner ist undNil wenn sie gleich sind.

Erläuterung:

{                                             } # 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

Brachylog , 49 40 Bytes

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

... Es ist immer noch ziemlich unscheinbar lang.

Erwartet eine Liste mit zwei Zeichenfolgen. Verwendet positive number / zero / negative number als > / = / <.

Probieren Sie es online!

Erläuterung

Aufteilung der Eingänge

Angesichts einen Eingang, der nicht mit sich vereinen [0, 0], wie beispielsweise ["1.02.0", "1.2.0.1.0"], die folgenden Segmentausgänge, zB [[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]

Vergleich der Eingaben

Zippt zum Beispiel [[1, "02.0"], [1, "2.0.1.0"]]die Unterlisten in [[1, 1], ["02.0", "2.0.1.0"]]und vergleicht die Werte im head ( [1,1]). Wiederholen Sie in der zweiten Unterliste. Man beachte , dass das Prädikat zip zZyklen durch kürzere Listen , so daß bei Schwirren [0,0]mit zu Zipping entspricht [0], daher die vorherigen Schritt vereinheitlicht 0mit 0ohne weitere Werte angehängt.

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)

JavaScript (ES6), 73-68 Byte

5 Bytes gespart dank @redundancy

(a)(b)$0$

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

Probieren Sie es online!

Java (JDK 10) , 201 96 89 Bytes

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

Probieren Sie es online!

Gibt eine negative Zahl zurück, wenn die erste Version kleiner als die zweite ist, eine positive, wenn die erste Version größer als die zweite ist und 0wenn sie gleich ist.

Ja, das ist einige schwere Arbeit, um "nur" ein eingebautes zu nennen!

Credits

• -14 Bytes, danke an Kevin Cruijssen

Python 2 , 87 Bytes

lambda*p:cmp(*zip(*map(lambda x,y:(x or 0,y or 0),*[map(int,u.split('.'))for u in p])))

Probieren Sie es online!

Gibt -1,0,1 für <, =,> aus.

Retina 0.8.2 , 54 Bytes

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

Probieren Sie es online!Link enthält Testfälle. Verwendet den Trennzeichenwert als Gleichheitsausgabe, sodass der Header das Eingabetrennzeichen der Einfachheit halber in konvertiert= , es kann sich jedoch auch um etwas anderes handeln [.\d]. Erläuterung:

\d+
$*

In Unary konvertieren.

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

Löschen Sie wiederholt das erste Zeichen von jeder Seite, bis sie sich unterscheiden oder eine Seite leer ist. Dies ist viel schneller als der Versuch, Präfixe abzugleichen, obwohl dies möglicherweise nicht mehr der Fall ist. Zu diesem Zeitpunkt liegen die Zeichenfolgen in einer von mehreren Formen vor, die zu einem Vergleichsergebnis decodiert werden müssen.

1. Wenn keiner der beiden Strings ein. Enthält 1 ist das Ergebnis=
2. Wenn die linke Zeichenfolge mit einem beginnt 1 lautet das Ergebnis>
3. Wenn die richtige Zeichenfolge mit einem beginnt 1 lautet das Ergebnis<
4. Wenn die linke Zeichenfolge leer ist, ist das Ergebnis <
5. Zu diesem Zeitpunkt ist die rechte Zeichenfolge leer und das Ergebnis ist >

Eine andere Art, darüber nachzudenken, ist, dass wenn eine Zeichenkette a enthält 1und die andere nicht mit a beginnt 1, diese Zeichenkette größer ist, sich jedoch herausstellt, dass sie ein Byte länger ist.

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

Suchen Sie nach Fall 3 oder Fall 4 ohne Fall 1.

.*1.*=.*
>

Wenn die linke Zeichenfolge 1zu diesem Zeitpunkt noch ein enthält , ist sie größer.

\.

Andernfalls löschen Sie alle verbleibenden . s.

Firefox-Browserkonsole REPL, 19 Byte

Services.vc.compare

Ich glaube, diese interne Funktion führt den erforderlichen Vergleich durch. Es gibt -1, 0 oder 1 zurück.

PHP , 38 Bytes

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

Ausgänge -1 → < | 0 → = | 1 → >

Probieren Sie es online!

C (gcc) ,  140  134 Bytes

Dieser Code gibt eine negative 0oder eine positive für <, =oder >jeweils.

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;}

Probieren Sie es online!

Bearbeitungen:

• 6 Bytes gespart dank ceilingcat!

Ruby , 75 Bytes

->a,b{c=d=0;c,d=[a,b].map{|f|f.slice!(/\d*./).to_i}while''<a+b&&c==d;c<=>d}

Probieren Sie es online!

JavaScript (Node.js) , 105 88 80 Byte

-17 Bytes von @redundancy. Wow!

-8 Bytes, die Math.sign entfernen. Danke @tsh

Gibt einen negativen, nullten oder positiven Wert zurück

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

Probieren Sie es online!

Japt , 16 11 Bytes

-5 Bytes von @Shaggy

Ausgänge:

• negative Zahl für <
• ( nulloder0 ) für=
• positive Zahl für >

N®q.Ãy_r-Ãf

Probieren Sie es online!

Sauber , 116 111 Bytes

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)

Probieren Sie es online!

Gibt eine negative Zahl aus, wenn das erste Argument kleiner als das zweite ist, eine Null, wenn es äquivalent ist, und eine positive Zahl, wenn es größer als das zweite ist.

Schnelle 4 , 155 Bytes

Header (nicht gezählt: der Code ist nicht rekursiv):

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

Code

{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)}

Probieren Sie es online!

Erklärungen

• Wir trimmen das Schleppen .0.
• Wir vergleichen Komponenten numerisch.

Zurückgegebene Konstanten

• Null für =
• wahr für <
• false für>

JavaScript 64 Bytes

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

Probieren Sie es online!

Mit Kommentaren:

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

Perl 5 , 55 Bytes

sub c{@_<2?sprintf"%9d"x9,split/\./,pop:-(c(pop)cmp c(pop))}

Probieren Sie es online!

Burlesque - 17 Bytes

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

Wenn Sie eine Ausgabe in '> <=' wünschen, fügen Sie hinzu ?i"<=>"j!!Q.

Powershell, 88 Bytes

Gibt 0für gleich, a positive integerfür größer als oder a negative integerfür kleiner als zurück.

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

Weniger Golf-Testskript:

$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"
}

Ausgabe:

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

Dart , 277 231 Bytes

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);}

Probieren Sie es online!

• -44 Bytes durch Verwendung von Variablen zum Speichern der Länge und Verwendung einer ternären In-Schleife
• -2 Bytes durch Entfernen der for-Klammern

Swift 4 + Foundation , 160 Byte (142 + 18) , 155 Byte (142 + 13)

Importieren (13 Bytes, einschließlich ; vom Code zu trennen):

Das wird Foundation importieren, ist aber 5 Bytes kürzer als import Foundation.

import UIKit;

Header (nicht gezählt: der Code ist nicht rekursiv):

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

Code (142 Bytes):

{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)}

Probieren Sie es online!

Erklärungen

1. Wir fügen für die gleiche Anzahl von Komponenten einige nachgestellte .0 an.
2. Wir vergleichen Komponenten numerisch.

Zurückgegebene Konstanten

• ComparisonResult.orderedSame for =
• ComparisonResult.orderedAscending für <
• ComparisonResult.orderedDescending für>

Zsh , 54 Bytes

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

Probieren Sie es online! Probieren Sie eine Testsuite aus!

Dies ist evalzu den folgenden acht Aussagen:

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
<<<$?

Die drei eindeutigen Werte sind also:

 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>