Levenshtein Entfernung & OEIS (Cops)

16

Dies ist der Cop-Post. Der Räuberposten ist da .

Ihre Aufgabe ist es, eine Ganzzahleingabe N zu nehmen und die n- te Ziffer in der Sequenz OEIS A002942 auszugeben .

Die Folge besteht aus den rückwärts geschriebenen Quadratzahlen:

1, 4, 9, 61, 52, 63, 94, 46, 18, 1, 121, 441, ...

Beachten Sie, dass führende Nullen weggeschnitten werden ( 100 wird zu 1 , nicht zu 001 ). Verketten in eine Zeichenkette (oder eine lange Zahl ergibt):

1496152639446181121441

Sie müssen die n-te Ziffer in dieser Zeichenfolge / Nummer ausgeben . Sie können N als 0-indexiert oder 1-indexiert wählen (bitte geben Sie an, welches Sie wählen).

Testfälle (1-indiziert):

N = 1,      ==> 1
N = 5,      ==> 1
N = 17,     ==> 1   <- Important test case! It's not zero.
N = 20,     ==> 4
N = 78,     ==> 0
N = 100,    ==> 4

Ihr Code sollte für Zahlen bis zu N = 2 ^ 15 funktionieren (es sei denn, Ihre Sprache kann standardmäßig keine 32-Bit-Ganzzahlen verarbeiten. In diesem Fall kann N niedriger sein).

Polizei:

Sie müssen zwei Funktionen / Programme in derselben Sprache schreiben, die dasselbe tun. Sie müssen eine der Funktionen / Programme sowie den Levenshtein-Abstand zwischen den beiden von Ihnen geschriebenen Funktionen / Programmen posten . Der Levenshtein-Abstand wird in Zeichen gemessen (also ergibt die Addition eines Zwei-Byte-Zeichens eine LD = 1).

Der nicht offenbarte Code darf nicht länger als die ursprüngliche Lösung sein (er kann jedoch dieselbe Größe haben). Die Räuber werden versuchen, einen Code mit der genauen Levenshtein-Distanz zu schreiben, die Sie angegeben haben (er kann sich von Ihrem nicht offenbarten Code unterscheiden, solange er funktioniert).

Der Gewinner ist die ungerissene Einsendung mit der niedrigsten Levenshtein-Distanz.

Sie können die Levenshtein Abstand hier überprüfen!

Wenn Ihre Einreichung 7 Tage lang nicht geknackt wurde, können Sie den von Ihnen geschriebenen alternativen Code offenlegen und Ihre Einreichung als sicher markieren.

number sequence cops-and-robbers Stewie Griffin
quelle
Ja, das werde ich zu den Regeln hinzufügen. :)
Stewie Griffin
Sie sprechen über Skripte, aber ich nehme an, dies ist das Standardprogramm oder die Standardfunktion ?
Kevin Cruijssen
Ja, standardmäßig alles :)
Stewie Griffin
Wie gehst du mit Kommentaren und Leerzeichen um? Ich sehe ein paar seltsame Dinge.
Magic Octopus Urn
1
"Ihr Code sollte für Zahlen bis N = 2 ^ 15 funktionieren" -> aber einer der Testfälle ist größer als dieser. Ist der Fall 274164 notwendig?
Tom Carpenter

Antworten:

6

Haskell , LD = 13, gerissen

((snd.span(<'1').reverse.show.(^2)=<<[1..])!!)

Probieren Sie es online!

Ich habe doppelt geprüft, ob führende Nullen abgeschnitten sind;)

Erläuterung:

                    [1..]     -- for each element in [1,2,3,4,5,...]
                 =<<          -- apply the following functions 
             (^2)             -- square [1,4,9,16,25,...]
           show.              -- convert to string ["1","4","9","16","25",...]
       reverse.               -- reverse ["1","4","9","61","52",...,"001",...]
   span(<'1').                -- split into leading zeros and remainder [("","1"),("","4"),...,("00","1"),...]
  snd.                        -- only keep remainder ["1","4","9","61","52",...,"1",...]
                              -- and concatenate the result "1496152..."
((                       )!!) -- index into the sequence
Laikoni
quelle
2
Geknackt !
H.PWiz
3

cQuents 0 , LD = 1, Cracked

":\r$*$

Probieren Sie es online!

Ich dachte, dass dies nicht für führende Nullen funktioniert, aber es funktioniert tatsächlich - die Umkehrfunktion in cQuents ist wie folgt codiert int(reversed(str(n))).

Erläuterung

"         Concatenate sequence together, get nth term in the string instead of the sequence
 :        Mode: Sequence: given input n, output the nth term, 1-indexed
          Each term in the sequences equals:
  \r      reverse(
    $*$           the index * the index
                  or
    $$            the index * the index
                   ) (implicit)
Stephen
quelle
geknackt?
Laikoni
@Laikoni yep, cQuents impliziert eine Multiplikation wie Mathematica, aber Sie brauchen keine Leerzeichen. Eine Erklärung hinzufügen.
Stephen
3

JavaScript (ES6), LD = 103 ( geknackt )

Die Verwendung einer so hohen Levenshtein-Distanz ist wahrscheinlich nicht die beste Strategie, aber versuchen wir es trotzdem.

n => { for(i = 0, str = ''; i <= n; i++) { str += +[...i * i + ''].reverse().join(''); } return str[n]; }

Testfälle

Code-Snippet anzeigen

Beabsichtigte Lösung

$=>eval(atob`Wy4uLkFycmF5KCQrMSldLm1hcCgoXyxpKT0+K1suLi5pKmkrJyddLnJldmVyc2UoKS5qb2luYGApLmpvaW5gYFskXQ`)

Codierter Teil:

[...Array($+1)].map((_,i)=>+[...i*i+''].reverse().join``).join``[$]
Arnauld
quelle
Führt dieser Streifen nach dem Umkehren zu Nullen?
Erik der Outgolfer
@EriktheOutgolfer Ja. Der Unary +stellt sicher, dass die umgekehrte Zeichenfolge in eine Zahl umgewandelt wird.
Arnauld
1
Ohhhh ... wow, das ist schwieriger als ich dachte.
Magic Octopus Urn
Geknackt !
Lynn
3

Python 2, 104 Bytes, LD = 21 Ungültig und geknackt

d=lambda y:y if'0'!=str(y)[-1]else d(y/10)
lambda n:''.join([str(d(x*x))[::-1]for x in range(1,n)])[n-1]

PS Ist eine unbegrenzte Anzahl von Leerzeichen und Kommentaren zulässig? Wenn ja, ist dies nicht schwer zu knacken.

dylnan
quelle
1
"Der nicht enthüllte Code kann nicht länger sein als die ursprüngliche Lösung."
Khuldraeseth na'Barya
@Scrooble Ich habe das gesehen, aber ich glaube nicht, dass es schwierig sein wird, ein Programm zu erstellen, das viel kürzer ist als dieses. Wurde bereits in Python 3 in einer anderen Antwort ausgeführt und funktioniert in Python 2. Alles, was hinzugefügt werden muss, ist ein Haufen \ns (ungefähr 50)
dylnan
Würden nicht 50 Newlines eine Levenshtein-Distanz von 21 überschreiten?
Khuldraeseth na'Barya
@Scrooble Du hast sehr recht, ich war verwirrt und habe falsch über das Problem nachgedacht. Vielen Dank
Dylnan
1
Dies scheint bei Eingaben unter 5
Leo
3

6502 Maschinencode (C64), LD = 1 ( geknackt )

00 C0 20 FD AE A0 00 99 5B 00 C8 20 73 00 90 F7 99 5B 00 A2 0B CA 88 30 09 B9
5B 00 29 0F 95 5B 10 F3 A9 00 95 5B CA 10 F9 A9 00 A0 03 99 69 00 88 10 FA A0
20 A2 76 18 B5 E6 90 02 09 10 4A 95 E6 E8 10 F4 A2 03 76 69 CA 10 FB 88 F0 11
A2 09 B5 5C C9 08 30 04 E9 03 95 5C CA 10 F3 30 D6 A2 03 B5 69 95 57 CA 10 F9
A9 01 85 FB A2 03 A9 00 95 FB CA D0 FB A2 03 B5 FB 95 22 95 26 CA 10 F7 A9 00
A2 03 95 69 CA 10 FB A0 20 A2 02 46 25 76 22 CA 10 FB 90 0C A2 7C 18 B5 AA 75
ED 95 ED E8 10 F7 A2 7D 06 26 36 AA E8 10 FB 88 10 DD A0 0B A9 00 99 5A 00 88
D0 FA A0 20 A2 09 B5 5C C9 05 30 04 69 02 95 5C CA 10 F3 06 69 A2 FD 36 6D E8
D0 FB A2 09 B5 5C 2A C9 10 29 0F 95 5C CA 10 F4 88 D0 D7 E0 0A F0 05 E8 B5 5B
F0 F7 09 30 99 5B 00 C8 E8 E0 0B F0 04 B5 5B 90 F1 88 B9 5B 00 C9 30 F0 F8 A2
7C 18 B5 DB E9 00 95 DB E8 10 F7 90 14 88 30 05 B9 5B 00 D0 EA A2 7C F6 7F D0
03 E8 10 F9 4C 73 C0 B9 5B 00 4C D2 FF

Online-Demo , Verwendung:sys49152,nWonist die 0-indizierte Eingabe.

Für den letzten Testfall brauchst du ein bisschen Geduld, da diese arme Maschine Millionen von Bitverschiebungen und Hinzufügungen machen muss, um dir das Ergebnis zu präsentieren;)

Die Sprache hier ist der Maschinencode, daher wird LD in diesem Format gemessen. Um dennoch einen Anfang zu geben, hier ist das Programm in der ca65Assembler-Quelle:

NUMSIZE         = 4     ; 32 bit integers ...
NUMSTRSIZE      = 11    ; need up to 11 characters for 0-terminated string

.segment "ZPUSR": zeropage
v_x:            .res    NUMSIZE         ; next number to be squared

.segment "ZPFAC": zeropage
v_n:            .res    NUMSIZE         ; input index (0-based), counts down
nc_string:      .res    NUMSTRSIZE      ; string buffer for numbers

.segment "ZPTMP": zeropage
mpm_arg1:       .res    NUMSIZE         ; arg1 for multiplication
mpm_arg2:       .res    NUMSIZE         ; arg2 for multiplication

.segment "ZPFAC2": zeropage
mpm_res:        .res    NUMSIZE         ; numeric result (mult and str convert)

; load address for creating a C64 .PRG file:

.segment "LDADDR"
                .word   $c000

.code

; first read number from command argument and convert to unsigned
; integer in little-endian:

                jsr     $aefd
                ldy     #$00
rn_loop:        sta     nc_string,y
                iny
                jsr     $73
                bcc     rn_loop
                sta     nc_string,y
                ldx     #NUMSTRSIZE
stn_copybcd:    dex
                dey
                bmi     stn_fillzero
                lda     nc_string,y
                and     #$f
                sta     nc_string,x
                bpl     stn_copybcd
stn_fillzero:   lda     #$0
                sta     nc_string,x
                dex
                bpl     stn_fillzero
                lda     #$0
                ldy     #(NUMSIZE-1)
stn_znumloop:   sta     mpm_res,y
                dey
                bpl     stn_znumloop
                ldy     #(NUMSIZE*8)
stn_loop:       ldx     #($81-NUMSTRSIZE)
                clc
stn_rorloop:    lda     nc_string+NUMSTRSIZE+$80,x
                bcc     stn_skipbit
                ora     #$10
stn_skipbit:    lsr     a
                sta     nc_string+NUMSTRSIZE+$80,x
                inx
                bpl     stn_rorloop
                ldx     #(NUMSIZE-1)
stn_ror:        ror     mpm_res,x
                dex
                bpl     stn_ror
                dey
                beq     main
stn_sub:        ldx     #(NUMSTRSIZE-2)
stn_subloop:    lda     nc_string+1,x
                cmp     #$8
                bmi     stn_nosub
                sbc     #$3
                sta     nc_string+1,x
stn_nosub:      dex
                bpl     stn_subloop
                bmi     stn_loop

main:
                ldx     #(NUMSIZE-1)
argloop:        lda     mpm_res,x
                sta     v_n,x
                dex
                bpl     argloop
                lda     #$01
                sta     v_x
                ldx     #(NUMSIZE-1)
                lda     #$00
initxloop:      sta     v_x,x
                dex
                bne     initxloop

mainloop:

; prepare arguments for multiplication:

                ldx     #(NUMSIZE-1)
sqrargloop:     lda     v_x,x
                sta     mpm_arg1,x
                sta     mpm_arg2,x
                dex
                bpl     sqrargloop

; do multiplication:

                lda     #$00
                ldx     #(NUMSIZE-1)
mul_clearloop:  sta     mpm_res,x
                dex
                bpl     mul_clearloop
                ldy     #(NUMSIZE*8)
mul_loop:       ldx     #(NUMSIZE-2)
                lsr     mpm_arg1+NUMSIZE-1
mul_rorloop:    ror     mpm_arg1,x
                dex
                bpl     mul_rorloop
                bcc     mul_noadd
                ldx     #($80-NUMSIZE)
                clc
mul_addloop:    lda     mpm_arg2+NUMSIZE+$80,x
                adc     mpm_res+NUMSIZE+$80,x
                sta     mpm_res+NUMSIZE+$80,x
                inx
                bpl     mul_addloop
mul_noadd:      ldx     #($81-NUMSIZE)
                asl     mpm_arg2
mul_rolloop:    rol     mpm_arg2+NUMSIZE+$80,x
                inx
                bpl     mul_rolloop
                dey
                bpl     mul_loop

; convert result to string:

                ldy     #NUMSTRSIZE
                lda     #$0
nts_fillzero:   sta     nc_string-1,y
                dey
                bne     nts_fillzero
                ldy     #(NUMSIZE*8)
nts_bcdloop:    ldx     #(NUMSTRSIZE-2)
nts_addloop:    lda     nc_string+1,x
                cmp     #$5
                bmi     nts_noadd
                adc     #$2
                sta     nc_string+1,x
nts_noadd:      dex
                bpl     nts_addloop
                asl     mpm_res
                ldx     #($ff-NUMSIZE+2)
nts_rol:        rol     mpm_res+NUMSIZE,x       ; + $100 w/o zp wraparound
                inx
                bne     nts_rol
                ldx     #(NUMSTRSIZE-2)
nts_rolloop:    lda     nc_string+1,x
                rol     a
                cmp     #$10
                and     #$f
                sta     nc_string+1,x
nts_rolnext:    dex
                bpl     nts_rolloop
                dey
                bne     nts_bcdloop
nts_scan:       cpx     #(NUMSTRSIZE-1)
                beq     nts_copydigits
                inx
                lda     nc_string,x
                beq     nts_scan
nts_copydigits: ora     #$30
                sta     nc_string,y
                iny
                inx
                cpx     #(NUMSTRSIZE)
                beq     strip0loop
                lda     nc_string,x
                bcc     nts_copydigits

; search for first non-0 character from the end of the string:

strip0loop:     dey
                lda     nc_string,y
                cmp     #$30
                beq     strip0loop

; decrement n for each digit:

founddigit:
                ldx     #($80-NUMSIZE)
                clc
decnloop:       lda     v_n+NUMSIZE+$80,x
                sbc     #$00
                sta     v_n+NUMSIZE+$80,x
                inx
                bpl     decnloop
                bcc     foundresult

                dey
                bmi     next_x
                lda     nc_string,y
                bne     founddigit

; increment x to calculate next square number:

next_x:
                ldx     #($80-NUMSIZE)
incxloop:       inc     v_x+NUMSIZE-$80,x
                bne     incxdone
                inx
                bpl     incxloop
incxdone:       jmp     mainloop

foundresult:    lda     nc_string,y
                jmp     $ffd2

... und hier ist das Linker-Skript für ld65:

MEMORY {
  LDADDR: start = $bffe, size = 2;
  CODE: start = $c000, size = $1000;
  ZPTMP: start = $0022, size = $0008;
  ZPFAC: start = $0057, size = $000f;
  ZPFAC2: start = $0069, size = $0004;
  ZPUSR: start = $00fb, size = $0004;
}

SEGMENTS {
  LDADDR: load = LDADDR;
  CODE: load = CODE;
  ZPTMP: load = ZPTMP, type = zp;
  ZPFAC: load = ZPFAC, type = zp;
  ZPFAC2: load = ZPFAC2, type = zp;
  ZPUSR: load = ZPUSR, type = zp;
}
Felix Palmen
quelle
geknackt (glaube ich)
Jo.
@Jo. ja, bearbeitet.
Felix Palmen
2

Java 8 (177 Byte) LD = 92 ( geknackt von @Arnauld )

( Ich habe diesen Online-LD-Rechner benutzt. )

n->{String r="",t=r;for(int i=1,j;r.length()<=n+1;i++)if(Math.sqrt(i)%1==0){for(t="",j=(i+"").length();j>0;t+=(i+"").charAt(--j));r+=t.replaceAll("^0+","");}return r.charAt(n);}

Dies ist wahrscheinlich nicht zu schwer, wenn Sie einfach Golf spielen. :)

Erläuterung:

Probieren Sie es hier aus.

n->{                             // Method with integer parameter and character return-type
  String r="",                   //  Result-String, starting empty
         t=r;                    //  Temp-String, starting empty
  for(int i=1,j;                 //  Index-integers
      r.length()<=n+1;i++)       //  Loop (1) as long as the length is at least n+1
    if(Math.sqrt(i)%1==0){       //   If the current number `i` is a perfect square:
      for(t="",                  //    Reset the temp-String to empty
          j=(i+"").length();     //    Set `j` to the length of the current number
          j>0;                   //    Inner loop (2) as long as `j` is larger than 0
        t+=                      //     Append the temp-String with:
           (i+"").charAt(--j)    //     The digit of integer `i` at index `j-1`
                                 //     (by first decrease `j` with 1 with `--j`)
      );                         //    End of inner loop (2)
      r+=t                       //    And then append the temp-String to the result-String
          .replaceAll("^0+","");}//    after we've removed any leading zeroes
                                 //  End of loop (1) (implicit / single-line body)
  return r.charAt(n);            //  Return the `n`'th character of the result-String
}                                // End of method
Kevin Cruijssen
quelle
1
Gebrochen
Arnauld
Geplante Lösung: n->{String r="";for(int i=1;r.length()<=n+1;r+=new Long(new StringBuffer(i*i+++"").reverse()+""));return r.charAt(n);}( 118 Bytes, 92 LD )
Kevin Cruijssen
2

Oktave , LD = 63, gerissen

@(t)[arrayfun(@(t)num2str(str2num(flip(num2str(t)))),(1:t).^2,'uni',0){:}](t)

Probieren Sie es online!

Die Übermittlung ist 77 Bytes, so müssen Sie ziemlich viel ersetzen =)

Stewie Griffin
quelle
geknackt .
Tom Carpenter
2

6502 Maschinencode (C64), LD = 1, sicher

00 C0 20 FD AE A0 00 99 5B 00 C8 20 73 00 90 F7 99 5B 00 A2 0B CA 98 88 30 09
B9 5B 00 29 0F 95 5B 10 F2 95 5B CA 10 FB A0 20 A2 76 18 B5 E6 90 02 09 10 4A
95 E6 E8 10 F4 A2 03 76 69 CA 10 FB 88 F0 11 A2 09 B5 5C C9 08 30 04 E9 03 95
5C CA 10 F3 30 D6 A2 03 B5 69 95 57 CA 10 F9 A9 01 85 FB A2 03 A9 00 95 FB CA
D0 FB A2 03 B5 FB 95 22 95 26 CA 10 F7 A9 00 A2 03 95 69 CA 10 FB A0 20 A2 02
46 25 76 22 CA 10 FB 90 0C A2 7C 18 B5 AA 75 ED 95 ED E8 10 F7 A2 7D 06 26 36
AA E8 10 FB 88 10 DD A2 0B A9 00 95 5A CA D0 FB A0 20 A2 09 B5 5C C9 05 30 04
69 02 95 5C CA 10 F3 06 69 A2 FD 36 6D E8 D0 FB A2 09 B5 5C 2A C9 10 29 0F 95
5C CA 10 F4 88 D0 D7 E8 B5 5B F0 FB 09 30 99 5B 00 C8 E8 E0 0B F0 04 B5 5B 90
F1 88 B9 5B 00 C9 30 F0 F8 A2 7C 18 B5 DB E9 00 95 DB E8 10 F7 90 14 88 30 05
B9 5B 00 D0 EA A2 7C F6 7F D0 03 E8 10 F9 4C 68 C0 B9 5B 00 4C D2 FF

Online-Demo , Verwendung:sys49152,nWonist die 0-indizierte Eingabe.

Beabsichtigte Lösung: (diff)

 B9 5B 00 29 0F 95 5B 10 F2 95 5B CA 10 FB A0 20 A2 76 18 B5 E6 90 02 09 10 4A
-95 E6 E8 10 F4 A2 03 76 69 CA 10 FB 88 F0 11 A2 09 B5 5C C9 08 30 04 E9 03 95
+95 E6 E8 10 F4 A2 03 76 69 CA 10 FB 88 F0 11 A2 09 B5 5C C9 08 90 04 E9 03 95
 5C CA 10 F3 30 D6 A2 03 B5 69 95 57 CA 10 F9 A9 01 85 FB A2 03 A9 00 95 FB CA

Der 30(opcode bmi) wird ersetzt durch 90(opcodebcc ) ersetzt. Dies entspricht dem folgenden Teil in der Assembler-Quelle:

stn_subloop:    lda     nc_string+1,x
                cmp     #$8
                bmi     stn_nosub       ; use bcc here for same result
                sbc     #$3
                sta     nc_string+1,x

Es funktioniert, weil dieser Code prüft, ob eine Zahl kleiner als 8 ist. Der cmpBefehl subtrahiert dies und setzt die Flags entsprechend. Wenn also der Akkumulator eine Zahl kleiner als 8 enthält, läuft dies unter und löscht das Übertragsflag. Daher ist der richtige Verzweigungsbefehl in der Tat bcc.bmi(Verzweigung wenn negativ), wie im Originalcode, funktioniert auch hier, weil die verglichenen Zahlen klein genug sind, sodass das Ergebnis der Subtraktion im negativen Bereich ( $80-$ff) endet, wenn ein Unterlauf auftritt.

Online-Demo

Dies ist eine verbesserte / komprimierte Version von meines vorherigen Beitrags . Neben einigen anderen Tricks, um die Größe zu reduzieren, wird der unnötige Code entfernt, der enthalten war, und es wurde eine Art "einfacher" *) Riss zugelassen. Insgesamt reduziert sich die Größe um 16 Bytes. Diesmal sollte es etwas schwieriger sein, das entsprechende Programm mit LD 1 zu finden :)

*) wahrscheinlich ist noch einiges an arbeit zu finden :)

Hier ist wieder die ca65Assembler-Quelle, um den Einstieg in den Code zu erleichtern:

NUMSIZE         = 4     ; 32 bit integers ...
NUMSTRSIZE      = 11    ; need up to 11 characters for 0-terminated string

.segment "ZPUSR": zeropage
v_x:            .res    NUMSIZE         ; next number to be squared

.segment "ZPFAC": zeropage
v_n:            .res    NUMSIZE         ; input index (0-based), counts down
nc_string:      .res    NUMSTRSIZE      ; string buffer for numbers

.segment "ZPTMP": zeropage
mpm_arg1:       .res    NUMSIZE         ; arg1 for multiplication
mpm_arg2:       .res    NUMSIZE         ; arg2 for multiplication

.segment "ZPFAC2": zeropage
mpm_res:        .res    NUMSIZE         ; numeric result (mult and str convert)

; load address for creating a C64 .PRG file:

.segment "LDADDR"
                .word   $c000

.code

; first read number from command argument and convert to unsigned
; integer in little-endian:

                jsr     $aefd
                ldy     #$00
rn_loop:        sta     nc_string,y
                iny
                jsr     $73
                bcc     rn_loop
                sta     nc_string,y
                ldx     #NUMSTRSIZE
stn_copybcd:    dex
                tya
                dey
                bmi     stn_fillzero
                lda     nc_string,y
                and     #$f
                sta     nc_string,x
                bpl     stn_copybcd
stn_fillzero:   sta     nc_string,x
                dex
                bpl     stn_fillzero
                ldy     #(NUMSIZE*8)
stn_loop:       ldx     #($81-NUMSTRSIZE)
                clc
stn_rorloop:    lda     nc_string+NUMSTRSIZE+$80,x
                bcc     stn_skipbit
                ora     #$10
stn_skipbit:    lsr     a
                sta     nc_string+NUMSTRSIZE+$80,x
                inx
                bpl     stn_rorloop
                ldx     #(NUMSIZE-1)
stn_ror:        ror     mpm_res,x
                dex
                bpl     stn_ror
                dey
                beq     main
stn_sub:        ldx     #(NUMSTRSIZE-2)
stn_subloop:    lda     nc_string+1,x
                cmp     #$8
                bmi     stn_nosub
                sbc     #$3
                sta     nc_string+1,x
stn_nosub:      dex
                bpl     stn_subloop
                bmi     stn_loop

main:
                ldx     #(NUMSIZE-1)
argloop:        lda     mpm_res,x
                sta     v_n,x
                dex
                bpl     argloop
                lda     #$01
                sta     v_x
                ldx     #(NUMSIZE-1)
                lda     #$00
initxloop:      sta     v_x,x
                dex
                bne     initxloop

mainloop:

; prepare arguments for multiplication:

                ldx     #(NUMSIZE-1)
sqrargloop:     lda     v_x,x
                sta     mpm_arg1,x
                sta     mpm_arg2,x
                dex
                bpl     sqrargloop

; do multiplication:

                lda     #$00
                ldx     #(NUMSIZE-1)
mul_clearloop:  sta     mpm_res,x
                dex
                bpl     mul_clearloop
                ldy     #(NUMSIZE*8)
mul_loop:       ldx     #(NUMSIZE-2)
                lsr     mpm_arg1+NUMSIZE-1
mul_rorloop:    ror     mpm_arg1,x
                dex
                bpl     mul_rorloop
                bcc     mul_noadd
                ldx     #($80-NUMSIZE)
                clc
mul_addloop:    lda     mpm_arg2+NUMSIZE+$80,x
                adc     mpm_res+NUMSIZE+$80,x
                sta     mpm_res+NUMSIZE+$80,x
                inx
                bpl     mul_addloop
mul_noadd:      ldx     #($81-NUMSIZE)
                asl     mpm_arg2
mul_rolloop:    rol     mpm_arg2+NUMSIZE+$80,x
                inx
                bpl     mul_rolloop
                dey
                bpl     mul_loop

; convert result to string:

                ldx     #NUMSTRSIZE
                lda     #$0
nts_fillzero:   sta     nc_string-1,x
                dex
                bne     nts_fillzero
                ldy     #(NUMSIZE*8)
nts_bcdloop:    ldx     #(NUMSTRSIZE-2)
nts_addloop:    lda     nc_string+1,x
                cmp     #$5
                bmi     nts_noadd
                adc     #$2
                sta     nc_string+1,x
nts_noadd:      dex
                bpl     nts_addloop
                asl     mpm_res
                ldx     #($ff-NUMSIZE+2)
nts_rol:        rol     mpm_res+NUMSIZE,x       ; + $100 w/o zp wraparound
                inx
                bne     nts_rol
                ldx     #(NUMSTRSIZE-2)
nts_rolloop:    lda     nc_string+1,x
                rol     a
                cmp     #$10
                and     #$f
                sta     nc_string+1,x
nts_rolnext:    dex
                bpl     nts_rolloop
                dey
                bne     nts_bcdloop
nts_scan:       inx
                lda     nc_string,x
                beq     nts_scan
nts_copydigits: ora     #$30
                sta     nc_string,y
                iny
                inx
                cpx     #(NUMSTRSIZE)
                beq     strip0loop
                lda     nc_string,x
                bcc     nts_copydigits

; search for first non-0 character from the end of the string:

strip0loop:     dey
                lda     nc_string,y
                cmp     #$30
                beq     strip0loop

; decrement n for each digit:

founddigit:
                ldx     #($80-NUMSIZE)
                clc
decnloop:       lda     v_n+NUMSIZE+$80,x
                sbc     #$00
                sta     v_n+NUMSIZE+$80,x
                inx
                bpl     decnloop
                bcc     foundresult

                dey
                bmi     next_x
                lda     nc_string,y
                bne     founddigit

; increment x to calculate next square number:

next_x:
                ldx     #($80-NUMSIZE)
incxloop:       inc     v_x+NUMSIZE-$80,x
                bne     incxdone
                inx
                bpl     incxloop
incxdone:       jmp     mainloop

foundresult:    lda     nc_string,y
                jmp     $ffd2

... und hier ist das Linker-Skript für ld65:

MEMORY {
  LDADDR: start = $bffe, size = 2;
  CODE: start = $c000, size = $1000;
  ZPTMP: start = $0022, size = $0008;
  ZPFAC: start = $0057, size = $000f;
  ZPFAC2: start = $0069, size = $0004;
  ZPUSR: start = $00fb, size = $0004;
}

SEGMENTS {
  LDADDR: load = LDADDR;
  CODE: load = CODE;
  ZPTMP: load = ZPTMP, type = zp;
  ZPFAC: load = ZPFAC, type = zp;
  ZPFAC2: load = ZPFAC2, type = zp;
  ZPUSR: load = ZPUSR, type = zp;
}
Felix Palmen
quelle
Betrachten Sie es als ungerissen :)
Jo.
@Jo. gut, wenn Sie darauf bestehen - vielen Dank, ich habe es bearbeitet.
Felix Palmen
1

Lua: LD = 1, rissig

i=1s=""while(#s<...+0)do s=s..((i*i)..""):reverse():gsub("(0+)(%d+)$","%2")i=i+1 end print(s:sub(...,...))

Keine ausgefallenen Tricks hier :)

Katenkyo
quelle
geknackt
Erik der Outgolfer
1

PHP, LD = 35 ( geknackt )

1-indiziert

<?while(strlen($s)<$argv[1])$s.=(int)strrev(++$i*$i);echo substr($s,$argv[1]-1,1);

Probieren Sie es online!

Jo.
quelle
0

Python 3: LD = 9 | Geknackt

lambda i:"".join(str(k*k+2*k+1)[::-1].lstrip("0")for k in range(i+1))[i]

Dieser sollte ziemlich (sehr) leicht zu bekommen sein: P

HyperNeutrino
quelle
Rissig .
Mr. Xcoder
1
Ich habe meinen Crack gelöscht, weil die ursprüngliche Antwort ungültig ist.
Mr. Xcoder
@ Mr.Xcoder Du kannst jetzt wiederherstellen; LD ist das gleiche, da das .lstrip("0")Teil nur kopiert werden kann.
HyperNeutrino
Erledigt
Mr. Xcoder
0

C ++, LD = 159

0-indiziert, Eingabe in argv[1], auf GCC 7.2.0 kompiliert

#import<bits/stdc++.h>
char*h,b[1<<17],*q=b;int x,y;main(int,char**j){sscanf(j[1],"%d",&y);do{x++;q+=sprintf(h=q,"%d",x*x);while(*--q==48);std::reverse(h,++q);}while(q-b<=y);b[y+1]=0,printf(b+y);}
Colera Su
quelle
0

Groovy , 61 Bytes (LD = 23)

{(1..it).collect{0.valueOf("${it**2}".reverse())}.join()[it]}

Probieren Sie es online!

Magische Kraken-Urne
quelle
Wie ist das sicher?> _> ...
Magic Octopus Urn