Рассмотрим последовательность натуральных чисел, для которых N появляется как подстрока в N ^ 2. A018834

Выведите nй элемент этой последовательности.

правила

Программа принимает только в nкачестве входных данных и выводит только одно число - N.

Последовательность может быть 0-индексированной или 1-индексированной.

Sequence: 1 5 6 10 25 50 60 76 100 250 376 500 600 625 760 ...
Squares:  1 25 36 100 625 2500 3600 5776 10000 62500 141376 250000 360000 390625 577600 ...

Это код-гольф, поэтому выигрывает самый короткий код.

code-golf sequence Ведант Кандой
источник

1

Многие реализации столкнутся с проблемами (для меня это из-за невозможности создания массивов с более чем 2 ^ 32 значениями), что сделает большинство решений привязанными к максимальному размеру по умолчанию. Должны ли эти решения быть дисквалифицированы?

Макс

1

@maxb Я думаю, теоретически подразумевалось, что это не обязательно практически .

Арно

1

@ Конечно, я знаю, что оно очень низкое, поэтому мне не нравится мое решение. Я мог бы добавить байт, и он работал бы для гораздо больших входов, поэтому я добавлю это как альтернативу

maxb

1

«N появляется в N ^ 2» было бы лучше сформулировать как что-то вроде «десятичные цифры N - это [непрерывная] подстрока десятичных цифр N в квадрате» (11 не «появляется в» 121). [Строго «смежные» излишни, но добавить это ясно.]

Джонатан Аллан

1

@JonathanAllan Alternate предложил изменить формулировку: «N лексикографически присутствует в N ^ 2»

urous

4

05AB1E , 6 байтов

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

µNNnNå

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

объяснение

µ         # loop over increasing N until counter equals input
 N        # push N (for the output)
  Nn      # push N^2
    N     # push N
     å    # push N in N^2
          # if true, increase counter

Emigna
источник

Эта µкоманда просто ... Я хотел бы иметь это.

maxb

@maxb: Это довольно практично для задач, где вам нужно найти Nthчисло, соответствующее определенному условию.

Emigna

" если правда , увеличить счетчик"?

Джонатан Аллан

@JonathanAllan: Как в «Если N содержится в N ^ 2, увеличьте значение счетчика на 1». Я, вероятно, должен был написать «счетчик приращений».

Emigna

Я на самом деле не понял объяснения; похоже, что если åвозвращает true, то у нас есть ток Nна вершине стека (счетчик приращений и приращение N), но если нет, мы продолжаем (приращение N). Возможно, используйте что-то отличное от " N", так как это конечный результат в теле вопроса: p

Джонатан Аллан

4

Perl 6 , 33 31 байт

-2 байта благодаря nwellnhof

{(grep {$^a²~~/$a/},1..*)[$_]}

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

Объяснение:

{                            }  # Anonymous code block that returns
 (                      )[$_]   # The nth index of
  grep {          },1..*        # Filtering from the natural numbers
        $^a²                    # If the square of the number
            ~~/$a/              # Contains the number

Джо Кинг
источник

3

JavaScript (ES6), 43 байта

f=(n,k=0)=>n?f(n-!!(++k*k+'').match(k),k):k

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

Нерекурсивная версия, 47 байт

n=>eval("for(k=0;n-=!!(++k*k+'').match(k););k")

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

Arnauld
источник

Это сдается n=23только?

Ведант Кандой

a (n)

$a(n)$

a (n)

$a(n)$

7600

$7600$

n = 23

$n=23$

3

MathGolf , 8 байт (работает для любого ввода в теории, но только для `n<10`практики)

úrgÉ²ï╧§

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

Альтернатива (работает на `n<49`практике и в теории)

►rgÉ²ï╧§

Разница лишь в том, что вместо создания списка со 10^(input)значениями я создаю список с 10^6элементами. Это займет некоторое время, поэтому вы можете поменять первый байт на любой другой 1-байтовый литерал, чтобы проверить его.

объяснение

ú          pop(a), push(10**a)
 r         range(0, n)
  g        filter array by...
   É       start block of length 3
    ²      pop a : push(a*a)
     ï     index of current loop
      ╧    pop a, b, a.contains(b)
           Block ends here
       §   get from array

Причина, по которой это решение не обрабатывает большие входные данные, состоит в том, что я заметил, что последовательность растет не экспоненциально, а больше, чем любой полином. Вот почему я использовал10**n оператор (я хотел использовать, 2**nно это не удалось для ввода 1). Это означает, что я создаю чрезвычайно большой массив даже для небольших входных данных, просто чтобы отфильтровать подавляющее большинство его, а затем взять один из первых элементов. Это чрезвычайно расточительно, но я не мог найти другой способ сделать это без увеличения количества байтов.

maxb
источник

3

Common Lisp, 95 байт

(lambda(n)(do((i 0))((= n 0)i)(if(search(format()"~d"(incf i))(format()"~d"(* i i)))(decf n))))

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

Renzo
источник

2

Чисто , 83 байта

import StdEnv,Text

(!!)[i\\i<-[1..]|indexOf(""<+i)(""<+i^2)>=0]

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

(!!)                               // index into the list of
 [ i                               // i for every
  \\ i <- [1..]                    // i from 1 upwards
  | indexOf (""<+i) (""<+i^2) >= 0 // where i is in the square of i
 ]

Οurous
источник

2

Желе , 6 байт

1ẇ²$#Ṫ

1-индексироваться.

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

Как?

Находит первое nиз последовательности в виде списка , а затем дает хвост, N.

1ẇ²$#Ṫ - Link: integer, n (>0)
1      - initialise x to 1
    #  - collect the first n matches, incrementing x, where:
   $   -   last two links as a monad:
  ²    -     square x
 ẇ     -     is (x) a substring of (x²)?
       -     (implicitly gets digits for both left & right arguments when integers)
     Ṫ - tail

Если бы мы 0считали натуральное число, мы могли бы использовать 1-индексированную полную программу ẇ²$#Ṫдля 5.

Джонатан Аллан
источник

2

Japt, 12 11 байт

@aJ±X²søY}f

Попытайся

È²søY «U´}a

Попытайся

мохнатый
источник

2

Рубин , 45 байт

->n,i=1{/#{i+=1}/=~"#{i*i}"&&n-=1while n>0;i}

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

Кирилл Л.
источник

2

Java 8, 66 65 63 байта

n->{int r=0;for(;!(++r*r+"").contains(r+"")||--n>0;);return r;}

-1 байт благодаря @Shaggy .
-2 байта благодаря @Arnauld .

1-индексироваться.

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

Объяснение:

n->{                // Method with integer as both parameter and return-type
  int r=0;          //  Result-integer, starting at 0
  for(;             //  Loop as long as:
       !(++r*r+"")  //    (increase result `r` by 1 first with `++r`)
                    //    If the square of the result `r` (as String) 
        .contains(  //    does not contain
          r+"")||   //    the result `r` itself (as String):
       --n>0;);     //     (decrease input `n` by 1 first with `--n`)
                    //     And continue looping if input `n` is not 0 yet
  return r;}        //  Return the result `r`

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

1

65 байтов

лохматый

1

@ Шэгги А, конечно. Благодарность!

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

1

@ Arnauld Ах, умный способ объединить цикл, и если! Благодарю.

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

2

Clojure , 81 байт

(fn[n](nth(filter #(clojure.string/includes?(str(* % %))(str %))(range))n))

Попробуйте онлайн! (К сожалению, TIO, похоже, не поддерживает стандартную библиотеку строк Clojure)

Если бы Clojure имел более короткий импортирующий синтаксис или имел includes?метод в базовой библиотеке, это могло бы быть несколько конкурентным.clojure.string/includes?один здесь длиннее, чем некоторые ответы здесь: /

(defn nth-sq-subs [n]
  (-> ; Filter from an infinite range of numbers the ones where the square of
      ;  the number contains the number itself
    (filter #(clojure.string/includes? (str (* % %)) (str %))
            (range))

    ; Then grab the "nth" result. Inc(rementing) n so 0 is skipped, since apparently
    ;  that isn't in the sequence
    (nth (inc n))))

Так как ссылка TIO не работает, вот тестовый прогон. Число слева - это индекс ( n) и результат (N ) - справа:

(mapv #(vector % (nth-sq-subs %)) (range 100))
=>
[[0 1]
 [1 5]
 [2 6]
 [3 10]
 [4 25]
 [5 50]
 [6 60]
 [7 76]
 [8 100]
 [9 250]
 [10 376]
 [11 500]
 [12 600]
 [13 625]
 [14 760]
 [15 1000]
 [16 2500]
 [17 3760]
 [18 3792]
 [19 5000]
 [20 6000]
 [21 6250]
 [22 7600]
 [23 9376]
 [24 10000]
 [25 14651]
 [26 25000]
 [27 37600]
 [28 50000]
 [29 60000]
 [30 62500]
 [31 76000]
 [32 90625]
 [33 93760]
 [34 100000]
 [35 109376]
 [36 250000]
 [37 376000]
 [38 495475]
 [39 500000]
 [40 505025]
 [41 600000]
 [42 625000]
 [43 760000]
 [44 890625]
 [45 906250]
 [46 937600]
 [47 971582]
 [48 1000000]
 [49 1093760]
 [50 1713526]
 [51 2500000]
 [52 2890625]
 [53 3760000]
 [54 4115964]
 [55 5000000]
 [56 5050250]
 [57 5133355]
 [58 6000000]
 [59 6250000]
 [60 6933808]
 [61 7109376]
 [62 7600000]
 [63 8906250]
 [64 9062500]
 [65 9376000]
 [66 10000000]
 [67 10050125]
 [68 10937600]
 [69 12890625]
 [70 25000000]
 [71 28906250]
 [72 37600000]
 [73 48588526]
 [74 50000000]
 [75 50050025]
 [76 60000000]
 [77 62500000]
 [78 66952741]
 [79 71093760]
 [80 76000000]
 [81 87109376]
 [82 88027284]
 [83 88819024]
 [84 89062500]
 [85 90625000]
 [86 93760000]
 [87 100000000]
 [88 105124922]
 [89 109376000]
 [90 128906250]
 [91 146509717]
 [92 177656344]
 [93 200500625]
 [94 212890625]
 [95 250000000]
 [96 250050005]
 [97 289062500]
 [98 370156212]
 [99 376000000]]

Это должно быть в состоянии поддерживать любую ценность n; при условии, что вы готовы дождаться его окончания (поиск 50-го и 100-го целых чисел в последовательности занял около 15 минут). Clojure поддерживает произвольно большую целочисленную арифметику, поэтому, как только числа начинают расти, она начинает использовать BigInts.

Carcigenicate
источник

1

Древесный уголь , 25 байт

Ｎθ≔¹ηＷθ«≦⊕η¿№Ｉ×ηηＩη≦⊖θ»Ｉη

Попробуйте онлайн! Ссылка на подробную версию кода. 0 индексированные. Объяснение:

Ｎθ

Вход n.

≔¹η

Начните Nс 1. (Или, это может начать подсчет, с 0которого вход 1 будет проиндексирован.)

Ｗθ«

Повторяйте, пока мы не найдем nчисла в последовательности.

≦⊕η

Приращение N.

¿№Ｉ×ηηＩη

Если N*Nсодержит N, то ...

≦⊖θ»

... декремент n.

Ｉη

Версия для печати N.

Мои дальнейшие попытки игры в гольф были заглушены углем: а) не иметь if..thenисключений, кроме конца блока (который стоит 2 байта); б) не иметь Containsоператора (преобразовывающего вывод Findили Countв логическое значение, которое я мог бы вычесть из nснова затрат 2 байта).

Нил
источник

1

Редактировать (ответ на комментарии): Python 2, 76 байт

Хотел попробовать нерекурсивный метод. (Новичок в гольфе, любые советы будут великолепны!)

def f(c,n=0):
    while 1:
        if`n`in`n*n`:
            if c<2:return n
            c-=1
        n+=1

Спасибо и BMO, и Веданту Кандою!

Генри Т
источник

2

Вам не нужно считать print(f(13))в коде. Кроме того while 1:, if c==1:return n,c==1 can be c<2

Vedant Kandoi

Ах, я не видел, что вы хотели нерекурсивную версию, nvm .. Во всяком случае, я в настоящее время считаю 76 байтов, а не 79.

ბიმო

И вы можете сохранить еще несколько: пробелы до и после `являются избыточными, а за одним - c<2:тоже, затем вы можете смешать табуляции и пробелы для отступа (как показано здесь ): 69 байтов . нет необходимости сохранять старую версию (она есть в истории редактирования для тех, кто интересуется), и почему бы не ссылаться на TIO (или аналогичную) / не использовать шаблон оттуда?

ბიმო

1

Haskell, 60 байт

([n^2|n<-[1..],elem(show n)$words=<<mapM(:" ")(show$n^2)]!!)

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

      n<-[1..]              -- loop n through all numbers starting with 1
 [n^2|        ,    ]        -- collect the n^2 in a list where
     elem(show n)           -- the string representation of 'n' is in the list
       words ... (show$n^2) -- which is constructed as follows:

            show$n^2        -- turn n^2 into a string, i.e. a list of characters
          (:" ")            -- a point free functions that appends a space
                            -- to a character, e.g.  (:" ") '1' -> "1 "
        mapM                -- replace each char 'c' in the string (n^2) with
                            -- each char from (:" ") c and make a list of all
                            -- combinations thereof.
                            -- e.g. mapM (:" ") "123" -> ["123","12 ","1 3","1  "," 23"," 2 ","  3","   "]
      words=<<              -- split each element into words and flatten to a single list
                            -- example above -> ["123","12","1","3","1","23","2","3"]

(                      !!)  -- pick the element at the given index

Ними
источник

1

Python 2 , 47 43 байта

^{-4 байта благодаря Денису (добавление 1 к рекурсивному вызову вместо возврата n-1)}

f=lambda c,n=1:c and-~f(c-(`n`in`n*n`),n+1)

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

Explantion / Ungolfed

Рекурсивная функция, принимающая два аргумента $c,n$ ; $n$ считается до $1,2,3\dots$ и каждый раз $n \texttt{ in } n^2$ это уменьшает $c$ , Рекурсия заканчивается, как только $c = 0$ :

# Enumerating elements of A018834 in reverse starting with 1
def f(counter, number=1):
    # Stop counting
    if counter == 0:
        return 0
    # Number is in A018834 -> count 1, decrement counter & continue
    elif `number` in `number ** 2`:
        return f(counter-1, number+1) + 1
    # Number is not in A018834 -> count 1, continue
    else:
        return f(counter, number+1) + 1

ბიმო
источник

1

APL (Dyalog Extended) , 31 30 байт

1∘{>⍵:⍺-1⋄(⍺+1)∇⍵-∨/(⍕⍺)⍷⍕⍺×⍺}

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

0 индексированные.

Zachary
источник

(⍕⍺)⍷⍕→⍺⍷⍥⍕

Adám

Я знал, что могу что-то сделать с этим ...

Захари

1

Perl 5 `-p` , 33 байта

map{1while++$\**2!~/${\}/}1..$_}{

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

Xcali
источник

1

Lua , 137 123 79 байт

-Спасибо @Jo King за 44 байта

n=io.read()i=0j=0while(i-n<0)do j=j+1i=i+(n.find(j*j,j)and 1or 0)end
print(j*j)

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

ouflak
источник

79 байтов . Некоторые общие советы; false/trueможет быть 0>1/ 0<1, скобки не нужны для ifs и whiles, вы можете удалить большую часть пробелов после чисел (даже новых строк).

Джо Кинг,

1

Tcl , 82 байта

proc S n {while 1 {if {[regexp [incr i] [expr $i**2]]&&[incr j]==$n} {return $i}}}

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

sergiol
источник

Я думаю, что вы можете смешивать время и с:proc S n {while {[incr j [regexp [incr i] [expr $i**2]]]-$n} {};return $i}

Дэвид

0

Приборка , 24 байта

{x:str(x)in'~.x^2}from N

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

Возвращает отложенный список, который при вызове как функция возвращает n th-й элемент в ряду.

объяснение

{x:str(x)in'~.x^2}from N
{x:              }from N       select all natural numbers `x` such that
   str(x)                      the string representation of `x`
         in                    is contained in
           '~.x^2              "~" + str(x^2)

Конор О'Брайен
источник

Число в квадрате

правила

Ответы:

05AB1E , 6 байтов

Perl 6 , 33 31 байт

Объяснение:

JavaScript (ES6), 43 байта

Нерекурсивная версия, 47 байт

MathGolf , 8 байт (работает для любого ввода в теории, но только для `n<10`практики)

Альтернатива (работает на `n<49`практике и в теории)

объяснение

Common Lisp, 95 байт

Чисто , 83 байта

Желе , 6 байт

Как?

Japt, 12 11 байт

Рубин , 45 байт

Java 8, 66 65 63 байта

Clojure , 81 байт

Древесный уголь , 25 байт

Редактировать (ответ на комментарии): Python 2, 76 байт

Haskell, 60 байт

Python 2 , 47 43 байта

Explantion / Ungolfed

APL (Dyalog Extended) , 31 30 байт

Perl 5 `-p` , 33 байта

Lua , 137 123 79 байт

Tcl , 82 байта

Приборка , 24 байта

объяснение

Число в квадрате

правила

Ответы:

05AB1E , 6 байтов

Perl 6 , 33 31 байт

Объяснение:

JavaScript (ES6), 43 байта

Нерекурсивная версия, 47 байт

MathGolf , 8 байт (работает для любого ввода в теории, но только для n<10практики)

Альтернатива (работает на n<49практике и в теории)

объяснение

Common Lisp, 95 байт

Чисто , 83 байта

Желе , 6 байт

Как?

Japt, 12 11 байт

Рубин , 45 байт

Java 8, 66 65 63 байта

Clojure , 81 байт

Древесный уголь , 25 байт

Редактировать (ответ на комментарии): Python 2, 76 байт

Haskell, 60 байт

Python 2 , 47 43 байта

Explantion / Ungolfed

APL (Dyalog Extended) , 31 30 байт

Perl 5 -p , 33 байта

Lua , 137 123 79 байт

Tcl , 82 байта

Приборка , 24 байта

объяснение

MathGolf , 8 байт (работает для любого ввода в теории, но только для `n<10`практики)

Альтернатива (работает на `n<49`практике и в теории)

Perl 5 `-p` , 33 байта