Considérons une séquence de nombres naturels pour laquelle N apparaît comme une sous-chaîne dans N ^ 2. A018834

Sortez le ne élément de cette séquence.

Règles

Le programme ne prend que ncomme entrée et sort un seul numéro - N.

La séquence peut être indexée 0 ou indexée 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 ...

C'est le code-golf donc le code le plus court gagne.

05AB1E , 6 octets

1 indexé

µNNnNå

Essayez-le en ligne!

Explication

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

-2 octets grâce à nwellnhof

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

Essayez-le en ligne!

Explication:

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

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

Essayez-le en ligne!

Version non récursive, 47 octets

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

Essayez-le en ligne!

MathGolf , 8 octets (fonctionne pour toute entrée en théorie, mais uniquement pour la n<10pratique)

úrgɲï╧§

Essayez-le en ligne!

Alternative (travaux n<49en pratique et théorie)

►rgɲï╧§

La seule différence est qu'au lieu de créer une liste avec des 10^(input)valeurs, je crée une liste avec des 10^6éléments. Cela prend un certain temps à s'exécuter, vous pouvez donc échanger le premier octet vers n'importe quel autre littéral de 1 octet pour le tester.

Explication

ú          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 raison pour laquelle cette solution ne gère pas les entrées volumineuses est que j'ai remarqué que la séquence croît moins qu'exponentiellement, mais plus que n'importe quel polynôme. C'est pourquoi j'ai utilisé l' 10**nopérateur (je voulais utiliser 2**nmais il a échoué pour l'entrée 1). Cela signifie que je crée un tableau extrêmement grand même pour de petites entrées, juste pour en filtrer la grande majorité, puis prendre l'un des premiers éléments. C'est extrêmement inutile, mais je ne pouvais pas trouver d'autre moyen de le faire sans augmenter le nombre d'octets.

Lisp commun, 95 octets

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

Essayez-le en ligne!

Nettoyer , 83 octets

import StdEnv,Text

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

Essayez-le en ligne!

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

Gelée , 6 octets

1ẇ²$#Ṫ

1 indexé.

Essayez-le en ligne!

Comment?

Recherche le premier nde la séquence comme une liste et on obtient alors la queue 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 0étaient considérés comme un nombre naturel, nous pourrions utiliser le programme complet indexé 1 ẇ²$#Ṫpour 5.

Japt, 12 11 octets

@aJ±X²søY}f

Essayez-le

ȲsøY «U´}a

Essayez-le

Rubis , 45 octets

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

Essayez-le en ligne!

Java 8, 66 65 63 octets

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

-1 octet grâce à @Shaggy .
-2 octets grâce à @Arnauld .

1 indexé.

Essayez-le en ligne.

Explication:

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 octets

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

Essayez-le en ligne! (Malheureusement, TIO ne semble pas prendre en charge la bibliothèque de chaînes standard de Clojure)

Si Clojure avait une syntaxe d'importation plus courte, ou avait une includes?méthode dans la bibliothèque principale, cela pourrait en fait être quelque peu compétitif. clojure.string/includes?seul est cependant plus long que certaines réponses ici: /

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

Étant donné que le lien TIO est rompu, voici un test. Le nombre à gauche est l'index ( n), et le résultat ( N) est à droite:

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

Cela devrait pouvoir prendre en charge n'importe quelle valeur de n; à condition que vous soyez prêt à attendre qu'il se termine (la recherche des 50e à 100e entiers dans la séquence a pris environ 15 minutes). Clojure prend en charge l'arithmétique arbitrairement grande, donc une fois que les nombres commencent à devenir énormes, il commence à utiliser BigInts.

Fusain , 25 octets

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

Essayez-le en ligne! Le lien est vers la version détaillée du code. 0 indexé. Explication:

Ｎθ

Entrée n.

≔¹η

Commencez Nà 1. (Ou, cela pourrait commencer à compter 0ce qui rendrait l'entrée 1 indexée.)

Ｗθ«

Répétez jusqu'à ce que nous ayons trouvé des nnombres dans la séquence.

≦⊕η

Incrément N.

¿№Ｉ×ηηＩη

Si N*N contient N, alors ...

≦⊖θ»

... décrémenter n.

Ｉη

Imprimer N.

Mes tentatives pour jouer au golf plus loin ont été contrecarrées par le charbon de bois a) n'ayant pas de if..thensauf à la fin d'un bloc (qui coûte 2 octets) b) n'ayant pas d' Containsopérateur (convertissant la sortie de Findou Counten booléen que je pourrais soustraire des ncoûts à nouveau 2 octets).

Edit (réponse aux commentaires): Python 2, 76 octets

Je voulais essayer une méthode non récursive. (Nouveau au golf, tous les conseils seraient formidables!)

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

Merci à BMO et à Vedant Kandoi!

Haskell, 60 octets

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

Essayez-le en ligne!

      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 octets

^{-4 octets grâce à Dennis (en ajoutant 1 à l'appel récursif au lieu de revenir n-1)}

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

Essayez-le en ligne!

Explantion / Ungolfed

Fonction récursive prenant deux arguments $c,n$; $n$ est compté $1,2,3\dots$ et à chaque fois $n \texttt{ in } n^2$ ça diminue $c$. La récursivité se termine dès que$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 octets

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

Essayez-le en ligne!

0 indexé.

Perl 5 -p , 33 octets

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

Essayez-le en ligne!

Lua , 137 123 79 octets

-Merci @Jo King pour 44 octets

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)

Essayez-le en ligne!

Tcl , 82 octets

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

Essayez-le en ligne!

Bien rangé , 24 octets

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

Essayez-le en ligne!

Renvoie une liste paresseuse qui, lorsqu'elle est appelée comme une fonction, renvoie n e élément de la série.

Explication

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