Inkrementiere Base-36-Saiten

20

Dies ist eine Code-Golf-Version einer ähnlichen Frage, die ich zuvor auf dem Stack gestellt habe, aber für ein interessantes Rätsel gehalten habe.

Wenn eine Zeichenfolge mit der Länge 10 eine Zahl zur Basis 36 darstellt, erhöhen Sie diese um eins und geben Sie die resultierende Zeichenfolge zurück.

Dies bedeutet, dass die Zeichenfolgen nur Ziffern von 0bis 9und Buchstaben von abis enthalten z.

Die Basis 36 funktioniert wie folgt:

Die am weitesten rechts stehende Ziffer wird zunächst mit 0bis inkrementiert9

0000000000> 9 Iterationen> 0000000009

und danach wird ato zverwendet:

000000000a> 25 Iterationen> 000000000z

Wenn zinkrementiert werden muss, wird die Schleife auf Null zurückgesetzt und die Ziffer links davon inkrementiert:

000000010

Weitere Regeln:

  • Sie können Groß- oder Kleinbuchstaben verwenden.
  • Sie dürfen keine führenden Nullen löschen. Sowohl Eingabe als auch Ausgabe sind Zeichenfolgen mit der Länge 10.
  • Sie müssen nicht zzzzzzzzzzals Eingabe behandeln.

Testfälle:

"0000000000" -> "0000000001"
"0000000009" -> "000000000a"
"000000000z" -> "0000000010"
"123456zzzz" -> "1234570000"
"00codegolf" -> "00codegolg"
Jack Hales
quelle
@JoKing Code-Golf, coole Ideen und Effizienz, denke ich.
Jack Hales
7
Ich mag die Idee, nur die Inkrementierungsoperation zu implementieren, weil sie das Potenzial für andere Strategien als die Basisumwandlung hin und zurück hat.
Xnor
2
Willkommen bei PPCG! Dies ist eine nette Herausforderungsidee, jedoch sind einige Teile der Spezifikation unklar, wie einige Kommentare gezeigt haben. Für die Zukunft empfehle ich die Verwendung unserer Sandbox, in der Sie vor dem Posten Feedback zu einer Herausforderung erhalten können.
Laikoni
1
"0zzzzzzzzz"Schlagen Sie vor, als Testfall etwas wie (Ändern der wichtigsten Ziffer) hinzuzufügen . Es hat meine C-Lösung aufgrund eines Fehler-zu-eins-Fehlers ausgelöst.
OOBalance
1
hat einen Eintrag hinzugefügt, vorausgesetzt, er ist in Ordnung - ein C-Eintrag erledigt dies bereits.
Felix Palmen

Antworten:

6

05AB1E , 10 Bytes

Die Eingabe erfolgt in Großbuchstaben .

Code

1ì36ö>36B¦

Erläuterung

1ì           # Prepend a 1 to the number
  36ö        # Convert from base 36 to decimal
     >       # Increment by 1
      36B    # Convert from decimal to base 36
         ¦   # Remove the first character

Verwendet die 05AB1E- Codierung. Probieren Sie es online! oder Überprüfen Sie alle Testfälle .

Adnan
quelle
Kann in der neuen Version von 05AB1E 8 Byte betragen.
Kevin Cruijssen
8

Japt , 13 Bytes

n36 Ä s36 ù0A

Probieren Sie es online! und Testfälle überprüfen

Übernimmt die Eingabe als Zeichenfolge

Erläuterung

n36            converts input to base 36
    Ä           +1
      s36       to base 36 string
          ù0A   left-pad with 0 to length 10
crashoz
quelle
Willkommen bei Japt! :)
Shaggy
8

JavaScript (ES6), 45 Byte

4 Bytes gespart dank @OOBalance

s=>(parseInt(1+s,36)+1).toString(36).slice(1)

Probieren Sie es online!

Arnauld
quelle
Du bist verrückt, guter. +1
Jack Hales
2
45 Bytes: bit.ly/2K5tjw0
OOBalance
Ich glaube nicht , ES8 mehr nach neuestem Golf ...
Downgoat
@ Downgoat Danke! Du hast recht. Aktualisiert.
Arnauld
7

Haskell , 58 Bytes

d=['0'..'9']
f s=snd(span(<s)$mapM(\_->d++['a'..'z'])d)!!1

Probieren Sie es online!

Eine Brute-Force-Strategie: Generieren Sie alle Zeichenfolgen der Länge 10 zur Basis 36 in der angegebenen Reihenfolge und suchen Sie die Zeichenfolge, die nach der Eingabe in der Liste steht. Nehmen Sie sich viel Zeit für Zeichenfolgen, die weit vom Anfang der Liste entfernt sind.


Haskell , 60 Bytes

q '9'='a'
q c=succ c
f(h:t)|any(<'z')t=h:f t|r<-'0'<$t=q h:r

Probieren Sie es online!

Liest die Zeichenfolge von links nach rechts, bis sie ein Zeichen erreicht, gefolgt von einem Suffix aller Zs, die möglicherweise leer sind. Erhöht dieses Zeichen und ersetzt die Zs durch Nullen.

xnor
quelle
6

C (GCC) , 50 48 Bytes

Ein explizites Carry-Flag war nach der Umstrukturierung der Schleife zum Ende nicht erforderlich, sobald kein Carry stattfinden würde. Die Einstellung 9-> A wird während der Schleifenprüfung durchgeführt.

Danke an ceilingcat für den Vorschlag.

f(char*s){for(s+=9;(*s+=*s-57?1:8)>90;*s--=48);}

Probieren Sie es online!


Originalversion: 71 57 Bytes

Diese Version verwendet ein Übertragsflag, um Aktualisierungen zu verbreiten: Ich habe es auf true gesetzt, um das Inkrement zu starten. Die Zeichenfolge wird direkt geändert und akzeptiert nur 0-9, AZ. Der knifflige Teil bestand darin, sicherzustellen, dass 9-> A beim Tragen richtig gehandhabt wurde.

Bearbeiten: Ich habe den Eingabezeiger als Übertragsflag neu verwendet.

f(s){for(char*t=s+9;s;)*t--+=(s=++*t>90)?-43:7*!(*t-58);}

Probieren Sie es online!

ErikF
quelle
6

C 82 81 53 50 Bytes

f(char*s){for(s+=10;*--s>89;)*s=48;*s+=*s-57?1:8;}

Ändert die Eingabezeichenfolge direkt. Eingabe und Ausgabe erfolgt in Großbuchstaben. Probieren Sie es hier online aus . Dank an Arnauld für das Golfen von 24 Bytes und an ceilingcat für das Golfen von 3 weiteren Bytes.

Ungolfed:

f(char *s) { // function taking a string argument
     for(s += 10; *--s > 89; ) // skip to the least significant digit, and step through the string until you hit something other than a 'Z' (90 is the ASCII code for 'Z') ...
         *s = 48; // ... replacing each digit with a zero (48 is the ASCII code for '0')
         *s += // the next digit has to be incremented:
         *s - 57 // if it's not a '9' (ASCII code 57) ...
         ? 1 // ... that is straightforward ...
         : 8; // ... otherwise it has to be replaced with an 'A' (ASCII code 65 = 57 + 8)
 }
OOBalance
quelle
Ich denke, das sollte sicher sein: 60 Bytes
Arnauld
1
@ Arnauld Sie können kein Null-Byte vor der Zeichenfolge annehmen ...
Jakob
1
@ Jakob Da bin ich mir nicht 100% sicher. Wir definieren Sprachen durch ihre Implementierungen. Dies ist C (gcc), das auf einer TIO-VM ausgeführt wird, bei der der Speicher - glaube ich - zunächst gelöscht werden kann. (Ich habe andere C-Antworten gesehen, die ähnliche Annahmen treffen.)
Arnauld
2
Indem ich die Testumgebung in die 'Implementierung' einbeziehe, gehe ich möglicherweise zu weit. Sie können jedoch weiterhin die 60-Byte-Version verwenden, für die keine Speicherannahme erforderlich ist.
Arnauld
1
@ Arnauld Ich habe noch 4 Bytes golfen. Es sollte wirklich sicher sein, da wir nicht damit umgehen müssen ZZZZZZZZZZ. ErikFs Antwort macht dasselbe, aber noch kürzer: codegolf.stackexchange.com/a/169468/79343
OOBalance
5

Online Turing Machine Simulator , 745 Byte

init:0
accept:2
0,0
0,0,>
0,1
0,1,>
0,2
0,2,>
0,3
0,3,>
0,4
0,4,>
0,5
0,5,>
0,6
0,6,>
0,7
0,7,>
0,8
0,8,>
0,9
0,9,>
0,a
0,a,>
0,b
0,b,>
0,c
0,c,>
0,d
0,d,>
0,e
0,e,>
0,f
0,f,>
0,g
0,g,>
0,h
0,h,>
0,i
0,i,>
0,j
0,j,>
0,k
0,k,>
0,l
0,l,>
0,m
0,m,>
0,n
0,n,>
0,o
0,o,>
0,p
0,p,>
0,q
0,q,>
0,r
0,r,>
0,s
0,s,>
0,t
0,t,>
0,u
0,u,>
0,v
0,v,>
0,w
0,w,>
0,x
0,x,>
0,y
0,y,>
0,z
0,z,>
0,_
1,_,<
1,0
2,1,-
1,1
2,2,-
1,2
2,3,-
1,3
2,4,-
1,4
2,5,-
1,5
2,6,-
1,6
2,7,-
1,7
2,8,-
1,8
2,9,-
1,9
2,a,-
1,a
2,b,-
1,b
2,c,-
1,c
2,d,-
1,d
2,e,-
1,e
2,f,-
1,f
2,g,-
1,g
2,h,-
1,h
2,i,-
1,i
2,j,-
1,j
2,k,-
1,k
2,l,-
1,l
2,m,-
1,m
2,n,-
1,n
2,o,-
1,o
2,p,-
1,p
2,q,-
1,q
2,r,-
1,r
2,s,-
1,s
2,t,-
1,t
2,u,-
1,u
2,v,-
1,v
2,w,-
1,w
2,x,-
1,x
2,y,-
1,y
2,z,-
1,z
1,0,<

Online-Dolmetscher

Erik der Outgolfer
quelle
5

Perl 6 , 34 32 30 Bytes

Dank nwellnhof für -2 Bytes durch die Verwendung des oOperators, um Funktionen zu kombinieren

{S/.//}o{base :36(1~$_)+1: 36}

Probieren Sie es online!

Funktion, die das Argument in Basis 36 konvertiert, 1 addiert, zurückkonvertiert und dann formatiert. Verwendet jetzt dieselbe Taktik wie Adnans Antwort , um die führenden Nullen beizubehalten.

Scherzen
quelle
{S/.//}o{base :36(1~$_)+1: 36}für 30 Bytes.
Nwellnhof
@nwellnhof Ordentlich! Ich habe noch nie daran gedacht, oGolf zu spielen, aber ich kann sehen, wo es nützlich sein könnte!
Jo King
Ah, es ist schade, dass .succ(inkrementieren um eins) nicht funktioniert
Jo King
4

MATL , 12 Bytes

36ZAQ5M10&YA

Probieren Sie es online!

           % Implicit input
36ZA       % convert from base 36 to decimal
Q          % increment by 1
5M         % bring the 36 back on stack (done this way to avoid needing space separator after this)
10         % = minimum length of output string
&YA        % convert back to base 36 with those arguments
           % Implicit output
Sundar - Setzen Sie Monica wieder ein
quelle
4

Haskell , 63 Bytes

r.f.r
f('9':r)='a':r
f('z':r)='0':f r
f(c:r)=succ c:r
r=reverse

Probieren Sie es online! Kehrt die Zeichenfolge um und überprüft das erste Zeichen:

  • A 9wird durch ein ersetzt a.
  • A zwird durch a ersetzt 0und rekursiv das nächste Zeichen geprüft.
  • Alle anderen Zeichen werden mithilfe succder Nachfolgerfunktion inkrementiert , die für Zeichen verwendet werden kann, da sie eine Instanz der Enum-Klasse sind .

Schließlich wird die resultierende Zeichenfolge wieder umgekehrt.

Laikoni
quelle
4

6502 (NMOS *) Maschinencode- Routine, 26 Bytes

A0 09 F3 FB B1 FB C9 5B 90 07 A9 30 91 FB 88 10 F1 C9 3A D0 04 A9 41 91 FB 60

*) verwendet einen "illegalen" Opcode ISB/ 0xF3, funktioniert auf allen Original-NMOS 6502-Chips, nicht auf späteren CMOS-Varianten.

Erwartet einen Zeiger auf eine 10-stellige Zeichenfolge in $fb/, bei $fcder es sich voraussichtlich um eine Zahl zur Basis 36 handelt. Erhöht diese Nummer an Ort und Stelle.

Macht bei ungültigen Eingaben (wie zB einer kürzeren Zeichenkette) nichts Sinnvolles - handhabt versehentlich ZZZZZZZZZZ"richtig";)

Kommentierte Demontage

; function to increment base 36 number as 10 character string
;
; input:
;   $fb/$fc: address of string to increment
; clobbers:
;   A, Y
 .inc36:
A0 09       LDY #$09            ; start at last character
 .loop:
F3 FB       ISB ($FB),Y         ; increment character ("illegal" opcode)
B1 FB       LDA ($FB),Y         ; load incremented character
C9 5B       CMP #$5B            ; > 'z' ?
90 07       BCC .checkgap       ; no, check for gap between numbers and letters
A9 30       LDA #$30            ; load '0'
91 FB       STA ($FB),Y         ; and store in string
88          DEY                 ; previous position
10 F1       BPL .loop           ; and loop
 .checkgap:
C9 3A       CMP #$3A            ; == '9' + 1 ?
D0 04       BNE .done           ; done if not
A9 41       LDA #$41            ; load 'a'
91 FB       STA ($FB),Y         ; and store in string
 .done:
60          RTS

Beispiel C64 Assembler Programm mit der Routine:

Online-Demo

Bildschirmfoto

Code in ca65- Syntax:

.import inc36   ; link with routine above

.segment "BHDR" ; BASIC header
                .word   $0801           ; load address
                .word   $080b           ; pointer next BASIC line
                .word   2018            ; line number
                .byte   $9e             ; BASIC token "SYS"
                .byte   "2061",$0,$0,$0 ; 2061 ($080d) and terminating 0 bytes

.bss
b36str:         .res    11

.data
prompt:         .byte   "> ", $0

.code
                lda     #<prompt        ; display prompt
                ldy     #>prompt
                jsr     $ab1e

                lda     #<b36str        ; read string into buffer
                ldy     #>b36str
                ldx     #$b
                jsr     readline

                lda     #<b36str        ; address of array to $fb/fc
                sta     $fb
                lda     #>b36str
                sta     $fc
                jsr     inc36           ; call incrementing function

                lda     #<b36str        ; output result
                ldy     #>b36str
                jmp     $ab1e

; read a line of input from keyboard, terminate it with 0
; expects pointer to input buffer in A/Y, buffer length in X
.proc readline
                dex
                stx     $fb
                sta     $fc
                sty     $fd
                ldy     #$0
                sty     $cc             ; enable cursor blinking
                sty     $fe             ; temporary for loop variable
getkey:         jsr     $f142           ; get character from keyboard
                beq     getkey
                sta     $2              ; save to temporary
                and     #$7f
                cmp     #$20            ; check for control character
                bcs     checkout        ; no -> check buffer size
                cmp     #$d             ; was it enter/return?
                beq     prepout         ; -> normal flow
                cmp     #$14            ; was it backspace/delete?
                bne     getkey          ; if not, get next char
                lda     $fe             ; check current index
                beq     getkey          ; zero -> backspace not possible
                bne     prepout         ; skip checking buffer size for bs
checkout:       lda     $fe             ; buffer index
                cmp     $fb             ; check against buffer size
                beq     getkey          ; if it would overflow, loop again
prepout:        sei                     ; no interrupts
                ldy     $d3             ; get current screen column
                lda     ($d1),y         ; and clear 
                and     #$7f            ;   cursor in
                sta     ($d1),y         ;   current row
output:         lda     $2              ; load character
                jsr     $e716           ;   and output
                ldx     $cf             ; check cursor phase
                beq     store           ; invisible -> to store
                ldy     $d3             ; get current screen column
                lda     ($d1),y         ; and show
                ora     #$80            ;   cursor in
                sta     ($d1),y         ;   current row
                lda     $2              ; load character
store:          cli                     ; enable interrupts
                cmp     #$14            ; was it backspace/delete?
                beq     backspace       ; to backspace handling code
                cmp     #$d             ; was it enter/return?
                beq     done            ; then we're done.
                ldy     $fe             ; load buffer index
                sta     ($fc),y         ; store character in buffer
                iny                     ; advance buffer index
                sty     $fe
                bne     getkey          ; not zero -> ok
done:           lda     #$0             ; terminate string in buffer with zero
                ldy     $fe             ; get buffer index
                sta     ($fc),y         ; store terminator in buffer
                sei                     ; no interrupts
                ldy     $d3             ; get current screen column
                lda     ($d1),y         ; and clear 
                and     #$7f            ;   cursor in
                sta     ($d1),y         ;   current row
                inc     $cc             ; disable cursor blinking
                cli                     ; enable interrupts
                rts                     ; return
backspace:      dec     $fe             ; decrement buffer index
                bcs     getkey          ; and get next key
.endproc
Felix Palmen
quelle
1
Die 65C02-Version kann das ISB verwerfen und dann INC verwenden, nachdem LDA (), Y (und .done um eine Zeile nach oben verschoben wurden) und um ein Byte kürzer sind.
Peter Ferrie
@peterferrie hat der 65C02 einen INC für den Akku?
Felix Palmen
@ Peterferrie ok, tut es, schön - das ist, was ich in erster Linie auf dem 6502 vermisst :)
Felix Palmen
3

Retina 0.8.2 , 12 Bytes

T`zo`dl`.z*$

Probieren Sie es online! Erläuterung: Der dlTeil des Ersetzungsziels wird erweitert, 0-9a-zwährend der Teil oan die Quelle kopiert wird, was dazu führt z0-9a-z(obwohl der zweite Teil zignoriert wird, da er niemals übereinstimmen kann). Dies erhöht die übereinstimmenden Ziffern. Der .z*$Teil des Musters stimmt mit der letzten Nicht- zZiffer plus allen nachfolgenden Zeichen überein z, wodurch der Übertrag von ihrem Inkrement bis behandelt wird 0.

Neil
quelle
3

Ruby , 40 Bytes

->s{(s.to_i(36)+1).to_s(36).rjust 10,?0}

Probieren Sie es online!

  1. Konvertieren Sie die Zeichenfolge in eine Ganzzahl, die sie als Basis 36 interpretiert
  2. Addiere 1
  3. Konvertiere zurück in die Basis 36 Zeichenkette
  4. Linkes Pad mit 0s

"zzzzzzzzzz" Gibt eine 11-lange Zeichenfolge zurück

Asone Tuhid
quelle
3

Brainfuck , 109 Bytes

,[>>,]<+[++++<[<--->>-<-]-[<->>+<---]<[[-]>-------<]+>>[[+<+>]<<+[>+<------]>>]-[<+>-----]<++++<]<[<<]>>[.>>]

Probieren Sie es online!

Nitrodon
quelle
Das wollte ich unbedingt sehen!
Jack Hales
3

Apl (Dyalog Unicode) , 30 28 24 Bytes

Danke an ngn für den Hinweis, einige Bytes zu sparen.

(f⍣¯1)1+f←36⊥1,(⎕D,⎕A)⍳⊢

Probieren Sie es online!

  • Benötigt ⎕IO von 0

  • Verwendet Großbuchstaben

jslip
quelle
Warum nicht noch einen Schritt weiter gehen und '1',Teil davon werden f? dann 1↓wird ein Teil seiner inversen worden
ngn
@ngn Schön, danke!
Jslip
noch kürzer: (⎕D,⎕A)⍳'1',->1,(⎕D,⎕A)⍳
ngn
eine letzte Verbesserung - es kann als Zug umgeschrieben werden:(f⍣¯1)1+f←36⊥1,(⎕D,⎕A)⍳⊢
ngn
3

PHP, 69 64 Bytes

lahme Version :

printf("%010s",base_convert(1+base_convert($argn,36,10),10,36));

Als Rohr mit laufen lassen -R. Eingabe unabhängig von Groß- / Kleinschreibung, Ausgabe in Kleinbuchstaben.

erster Ansatz, 69 Bytes:

<?=str_pad(base_convert(1+base_convert($argn,36,10),10,36),10,'0',0);

Als Rohr mit laufen lassen -F

Loop-Version, auch 69 Bytes :

for($n=$argn;~$c=$n[$i-=1];)$f||$f=$n[$i]=$c!=9?$c>Y?0:++$c:A;echo$n;
  • Nur PHP 7.1: älteres PHP versteht keine negativen String-Indizes,
    jüngeres PHP gibt Warnungen für undefinierte Konstanten aus.
  • erfordert die Eingabe von Großbuchstaben. Ersetzen Sie Yund Adurch Kleinbuchstaben für die Eingabe von Kleinbuchstaben.

Als Rohr mit laufen lassen -nR

... oder online ausprobieren .

Titus
quelle
68 Bytes: Probieren Sie es online!
Night2
Weitere 68-Byte-Version: Probieren Sie es online! Sie können Ihr auch verwenden -Rund dieses 66 Bytes nennen.
Night2
1
@ Night2 Guter Ansatz; aber es kann noch kürzer gemacht werden: printf('%010s',($b=base_convert)(1+$b($argn,36,10),10,36));- 59 Bytes
Titus
1
Schön. Haben Sie nicht wissen , dass wir eine Funktion wie diese nennen könnte: ($b=base_convert)(a,b,c). Ich lerne viel von dir.
Night2
2

Python 2 , 88 Bytes

def f(s):L,R=s[:-1],s[-1:];return s and[[L+chr(ord(R)+1),f(L)+'0'][R>'y'],L+'a'][R=='9']

Probieren Sie es online!

Erhöht die Zeichenfolge "von Hand".

Chas Brown
quelle
2

Holzkohle , 14 Bytes

×0⁹←⮌⍘⊕⍘S³⁶¦³⁶

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Erläuterung:

×0⁹

9 0s drucken . Dies dient zum Auffüllen des Ergebnisses.

←⮌⍘⊕⍘S³⁶¦³⁶

Konvertieren Sie die Eingabe von der Basis 36, inkrementieren Sie sie und konvertieren Sie sie dann zurück zur Basis 36. Kehren Sie dann das Ergebnis um und drucken Sie es nach links.

Neil
quelle
2

Java 8, 90 76 56 Bytes

s->Long.toString(Long.valueOf(1+s,36)+1,36).substring(1)

Akzeptiert sowohl Groß- als auch Kleinbuchstaben für die Eingabe. Die Ausgabe erfolgt immer in Kleinbuchstaben.

Danke an Okx für das Golfen mit 18 Bytes.

Probieren Sie es hier online aus .

Ungolfed:

s -> // lambda taking a String argument and returning a String
    Long.toString(Long.valueOf(1+s,36)+1,36) // prefix input with '1' to ensure leading zeros, convert to Long using base 36, increment, then convert back to String in base 36
    .substring(1) // remove the leading '1'
OOBalance
quelle
Nett! Zum späteren Nachschlagen in älterem Java können Sie mit so etwas wie"".format("%10s",t).replace(' ','0')
Jakob
@ Jakob Danke, das habe ich gesucht.
OOBalance
Es ist kürzer, a 1am Anfang hinzuzufügen, als es zu entfernen:s->Long.toString(Long.valueOf("1"+s,36)+1,36).substring(1)
Okx
@Okx Netter Ansatz. 2 weitere Bytes: "1"+s=>1+s
OOBalance
2

JavaScript (ES6), 89 Byte

Dieser ist bei weitem nicht so byteeffizient wie der andere JavaScript-Eintrag , aber ich habe das gemacht, ohne die folgende Regel zu beachten:

Gegeben eine Zeichenfolge von Länge 10

Das ist also kein ernstzunehmender Eintrag - nur zum Spaß! Es funktioniert mit Zeichenfolgen allgemeiner Länge, wie z . B. -> 0abc, und es wird ein vorangestellt, 1wenn die erste Ziffer zz . B. zzz-> ist 1000. Die Eingabe muss in Kleinbuchstaben erfolgen.

s=>(l=s[s.length-1],r=s.slice(0,-1),l=='z'?f(r||'0')+0:r+(parseInt(l,36)+1).toString(36))

Erläuterung

Der Ausdruck (A, B, C)bedeutet tatsächlich "mache A, dann mache B, dann gebe C zurück", mit dem ich einige Variablen deklariere, die ich im Code wiederverwende. ssteht für "string", lbedeutet "last", rbedeutet "rest".

/*1*/ s=>(
/*2*/   l=s[s.length-1],
/*3*/   r=s.slice(0,-1),
/*4*/   l=='z'
/*5*/     ? f(r||'0')+0
/*6*/     : r+(parseInt(l,36)+1).toString(36))

Dies ist eine rekursive Funktion. Bei einer typischen Zeichenfolge azawird nur das letzte Zeichen erhöht (siehe Zeile 6) azb. Aber für eine Zeichenkette, die mit endet z, h0gzwird sie sich bis zum letzten Zeichen (the z) selbst abarbeiten und stattdessen a einsetzen 0(siehe Zeile 5) - f(h0gz)= f(h0g) + 0= h0h0.

Die ||'0'in Zeile 5 ist so, dass die Funktion funktioniert, wenn sie für eine Zeichenfolge mit einer Länge von 1 (dh die Zeichenfolge 'z') aufgerufen wird . Ohne es f('')heißt (da 'z'.slice(0, -1)ist ''), was undefiniertes Verhalten hat (buchstäblich - probiere es selbst aus), und das ist nicht gut. Das erwartete Ergebnis von f('z')ist '10', was wir bekommen f('0') + 0, also verwenden wir ||'0'. ( Dies ||'0'ist besonders nützlich, weil es nicht den üblichen Fall beeinträchtigt - rmindestens 1 Länge ( smindestens 2 Länge) - weil Zeichenfolgen nur dann falsch sind, wenn sie 0 Länge haben.)

Die Methode zum Inkrementieren eines Strings ist die gleiche wie im anderen JS-Eintrag: Konvertieren Sie die "Zahl" der Basis 36 in eine tatsächliche Zahl, addieren Sie 1 und konvertieren Sie sie dann zurück in die Basis 36. Wir brauchen uns keine Gedanken über das 1Inkrementieren von 'z' ( 'z'-> '10') zu machen, da wir 'z' eigentlich nie inkrementieren (siehe Zeile 4 und 6: Das letzte Zeichen wird nur inkrementiert, wenn es nicht 'z' ist).

Außerdem riskieren wir niemals, führende Nullen zu verwerfen, da wir nie mehr als ein einzelnes Zeichen gleichzeitig manipulieren - immer nur das letzte Zeichen in der Zeichenfolge. Der Rest der Zeichen wird sauber abgetrennt, wenn Sie eine Zeichenfolge und vorangestellte Nachwörter aufschneiden.

Florrie
quelle
2

Sauber , 89 84 Bytes

import StdEnv
@['9':t]=['a':t]
@['z':t]=['0': @t]
@[c:t]=[inc c:t]
r=reverse

r o@o r

Probieren Sie es online!

Eine kürzere Lösung dank Laikoni .

Sauber , 115 Bytes

Ich liebe es, wenn ich es benutzen darf limit(iterate...

import StdEnv
@'9'='a'
@c=inc c
?[h,'{':t]=[@h,'0': ?t]
?[h:t]=[h: ?t]
?e=e
$l=limit(iterate?(init l++[@(last l)]))

Probieren Sie es online!

Erzeugt die Antwort ohne Konvertierung der Basen mittels Listenabgleich.

  • ? :: [Char] -> [Char] führt vorwärts tragen.
  • @ :: Char -> CharInkremente um eins, unter Berücksichtigung der Lücke zwischen '9'und 'z'.
  • $ :: [Char] -> [Char]erhöht das letzte Zeichen und wird angewendet, ?bis sich der Wert stabilisiert.
Οurous
quelle
1
Weniger ausgefallen, aber etwas kürzer: Probieren Sie es online aus!
Laikoni
@Laikoni Bearbeitet in, danke!
Freitag,
2

R , 152 123 Bytes

function(x)f(utf8ToInt(x),10)
f=function(x,n,y=x[n]){x[n]=y+(y==57)*39+(y==122)*(-75)+1
"if"(y==122,f(x,n-1),intToUtf8(x))}

Probieren Sie es online!

Ein ganz anderer Ansatz. Holen Sie sich die ASCII-Codepunkte und "erhöhen" Sie rekursiv den am weitesten rechts stehenden Codepunkt (wobei 0(57) zu a(97) und z(122) zu 0(48) zurückspringt, bis Sie keine zs mehr haben. Zurück in String konvertieren.

Alte Version

function(s,w=gsub("(z)(?=\\1*$)","0",s,,T),x=regexpr(".0*$",w)[1],y=substr(w,x,x),z=chartr("0-9a-z","1-9a-z0",y))sub(p(y,"(0*$)"),p(z,"\\1"),w)
p=paste0

Probieren Sie es online!

Dies ist alles eine Textmanipulation, die nicht mit R-Code-Golfen einhergeht.

Ersetzen Sie alle zam Ende der Zeichenfolgen mit 0. Suchen Sie die Position des letzten Elements vor dem neu geprägten abschließenden 0s. Suchen Sie die nächste 36-stellige Basis. Mach die Veränderung. Seien Sie froh, die Online Turing Machine Simulator-Lösung kaum geschlagen zu haben.

ngm
quelle
Sie können viel besser als das tun! Ich glaube, ich habe 72 Bytes, wenn Sie die richtigen eingebauten finden können ...
Giuseppe
Ups ... dachte, diese Herausforderung war Code-Bowling!
ngm
Nun, die integrierte Funktion soll strtoiIhnen den Einstieg erleichtern. Es gibt ein paar weitere Golf-Tricks, um es auf 72 zu bringen.
Giuseppe
1
strtoiist allerdings auf eher kleine zahlen beschränkt? Ich habe es vor einer Weile aufgegeben.
ngm
Oh ich verstehe. Haben Sie nicht die Realisierung intEinschränkung war so problematisch. Schade! Für die Nachwelt war dies meine gescheiterte Lösung: Probieren Sie es online!
Giuseppe
2

Sternenklar , 325 Bytes

     + , , , , , , , , , ,     +      +   +   +`* +          + +* + +**      + * +* * '    +           + +* +* +* +*      +* `     +  + +                + +  *       +* *  '    +      +*           + +* +* +*  `   +   +           + +* +  *  **   +  + +'    +    +   ` +           + +* +  *    * .           + +* +  *   * +   '

Probieren Sie es online!

Erläuterung:

Put-a-zero-at-the-base-of-the-stack
|     +
Read-10-digits
| , , , , , , , , , ,
Initialise-next-stack
|     +
Initialise-carry-bit
|      +
|   +   +
Do
|`
    Top-of-stack:-[output-stack]-[carry-bit]-[next-value]
    Add-Carry-bit-to-digit
    |*

    Compare-with-58-("9"=57)
    | +
    5-double-triple-sub1-double
    |          + +* + +**      + * +*
    Take-difference
    | *
    If-one-above-"9"
    | '
        set-to-"a"=97=6-double-double-double-double-add1
        |    +
        |           + +* +* +* +*      +*
    | `

    Initialise-next-carry-bit
    |     +
    |  +

    Compare-with-123-("z"=122)
    | +
    11-squared-add2
    |                + +  *       +*
    Take-difference
    | *
    If-one-above-"z"
    |  '
        Delete-current-value
        |    +
        set-carry-bit
        |      +*
        Set-to-"0"=48
        |           + +* +* +*
    |  `

    Push-value-to-stack
    |   +   +
    |           + +* +  *
    |  **

    |   +  +
While-next-value-is-not-null
| +'

Pop-carry-bit-and-null-string-terminator
|    +    +
Do
|   `
    Get-top-value
    | +
    |           + +* +  *
    |    *

    Print-it
    | .

    Pop-the-value-off-the-stack
    |           + +* +  *
    |   *
While-stack-is-not-null
| +   '
Sasha
quelle
1

Python 3.6+ und gmpy2 , 62 Bytes

from gmpy2 import*;f=lambda s:f'{digits(mpz(s,36)+1,36):0>10}'

Probieren Sie es online!

(Beachten Sie, dass gmpy2 nicht Teil der Python-Standardbibliothek ist und eine separate Installation erfordert.)

trolley813
quelle
Ich glaube nicht, dass du das brauchst f=. Anonyme Funktionen gelten normalerweise als im Code Golf zu finden.
Mypetlion
1

Pyke , 11 Bytes

? b!!R+bhbt

Probieren Sie es hier aus!

? b         - Change default base of `base` command to 36 
            -  This is kind of clever because it modifies the list of characters 
            -  the command uses to exactly the same as it was originally, whilst
            -  forcing an overwrite from the default settings of 10. 
            -  The default setup works for base 36, you just have to specify it
            -  time when using the command.
            -  Literally `b.contents = modify(b.contents, func=lambda: noop)`
   !!       - The previous command returns `0123456789abcdefghijklmnopqrstuvwxyz`
            -  So we convert it into a 1 with (not not ^) for the following command:
     R+     -     "1"+input
       b    -    base(^, 36)
        h   -   ^ + 1
         b  -  base(^, 36)
          t - ^[1:]

Könnte mit der folgenden Sprachänderung 2 Byte kürzer sein: Wenn der Hex-Modus verwendet wird, ändern Sie alle base_36- und base_10-Verwendungen in base_92 (was in diesem Kontext ohnehin nicht wirklich base 92 ist).

Blau
quelle
1

sed , 94 bytes

s/$/#:0123456789abcdefghijklmnopqrstuvwxyz#0/
:l
s/\(.\)#\(.*:.*\1\)\(#*.\)/\3\2\3/
tl
s/:.*//

Probieren Sie es online!

Sed leidet sehr darunter, dass er die Charaktere durch Nachschlagen ändern muss.

Geoff Reedy
quelle
@ETHproductions whoops, danke für den Fang
Geoff Reedy
0

Jelly , 21 Bytes

ØBḊiⱮḅ‘bɗ36Ż9¡ṫ-9‘ịØB

Probieren Sie es online!

Verwendet Großbuchstaben. TIO-Link ermöglicht auch Klein- / Mischschreibung.

Erik der Outgolfer
quelle