Como golfistas de código, no estamos acostumbrados a lanzar ( seguramente ). Necesitaremos algunas herramientas para ayudarnos a hacer eso.

Por supuesto, para ayudar a comercializar un nuevo lanzamiento, necesitamos una versión de lanzamiento agradable y brillante. ¿Quién no se emociona cuando escuchan sobre la versión 3.0.0?

Tarea

Su tarea será escribir un programa / rutina / ... para incrementar un número de versión.

Debe incrementar el número de versión y restablecer los "menos importantes" (es decir, la versión del parche).

Obtiene dos argumentos: la versión actual (por ejemplo, "1.0.3") como una cadena, y un índice para saber cuál actualizar (indexado 0 o 1).

Ejemplo, 0 indexado:

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

La versión es una cadena, cada parte es un número, separado con un punto. No puede haber puntos iniciales, finales o no consecutivos (y nada fuera de números / puntos). No hay límite para el tamaño de la cadena de versión.

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

El caso de error (los dos últimos ejemplos) es un comportamiento indefinido. Lo que sucede en caso de entradas incorrectas no es relevante para este desafío.

Como de costumbre, las lagunas estándar están prohibidas. Se le permite imprimir o devolver la cadena.

Japt, 16 11 bytes

¡V«´V+ÂX}'.

¡Pruébelo en línea! El número de entrada está 1 indexado.

Basado en mi respuesta de JavaScript. Esto aprovecha una de las características más útiles de Japt: dividir una cadena en otra antes de asignar cada elemento, y luego volver a unir esa cadena después de la asignación.

Sin golfos y explicación

¡  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

Empuje 20 25 bytes

Desafortunadamente, me di cuenta de que no manejaba el caso de actualizar el último número, así que tuve que agregar bytes. Esto es 1 indexado.

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

TryItOnline

No imprimibles

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

Esto toma los argumentos en orden inverso, como líneas separadas:

3
1.2.3.4.5

Explicación:

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 gracias a @Neil

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

El número de entrada está 1 indexado.

Fragmento de prueba

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

Pruébalo en línea!

Esto está indexado a 0.

Hay un ctrl-a(ASCII 0x01) allí, así que aquí hay una versión legible:

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

Explicación:

À                   " '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 gracias a @Dada. -3 bytes gracias a una idea que obtuve al leer el código Japt de @ ETHproductions.

Corre con la -pbandera.

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

Pruébalo en línea!

Desglose del 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

Jalea , 19 17 bytes

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

1 indexado.

TryItOnline!

¿Cómo?

ṣ”.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,'.')

¡Uno basado y primer intento de golf!

C # 116104 Bytes

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

Explicación

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

Pruébalo aquí

Python 2, 84 bytes

Siento que esto realmente podría ser más corto. Podría necesitar una forma de tener una opción no enumerada.

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

Si pudiéramos tomar la versión como una lista de cadenas, hay una solución de 75 bytes:

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

Además, si tanto la entrada como la salida eran listas de números, hay una solución 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

Nuevamente, tuve que agregar código para el caso de la esquina de incrementar el dígito final. (1 indexado)

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

TryItOnline

No imprimibles

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

Esto toma los argumentos en orden inverso, como líneas 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 0

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

Explicación:

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

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

Sin golf

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

Explicación

Los parámetros se aceptan utilizando la $argsmatriz.

1. Divida la cadena de versión ., luego para cada elemento:
   1. $mestá configurado para ser -not $b. En la primera ejecución, $bserá indefinido, que se fusionará $false, por $mlo que comenzará como $true. $mestá destinado a ser un multiplicador que siempre es 0o 1y se usará más adelante.$mdebe evaluarse aquí porque queremos que se base en la última iteración$b valor de .
   2. $bse establece en sí mismo -orel resultado de comparar un iterador $icon $args[1](el parámetro de índice). Esto significa $bque se establecerá $trueaquí una vez que estemos en el elemento que se va a incrementar. Además, estará $trueen cada iteración posterior porque el condicional es-or 'd con su valor actual.
   3. $bse convierte en un número usando unario +( $false=> 0, $true=> 1), luego se agrega al elemento de versión actual $_que es un [string], pero PowerShell siempre intenta fusionar el argumento de la derecha con el tipo de la izquierda, por lo que se realizará la aritmética, no concatenación de cadenas. Entonces este valor se multiplicará por $m, que todavía está [bool]pero se unirá implícitamente.
2. Vuelva a unir la matriz resultante con ..

Entonces, la primera iteración donde se $bconvierte $true, $bhabría sido $falsecuando $mse evaluó, haciendo $migual$true , lo que mantendrá el multiplicador en1 .

Durante esa carrera se $bconvierte$true y se agrega al elemento de versión (as 1), incrementándolo, y dado que el multiplicador sigue1 , ese será el resultado final.

Entonces, en la próxima iteración, $bya será $true, haciendo $migual $false, lo que hará que el multiplicador 0. Como $bsiempre será $trueahora, el multiplicador siempre lo será 0, por lo que todos los elementos devueltos también lo serán 0.

R, 100 95 92 86 bytes

Inusualmente para R, esto usa indexación 0. Función anónima con dos argumentos (una cadena y un entero). Probablemente se puede jugar golf un poco.

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>})'.ý

Pruébalo en línea!

No sé cómo hacer if-else en 05AB1E, así que esto es más largo de lo que debería ser.

Escritura de café: 77 67 bytes

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

Woot! Tiempo para pastel y café para la versión beta.

¡Gracias a @ven y @Cyoce me afeité 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('.')))

forma muy ingenua de hacer las cosas

Editar: reescribió el condicional haciendo referencia a @kade

PHP, 81 bytes

terriblemente largo Al menos: el Elephpant todavía supera a Python.

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

recorre el primer argumento dividido por puntos: "."[!$i]está vacío para el primero y un punto para cualquier otro elemento; ($i<=$n)y ($i==$n)se convierten implícitamente en enteros 0o 1para aritmética de enteros.

JavaScript (ES6), 57 55 bytes

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

Ejemplos:

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

No es la mejor implementación de JS, pero es bastante simple y sigue la lógica que esperarías.

Pyth - 21 bytes

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

Banco de pruebas

PowerShell, 80 100 95 92 Bytes

Guardado 5 bytes mediante el uso de una constante para -1..if

Guardado 3 bytes usando en !$blugar de$b-eq0

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

Explicación:

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 prueba:

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.

Objetivo-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=".")}

La indexación se basa en 1. Puedes jugar en línea aquí .

APL (Dyalog) , 31 bytes

Requiere ⎕IO←0( I ndex O rigin 0), que es por defecto en muchos sistemas. Cuerpo completo del programa; solicita entrada de texto (versión) y luego entrada numérica (índice).

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

Pruébalo en línea!

⍞ solicitud de ingreso de texto

'.'⎕VFI V erify y F Ix I nput usando período como separador de campo (validez de campos, valores de campos)

⌽ reversa (para poner los valores al frente)

⊃ elige el primero (los valores)

⎕(... ) aplique la siguiente función tácita a eso, utilizando la entrada evaluada como argumento izquierdo:

_{Para explicar los equivalentes no tácitos de cada aplicación de función, usaremos ahora ⍺para indicar el argumento izquierdo (el índice) y ⍵para indicar el argumento correcto (la lista de números individuales del número de versión actual ingresado originalmente).}

 ⊃ equivalente a  (⍺⊃⍵) utilizar ⍺para elegir un elemento de⍵

 1+ agrega uno a eso 

 ↑, equivalente a  (⍺↑⍵), anteponer ⍺números tomados de⍵

 ⊢∘≢↑ equivalente a  (⍺⊢∘≢⍵)↑ equivalente para  (≢⍵)↑ tomar tantos números de eso como elementos hay en⍵ , rellenando con ceros si es necesario

⍕ formato (stringify con un espacio entre cada número)

' '⎕R'.' PCRE R espacios EColoque con 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;}

Explicación:

Pruébalo aquí

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 gracias a @ ASCII-only!

Vieja explicación:

(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

Otra respuesta propia ... No es que nadie juegue en LiveScript de todos modos. :PAGS

Estaba trabajando en otra versión:

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

Pero *está demasiado sobrecargado para ser reconocido en un índice de empalme, por =0lo que intentará acceder 0[0]. Entonces necesitas escribir algo así ..[b to ..length- b]=[0]*(..length-1-b)y al final es más largo.

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)

Pruébalo en línea!

Original