16

Ceci est le poste Cop. Le billet Robber est ici .

Votre tâche consiste à prendre un entier N et à sortir le Nième chiffre dans la séquence OEIS A002942 .

La séquence se compose des nombres carrés écrits à l'envers:

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

Notez que les zéros non significatifs sont supprimés ( 100 devient 1 , pas 001 ). Concaténer cela en une chaîne (ou un nombre long donne):

1496152639446181121441

Vous devez sortir le Nième chiffre dans cette chaîne / numéro. Vous pouvez choisir de prendre N comme index 0 ou 1 (veuillez indiquer lequel vous choisissez).

Cas de test (1 indexé):

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

Votre code devrait fonctionner pour les nombres jusqu'à N = 2 ^ 15 (sauf si votre langue ne peut pas gérer les entiers 32 bits par défaut, auquel cas N peut être inférieur).

Flics:

Vous devez écrire deux fonctions / programmes, dans la même langue, qui font la même chose. Vous devez publier une des fonctions / programmes, ainsi que la distance Levenshtein entre les deux fonctions / programmes que vous avez écrits. La distance de Levenshtein est mesurée en caractères (donc l'ajout d'un caractère à deux octets donnera un LD = 1).

Le code non révélé ne peut pas être plus long que la solution d'origine (mais il peut être de la même taille). Les voleurs tenteront d'écrire un code avec la distance Levenshtein exacte que vous avez donnée (il peut être différent de votre code non révélé, tant qu'il fonctionne).

Le gagnant sera la soumission non fissurée ayant la distance Levenshtein la plus faible.

Vous pouvez vérifier la distance de Levenshtein ici!

Si votre soumission n'est pas fissurée pendant 7 jours, vous pouvez révéler le code alternatif que vous avez écrit et marquer votre soumission comme sûre.

number sequence cops-and-robbers

— Stewie Griffin
source

Oui, je vais ajouter cela aux règles. :)

— Stewie Griffin

Vous parlez de scripts, mais je suppose que c'est le programme ou la fonction par défaut ?

— Kevin Cruijssen

Oui, tout par défaut :)

— Stewie Griffin

Comment gérez-vous les commentaires et les espaces, je vois des trucs bizarres.

— Urne de poulpe magique

1

"Votre code devrait fonctionner pour des nombres jusqu'à N = 2 ^ 15" -> mais l'un des cas de test est plus grand que cela. Le boîtier 274164 est-il nécessaire?

— Tom Carpenter

6

Haskell , LD = 13, fissuré

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

Essayez-le en ligne!

J'ai revérifié que les zéros non significatifs sont coupés;)

Explication:

                    [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
source

2

Craqué !

— H.PWiz

3

cQuents 0 , LD = 1, fissuré

":\r$*$

Essayez-le en ligne!

Je pensais que cela ne fonctionnait pas pour les zéros non significatifs, mais c'est effectivement le cas - la fonction inverse dans cQuents est codée comme int(reversed(str(n))).

Explication

"         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
source

fissuré?

— Laikoni

@Laikoni oui, cQuents fait une multiplication implicite comme, un peu comme Mathematica, mais vous n'avez pas besoin des espaces. Ajout d'une explication.

— Stephen

3

JavaScript (ES6), LD = 103 ( fissuré )

Utiliser une distance Levenshtein aussi élevée n'est probablement pas la meilleure stratégie, mais essayons quand même.

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

Cas de test

Afficher l'extrait de code

let f =

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

console.log(f(5))      // 1
console.log(f(17))     // 1
console.log(f(20))     // 4
console.log(f(78))     // 0
console.log(f(100))    // 4
console.log(f(274164)) // 1

Expand snippet

Solution envisagée

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

Partie codée:

[...Array($+1)].map((_,i)=>+[...i*i+''].reverse().join``).join``[$]

— Arnauld
source

Cette bande mène-t-elle à 0 après inversion?

— Erik the Outgolfer

@EriktheOutgolfer Oui. L'unaire +garantit que la chaîne inversée est contrainte à un nombre.

— Arnauld

1

Ohhhh ... wow, c'est plus difficile que je ne le pensais.

— Urne de poulpe magique

Craqué !

— Lynn

3

Python 2, 104 octets, LD = 21 invalide ET fissuré

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 Un nombre illimité d'espaces et de commentaires est-il autorisé? Si c'est le cas, ce ne sera pas difficile à casser.~~

— dylnan
source

1

"Le code non révélé ne peut pas être plus long que la solution d'origine."

— Khuldraeseth na'Barya

@Scrooble J'ai vu ça mais je ne pense pas qu'il sera difficile de faire un programme beaucoup plus court que celui-ci. Déjà fait en python 3 dans une autre réponse et cela fonctionne en python 2 donc tout ce qu'ils doivent ajouter est un tas de \ns (environ 50)

— dylnan

50 sauts de ligne ne dépasseraient-ils pas une distance Levenshtein de 21?

— Khuldraeseth na'Barya

@Scrooble Vous avez tout à fait raison, je me suis trompé et je pensais mal au problème. Merci

— dylnan

1

Cela semble être une erreur sur les entrées inférieures à 5

— Leo

3

6502 code machine (C64), LD = 1 ( fissuré )

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

Démo en ligne , utilisation:sys49152,noùnest l'entrée indexée 0.

Pour le dernier cas de test, vous avez besoin d'un peu de patience, car cette pauvre machine doit faire des millions de décalages de bits et d'ajouts pour vous présenter le résultat;)

Le langage ici est le code machine, donc LD est mesuré dans ce format - néanmoins, pour commencer, voici le programme en ca65source assembleur:

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

... et voici le script de l'éditeur de liens pour 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
source

fissuré (je crois)

— Jo.

@Jo. oui, édité.

— Felix Palmen

2

Perl 5 , 59 + 1 ( `-a`) = 60 octets, LD = 55

$j.=int reverse$_**2for 1..$_;$_--;say$j=~s/.{$_}(.).*/$1/r

Essayez-le en ligne!

— Xcali
source

peut-être craqué, je ne suis pas sûr de mon entrée codegolf.stackexchange.com/questions/146927/…

— Nahuel Fouilleul

2

Java 8, (177 octets) LD = 92 ( Cracké par @Arnauld )

( J'ai utilisé cette calculatrice LD en ligne. )

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

Ce n'est probablement pas trop difficile si vous jouez simplement au golf. :)

Explication:

Essayez-le ici.

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
source

1

Cracked

— Arnauld

Solution prévue: n->{String r="";for(int i=1;r.length()<=n+1;r+=new Long(new StringBuffer(i*i+++"").reverse()+""));return r.charAt(n);}( 118 octets, 92 LD )

— Kevin Cruijssen

2

Octave , LD = 63, fissuré

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

Essayez-le en ligne!

La soumission est de 77 octets, vous devez donc en substituer un peu =)

— Stewie Griffin
source

fissuré .

— Tom Carpenter

2

6502 code machine (C64), LD = 1, sûr

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

Démo en ligne , utilisation:sys49152,noùn est l'entrée indexée 0.

Solution envisagée: (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

L' 30opcode bmiest remplacé par l' 90opcode bcc. Cela correspond à la partie suivante dans la source de l'assembleur:

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

Cela fonctionne car ce code vérifie si un nombre est inférieur à 8. L' cmpinstruction effectue une soustraction pour cela, définissant les indicateurs en conséquence. Donc, si l'accumulateur contient un nombre inférieur à 8, cela sous-estime, effaçant le drapeau de report, donc la bonne instruction de branchement est en effet bcc. bmi(ramification lorsqu'elle est négative), comme dans le code d'origine, fonctionne également ici, car les nombres comparés sont suffisamment petits, de sorte que le résultat de la soustraction se retrouve dans la plage négative ($80-$ff ) lorsqu'un débordement se produit.

Démo en ligne

Il s'agit d'une version améliorée / compactée de ma soumission précédente . Parmi d'autres astuces pour réduire la taille, il supprime le code inutile qui était contenu et permettait une sorte de "simple" *) crack. Dans l'ensemble, la taille est réduite de 16 octets. Cette fois, il devrait être un peu plus difficile de trouver le programme équivalent avec LD 1 :)

^{*) probablement encore pas mal de travail à trouver, bien sûr :)}

Encore une fois, voici la ca65source de l' assembleur, pour vous aider à démarrer avec le code:

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

... et voici le script de l'éditeur de liens pour 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
source

Considérez-le comme non fissuré :)

— Jo.

@Jo. eh bien si vous insistez - merci beaucoup, je l'ai édité.

— Felix Palmen

1

Lua: LD = 1, fissuré

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

Pas de trucs fantaisistes ici :)

— Katenkyo
source

cracké

— Erik l'Outgolfer

1

Mathematica, LD = 43 fissuré

Flatten[Table[(k=IntegerDigits)@FromDigits@Reverse@k[i^2],{i,10^4}]][[#]]&

Essayez-le en ligne!

— J42161217
source

Fissuré .

— Misha Lavrov

1

PHP, LD = 35 ( fissuré )

1 indexé

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

Essayez-le en ligne!

— Jo.
source

0

Python 3: LD = 9 | Fissuré

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

Celui-ci devrait être assez (très) facile à obtenir: P

— HyperNeutrino
source

Fissuré .

— M. Xcoder

1

J'ai supprimé mon Crack car la réponse d'origine n'est pas valide.

— M. Xcoder

@ Mr.Xcoder Vous pouvez annuler la suppression maintenant; LD est le même car la .lstrip("0")pièce peut simplement être copiée.

— HyperNeutrino

Fait

— M. Xcoder,

0

C ++, LD = 159

0 indexé, entrée dans argv[1], compilé sur GCC 7.2.0

#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
source

0

Groovy , 61 octets (LD = 23)

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

Essayez-le en ligne!

— Urne de poulpe magique
source

Comment est-ce sécuritaire> _> ...

— Urne de poulpe magique

Levenshtein distance & OEIS (flics)

Cas de test (1 indexé):

Flics:

Haskell , LD = 13, fissuré

cQuents 0 , LD = 1, fissuré

Explication

JavaScript (ES6), LD = 103 ( fissuré )

Cas de test

Solution envisagée

Python 2, 104 octets, LD = 21 invalide ET fissuré

6502 code machine (C64), LD = 1 ( fissuré )

Perl 5 , 59 + 1 ( -a) = 60 octets, LD = 55

Java 8, (177 octets) LD = 92 ( Cracké par @Arnauld )

Octave , LD = 63, fissuré

6502 code machine (C64), LD = 1, sûr

Lua: LD = 1, fissuré

Mathematica, LD = 43 fissuré

PHP, LD = 35 ( fissuré )

Python 3: LD = 9 | Fissuré

C ++, LD = 159

Groovy , 61 octets (LD = 23)

Perl 5 , 59 + 1 ( `-a`) = 60 octets, LD = 55