作为代码高尔夫球手，我们不习惯发布（当然是）。我们将需要一些工具来帮助我们做到这一点。

当然，为了帮助营销一个新版本，我们需要一个漂亮而闪亮的发行版本。谁对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*)*$

错误情况（最后两个示例）是未定义的行为。在输入错误的情况下发生的情况与此挑战无关。

像往常一样，禁止出现标准漏洞。您可以打印或返回字符串。

Japt，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

在线试用

无法打印的内容：

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

JavaScript（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'

Perl，40 37 34 +1 = 35字节

-2个字节感谢@Dada。-3个字节，这归功于我从阅读@ETHproductions的Japt代码中得到的想法。

与-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

在这里尝试

Python 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

在线试用

无法打印的内容：

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将是undefined，它将合并为$false，因此$m将以开头$true。$m旨在成为始终为0或的乘数，1并将在以后使用。$m必须在此处进行评估，因为我们希望它基于上一次迭代的$b值。
   2. $b将自身与（索引参数）-or的迭代器进行比较的结果设置为自身。这意味着一旦我们要增加的元素将被设置为此处。此外，它将存在于每个后续迭代中，因为条件是$i$args[1]$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并将其添加到version元素（如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 '.'

！Beta版发布蛋糕和咖啡的时间。

感谢@ven和@Cyoce，我剃了10个字节！

Python 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整数运算。

JavaScript（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

测试套件

Powershell，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

Javascript 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 我 NPUT使用期间作为字段分隔符（字段效度，字段的值）

⌽ 反向（将值放在前面）

⊃ 选择第一个（值）

⎕(... ) 使用评估的输入作为左参数，对它应用以下默认函数：

_{为了解释每个函数应用程序的非默认等效项，我们现在将使用它⍺来指示左参数（索引）并⍵指示右参数（原始输入的当前版本号的各个数字的列表）。}

 ⊃ 相当于  (⍺⊃⍵) 使用⍺来接从一个元件⍵

 1+ 加一个 

 ↑, 相当于  (⍺↑⍵), 前面加上⍺取自号码⍵

 ⊢∘≢↑ 等价于  (⍺⊢∘≢⍵)↑ 从中  (≢⍵)↑ 取尽可能多的数字⍵必要时用零填充

⍕ 格式（每个数字之间用一个空格串起来）

' '⎕R'.' PCRE ř E放置空间与周期

Java 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)])*\.

-1字节感谢@ ASCII-only！

旧说明：

(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。：P

我正在制作另一个版本：

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

但是*在拼接索引中却无法识别，因此=0将尝试访问0[0]。因此，您需要编写类似的内容..[b to ..length- b]=[0]*(..length-1-b)，最终它会更长。

Haskell中，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)

在线尝试！

原版的