Kiedy publikujemy oprogramowanie, przypisujemy mu numer wersji. Użytkownicy mogą chcieć zaktualizować oprogramowanie do najnowszej wersji. Czas więc dowiedzieć się, która wersja powinna być nowsza.

Wkład

Wprowadź dwa numery wersji jako ciągi.

W kontekście tego wyzwania obsługujemy tylko numery wersji, które są niektórymi cyframi połączonymi kropkami.

• Numer wersji to ciąg znaków, który może zawierać tylko cyfry ( 0~ 9) i kropki ( .).
• Kropki nie byłyby pierwszym / ostatnim znakiem numeru wersji.
• Pomiędzy kropkami muszą znajdować się cyfry. Nie mogą pojawiać się dwie kropki w sposób ciągły.
• Wszystkie liczby w numerze wersji byłyby mniejsze niż 2 ¹⁶ .

Wydajność

Porównaj wprowadzone numery wersji i wypisz, czy pierwszy jest większy niż / jest równy / mniejszy niż drugi. Możesz wybrać jedną z następujących prezentacji:

• Użyj liczby dodatniej / zera / liczby ujemnej, podczas gdy zero oznacza równość;
• Użyj trzech stałych odrębnych wartości;

Porównywanie

Nie musisz implementować algorytmu opisanego w tej sekcji. Twoje zgłoszenie jest ważne, o ile daje ten sam wynik w przypadku tego algorytmu.

• Numery wersji to niektóre liczby dziesiętne połączone kropkami. Najpierw dzielimy dwa numery wersji na tablice liczb;
• Wypełnianie końcówek tablic zerami, aby miały taką samą długość;
• Porównaj od pierwszego elementu do ostatniego:
  • Jeśli dwa elementy tablicy różnią się, większa liczba oznacza większy numer wersji
  • Jeśli są takie same, kontynuuj porównywanie następujących pozycji;
  • Jeśli wszystkie elementy w tablicy są równe, obie wersje są równe.

Przypadki testowe

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 bajtów

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

Wypróbuj online!

Wyjścia -1,0,1dla<,=,>

05AB1E (starsza wersja) , 15 14 13 bajtów

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

Wyjścia -1 [] 1dla < = >odpowiednio.

-1 bajt dzięki @Emigna .

Wypróbuj online lub sprawdź wszystkie przypadki testowe .

Wyjaśnienie:

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

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

Wypróbuj online!

Korzystanie z wbudowanego R.

Wyjścia 1 2, 1.5 1.5, 2 1za mniejsze, równe, Wielkopolska.

Najlepsze jak dotąd, bez wbudowanego:

R , 151 142 125 107 bajtów

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

Wypróbuj online!

Kod rozwinięty z wyjaśnieniem:

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)

Wyjścia -1, NULL, 1za mniejsze, równe, Wielkopolska.

Koncepcji oryginalny, grałem w dół za pomocą sapply, [<-i %*%:

R , 129 bajtów

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]

Wypróbuj online!

Teraz masz listę dwóch wektorów liczb całkowitych o jednakowej długości. Obliczyć różnice par przy użyciu Reducei wyprowadzić pierwszy niezerowy element przy użyciu trudnej małej w[!!w][1]formy na końcu.

Wyjścia -1, NA, 1za mniejsze, równe, Wielkopolska.

APL (Dyalog Unicode) , 18 17 bajtów

1 bajt zapisany dzięki @ Adám za używanie ⍤1zamiast ∘↑(...)¨i przez zmianę formatu wejściowego z zagnieżdżonej tablicy na macierz

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

Wypróbuj online!

Traktuje dane wejściowe jako macierz znaków jako właściwy argument, gdzie każdy ciąg wersji znajduje się w osobnym wierszu. Wyjścia ¯1 1, 0 0, 1 ¯1na <, =, >odpowiednio.

(⍎¨∊∘⎕D⊆⊢)⍤1 w każdym rzędzie

• ∊∘⎕D⊆⊢ zgrupuj wszystkie wystąpienia cyfr, czyli podziel na .

• ⍎¨ i przekonwertuj każde z tych wystąpień na liczbę

↑przekonwertować na macierz, gdzie pierwsze wejście znajduje się w górnym rzędzie, a drugie na dole, dopełniając w 0razie potrzeby s

(⍋-⍒) i

• - odejmować
  • ⍒ indeksy w wierszach, które posortowałyby je w kolejności malejącej
  • ⍋ tak samo jak u góry, ale w porządku rosnącym

Perl 6 , 63 47 22 bajtów

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

Wypróbuj online!

Okazuje się, że Perl 6 ma typ wersji, który właściwie pasuje do opisu. Jest to anonimowy blok kodu, który pobiera listę dwóch ciągów wersji i zwraca albo More, Samealbo Less.

Wyjaśnienie:

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

Lub bez wbudowanych typów dla 47 bajtów:

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

Wypróbuj online!

Anonimowy blok kodu, który pobiera dwa ciągi znaków i zwraca, Morejeśli drugi jest większy, Lessjeśli drugi jest mniejszy i Niljeśli są równe.

Wyjaśnienie:

{                                             } # 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 bajtów

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

... Nadal jest dość imponująco długa.

Oczekuje listy dwóch ciągów. Używa positive number / zero / negative number jako > / = / <.

Wypróbuj online!

Wyjaśnienie

Podział wejść

Biorąc pod uwagę dane wejściowe, które nie są jednoczące z [0, 0], takie jak ["1.02.0", "1.2.0.1.0"]wyjścia segmentu poniżej, np [[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]

Porównywanie danych wejściowych

Biorąc pod uwagę, na przykład, [[1, "02.0"], [1, "2.0.1.0"]]zamyka podlisty [[1, 1], ["02.0", "2.0.1.0"]]i porównuje wartości w head ( [1,1]). Powtórz na drugiej liście podrzędnej. Zauważ, że predykat zip przełącza zcyklicznie krótsze listy, dzięki czemu zipowanie [0,0]jest równoważne zipowaniu za pomocą [0], dlatego poprzedni krok łączy 0się 0bez dodawania kolejnych wartości.

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 bajtów

Zaoszczędzono 5 bajtów dzięki @redundancy

(a)(b)$0$

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

Wypróbuj online!

Java (JDK 10) , 201 96 89 bajtów

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

Wypróbuj online!

Zwraca liczbę ujemną, jeśli pierwsza wersja jest mniejsza od drugiej, wartość dodatnią, jeśli pierwsza wersja jest większa od drugiej i 0jeśli są równe.

Tak, to ciężka praca, aby „po prostu” zadzwonić do wbudowanego!

Kredyty

• -14 bajtów, dzięki Kevin Cruijssen

Python 2 , 87 bajtów

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

Wypróbuj online!

Wykazuje -1,0,1 odpowiednio dla <, =,>.

Retina 0.8.2 , 54 bajty

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

Wypróbuj online! Link zawiera przypadki testowe. Używa wartości separatora jako wyjścia równości, więc dla wygody nagłówek konwertuje separator wejściowy na, =ale może to być coś, czego nie ma [.\d]. Wyjaśnienie:

\d+
$*

Konwertuj na unary.

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

Kilkakrotnie usuwaj pierwszy znak z każdej strony, aż będą się różnić lub skończy się jedna strona. Jest to o wiele szybsze niż próba dopasowania prefiksów, choć być może nie golfista. W tym momencie ciągi są w jednej z kilku form, które należy zdekodować w celu uzyskania wyniku porównania.

1. Jeśli żaden ciąg nie zawiera 1a, wynikiem jest=
2. Jeśli lewy ciąg zaczyna się od 1a, wynikiem jest>
3. Jeśli właściwy ciąg zaczyna się od 1a, wynikiem jest<
4. Jeśli lewy ciąg jest pusty, wynikiem jest <
5. W tym momencie właściwy ciąg znaków jest pusty, więc wynikiem jest >

Innym sposobem myślenia na ten temat jest to, że jeśli jeden ciąg zawiera a, 1a drugi nie zaczyna się od, 1to ten ciąg jest większy, jednak okazuje się, że jest to bajt dłuższy.

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

Sprawdź przypadek 3 lub przypadek 4 bez przypadku 1.

.*1.*=.*
>

Jeśli lewy ciąg znaków nadal zawiera 1w tym momencie znak , jest on większy.

\.

W przeciwnym razie usuń wszelkie pozostałości ..

Konsola przeglądarki Firefox REPL, 19 bajtów

Services.vc.compare

Uważam, że ta funkcja wewnętrzna wykonuje wymagane porównanie. Zwraca -1, 0 lub 1.

PHP , 38 bajtów

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

Wyjścia -1 → < | 0 → = | 1 → >

Wypróbuj online!

C (gcc) ,  140  134 bajtów

Kod ten wysyła negatywne, 0lub dodatnią na <, =lub >odpowiednio.

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

Wypróbuj online!

Edycje:

• Oszczędność 6 bajtów dzięki pułapowi cat!

Rubinowy , 75 bajtów

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

Wypróbuj online!

JavaScript (Node.js) , 105 88 80 bajtów

-17 bajtów od @redundancy. Łał!

-8 bajtów usuwania Math.sign. Dzięki @tsh

Zwraca wartość ujemną, zerową lub dodatnią

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

Wypróbuj online!

Japt , 16 lat 11 bajtów

-5 bajtów z @Shaggy

Wyjścia:

• liczba ujemna dla <
• ( nulllub0 ) dla=
• liczba dodatnia dla >

N®q.Ãy_r-Ãf

Wypróbuj online!

Czysty , 116 111 bajtów

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)

Wypróbuj online!

Zwraca liczbę ujemną, gdy pierwszy argument jest mniejszy niż drugi, zero, gdy są one równoważne, i liczbę dodatnią, gdy jest większa niż drugi.

Swift 4 , 155 bajtów

Nagłówek (nie liczony: kod nie jest rekurencyjny):

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

Kod

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

Wypróbuj online!

Objaśnienia

• Przycinamy końcowe 0,0.
• Porównujemy komponenty numerycznie.

Zwrócone stałe

• zero dla =
• prawda dla <
• false dla>

JavaScript 64 bajty

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

Wypróbuj online!

Z komentarzami:

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 bajtów

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

Wypróbuj online!

Burleska - 17 bajtów

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

Jeśli chcesz otrzymać dane wyjściowe w „> <=”, dodaj ?i"<=>"j!!Q.

PowerShell, 88 bajtów

Zwraca wartość 0równą, a positive integerwiększą lub negative integermniejszą niż.

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

Skrypt testu mniej golfowego:

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

Wydajność:

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 bajtów

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

Wypróbuj online!

• -44 bajty przy użyciu zmiennych do przechowywania długości i przy użyciu pętli trójskładnikowej
• -2 bajty, usuwając nawiasy kwadratowe

Swift 4 + Foundation , 160 bajtów (142 + 18) , 155 bajtów (142 + 13)

Importuj (13 bajtów, w tym ;aby oddzielić od kodu):

Spowoduje to zaimportowanie Fundacji, ale jest o 5 bajtów krótsze niż import Foundation.

import UIKit;

Nagłówek (nie liczony: kod nie jest rekurencyjny):

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

Kod (142 bajty):

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

Wypróbuj online!

Objaśnienia

1. Dodajemy część końcową 0,0 dla tej samej liczby komponentów.
2. Porównujemy komponenty numerycznie.

Zwrócone stałe

• CompareResult.orderedSame dla =
• CompareResult.orderedAscending for <
• CompareResult.orderedDescending dla>

Zsh , 54 bajty

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

Wypróbuj online! Wypróbuj zestaw testowy!

Dotyczy evalto ośmiu następujących oświadczeń:

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

Tak więc trzy unikalne wartości to:

 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>