Como jogadores de código, não estamos acostumados a liberar (com certeza ). Vamos precisar de algumas ferramentas para nos ajudar a fazer isso.

Obviamente, para ajudar a comercializar um novo lançamento, precisamos de uma Versão de Lançamento agradável e brilhante. Quem não fica empolgado ao saber da versão 3.0.0?

Tarefa

Sua tarefa será escrever um programa / rotina / ... para incrementar um número de versão.

Você precisa incrementar o número da versão e redefinir os "menos importantes" (por exemplo, versão do patch).

Você obtém dois argumentos: a versão atual (ex "1.0.3") como uma string e um índice para saber qual atualizar (indexado 0 ou 1).

Exemplo, indexado em 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

A versão é uma string, cada parte é um número, separado por um ponto. Não pode haver pontos iniciais, finais ou consecutivos (e nada fora dos números / pontos). Não há limite para o tamanho da string de versão.

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

O caso de erro (dois últimos exemplos) é um comportamento indefinido. O que acontece em caso de insumos errados não tem relevância para esse desafio.

Como de costume, são proibidas brechas padrão. Você tem permissão para imprimir ou retornar a sequência.

Japonês, 16 11 bytes

¡V«´V+ÂX}'.

Teste online! O número da entrada é 1 indexado.

Com base na minha resposta JavaScript. Isso tira proveito de um dos recursos mais úteis de Japt: dividir uma sequência de caracteres em outra antes de mapear cada item e, em seguida, ingressar nessa sequência novamente após o mapeamento.

Ungolfed e explicação

¡  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 bytes

Infelizmente, percebi que não tratava do caso de atualizar o último número, então tive que adicionar bytes. Isso é indexado em 1.

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

TryItOnline

Não imprimíveis:

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

Isso leva os argumentos na ordem inversa, como linhas separadas:

3
1.2.3.4.5

Explicação:

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 bytes

Guardado 3 bytes graças a @Neil

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

O número da entrada é 1 indexado.

Snippet de teste

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 bytes

Àñf.ñò2wcw0

Experimente online!

Este é o índice 0.

Há um ctrl-a(ASCII 0x01) lá, então aqui está uma versão legível:

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

Explicação:

À                   " '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 bytes

-2 bytes graças a @Dada. -3 bytes graças a uma idéia que tive ao ler o código Japt da @ ETHproductions.

Corra com a -pbandeira.

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

Experimente online!

Repartição do código

-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

Geléia , 19 17 bytes

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

1 indexado.

TryItOnline!

Quão?

ṣ”.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 bytes

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

Um baseado, e primeira tentativa de golfe!

C # 116 104 bytes

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

Explicação

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

Experimente aqui

Python 2, 84 bytes

Eu sinto que isso poderia ser realmente mais curto. Pode ser necessário ter uma opção não enumerada.

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

Se pudéssemos usar a versão como uma lista de strings, há uma solução de 75 bytes:

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

Além disso, se a entrada e a saída eram listas de números, há uma solução de 64 bytes:

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

V 14 20 bytes

Novamente, eu tive que adicionar código para a caixa de canto para aumentar o dígito final. (Indexado 1)

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

TryItOnline

Não imprimíveis:

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

Isso leva os argumentos na ordem inversa, como linhas separadas:

3
1.2.3.4.5

Lote, 119 bytes

@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 indexado.

Perl 6, 67 bytes, indexado em 0

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

Explicação:

->$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 ou mais, 75 74 bytes

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

Ungolfed

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

Explicação

Os parâmetros são aceitos usando o $args matriz.

1. Divida a sequência da versão em . , seguida, para cada elemento:
   1. $mestá definido para ser -not $b. Na primeira corrida, $bserá indefinido o que será coalescido e $false, assim $m, começará como $true. $mpretende ser um multiplicador que é sempre 0ou 1será usado mais tarde.$mdeve ser avaliado aqui porque queremos que seja baseado no valor da última iteração $b.
   2. $bé definido como -oro resultado da comparação de um iterador $icom $args[1](o parâmetro index). Isso significa $bque será definido $trueaqui quando estivermos no elemento a ser incrementado. Além disso, ele estará $trueem todas as iterações subsequentes porque o condicional é -or'd com seu valor atual.
   3. $bé convertido em um número usando unário +( $false=> 0, $true=> 1) e, em seguida, adicionado ao elemento de versão atual $_que é a [string], mas o PowerShell sempre tenta unir o argumento da direita ao tipo da esquerda, para que a aritmética seja executada, não concatenação de cadeias. Então esse valor será multiplicado por $m, que ainda é, [bool]mas será implicitamente coalescido.
2. Junte novamente a matriz resultante com ..

Portanto, a primeira iteração onde $bse torna $true, $bteria sido $falsequando $mfoi avaliada, tornando $migual$true , o que manterá o multiplicador em 1.

Durante essa execução, $btorna-se$true - e é adicionado ao elemento de versão (as 1), incrementando-o e, como o multiplicador ainda é 1, esse será o resultado final.

Então, na próxima iteração, $bjá estará $true, tornando-se $migual $false, o que tornará o multiplicador 0. Como $bsempre será $trueagora, o multiplicador sempre será 0, então todos os elementos retornados também serão 0.

R, 100 95 92 86 bytes

Invulgarmente para R, isso usa indexação 0. Função anônima com dois argumentos (uma sequência e um número inteiro). Provavelmente pode ser jogado um pouco.

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

05AB1E , 22 bytes

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

Experimente online!

Eu não sei como fazer se-mais em 05AB1E, então isso é mais longo do que deveria ser.

Script de café: 77 67 bytes

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

Woot! Hora de bolo e café para a versão beta.

Graças a @ven e @Cyoce eu barbeei 10 bytes!

Python 3, 89 86 bytes

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

maneira muito ingênua de fazer as coisas

Editar: reescreveu o condicional consultando @kade

PHP, 81 bytes

terrivelmente longo. Pelo menos: o Elephpant ainda vence o Python.

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

percorre o primeiro argumento dividido por pontos: "."[!$i]está vazio para o primeiro e um ponto para todos os outros elementos; ($i<=$n)e ($i==$n)são implicitamente convertidos em números inteiros 0ou 1aritméticos inteiros.

JavaScript (ES6), 57 55 bytes

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

Exemplos:

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

Não é a melhor implementação de JS, mas é bastante simples e segue a lógica que você esperaria.

Pitão - 21 bytes

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

Suíte de teste

Powershell, 80 100 95 92 Bytes

Salva 5 bytes usando uma const para o -1..if

Salva 3 bytes usando em !$bvez de$b-eq0

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

Explicação:

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
}

Casos de teste:

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 bytes

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

compilar:

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

uso:

./main 1.2.3 1

Javascript ES6: 60 bytes

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

R, 75 bytes

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

A indexação é baseada em 1. Você pode jogar online aqui .

APL (Dyalog) , 31 bytes

Requer ⎕IO←0( I NDEX O Rigin 0), que é padrão em muitos sistemas. Corpo do programa completo; solicita a entrada de texto (versão) e, em seguida, a entrada numérica (índice).

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

Experimente online!

⍞ solicitar entrada de texto

'.'⎕VFI V erify e F ix I ntrada usando período como separador de campo (validades, campos dos campos de valores)

⌽ reverso (para colocar os valores na frente)

⊃ escolha o primeiro (os valores)

⎕(...)  aplique a seguinte função tácita a isso, usando a entrada avaliada como argumento à esquerda:

_{Para explicar os equivalentes não tácitos de cada aplicativo de função, usaremos agora ⍺para indicar o argumento da esquerda (o índice) e ⍵o argumento da direita (a lista de números individuais do número da versão atual originalmente inserida).}

 ⊃ equivalente a  (⍺⊃⍵) usar ⍺para escolher um elemento⍵

 1+ adicione um a isso 

 ↑, equivalente a  (⍺↑⍵), preceder ⍺números retirados de⍵

 ⊢∘≢↑ equivalente a  (⍺⊢∘≢⍵)↑ equivalente para  (≢⍵)↑ tirar o maior número possível de elementos⍵ , preencher com zeros, se necessário

⍕ formato (stringify com um espaço entre cada número)

' '⎕R'.' PCRE R espaços EColoque com períodos

Java 8, 130 bytes

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

Explicação:

Experimente aqui.

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 bytes

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

-1 byte graças a @ ASCII-only!

Explicação antiga:

(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

Outra resposta automática ... Não que alguém jogue no LiveScript de qualquer maneira. : P

Eu estava trabalhando em outra versão:

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

Mas *está sobrecarregado demais para ser reconhecido em um índice de emenda, portanto =0, tentará acessar 0[0]. Então você precisa escrever algo como ..[b to ..length- b]=[0]*(..length-1-b)e é mais longo no final.

Haskell , 136 129 bytes

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)

Experimente online!

Original