Khi chúng tôi xuất bản một số phần mềm, chúng tôi gán một số phiên bản cho nó. Và người dùng có thể muốn cập nhật lên phiên bản mới nhất của một số phần mềm. Vì vậy, đây là lúc để tìm ra phiên bản nào mới hơn.

Đầu vào

Nhập hai số phiên bản dưới dạng chuỗi.

Trong bối cảnh của thử thách này, chúng tôi chỉ hỗ trợ các số phiên bản là một số chữ số được nối bằng dấu chấm.

• Số phiên bản là một chuỗi chỉ có thể chứa các chữ số ( 0~ 9) và dấu chấm ( .).
• Dấu chấm sẽ không phải là ký tự đầu tiên / cuối cùng của số phiên bản.
• Phải có một số chữ số giữa các dấu chấm. Không có hai dấu chấm có thể xuất hiện liên tục.
• Tất cả các số trong một số phiên bản sẽ ít hơn 2 ¹⁶ .

Đầu ra

So sánh số phiên bản được nhập và đầu ra cho dù số thứ nhất lớn hơn / bằng / nhỏ hơn số thứ hai. Bạn được phép chọn một trong các bài thuyết trình sau:

• Sử dụng số dương / không / số âm, trong khi số 0 có nghĩa là bằng nhau;
• Sử dụng ba giá trị khác biệt không đổi;

So sánh

Bạn không cần phải thực hiện thuật toán được mô tả trong phần này. Việc gửi của bạn là hợp lệ miễn là nó dẫn đến cùng một đầu ra với thuật toán này.

• Số phiên bản là một số số thập phân được nối bằng dấu chấm. Trước tiên chúng tôi chia hai số phiên bản thành mảng số;
• Đệm phần cuối của mảng với các số 0 để làm cho chúng có cùng độ dài;
• So sánh từ mục đầu tiên đến mục cuối cùng:
  • Nếu hai mục mảng khác nhau, số lớn hơn có nghĩa là số phiên bản lớn hơn
  • Nếu chúng giống nhau, tiếp tục so sánh các mục sau đây;
  • Nếu tất cả các mục trong mảng bằng nhau, hai phiên bản bằng nhau.

Tủ thử

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 byte

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

Hãy thử trực tuyến!

Đầu ra -1,0,1cho<,=,>

05AB1E (di sản) , 15 14 13 byte

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

Đầu ra -1 [] 1cho < = >tương ứng.

-1 byte nhờ @Emigna .

Hãy thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình:

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

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

Hãy thử trực tuyến!

Sử dụng nội dung R

Kết quả đầu ra 1 2, 1.5 1.5, 2 1cho ít hơn, bằng nhau, lớn hơn.

Tốt nhất cho đến nay, không có nội dung:

R , 151 142 125 107 byte

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

Hãy thử trực tuyến!

Mã không được kiểm soát với lời giải thích:

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)

Kết quả đầu ra -1, NULL, 1cho ít hơn, bằng nhau, lớn hơn.

Gốc khái niệm, golfed xuống bằng sapply, [<-và %*%:

R , 129 byte

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]

Hãy thử trực tuyến!

Bây giờ bạn có một danh sách hai vectơ có độ dài bằng nhau. Tính toán sự khác biệt theo cặp bằng cách sử dụng Reducevà xuất phần tử khác không đầu tiên bằng cách sử dụng w[!!w][1]mẫu nhỏ khó hiểu ở cuối.

Kết quả đầu ra -1, NA, 1cho ít hơn, bằng nhau, lớn hơn.

APL (Dyalog Unicode) , 18 17 byte

Lưu 1 byte nhờ @ Adám để sử dụng ⍤1thay vì ∘↑(...)¨và bằng cách thay đổi định dạng đầu vào từ một mảng lồng nhau thành ma trận

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

Hãy thử trực tuyến!

Lấy đầu vào là một ma trận ký tự là đối số đúng, trong đó mỗi chuỗi phiên bản nằm trên hàng riêng của nó. Kết quả đầu ra ¯1 1, 0 0, 1 ¯1cho <, =, >tương ứng.

(⍎¨∊∘⎕D⊆⊢)⍤1 trên mỗi hàng

• ∊∘⎕D⊆⊢ nhóm tất cả các lần xuất hiện của các chữ số, nghĩa là, chia trên .

• ⍎¨ và chuyển đổi mỗi lần xuất hiện này thành một số

↑chuyển đổi thành ma trận, trong đó đầu vào đầu tiên nằm ở hàng trên cùng và đầu vào thứ hai ở dưới cùng, đệm với 0s khi cần thiết

(⍋-⍒) và

• - trừ
  • ⍒ các chỉ số vào các hàng sẽ sắp xếp chúng theo thứ tự giảm dần
  • ⍋ tương tự như trên nhưng cho thứ tự tăng dần

Perl 6 , 63 47 22 byte

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

Hãy thử trực tuyến!

Hóa ra Perl 6 có một loại phiên bản khá phù hợp với mô tả. Đây là một khối mã nặc danh mà phải mất một danh sách hai chuỗi phiên bản và trả về một trong hai More, Samehoặc Less.

Giải trình:

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

Hoặc, không có loại tích hợp cho 47 byte:

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

Hãy thử trực tuyến!

Khối mã ẩn danh nhận hai chuỗi và trả về Morenếu chuỗi thứ hai lớn hơn, Lessnếu chuỗi thứ hai nhỏ hơn và Nilnếu chúng bằng nhau.

Giải trình:

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

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

... Nó vẫn còn khá dài ấn tượng.

Mong đợi một danh sách của hai chuỗi. Sử dụng positive number / zero / negative number như > / = / <.

Hãy thử trực tuyến!

Giải trình

Tách đầu vào

Đưa ra một đầu vào không thống nhất với [0, 0], chẳng hạn như ["1.02.0", "1.2.0.1.0"], các đầu ra phân đoạn dưới đây, ví dụ , [[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]

So sánh các đầu vào

Đã cho, ví dụ, [[1, "02.0"], [1, "2.0.1.0"]]nén các danh sách con vào [[1, 1], ["02.0", "2.0.1.0"]]và so sánh các giá trị trong phần đầu ( [1,1]). Recur trên danh sách phụ thứ hai. Lưu ý rằng vị từ zip quay zvòng qua các danh sách ngắn hơn để nén với [0,0]tương đương với nén [0], do đó bước trước đó hợp nhất 0với 0mà không cần thêm giá trị.

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

Đã lưu 5 byte nhờ @redundancy

(a)(b)$0$

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

Hãy thử trực tuyến!

Java (JDK 10) , 201 96 89 byte

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

Hãy thử trực tuyến!

Trả về số âm nếu phiên bản đầu tiên nhỏ hơn số thứ hai, số dương nếu phiên bản thứ nhất lớn hơn số thứ hai và 0nếu chúng bằng nhau.

Đúng, đó là một số công việc nặng nề để "chỉ" gọi một tích hợp!

Tín dụng

• -14 byte, nhờ Kevin Cruijssen

Python 2 , 87 byte

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

Hãy thử trực tuyến!

Đầu ra -1,0,1 tương ứng cho <, =,>.

Võng mạc 0.8.2 , 54 byte

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

Hãy thử trực tuyến! Liên kết bao gồm các trường hợp thử nghiệm. Sử dụng giá trị dấu phân cách làm đầu ra đẳng thức, vì vậy để thuận tiện, tiêu đề chuyển đổi dấu tách đầu vào thành =nhưng nó có thể là bất cứ thứ gì không nằm trong [.\d]. Giải trình:

\d+
$*

Chuyển đổi sang unary.

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

Liên tục xóa ký tự đầu tiên từ mỗi bên cho đến khi chúng khác nhau hoặc hết một bên. Điều này nhanh hơn nhiều so với việc cố gắng khớp các tiền tố, mặc dù có thể không phải là gôn thủ. Tại thời điểm này, các chuỗi ở một trong một số dạng, cần được giải mã thành kết quả so sánh.

1. Nếu không có chuỗi nào chứa a 1thì kết quả là=
2. Nếu chuỗi bên trái bắt đầu bằng a 1thì kết quả là>
3. Nếu chuỗi bên phải bắt đầu bằng a 1thì kết quả là<
4. Nếu chuỗi bên trái trống thì kết quả là <
5. Tại thời điểm này, chuỗi bên phải trống nên kết quả là >

Một cách nghĩ khác về điều này là nếu một chuỗi chứa a 1và chuỗi kia không bắt đầu bằng 1chuỗi thì chuỗi đó lớn hơn, tuy nhiên hóa ra là một byte dài hơn.

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

Kiểm tra trường hợp 3, hoặc trường hợp 4 không có trường hợp 1.

.*1.*=.*
>

Nếu chuỗi bên trái vẫn chứa a 1tại thời điểm này thì nó lớn hơn.

\.

Nếu không xóa bất kỳ còn lại .s.

Bảng điều khiển trình duyệt Firefox REPL, 19 byte

Services.vc.compare

Tôi tin rằng chức năng nội bộ này thực hiện so sánh cần thiết. Nó trả về -1, 0 hoặc 1.

PHP , 38 byte

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

Đầu ra -1 → < | 0 → = | 1 → >

Hãy thử trực tuyến!

C (gcc) ,  140  134 byte

Mã này xuất ra một tiêu cực, 0hoặc dương tính với <, =hoặc >tương ứng.

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

Hãy thử trực tuyến!

Chỉnh sửa:

• Đã lưu 6 byte nhờ vào trần nhà!

Ruby , 75 byte

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

Hãy thử trực tuyến!

JavaScript (Node.js) , 105 88 80 byte

-17 byte từ @redundancy. Ồ

-8 byte loại bỏ Math.sign. Cảm ơn @tsh

Trả về giá trị âm, bằng 0 hoặc dương

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

Hãy thử trực tuyến!

Japt , 16 11 byte

-5 byte từ @Shaggy

Đầu ra:

• số âm cho <
• ( nullhoặc 0) cho=
• số dương cho >

N®q.Ãy_r-Ãf

Hãy thử trực tuyến!

Sạch , 116 111 byte

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)

Hãy thử trực tuyến!

Xuất ra một số âm khi đối số thứ nhất nhỏ hơn đối số thứ hai, bằng 0 khi chúng tương đương và một số dương khi nó nhiều hơn đối số thứ hai.

Swift 4 , 155 byte

Tiêu đề (không được tính: mã không đệ quy):

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

Mã

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

Hãy thử trực tuyến!

Giải thích

• Chúng tôi cắt đuôi .0.
• Chúng tôi so sánh các thành phần số.

Hằng số trả về

• không cho =
• đúng cho <
• sai cho>

JavaScript 64 byte

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

Hãy thử trực tuyến!

Với nhận xét:

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 byte

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

Hãy thử trực tuyến!

Burlesque - 17 byte

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

Nếu bạn muốn đầu ra trong '> <=' thì thêm ?i"<=>"j!!Q.

Powershell, 88 byte

Trả về 0cho bằng, một positive integercho lớn hơn hoặc một negative integerít hơn.

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

Kịch bản kiểm tra ít chơi gôn hơn:

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

Đầu ra:

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

Phi tiêu , 277 231 byte

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

Hãy thử trực tuyến!

• -44 byte bằng cách sử dụng các biến để lưu trữ độ dài và sử dụng ternary trong vòng lặp
• -2 byte bằng cách loại bỏ dấu ngoặc

Nền tảng Swift 4 + , 160 byte (142 + 18) , 155 byte (142 + 13)

Nhập (13 byte, bao gồm ;để tách khỏi mã):

Điều này sẽ nhập Foundation, nhưng ngắn hơn 5 byte import Foundation.

import UIKit;

Tiêu đề (không được tính: mã không đệ quy):

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

Mã (142 byte):

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

Hãy thử trực tuyến!

Giải thích

1. Chúng tôi nối thêm một số dấu .0 cho cùng một số thành phần.
2. Chúng tôi so sánh các thành phần số.

Hằng số trả về

• So sánhResult.orderedSame cho =
• So sánhResult.orderedAsceinating cho <
• So sánhResult.orderedDesceinating cho>

Zsh , 54 byte

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

Hãy thử trực tuyến! Hãy thử một bộ thử nghiệm!

Đây evallà tám tuyên bố sau:

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

Vì vậy, ba giá trị duy nhất là:

 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>