코드 골퍼로서 우리는 ( 확실히 ) 공개하는 데 익숙하지 않습니다 . 이를 위해 몇 가지 도구가 필요합니다.

물론 새 릴리스를 마케팅하려면 멋지고 빛나는 릴리스 버전이 필요합니다. 버전 3.0.0에 대해들을 때 누가 흥분하지 않습니까?

태스크

당신의 임무는 버전 번호를 증가시키기 위해 프로그램 / 루틴 / ...을 작성하는 것입니다.

버전 번호를 늘리고 "중요하지 않은"버전 (즉, 패치 버전)을 재설정해야합니다.

현재 버전 (예 : "1.0.3")과 문자열 중 하나를 업데이트 할 인덱스 (0 또는 1- 인덱스)를 나타내는 인덱스가 있습니다.

예, 0 인덱스 :

next-version("1.0.3", 0) # 2.0.0
next-version("1.2.3.4.5", 2) # 1.2.4.0.0
next-version("10.0", 0) # 11.0
next-version("3", 0) # 4
next-version("1", 7) # ERROR
next-version("01", 0) # ERROR

버전은 문자열이며 각 부분은 숫자이며 점으로 구분됩니다. 선행, 후행 또는 연속적인 점이 없으며 숫자 / 점 이외의 것도 없습니다. 버전 문자열의 크기에는 제한이 없습니다.

^[1-9]\d*(\.[1-9]\d*)*$

오류 사례 (마지막 두 예제)는 정의되지 않은 동작입니다. 입력이 잘못되었을 때 발생하는 일은이 문제와 관련이 없습니다.

평소와 같이 표준 허점은 금지되어 있습니다. 문자열을 인쇄하거나 반환 할 수 있습니다.

apt, 16 11 바이트

¡V«´V+ÂX}'.

온라인으로 테스트하십시오! 입력 번호는 1 인덱스입니다.

내 JavaScript 답변을 기반으로합니다. 이는 Japt의 가장 유용한 기능 중 하나를 활용합니다. 각 항목을 매핑하기 전에 한 문자열을 다른 문자열로 분할 한 다음 매핑 후 해당 문자열을 다시 결합합니다.

언 골프와 설명

¡  V«  ´ V+Â X}'.
Um@V&&!--V+~~X}'.
                   Implicit: U = input string, V = input number
Um@           }'.  Split U at periods, then map each item X by this function:
   V&&               If V is 0, return V.
      !--V+~~X       Otherwise, decrement V and return X + !V (increments X iff V was 1).
               '.  Re-join the result with periods.
                   Implicit: output last expression

Vim 20 25 바이트

불행히도 마지막 숫자를 업데이트하는 경우를 처리하지 못 했으므로 바이트를 추가해야했습니다. 이것은 1 인덱스입니다.

DJA.0@"t.qq2wcw0@qq@qx

TryItOnline

인쇄 할 수없는 항목 :

DJA.^[0@"t.^Aqq2wcw0^[@qq@qx

이것은 별도의 라인으로 인수를 역순으로 취합니다.

3
1.2.3.4.5

설명:

DJ                           # Delete the input argument, and join lines
  A.^[0                      # Add a period to the end
       @"t.                  # Move to the "Copy register"th period
           ^A                # Increment the number under the cursor
             qq       @qq@q  # Until an error
               2w            # Move the cursor forward to the next number
                 cw0^[       # Change the number to 0
                           x # Delete the last '.'

자바 스크립트 (ES6), 44 42 40 37 바이트

@Neil 덕분에 3 바이트 절약

x=>i=>x.replace(/\d+/g,n=>i&&+n+!--i)

입력 번호는 1 인덱스입니다.

테스트 스 니펫

f = x=>i=>x.replace(/\d+/g,n=>i&&+n+!--i)

console.log(f("1.0.3")(1))
console.log(f("1.2.3.4.5")(3))
console.log(f("10.0")(1))
console.log(f("1")(8))

V , 13 , 12 바이트

Àñf.ñò2wcw0

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

이것은 0 인덱스입니다.

거기에 ctrl-a(ASCII 0x01)이 있으므로 읽을 수있는 버전이 있습니다.

Àñf.ñ<C-a>ò2wcw0

설명:

À                   " 'arg1' times
 ñ  ñ               " Repeat the following:
  f.                "   Move to the next '.' character
     <C-a>          " Increment the next number
          ò         " Recursively:
           2w       "   Move two words forward
              cw    "   Change this word
                0   "   to a '0'

펄, 40 37 34 + 1 = 35 바이트

@Dada 덕분에 -2 바이트. @ETHproductions의 Japt 코드를 읽은 아이디어 덕분에 -3 바이트.

-p플래그로 실행하십시오 .

$a=<>;s/\d+/$a--<0?0:$&+!($a+1)/ge

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

코드 분석

-p          #Wraps the program in a while(<>){ ... print$_} statement.
            #Input is read into the $_ variable
$a=<>;s/\d+/$a--<0?0:$&+!($a+1)/ge
$a=<>;                              #Reads the version update into $a
      s/   /                   /ge  #Substitution regex:
                                g   #Repeats the substitution after first match
                                 e  #Interprets replacement as Perl code
       \d+                          #Matches 1 or more digits, and stores match in $&
                  ? :               #Ternary operation
            $a--<0                  #Checks if $a is negative and then decrements $a
                  ?0                #If negative, we've passed our match; print 0 instead
                    :$&+!($a+1)     #Otherwise, we're either printing $& + 0 (if $a was positive) or $& + 1 (if $a was 0).
#Since substitution implicitly modifies $_, and -p prints $_, it prints our answer

젤리 , 19 17 바이트

ṣ”.V€‘⁹¦µJ’<⁹×j”.

1- 색인.

TryItOnline!

어떻게?

ṣ”.V€‘⁹¦µJ’<⁹×j”. - Main link: currentVersion, theIndex
ṣ”.               - ṣplit left (currentVersion) at occurences of '.'
   V€             - eVal €ach (creates a list of integers)
      ⁹           - right argument (theIndex)
       ¦          - apply to given index(es)
     ‘            -    increment
        µ         - monadic chain separation (call the above result z)
         J        - range(length(z))  i.e. ([1,2,3,...,length])
          ’       - decrement         i.e. ([0,1,2,...,length-1])
            ⁹     - right argument (theIndex)
           <      - less than?        i.e. ([1,1,...,(1 at theIndex),0...,0,0,0]
             ×    - multiply by z (vectortises) - zeros out all of z after theIndex
              j”. - join with '.'

MATLAB, 85 바이트

function f(s,j);a=split(s,'.');a(j)=string(double(a(j))+1);a(j+1:end)='0';join(a,'.')

하나의 기초, 그리고 첫 번째 골프 시도!

C # 116104 바이트

using System.Linq;(v,i)=>string.Join(".",v.Split('.').Select(int.Parse).Select((x,n)=>n==i?x+1:n>i?0:x));

설명

using System.Linq;(v,i)=>   //Anonymous function and mandatory using
    string.Join(".",                    //Recreate the version string with the new values
        v.Split('.')                    //Get individual pieces
            .Select(int.Parse)          //Convert to integers
                .Select(            
                    (x,n)=>             //Lambda with x being the part of the version and n being the index in the collection
                        n==i                    
                            ?x+1        //If n is the index to update increment x
                            :n>i        //Else if n is greater than index to update
                                ?0      //Set to zero
                                :x));   //Otherwise return x

여기 사용해보십시오

파이썬 2, 84 바이트

나는 이것이 실제로 더 짧을 수 있다고 생각한다. 열거되지 않은 옵션을 갖는 방법이 필요할 수있다.

lambda s,n:'.'.join(str([-~int(x)*(i==n),x][i<n])for i,x in enumerate(s.split('.')))

버전을 문자열 목록으로 사용할 수 있다면 75 바이트 솔루션이 있습니다.

g=lambda s,n:(str(-~int(s[0]))+'.0'*~-len(s))*(n<1)or s[0]+'.'+g(s[1:],n-1)

또한 입력과 출력이 모두 숫자 목록 인 경우 64 바이트 솔루션이 있습니다.

g=lambda s,n:([-~s[0]]+[0]*~-len(s))*(n<1)or [s[0]]+g(s[1:],n-1)

V 14 20 바이트

다시 말하지만, 최종 숫자를 증가시키는 코너 케이스 코드를 추가해야했습니다. (1 인덱스)

DJA.0@"t.ò2wcw0òx

TryItOnline

인쇄 할 수없는 항목 :

DJA.^[0@"t.^Aò2wcw0^[òx

이것은 별도의 라인으로 인수를 역순으로 취합니다.

3
1.2.3.4.5

배치, 119 바이트

@set s=%1
@set i=%2
@set t=
@for %%i in (%s:.=,%)do @set/an=!!i*(%%i+!(i-=!!i))&call set t=%%t%%.%%n%%
@echo %t:~1%

1- 색인.

Perl 6, 67 바이트, 0 인덱스

->$v,$i {$v.split('.').map({++$>$i??($++??0!!$_+1)!!$_}).join: '.'}

설명:

->$v,$i {$v.split('.').map({++$>$i??($++??0!!$_+1)!!$_}).join: '.'}
->$v,$i {                                                         } # function taking version/index to increment
         $v.split('.')                                              # split by dot
                      .map({                          })            # for each version number
                            ++$>$i??                                # if an anonymous variable ($), incremented,
                                                                    #  is greater than $i (index to increment)
                                    ($++??       )                  # if it's not the first time we've been over $i
                                                                    # (using another anonymous value, which gets default-init'd to 0)
                                          0                         # then 0 (reset lower version numbers)
                                           !!$_+1                   # otherwise, increment the number at $i
                                                  !!$_              # otherwise return the number part
                                                        .join: '.'  # join with a dot

PowerShell 3 이상, 75 74 바이트

($args[0]-split'\.'|%{$m=!$b;$b=$b-or$args[1]-eq$i++;(+$b+$_)*$m})-join'.'

언 골프

(
    $args[0] -split '\.' | 
        ForEach-Object -Process {
            $m= -not $b
            $b = $b -or ($args[1] -eq $i++)
            (([int]$b) + $_) * $m
        }
) -join '.'

설명

$args배열을 사용하여 매개 변수를 승인합니다 .

1. 버전 문자열을에 분할 한 .다음 각 요소에 대해 분할하십시오 .
   1. $m로 설정되어 있습니다 -not $b. 첫 실행시 $b정의되지 않은 정의 $false되어 $m로 시작됩니다 $true. $m항상 0또는 1나중에 사용되는 승수입니다 . $m마지막 반복 $b값을 기반으로하기 때문에 여기서 평가해야합니다 .
   2. $b-or이터레이터 $i를 $args[1](index 매개 변수) 와 비교 한 결과 자체로 설정됩니다 . 이것은 증가시킬 요소에 도달 $b하면 $true여기 로 설정 됨을 의미 합니다. 또한 $true조건부 -or값이 현재 값으로 지정 되므로 이후의 모든 반복에서 발생 합니다.
   3. $b은 단항 +( $false=> 0, $true=> 1)을 사용하여 숫자로 변환 된 다음 현재 버전 요소 $_인에 추가 [string]되지만 PowerShell은 항상 오른쪽의 인수를 왼쪽의 유형에 통합하려고하므로 산술이 수행됩니다. 문자열 연결이 아닙니다. 그런 다음이 값에을 곱하면 $m여전히 [bool]묵시적으로 통합됩니다.
2. 을 사용하여 결과 배열을 다시 결합하십시오 ..

그래서, 첫 번째 반복 $b하게는 $true, $b했을 $false때 $m하고, 평가 $m동일한 $true에서 승수를 유지할 것이다, 1.

그 실행 중에 $b하게 $true상기 버전 요소 (AS에 추가 1하여이를 증가) 곱셈기가 여전히 있으므로, 및 1, 그 최종 결과가 될 것이다.

다음 반복에 그래서, $b이미 것 $true, 만드는 $m동일한 $false승수를 만들 것이다, 0. 이제 $b영원히있을 것이기 때문에 $true승수는 항상 0이므로 반환 된 모든 요소 0도 마찬가지입니다.

R, 100 95 92 86 바이트

일반적으로 R의 경우 0 인덱싱을 사용합니다. 두 개의 인수 (문자열과 정수)를 가진 익명 함수 아마 약간 아래로 골프를 칠 수 있습니다.

function(v,i)cat((x=scan(t=el(strsplit(v,"\\."))))+c(rep(0,i),1,-x[-(0:i+1)]),sep=".")

05AB1E , 22 바이트

'.¡vy²N‹i0*}²NQi>})'.ý

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

05AB1E에서 if-else를 수행하는 방법을 모르겠으므로 이보다 오래 걸립니다.

커피 스크립트 : 77 67 바이트

f=(p,i)->((z<i&&v||z==i&&~~v+1||0)for v,z in p.split '.').join '.'

우와! 베타 출시를위한 케이크와 커피를위한 시간.

@ven과 @Cyoce 덕분에 10 바이트를 깎았습니다!

파이썬 3, 89 86 바이트

lambda v,c:'.'.join((str((int(x)+1)*(i==c)),x)[i<c]for i,x in enumerate(v.split('.')))

일을 끝내는 매우 순진한 방법

편집 : @kade를 참조하여 조건부를 다시 작성하십시오.

PHP, 81 바이트

엄청나게 길다. 적어도 : Elephpant는 여전히 Python보다 뛰어납니다.

foreach(explode(".",$argv[1])as$i=>$v)echo"."[!$i],($i<=$n=$argv[2])*$v+($i==$n);

첫 번째 인수를 점으로 분할하여 반복합니다. 첫 번째 인수 "."[!$i]는 비어 있고 다른 모든 요소는 도트입니다. ($i<=$n)그리고 ($i==$n)암시 적으로 정수로 캐스팅되는 0또는 1정수를 arithmetics을 위해.

자바 스크립트 (ES6), 57 55 바이트

(s,x)=>s.split`.`.map((j,i)=>i==x?+j+1:i>x?0:j).join`.`

예 :

n=(s,x)=>s.split`.`.map((j,i)=>i==x?+j+1:i>x?0:j).join`.`

console.log(n('1.0.3', 0))
console.log(n('1.2.3.4.5', 2))
console.log(n('10.0', 0))
console.log(n('3', 0))
console.log(n('1', 7))

최고의 JS 구현은 아니지만 상당히 간단하며 예상되는 논리를 따릅니다.

Pyth-21 바이트

j\.++<Kcz\.Qhs@KQmZ>K

테스트 스위트

파워 쉘, 80 100 95 92 바이트

에 대한 const를 사용하여 5 바이트를 절약했습니다. -1..if

!$b대신 에 사용하여 3 바이트 절약$b-eq0

filter x($a,$b){[int[]]$y=$a.Split('.');-1..((-$b,-1)[!$b])|%{$y[$_]=0};$y[$b]++;$y-join'.'}

설명:

filter x($a,$b){
    [int[]]$y=$a.Split('.') #Split input into integer array
    $y[$b]++ #Increment 'major' version no. ($b) by one
    -1..((-$b,-1)[!$b])|%{$y[$_]=0} #Set all trailing numbers to 0, now also checks for $b=0 cases.
    $y-join'.' #Join back into '.' seperated Array
}

테스트 사례 :

x "1.0.3" 0
x "1.2.3.4.5" 2
x "10.0" 0
x "1" 7
2.0.0
1.2.4.0.0
11.0
Index was outside the bounds of the array.

Objective-C 531 바이트

#import<Foundation/Foundation.h>
int main(int argc,const char *argv[]){@autoreleasepool{NSString *s=[NSString stringWithUTF8String:argv[1]];NSInteger n=strtol(argv[2],NULL,0);NSArray *c=[s componentsSeparatedByString:@"."];if(c.count<=n)NSLog(@"ERROR");else{int i=0;NSMutableString *v=[[NSMutableString alloc]init];for(;i<n;++i)[v appendFormat:@"%@.",[c objectAtIndex:i]];[v appendFormat:@"%li", strtol(((NSString *)[c objectAtIndex:i++]).UTF8String,NULL,0)+1l];for(;i<c.count;++i)[v appendString:@".0"];NSLog(@"%@",v);}}return 0;}

엮다:

clang -fobjc-arc -Os main.m -o main

용법:

./main 1.2.3 1

자바 스크립트 ES6 : 60 바이트

n.split(".").map((n,r)=>{return r>i?n=0:n}).join("."),n[i]++}

R, 75 바이트

f=function(a,b){n=scan(t=a,se=".");m=-n;m[b]=1;m[1:b-1]=0;cat(n+m,sep=".")}

인덱싱은 1 기반입니다. 여기서 온라인으로 게임을 즐길 수 있습니다 .

APL (Dyalog) , 31 바이트

많은 시스템에서 기본값 인 ⎕IO←0( I ndex O rigin 0)이 필요 합니다. 전체 프로그램 본문; 텍스트 입력 (버전)과 숫자 입력 (인덱스)을 묻는 메시지가 나타납니다.

' '⎕R'.'⍕⎕(⊢∘≢↑↑,1+⊃)⊃⌽'.'⎕VFI⍞

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

⍞ 텍스트 입력을위한 프롬프트

'.'⎕VFI V의 erify 및 F는 IX I를 필드 구분자로 사용 nput 기간 (필드 'validities 필드'값)

⌽ 반대 (값을 앞에두기 위해)

⊃ 첫 번째 (값)를 선택하십시오

⎕(... ) 평가 된 입력을 왼쪽 인수로 사용하여 다음 암묵적 인 기능을 적용하십시오.

_{각 함수 응용 프로그램의 비 암묵적인 동등성을 설명하기 위해 이제 ⍺왼쪽 인수 (인덱스) ⍵를 표시하고 오른쪽 인수 (원래 입력 된 현재 버전 번호의 개별 숫자 목록 ) 를 나타내는 데 사용합니다.}

 ⊃요소를 선택하는  데 (⍺⊃⍵) 사용 ⍺하는 것과 동등 ⍵

 1+ 그것에 하나를 추가 

 ↑,에서 가져온 숫자 (⍺↑⍵), 앞에  해당 ⍺⍵

 ⊢∘≢↑ 에 해당  (⍺⊢∘≢⍵)↑ 상응하는  (≢⍵)↑ 요소가 있기 때문에 그 많은 숫자로 받아 ⍵필요한 경우에 제로 패딩,

⍕ 형식 (각 숫자 사이에 공백이 하나씩 있음)

' '⎕R'.' PCRE R의 주기와 공간 eplace

자바 8, 130 바이트

s->n->{String r="",a[]=s.split("\\.");for(int l=a.length,i=-1;++i<l;)r+=(i>n?0:new Long(a[i])+(i<n?0:1))+(i<l-1?".":"");return r;}

설명:

여기에서 시도하십시오.

s->n->{                 // Method with String and Integer parameters and String return-type
  String r="",          //  Result-String
  a[]=s.split("\\.");   //  String-array split by the dots
  for(int l=a.length,   //  Length of the array
      i=-1;++i<l;)      //  Loop from 0 to `l` (exclusive)
    r+=                 //   Append the result-String with:
       (i>n?            //    If index `i` is beyond input `n`:
        0               //     Append a zero
       :                //    Else:
        new Long(a[i])  //     Convert the current String to a number
        +(i<n?          //     If index `i` is before input `n`
           0            //      Leave the number the same by adding 0
          :             //     Else:
           1))          //      Add 1 to raise the version at index `n`
       +(i<l-1?         //    If we've haven't reached the last iteration yet:
          "."           //     Append a dot
         :              //    Else:
          ""            //     Append nothing
   );                   //  End of loop
   return r;            //  Return the result-String
}                       // End of method

LiveScript, 53 52 바이트

->(for e,i in it/\.
 [+e+1;0;e][(i>&1)+2*(i<&1)])*\.

@ASCII 전용 덕분에 -1 바이트!

이전 설명 :

(a,b)->x=a/\.;x[b]++;(x[to b] ++ [0]*(x.length-1-b))*\.
(a,b)->                                                 # a function taking a and b (version and index)
       x=a/\.;                                          # split a on dot, store in x
              x[b]++;                                   # increment at the given index
                     (x[to b]                           # slice be from 0 to the index
                              ++                        # concat (both spaces are necessary so it's not interpreted as an increment operator
                                 [0]*(x.length-1-b))    # with enough zeros to fill the array back to its original size (x's size)
                                                    *\. # join on dot

또 다른 자기 대답 ... 어쨌든 LiveScript에서 골프를 치는 사람은 아닙니다. :피

다른 버전으로 작업 중이었습니다.

(a,b)->(a/\.=>..[b]++;..[b to *]=0)*\.

그러나 *스 플라이 싱 인덱스에서 인식하기에는 너무 오버로드 =0되어 액세스하려고합니다 0[0]. 그래서 당신은 같은 것을 쓸 필요가 ..[b to ..length- b]=[0]*(..length-1-b)있으며 결국 더 깁니다.

하스켈 , 136 129 바이트

import Data.List.Split
import Data.List
f s n|(x,z:y)<-splitAt n(splitOn "."s)=intercalate "."(x++[show$read z+1]++map(\_->"0")y)

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

기발한