일부 소프트웨어를 게시 할 때 버전 번호를 지정합니다. 또한 사용자는 일부 소프트웨어의 최신 버전으로 업데이트 할 수 있습니다. 따라서 어떤 버전이 최신 버전인지 확인해야합니다.

입력

두 개의 버전 번호를 문자열로 입력하십시오.

이 과제와 관련하여, 우리는 점으로 연결된 일부 숫자 인 버전 번호 만 지원합니다.

• 버전 번호는 숫자 ( 0~ 9)와 점 ( .) 만 포함 할 수있는 문자열입니다 .
• 점은 버전 번호의 첫 번째 / 마지막 문자가 아닙니다.
• 점 사이에 숫자가 있어야합니다. 두 개의 점이 연속적으로 나타나지 않을 수 있습니다.
• 버전 번호의 모든 숫자는 2 ¹⁶ 미만 입니다.

산출

입력 된 버전 번호를 비교하고 첫 번째 버전이 두 번째 버전보다 크거나 같은지 여부를 출력합니다. 다음 프레젠테이션 중 하나를 선택할 수 있습니다.

• 양수 / 0 / 음수를 사용하고 0은 같음을 의미합니다.
• 3 개의 상수 고유 값을 사용하십시오.

비교

이 섹션에 설명 된 알고리즘을 구현할 필요는 없습니다. 제출 한 내용은이 알고리즘으로 동일한 결과를 얻는 한 유효합니다.

• 버전 번호는 점으로 연결된 일부 10 진수입니다. 먼저 두 버전 번호를 숫자 배열로 나눕니다.
• 배열의 끝을 0으로 채워서 같은 길이를 갖도록합니다.
• 첫 번째 항목과 마지막 항목을 비교하십시오.
  • 두 배열 항목이 다른 경우 숫자가 클수록 버전 번호가 커짐을 의미합니다.
  • 동일한 경우 다음 항목을 계속 비교하십시오.
  • 배열의 모든 항목이 동일하면 두 버전이 동일합니다.

테스트 케이스

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   >

파이썬 2 , 84 79 76 바이트

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

온라인으로 사용해보십시오!

에 -1,0,1대한 출력<,=,>

05AB1E (레거시) , 15 14 13 바이트

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

각각 출력 -1 [] 1합니다 < = >.

@Emigna 덕분에 -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

R , 32 바이트

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

온라인으로 사용해보십시오!

R 내장 사용

출력 1 2, 1.5 1.5, 2 1이하 동일 큰 대.

내장없이 지금까지 가장 좋습니다.

R , 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이하 동일 큰 대.

원래 개념을 사용하여 아래로 golfed sapply, [<-및 %*%:

R 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]양식을 사용하여 0이 아닌 첫 번째 요소를 사용 하여 쌍별 차이를 계산하십시오 .

출력 -1, NA, 1이하 동일 큰 대.

APL (Dyalog Unicode) , 18 17 바이트

중첩 배열에서 행렬로 입력 형식을 변경하는 ⍤1대신 사용하고 @ Adám 덕분에 1 바이트 절약∘↑(...)¨

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

온라인으로 사용해보십시오!

입력을 문자 인수로 올바른 인수로 사용합니다. 여기서 각 버전 문자열은 자체 행에 있습니다. 출력 ¯1 1, 0 0, 1 ¯1대한 <, =, >각각.

(⍎¨∊∘⎕D⊆⊢)⍤1 각 줄에

• ∊∘⎕D⊆⊢ 모든 자릿수 그룹화, 즉 분할 .

• ⍎¨ 이러한 각 발생을 숫자로 변환

↑첫 번째 입력이 맨 위 행에 있고 두 번째 입력이 맨 아래에 있고 0필요한 경우 s로 채워지는 행렬로 변환

(⍋-⍒) 과

• - 덜다
  • ⍒ 내림차순으로 정렬하는 행의 인덱스
  • ⍋ 상단과 동일하지만 오름차순

펄 6 , 63 47 22 바이트

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

온라인으로 사용해보십시오!

Perl 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

Brachylog , 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)

자바 스크립트 (ES6), 73 68 바이트

@redundancy 덕분에 5 바이트 절약

(a)(b)$0$

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

온라인으로 사용해보십시오!

자바 (JDK 10) , 201 96 89 바이트

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

온라인으로 사용해보십시오!

첫 번째 버전이 두 번째 버전보다 작은 경우 음수를, 첫 번째 버전이 두 번째 버전보다 크면 같으면 양수를 반환합니다 0.

그렇다, 그것은 내장 된 것을 "그냥"호출하기위한 많은 노력이다!

크레딧

• Kevin Cruijssen 덕분에 -14 바이트

파이썬 2 , 87 바이트

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

온라인으로 사용해보십시오!

<, =,>에 대해 각각 -1,0,1을 출력합니다.

망막 0.8.2 , 54 바이트

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

온라인으로 사용해보십시오!링크에는 테스트 사례가 포함됩니다. 구분 기호 값을 등식 출력으로 사용하므로 편의상 헤더는 입력 구분 기호를로 변환 =하지만에 포함되지 않은 항목이 될 수 있습니다 [.\d]. 설명:

\d+
$*

단항으로 변환합니다.

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

첫 번째 문자가 다르거 나 한쪽이 없어 질 때까지 각 문자를 반복해서 삭제하십시오. 골퍼는 아니지만 접두사를 일치시키는 것보다 훨씬 빠릅니다. 이 시점에서 문자열은 여러 형식 중 하나이며 비교 결과로 디코딩해야합니다.

1. 두 문자열 모두에 1 결과는=
2. 왼쪽 문자열이 1 로 하면 결과는>
3. 올바른 문자열이 1 로 하면 결과는<
4. 왼쪽 문자열이 비어 있으면 결과는 <
5. 이 시점에서 오른쪽 문자열은 비어 있으므로 결과는 >

이것에 대해 생각하는 또 다른 방법은 하나의 문자열에 a가 포함 1되고 다른 1문자열이 a 로 시작하지 않으면 해당 문자열이 더 커지지 만 바이트가 더 길다는 것입니다.

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

사례 3 또는 사례 1이없는 사례 4를 확인하십시오.

.*1.*=.*
>

1이 시점에서 왼쪽 문자열에 여전히가 포함되어 있으면 더 큽니다.

\.

그렇지 않으면 남은 .s를 삭제하십시오 .

Firefox 브라우저 콘솔 REPL, 19 바이트

Services.vc.compare

이 내부 기능이 필요한 비교를 수행한다고 생각합니다. -1, 0 또는 1을 반환합니다.

PHP , 38 바이트

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

출력 -1 → < | 0 → = | 1 → >

온라인으로 사용해보십시오!

C (GCC) ,  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;}

온라인으로 사용해보십시오!

편집 :

• ceilingcat 덕분에 6 바이트를 절약했습니다!

루비 , 75 바이트

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

온라인으로 사용해보십시오!

자바 스크립트 (Node.js) , 105 88 80 바이트

@redundancy에서 -17 바이트 와우!

Math.sign을 제거하는 -8 바이트 감사합니다 @tsh

음수, 0 또는 양수 값을 반환

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

온라인으로 사용해보십시오!

apt , 16 11 바이트

@Shaggy에서 -5 바이트

출력 :

• 음수 <
• ( null또는 0)=
• 에 대한 양수 >

N®q.Ãy_r-Ãf

온라인으로 사용해보십시오!

클린 , 116111 바이트

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)

온라인으로 사용해보십시오!

첫 번째 인수가 두 번째 인수보다 작 으면 음수를, 해당 인수가 같으면 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을 다듬습니다.
• 구성 요소를 수치 적으로 비교합니다.

반환 된 상수

• = 없음
• <에 해당
• >에 대한 거짓

자바 스크립트 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

펄 5 , 55 바이트

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

온라인으로 사용해보십시오!

해 학적 인-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.

파워 쉘, 88 바이트

0같음, a 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

다트 , 277231 바이트

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

온라인으로 사용해보십시오!

• 변수를 사용하여 길이를 저장하고 3 진 루프를 사용하여 -44 바이트
• for 대괄호를 제거하여 -2 바이트

스위프트 4+ 파운데이션 , 160 바이트 (142 + 18) , 155 바이트 (142 + 13)

가져 오기 ( ;코드와 구분 하여 13 바이트 ) :

Foundation을 가져 오지만 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. 구성 요소를 수치 적으로 비교합니다.

반환 된 상수

• 비교 결과.
• 비교 결과-오름차순 <
• 비교 결과.

Zsh , 54 바이트

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

온라인으로 사용해보십시오! 테스트 스위트를 사용해보십시오!

이것은 eval다음 8 가지 진술에 따른다.

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>