Considere una secuencia de números naturales para la cual N aparece como una subcadena en N ^ 2. A018834

Salida del nelemento th de esta secuencia.

Reglas

El programa solo toma ncomo entrada y produce solo un número - N.

La secuencia puede ser 0 indexada o 1 indexada.

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 ...

Este es el código de golf, por lo que gana el código más corto.

05AB1E , 6 bytes

1 indexado

µNNnNå

Pruébalo en línea!

Explicación

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

Perl 6 , 33 31 bytes

-2 bytes gracias a nwellnhof

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

Pruébalo en línea!

Explicación:

{                            }  # 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

JavaScript (ES6), 43 bytes

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

Pruébalo en línea!

Versión no recursiva, 47 bytes.

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

Pruébalo en línea!

MathGolf , 8 bytes (funciona para cualquier entrada en teoría, pero solo para la n<10práctica)

úrgɲï╧§

Pruébalo en línea!

Alternativa (funciona n<49en la práctica y la teoría)

►rgɲï╧§

La única diferencia es que, en lugar de crear una lista con 10^(input)valores, creo una lista con 10^6elementos. Esto tarda un tiempo en ejecutarse, por lo que puede cambiar el primer byte a cualquier otro literal de 1 byte para probarlo.

Explicación

ú          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

La razón por la cual esta solución no maneja entradas grandes es que noté que la secuencia crece menos que exponencialmente, pero más que cualquier polinomio. Es por eso que usé el 10**noperador (quería usarlo 2**npero falló para la entrada 1). Eso significa que creo una matriz extremadamente grande incluso para entradas pequeñas, solo para filtrar la gran mayoría y luego tomar uno de los primeros elementos. Es extremadamente derrochador, pero no pude encontrar otra forma de hacerlo sin aumentar el recuento de bytes.

Lisp común, 95 bytes

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

Pruébalo en línea!

Limpio , 83 bytes

import StdEnv,Text

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

Pruébalo en línea!

(!!)                               // 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
 ]

Jalea , 6 bytes

1ẇ²$#Ṫ

1 indexado.

Pruébalo en línea!

¿Cómo?

Busca el primero nde la secuencia como una lista y luego se obtiene la cola, 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

Si 0se considerara un número natural, podríamos usar el programa completo indexado 1 ẇ²$#Ṫpara 5.

Japt, 12 11 bytes

@aJ±X²søY}f

Intentalo

ȲsøY «U´}a

Intentalo

Ruby , 45 bytes

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

Pruébalo en línea!

Java 8, 66 65 63 bytes

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

-1 byte gracias a @Shaggy .
-2 bytes gracias a @Arnauld .

1 indexado.

Pruébalo en línea.

Explicación:

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`

Clojure , 81 bytes

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

Pruébalo en línea! (Desafortunadamente, TIO no parece admitir la biblioteca de cadenas estándar de Clojure)

Si Clojure tuviera una sintaxis de importación más corta, o tuviera un includes?método en la biblioteca central, esto podría ser algo competitivo. clojure.string/includes?solo es más largo que algunas respuestas aquí: /

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

Como el enlace TIO está roto, aquí hay una prueba de funcionamiento. El número a la izquierda es el índice ( n), y el resultado ( N) está a la derecha:

(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]]

Esto debería ser capaz de soportar cualquier valor de n; siempre que esté dispuesto a esperar a que termine (encontrar los números enteros 50 a 100 en la secuencia tomó como 15 minutos). Clojure admite aritmética de enteros arbitrariamente grandes, por lo que una vez que los números comienzan a ser enormes, comienza a usar BigInts.

Carbón de leña , 25 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. 0 indexado. Explicación:

Ｎθ

Entrada n.

≔¹η

Comience Nen 1. (O, esto podría comenzar a contar en lo 0que haría que la entrada se indexara 1).

Ｗθ«

Repita hasta que hayamos encontrado nnúmeros en la secuencia.

≦⊕η

Incremento N.

¿№Ｉ×ηηＩη

Si N*Ncontiene N, entonces ...

≦⊖θ»

... decremento n.

Ｉη

Imprimir N.

Mis intentos de jugar al golf más allá se vieron obstaculizados por el carbón vegetal a) no tener un if..thenexcepto al final de un bloque (que cuesta 2 bytes) b) no tener un Containsoperador (convertir la salida de Findo Counten un booleano del que podría restar nnuevamente costos 2 bytes).

Editar (respuesta a comentarios): Python 2, 76 bytes

Quería probar un método no recursivo. (¡Nuevo en el golf, cualquier consejo sería genial!)

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

¡Gracias BMO y Vedant Kandoi!

Haskell, 60 bytes

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

Pruébalo en línea!

      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

Python 2 , 47 43 bytes

^{-4 bytes gracias a Dennis (agregando 1 a la llamada recursiva en lugar de regresar n-1)}

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

Pruébalo en línea!

Explantion / Ungolfed

Función recursiva tomando dos argumentos $c,n$; $n$ se cuenta $1,2,3\dots$ y cada vez $n \texttt{ in } n^2$ disminuye $c$. La recursión termina tan pronto como$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

APL (Dyalog Extended) , 31 30 bytes

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

Pruébalo en línea!

0 indexado.

Perl 5 -p , 33 bytes

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

Pruébalo en línea!

Lua , 137 123 79 bytes

-gracias a @Jo King por 44 bytes

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)

Pruébalo en línea!

Tcl , 82 bytes

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

Pruébalo en línea!

Ordenado , 24 bytes

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

Pruébalo en línea!

Devuelve una lista perezosa que, cuando se llama como una función, devuelve el n elemento th de la serie.

Explicación

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