Als Code-Golfer sind wir es ( sicher ) nicht gewohnt, etwas zu veröffentlichen . Wir brauchen ein paar Tools, die uns dabei helfen.

Um ein neues Release zu vermarkten, benötigen wir natürlich eine schöne und glänzende Release-Version. Wer wird nicht aufgeregt, wenn er von Version 3.0.0 erfährt?

Aufgabe

Ihre Aufgabe wird es sein, ein Programm / eine Routine / ... zu schreiben, um eine Versionsnummer zu erhöhen.

Sie müssen die Versionsnummer erhöhen und die "weniger wichtigen" (dh die Patch-Version) zurücksetzen.

Sie erhalten zwei Argumente: die aktuelle Version (z. B. "1.0.3") als Zeichenfolge und einen Index, um zu wissen, welcher zu aktualisieren ist (0 oder 1-indiziert).

Beispiel 0-indiziert:

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

Die Version ist eine Zeichenfolge, jeder Teil ist eine Zahl, die durch einen Punkt getrennt ist. Es darf keine führenden, keine nachgestellten oder keine aufeinanderfolgenden Punkte geben (und nichts außerhalb von Zahlen / Punkten). Die Größe der Versionszeichenfolge ist unbegrenzt.

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

Der Fehlerfall (die letzten beiden Beispiele) ist undefiniertes Verhalten. Was bei Fehleingaben passiert, ist für diese Herausforderung nicht relevant.

Standardlücken sind wie üblich verboten. Sie dürfen den String ausdrucken oder zurücksenden.

Japt, 16 11 Bytes

¡V«´V+ÂX}'.

Testen Sie es online! Die Eingangsnummer ist 1-indiziert.

Basierend auf meiner JavaScript-Antwort. Dies nutzt eine der hilfreichsten Funktionen von Japt: Aufteilen einer Zeichenfolge auf eine andere, bevor die einzelnen Elemente zugeordnet werden, und erneutes Verknüpfen dieser Zeichenfolge nach der Zuordnung.

Ungolfed und Erklärung

¡  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

Ich bemerkte leider, dass es den Fall der Aktualisierung der letzten Nummer nicht handhabte, also musste ich Bytes hinzufügen. Dies ist 1-indiziert.

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

TryItOnline

Unbedruckbares:

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

Dies nimmt die Argumente in umgekehrter Reihenfolge als separate Zeilen:

3
1.2.3.4.5

Erläuterung:

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 Byte

3 Bytes dank @Neil gespart

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

Die Eingangsnummer ist 1-indiziert.

Testschnipsel

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

Probieren Sie es online!

Dies ist 0-indiziert.

Es gibt dort eine ctrl-a(ASCII 0x01), also hier ist eine lesbare Version:

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

Erläuterung:

À                   " '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 dank @Dada. -3 Bytes dank einer Idee, die ich beim Lesen des Japt-Codes von @ ETHproductions erhalten habe.

Laufen Sie mit der -pFlagge.

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

Probieren Sie es online!

Aufschlüsselung des Codes

-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

Jelly , 19 17 Bytes

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

1-indiziert.

TryItOnline!

Wie?

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

One based und erster Golfversuch!

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

Erläuterung

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

Probieren Sie es hier aus

Python 2, 84 Bytes

Ich habe das Gefühl, dass dies wirklich kürzer sein könnte. Möglicherweise ist eine Möglichkeit erforderlich, eine nicht aufzählbare Option zu haben.

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

Wenn wir die Version als Liste von Zeichenfolgen verwenden könnten, gäbe es eine 75-Byte-Lösung:

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

Wenn sowohl die Eingabe als auch die Ausgabe Listen von Zahlen waren, gibt es außerdem eine 64-Byte-Lösung:

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

V 14 20 Bytes

Wieder musste ich Code für den Eckfall des Inkrementierens der letzten Ziffer hinzufügen. (1-indiziert)

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

TryItOnline

Unbedruckbares:

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

Dies nimmt die Argumente in umgekehrter Reihenfolge als separate Zeilen:

3
1.2.3.4.5

Batch, 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-indiziert.

Perl 6, 67 Bytes, 0-indiziert

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

Erläuterung:

->$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 bis 74 Byte

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

Erläuterung

Parameter werden über das $argsArray akzeptiert .

1. Teilen Sie die Versionszeichenfolge .für jedes Element auf:
   1. $mwird gesetzt, um zu sein -not $b. Beim ersten Durchlauf $bwird undefiniert, woraufhin zusammengeführt wird $falseund so wie $mfolgt gestartet wird $true. $msoll ein Multiplikator sein, der immer 0oder ist 1und später verwendet wird. $mmuss hier ausgewertet werden, da wir wollen, dass es auf dem $bWert der letzten Iteration basiert .
   2. $bwird auf sich selbst gesetzt, -orwenn ein Iterator $imit $args[1](dem Indexparameter) verglichen wird . Dies bedeutet $b, dass hier gesetzt wird, $truesobald wir uns auf dem Element befinden, das inkrementiert werden soll. Darüber hinaus wird es $truein jeder nachfolgenden Iteration verwendet, da die Bedingung -orden aktuellen Wert hat.
   3. $bumgewandelt wird einstellige auf eine Zahl mit +( $false=> 0, $true=> 1), dann auf die aktuelle Version Element hinzugefügt , $_das eine ist [string], aber Powershell immer versucht , das Argument auf der rechten Seite auf den Typ auf der linken Seite zu vereinigen, werden so Arithmetik durchgeführt, keine String-Verkettung. Dann wird dieser Wert mit multipliziert $m, der noch vorhanden ist, [bool]aber implizit verschmolzen wird.
2. Verbinden Sie das resultierende Array erneut mit ..

Die erste Iteration, $bzu der es kommt $true, $bwäre gewesen, $falsewenn sie $mausgewertet worden wäre, wobei sie $mgleich gemacht worden wäre $true, was den Multiplikator aufrechterhalten würde 1.

Während dieses Laufs $bwird $trueund wird das Versionselement (as 1) hinzugefügt , wodurch es inkrementiert wird, und da der Multiplikator noch 1ist, ist dies das Endergebnis.

So bei der nächsten Iteration, $bwird schon sein $true, was $mgleich $false, was den Multiplikator machen 0. Da dies $bfür immer der Fall sein wird $true, wird der Multiplikator immer derselbe sein 0, und jedes zurückgegebene Element wird es 0auch sein.

R 100 95 92 86 Bytes

Ungewöhnlich für R verwendet dies die 0-Indizierung. Anonyme Funktion mit zwei Argumenten (einer Zeichenfolge und einer Ganzzahl). Wahrscheinlich kann ein bisschen Golf gespielt werden.

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

Probieren Sie es online!

Ich weiß nicht, wie ich if-else in 05AB1E machen soll, das ist also länger als es sein sollte.

Kaffeeskript: 77 67 Bytes

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

Woot! Zeit für Kuchen und Kaffee für die Beta-Version.

Dank @ven und @Cyoce habe ich 10 Bytes rasiert!

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

sehr naive Art, Dinge zu erledigen

Bearbeiten: Die Bedingung wurde unter Bezugnahme auf @kade umgeschrieben

PHP, 81 Bytes

furchtbar lang. Zumindest: Der Elefant schlägt immer noch die Python.

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

durchläuft das erste Argument, das durch Punkte geteilt ist: "."[!$i]ist für das erste leer und für jedes andere Element ein Punkt; ($i<=$n)und ($i==$n)werden implizit in Ganzzahl 0oder 1für Ganzzahlarithmetik umgewandelt.

JavaScript (ES6), 57-55 Byte

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

Beispiele:

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

Nicht die beste JS-Implementierung, aber sie ist recht einfach und folgt der erwarteten Logik.

Pyth - 21 Bytes

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

Test Suite

Powershell, 80 100 95 92 Bytes

5 Bytes mit einer Konstante für die gespeichert -1..if

3 Bytes mit !$banstelle von gespeichert$b-eq0

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

Erläuterung:

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
}

Testfälle:

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

kompilieren:

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

Verwendung:

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

Die Indizierung basiert auf 1. Sie können hier online damit spielen .

APL (Dyalog) , 31 Bytes

Benötigt ⎕IO←0( I ndex O rigin 0), was auf vielen Systemen Standard ist. Vollständiger Programmteil; fordert zur Texteingabe (Version) und dann zur numerischen Eingabe (Index) auf.

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

Probieren Sie es online!

⍞ Eingabeaufforderung für Texteingabe

'.'⎕VFI V erify und F ix I nput mit Punkt als Feldtrennzeichen (Feldgültigkeiten, Feldwerte)

⌽ umkehren (um die Werte in den Vordergrund zu stellen)

⊃ wähle den ersten (die Werte)

⎕(... ) wende die folgende implizite Funktion an, wobei die ausgewertete Eingabe als linkes Argument verwendet wird:

_{Um die nicht stillschweigenden Entsprechungen jeder Funktionsanwendung zu erläutern ⍺, geben wir nun das linke Argument (den Index) und ⍵das rechte Argument (die Liste der einzelnen Nummern der ursprünglich eingegebenen aktuellen Versionsnummer) an.}

 ⊃ äquivalent zu  (⍺⊃⍵) verwenden , ⍺ein Element zur Auswahl⍵

 1+ füge eins hinzu 

 ↑, Entspricht den  (⍺↑⍵), vorangestellten ⍺Nummern von⍵

 ⊢∘≢↑ äquivalent zu  (⍺⊢∘≢⍵)↑ äquivalent, (≢⍵)↑ um so viele Zahlen davon zu  nehmen, wie Elemente enthalten sind ⍵, und erforderlichenfalls mit Nullen aufzufüllen

⍕ Format (mit einem Leerzeichen zwischen jeder Zahl versehen)

' '⎕R'.' PCRE R ePlace Räume mit Perioden

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

Erläuterung:

Probieren Sie es hier aus.

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 dank nur @ ASCII!

Alte Erklärung:

(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

Noch eine Selbstantwort ... Nicht, dass irgendjemand in LiveScript Golf spielt. : P

Ich habe an einer anderen Version gearbeitet:

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

Ist *aber zu überlastet, um in einem Spleißindex erkannt zu werden, so =0wird versucht, darauf zuzugreifen 0[0]. Also musst du so etwas schreiben ..[b to ..length- b]=[0]*(..length-1-b)und es ist am Ende länger.

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)

Probieren Sie es online!

Original