En tant que golfeurs de code, nous ne sommes pas habitués à libérer ( sûrement ). Nous aurons besoin de quelques outils pour nous aider à le faire.

Bien entendu, pour aider à la commercialisation d'une nouvelle version, nous avons besoin d'une version agréable et brillante. Qui ne s'énerve pas quand ils entendent parler de la version 3.0.0?

Tâche

Votre tâche sera d'écrire un programme / routine / ... pour incrémenter un numéro de version.

Vous devez incrémenter le numéro de version et réinitialiser les versions "moins importantes" (c.-à-d. La version du correctif).

Vous obtenez deux arguments: la version actuelle (ex "1.0.3") sous forme de chaîne et un index pour savoir lequel mettre à jour (0 ou 1-indexé).

Exemple, indexé 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

La version est une chaîne, chaque partie est un nombre, séparé par un point. Il ne peut y avoir aucun point d’avant, aucun point de fuite ou aucun point consécutif (et rien en dehors des nombres / points). Il n'y a pas de limite à la taille de la chaîne de version.

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

Le cas d'erreur (les deux derniers exemples) est un comportement indéfini. Que se passe-t-il en cas de mauvaise saisie n’a aucune pertinence pour ce défi?

Comme d'habitude, les échappatoires standard sont interdites. Vous êtes autorisé à imprimer ou à retourner la chaîne.

Japt, 16 à 11 octets

¡V«´V+ÂX}'.

Testez-le en ligne! Le numéro d'entrée est 1 indexé.

Basé sur ma réponse JavaScript. Cela tire parti de l’une des fonctionnalités les plus utiles de Japt: fractionner une chaîne en une autre avant de mapper chaque élément, puis rejoindre cette chaîne après le mappage.

Ungolfed et explication

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

J'ai malheureusement réalisé que cela ne traitait pas le cas de la mise à jour du dernier numéro. J'ai donc dû ajouter des octets. Ceci est 1 indexé.

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

TryItOnline

Non imprimables:

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

Cela prend les arguments dans l'ordre inverse, sous forme de lignes séparées:

3
1.2.3.4.5

Explication:

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 octets

3 octets sauvés grâce à @Neil

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

Le numéro d'entrée est 1 indexé.

Extrait de test

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 octets

Àñf.ñò2wcw0

Essayez-le en ligne!

Ceci est 0 indexé.

Il y a un ctrl-afichier (ASCII 0x01), donc voici une version lisible:

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

Explication:

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

-2 octets grâce à @Dada. -3 octets grâce à une idée que j'ai lue en lisant le code Japt de @ ETHproductions.

Courez avec le -pdrapeau.

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

Essayez-le en ligne!

Ventilation du code

-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ée , 19 17 octets

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

1 indexé.

TryItOnline!

Comment?

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

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

Une base et une première tentative de golf!

C # 116 104 octets

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

Explication

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

Essayez-le ici

Python 2, 84 octets

Je pense que cela pourrait vraiment être plus court. Il faudrait peut-être un moyen d’avoir une option non énumérative.

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

Si nous pouvions prendre la version sous forme de liste de chaînes, il existe une solution de 75 octets:

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

De plus, si l'entrée et la sortie étaient toutes deux des listes de nombres, il existe une solution à 64 octets:

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

V 14 20 octets

Encore une fois, je devais ajouter du code pour le cas de l'incrémentation du dernier chiffre. (1 indexé)

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

TryItOnline

Non imprimables:

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

Cela prend les arguments dans l'ordre inverse, sous forme de lignes séparées:

3
1.2.3.4.5

Lot, 119 octets

@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 indexé.

Perl 6, 67 octets, indexé par 0

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

Explication:

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

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

Explication

Les paramètres sont acceptés à l'aide du $argstableau.

1. Fractionner la chaîne de version sur ., puis pour chaque élément:
   1. $mest prêt à être -not $b. Au premier passage, $bsera indéfini sur lequel sera fusionné $false, donc $mcommencera comme $true. $mest destiné à être un multiplicateur qui est toujours 0ou 1et il sera utilisé plus tard. $mdoit être évalué ici parce que nous voulons qu'il soit basé sur la $bvaleur de la dernière itération .
   2. $best réglé sur lui -or- même le résultat de la comparaison d'un itérateur $iavec $args[1](le paramètre index). Cela signifie que cette option $bsera définie $trueici une fois que nous aurons défini l'élément à incrémenter. En outre, il le sera $trueà chaque itération ultérieure car le conditionnel est -or'd avec sa valeur actuelle.
   3. $best converti en un nombre à l’aide de unary +( $false=> 0, $true=> 1), puis ajouté à l’élément de la version actuelle $_qui est un [string], mais PowerShell essaie toujours de fusionner l’argument situé à droite du type à gauche; pas de concaténation de chaînes. Ensuite, cette valeur sera multipliée par $m, ce qui est toujours, [bool]mais sera implicitement fusionnée.
2. Re-rejoindre le tableau résultant avec ..

Donc, la première itération où $bdevient $true, $baurait été $falsequand a $mété évaluée, rendant $mégal $true, ce qui maintiendra le multiplicateur à 1.

Au cours de cette course $bdevient $trueet est ajouté à l'élément de version (comme 1), incrémenter ainsi, et puisque le multiplicateur est encore1 , ce sera le résultat final.

Donc, à la prochaine itération, $bsera déjà $true, rendant $mégal $false, ce qui fera le multiplicateur 0. Depuis $btoujours $true, le multiplicateur sera toujours 0, de sorte que chaque élément retourné le sera 0aussi.

R, 100 95 92 86 octets

Exceptionnellement pour R, cela utilise l'indexation 0. Fonction anonyme avec deux arguments (une chaîne et un entier). Probablement peut être joué au golf un peu.

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

05AB1E , 22 octets

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

Essayez-le en ligne!

Je ne sais pas comment faire si-sinon dans 05AB1E, donc c'est plus long que cela ne devrait être.

Café-script: 77 67 octets

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

Woot! Temps pour le gâteau et le café pour la version bêta.

Grâce à @ven et @Cyoce, j'ai rasé 10 octets!

Python 3, 89 86 octets

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

manière très naïve de faire avancer les choses

Edit: réécrit le conditionnel en faisant référence à @kade

PHP, 81 octets

terriblement long. Au moins: l'Elephpant bat toujours le Python.

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

boucle le premier argument divisé par des points: "."[!$i]est vide pour le premier et un point pour chaque autre élément; ($i<=$n)et ($i==$n)sont implicitement convertis en entier0 ou en 1arithmétiques entiers.

JavaScript (ES6), 57 55 octets

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

Exemples:

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

Ce n'est pas la meilleure implémentation de JS, mais elle est assez simple et suit la logique à laquelle vous vous attendez.

Pyth - 21 octets

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

Suite de tests

Powershell, 80 100 95 92 octets

5 octets enregistrés en utilisant un const pour le -1..if

3 octets sauvegardés en utilisant !$bau lieu de$b-eq0

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

Explication:

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
}

Cas de test:

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 octets

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

compiler:

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

usage:

./main 1.2.3 1

Javascript ES6: 60 octets

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

R, 75 octets

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

L'indexation est basée sur 1. Vous pouvez jouer avec en ligne ici .

APL (Dyalog) , 31 octets

Nécessite ⎕IO←0( I ndex O rigin 0), qui est utilisé par défaut sur de nombreux systèmes. Corps du programme complet; invite à saisir du texte (version), puis une entrée numérique (index).

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

Essayez-le en ligne!

⍞ invite pour la saisie de texte

'.'⎕VFI V erifier et F ix I nput utilisant période comme séparateur de champ (par les validités, les champs de champs de valeurs)

⌽ reverse (pour mettre les valeurs devant)

⊃ choisir le premier (les valeurs)

⎕(...)  applique la fonction tacite suivante à celle-ci, en utilisant l'entrée évaluée comme argument de gauche:

_{Pour expliquer les équivalents non tacites de chaque application de fonction, nous allons maintenant utiliser ⍺pour indiquer l’argument de gauche (l’index) et ⍵pour indiquer l’argument de droite (la liste des numéros individuels du numéro de version actuel initialement saisi).}

 ⊃ équivalent à  (⍺⊃⍵) utiliser ⍺pour choisir un élément de⍵

 1+ ajouter un à cela 

 ↑, équivalent à  (⍺↑⍵), pré-compter des ⍺numéros pris de⍵

 ⊢∘≢↑ équivalent à  (⍺⊢∘≢⍵)↑ équivalent à  (≢⍵)↑ prendre autant de nombres de cela qu'il y a des éléments dans⍵ , rembourrage avec des zéros si nécessaire

⍕ format (chaîne avec un espace entre chaque nombre)

' '⎕R'.' PCRE R espaces avec des périodes EPlacez

Java 8, 130 octets

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

Explication:

Essayez ici.

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 octets

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

-1 octet grâce à @ ASCII uniquement!

Ancienne Explication:

(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

Une autre réponse automatique ... Pas que quiconque golfe dans LiveScript de toute façon. : P

Je travaillais sur une autre version:

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

Mais *est trop surchargé pour être reconnu dans un index d'épissage, =0tentera donc d'accéder 0[0]. Donc, vous devez écrire quelque chose comme ..[b to ..length- b]=[0]*(..length-1-b)et c'est plus long à la fin.

Haskell , 136 129 octets

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)

Essayez-le en ligne!

Original