16

Это полицейский пост. Сообщение Грабителя здесь .

Ваша задача - взять целочисленный ввод N и вывести N-ю цифру в последовательности OEIS A002942 .

Последовательность состоит из квадратных чисел, написанных в обратном порядке:

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

Обратите внимание, что ведущие нули обрезаются ( 100 становится 1 , а не 001 ). Конкатенация в строку (или одно длинное число дает):

1496152639446181121441

Вы должны вывести N-ую цифру в этой строке / числе. Вы можете принять N за 0 или 1 (укажите, какой из них вы выбрали).

Контрольные примеры (1-индексированные):

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

Ваш код должен работать для чисел до N = 2 ^ 15 (если ваш язык не может обрабатывать 32-битные целые числа по умолчанию, в этом случае N может быть меньше).

Менты:

Вы должны написать две функции / программы на одном языке, которые делают одно и то же. Вы должны опубликовать одну из функций / программ, а также расстояние Левенштейна между двумя функциями / программами, которые вы написали. Расстояние Левенштейна измеряется в символах (поэтому добавление двухбайтового символа даст LD = 1).

Раскрытый код не может быть длиннее исходного решения (но может иметь одинаковый размер). Грабители попытаются написать код с точным расстоянием Левенштейна, которое вы дали (оно может отличаться от вашего нераскрытого кода, если оно работает).

Победителем станет безотказная подача, которая имеет самое низкое расстояние Левенштейна.

Вы можете проверить расстояние Левенштейна здесь!

Если ваша заявка не будет взломана в течение 7 дней, вы можете указать альтернативный код, который вы написали, и пометить вашу отправку как безопасную.

number sequence cops-and-robbers Стьюи Гриффин
источник

Да, я добавлю это к правилам. :)

Стьюи Гриффин

Вы говорите о скриптах, но я предполагаю, что это программа или функция по умолчанию ?

Кевин Круйссен

Да, по умолчанию все :)

Stewie Griffin

Как вы справляетесь с комментариями и пробелами, я вижу странные вещи.

Волшебная Осьминог Урна

1

«Ваш код должен работать для чисел до N = 2 ^ 15» -> но один из тестовых случаев больше этого. Нужен ли случай 274164?

Том Карпентер

6

Haskell , LD = 13, трещины

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

Попробуйте онлайн!

Я дважды проверил, что ведущие нули обрезаны;)

Объяснение:

                    [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
источник

2

Трещины !

H.PWiz

3

cQuents 0 , LD = 1, трещины

":\r$*$

Попробуйте онлайн!

Я думал, что это не работает для ведущих нулей, но на самом деле это работает - обратная функция в cQuents кодируется как int(reversed(str(n))).

объяснение

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

Стивен
источник

трещины?

Лайкони

@Laikoni Да, cQuents неявно умножают, вроде Mathematica, но вам не нужны пробелы. Добавление объяснения.

Стивен

3

JavaScript (ES6), LD = 103 ( взломан )

Использование такого большого расстояния Левенштейна, вероятно, не лучшая стратегия, но давайте все равно попробуем.

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

Контрольные примеры

Показать фрагмент кода

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

Предполагаемое решение

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

Закодированная часть:

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

Arnauld
источник

Эта полоса лидирует в 0 после реверса?

Эрик Outgolfer

@EriktheOutgolfer Да. Унарный +код гарантирует, что обратная строка приведена к числу.

Арно

1

Оооо ... Вау, это сложнее, чем я думал.

Волшебная Урна Осьминога

Трещины !

Линн

3

Python 2, 104 байта, LD = 21 неверно и взломан

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 Разрешено ли неограниченное количество пробелов и комментариев? Если так, то это не будет трудно взломать.~~

dylnan
источник

1

«Раскрытый код не может быть длиннее исходного решения».

Хулдрасет на'Барья

@ Scrooble Я видел это, но я не думаю, что будет трудно сделать программу, которая намного короче этой. Уже было сделано в python 3 в другом ответе, и это работает в python 2, поэтому все, что им нужно добавить, это набор \ns (около 50)

dylnan

Разве 50 строк не превысили бы расстояние Левенштейна, равное 21?

Хулдрасет на'Барья

@ Scrooble Вы очень правы, я запутался и неправильно думал о проблеме. Спасибо

Дилнан

1

Кажется, это ошибка на входах ниже 5

Лев

3

Машинный код 6502 (C64), LD = 1 ( взломан )

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

Демонстрация онлайн , использование:sys49152,nгдеnввод 0-index.

В последнем тестовом случае вам нужно немного терпения, так как эта бедная машина должна делать миллионы битовых сдвигов и дополнений, чтобы представить вам результат;)

Язык здесь - машинный код, поэтому LD измеряется в этом формате - тем не менее, чтобы дать начало, вот программа в ca65исходном коде на ассемблере:

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

... и вот скрипт компоновщика для 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;
}

Феликс Палмен
источник

треснул (я верю)

Джо.

@Джо. да, отредактировано.

Феликс Палмен

2

Perl 5 , 59 + 1 ( `-a`) = 60 байт, LD = 55

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

Попробуйте онлайн!

Xcali
источник

возможно взломан, я не уверен в своей записи codegolf.stackexchange.com/questions/146927/…

Науэль Фуийо

2

Java 8, (177 байт) LD = 92 ( взломано @Arnauld )

( Я использовал этот онлайн LD-калькулятор. )

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

Это, вероятно, не так уж сложно, если вы просто играете в гольф. :)

Объяснение:

Попробуй это здесь.

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

Кевин Круйссен
источник

1

Трещины

Арно

Предполагаемое решение: n->{String r="";for(int i=1;r.length()<=n+1;r+=new Long(new StringBuffer(i*i+++"").reverse()+""));return r.charAt(n);}( 118 байт, 92 LD )

Кевин Круйссен,

2

Октава , LD = 63, трещины

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

Попробуйте онлайн!

Передача составляет 77 байт, поэтому нужно заменить совсем немного =)

Стьюи Гриффин
источник

трещины .

Том Карпентер

2

Машинный код 6502 (C64), LD = 1, безопасный

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

Демонстрация онлайн , использование:sys49152,nгдеnввод 0-index.

Предполагаемое решение: (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

30( Код операции bmi) заменяется на 90(код операции bcc). Это соответствует следующей части в источнике ассемблера:

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

Это работает, потому что этот код проверяет, меньше ли число 8. Для этого cmpинструкция выполняет вычитание, соответственно устанавливая флаги. Таким образом, если аккумулятор содержит число меньше 8, это приводит к потере значения, стирающему флаг переноса, поэтому правильная инструкция ветвления действительно существует bcc. bmi(разветвление при отрицательном значении), как и в исходном коде, просто работает и здесь, потому что сравниваемые числа достаточно малы, поэтому результат вычитания заканчивается в отрицательном диапазоне ( $80-$ff) при возникновении недостаточного значения .

Онлайн демо

Это улучшенная / сжатая версия моего предыдущего представления . Среди некоторых других приемов по уменьшению размера, он удаляет ненужный код, который содержался, и допускает своего рода «простой» *) взлом. В целом размер уменьшен на 16 байт. На этот раз будет немного сложнее найти эквивалентную программу с LD 1 :)

^{*) наверняка еще какую-то работу найти, конечно :)}

Опять же, вот ca65исходный код ассемблера, чтобы помочь начать работу с кодом:

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

... и вот скрипт компоновщика для 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;
}

Феликс Палмен
источник

Считайте это без трещин :)

Джо.

@Джо. хорошо, если вы настаиваете - большое спасибо, я редактировал его.

Феликс Пальмен

1

Lua: LD = 1, трещины

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

Никаких причудливых трюков здесь :)

Katenkyo
источник

трещины

Эрик Outgolfer

1

Mathematica, LD = 43 трещины

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

Попробуйте онлайн!

J42161217
источник

Трещины .

Миша Лавров

1

PHP, LD = 35 ( треснувший )

1-индексированных

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

Попробуйте онлайн!

Джо.
источник

0

Python 3: LD = 9 | Трещины

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

Это должно быть довольно (очень) легко получить: P

HyperNeutrino
источник

Трещины .

г-н Xcoder

1

Я удалил свой Crack, потому что оригинальный ответ недействителен.

г-н Xcoder

@ Mr.Xcoder Вы можете восстановить сейчас; LD то же самое, потому что .lstrip("0")часть может быть просто скопирована.

HyperNeutrino

Готово

Mr. Xcoder

0

C ++, LD = 159

0-индексированный, входной argv[1], скомпилированный в 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);}

Колера Су
источник

0

Groovy , 61 байт (LD = 23)

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

Попробуйте онлайн!

Урна волшебного осьминога
источник

Как это безопасно> _> ...

Волшебный осьминог Urn

Расстояние Левенштейна и OEIS (Копы)

Контрольные примеры (1-индексированные):

Менты:

Ответы:

Haskell , LD = 13, трещины

cQuents 0 , LD = 1, трещины

объяснение

JavaScript (ES6), LD = 103 ( взломан )

Контрольные примеры

Предполагаемое решение

Python 2, 104 байта, LD = 21 неверно и взломан

Машинный код 6502 (C64), LD = 1 ( взломан )

Perl 5 , 59 + 1 ( `-a`) = 60 байт, LD = 55

Java 8, (177 байт) LD = 92 ( взломано @Arnauld )

Октава , LD = 63, трещины

Машинный код 6502 (C64), LD = 1, безопасный

Lua: LD = 1, трещины

Mathematica, LD = 43 трещины

PHP, LD = 35 ( треснувший )

Python 3: LD = 9 | Трещины

C ++, LD = 159

Groovy , 61 байт (LD = 23)

Расстояние Левенштейна и OEIS (Копы)

Контрольные примеры (1-индексированные):

Менты:

Ответы:

Haskell , LD = 13, трещины

cQuents 0 , LD = 1, трещины

объяснение

JavaScript (ES6), LD = 103 ( взломан )

Контрольные примеры

Предполагаемое решение

Python 2, 104 байта, LD = 21 неверно и взломан

Машинный код 6502 (C64), LD = 1 ( взломан )

Perl 5 , 59 + 1 ( -a) = 60 байт, LD = 55

Java 8, (177 байт) LD = 92 ( взломано @Arnauld )

Октава , LD = 63, трещины

Машинный код 6502 (C64), LD = 1, безопасный

Lua: LD = 1, трещины

Mathematica, LD = 43 трещины

PHP, LD = 35 ( треснувший )

Python 3: LD = 9 | Трещины

C ++, LD = 159

Groovy , 61 байт (LD = 23)

Perl 5 , 59 + 1 ( `-a`) = 60 байт, LD = 55