Étant donné l'entrée d'un entier positif n, écrivez un programme qui termine le processus suivant.

• Trouver le plus petit entier positif plus grand que ncela est un carré parfait et est la concaténation de net un autre nombre. L'ordre des chiffres de nne peut pas être modifié. Le nombre concaténé npour produire un carré parfait peut être appelé r_1.
• Si ce r_1n'est pas un carré parfait, répétez le processus ci-dessus avec r_1comme nouvelle entrée dans le processus. Répétez jusqu'à ce que r_ksoit un carré parfait, noté s.
• Imprime la valeur de sqrt(s).

L'entrée peut être prise dans n'importe quel format. Vous pouvez supposer qu'il ns'agit d'un entier positif. Si l'un r_ka un zéro de tête (et r_k≠ 0), le zéro peut être ignoré.

Cas de test

Voici quelques cas de test. Le processus illustre les étapes ci-dessus.

Input:   23
Process: 23, 2304, 4
Output:  2

Input:   10
Process: 10, 100, 0
Output:  0

Input:   1
Process: 1, 16, 6, 64, 4
Output:  2

Input:   5
Process: 5, 529, 29, 2916, 16
Output:  4

Input:   145
Process: 145, 145161, 161, 16129, 29, 2916, 16
Output:  4

Input:   1337
Process: 1337, 13373649, 3649, 36493681, 3681, 368102596, 2596, 25969216, 9216
Output:  96

C'est le golf de code. Des règles standard s'appliquent. La réponse la plus courte (en octets) l'emporte.

Pyth, 26 octets

LsI@b2 fy=sh.fys+QZ1\0)@Q2

Suite de tests

La sortie est comme un flotteur. Si la sortie en tant qu'int est souhaitée, ce serait 1 octet supplémentaire.

Explication:

LsI@b2 fy=sh.fys+QZ1\0)s@Q2
                               Q = eval(input())
L                              def y(b): return
   @b2                         Square root of b
 sI                            Is an integer.
       f              )        Find the first positive integer T that satisfies
           h.f     1\0         Find the first digit string Z that satisfies
                +QZ            Concatenation of Q and Z
               s               Converted to an integer
              y                Is a pergect square.
          s                    Convert the string to an integer
         =                     Assign result to the next variable in the code, Q
        y                      Repeat until result is a perfect square
                               (The space) Discard return value
                        @Q2    Take square root of Q and print.

MATL , 35 44,0 octets

XK``x@2^tVKVXf1=a~]VKVnQ0h)UXKX^t1\

Essayez-le en ligne!

XK        % implicit input: n. Copy to clipboard K
`         % do...while. Each iteration applies the algorithm
  `       %   do...while. Each iteration tests a candidate number
    x     %     delete top of stack
    @2^   %     iteration index squared
    t     %     duplicate
    V     %     convert to string                
    K     %     paste from clipboard K: n or r_k
    V     %     convert to string  
    Xf    %     find one string within another. Gives indices of starting matches, if any 
    1=a~  %     test if some of those indices is 1. If not: next iteration
  ]       %   end. We finish with a perfect square that begins with digits of n or r_k
  V       %   convert to string
  K       %   paste from clipboard K: n or r_k
  VnQ0h   %   index of rightmost characters, as determined by r_k
  )       %   keep those figures only
  U       %   convert to number. This is the new r_k
  XK      %   copy to clipboard K, to be used as input to algorithm again, if needed
  X^      %   square root
  1\      %   fractional part. If not zero: apply algorithm again
          % implitic do...while loop end
          % implicit display

Python 2, 98

i=input();d=o=9
while~-d:
 n=i;d=o+1;o=i=0
 while(n*d+i)**.5%1:i=-~i%d;d+=9*d*0**i
print'%d'%n**.5

Essayez-le en ligne .

Python, 200 198 178 octets

import math
def r(i):
 j=int(i**.5)+1
 while str(j*j)[:len(str(i))]!=str(i):j+=1
 return int(str(j*j)[len(str(i)):])
q=r(int(input()))
while math.sqrt(q)%1!=0:q=r(q)
print(q**.5)

Brachylog , 26 octets

{~a₀X√ℕ∧YcX∧Yh?∧Ybcℕ≜!}ⁱ√ℕ

Essayez-le en ligne!

Le dernier cas de test a été omis dans la liaison TIO car il suffit de plus d'une minute pour s'exécuter. Je l'ai exécuté sur mon ordinateur portable et le résultat correct a été obtenu en moins de deux heures.

{                             The input
 ~a₀                          is a prefix of
    X√                        X, the square root of which
      ℕ                       is a whole number.
       ∧YcX                   Y concatenated is X.
           ∧Yh?               The input is the first element of Y.
               ∧Yb            The rest of Y,
                  c           concatenated,
                      }       is the output
                   ℕ          which is a whole number.
                    ≜         Make sure that it actually has a value,
                     !        and discard all choice points.
{                     }ⁱ      Keep feeding that predicate its own output until
                        √     its output's square root
                         ℕ    is a whole number
                              which is the output.

L'avant-dernier ℕest nécessaire lorsque l'entrée initiale est déjà un carré parfait, donc le premier carré parfait qui l'a comme préfixe est lui-même, et !est nécessaire pour s'assurer que le retour arrière itère au lieu de trouver un carré concaténé plus grand, mais je ne sais pas vraiment pourquoi ≜est nécessaire, je sais juste que 5 produit une mauvaise réponse sans elle.

Perl 6 , 101 octets

my&q={$^k;$_=({++($||=$k.sqrt.Int)**2}.../^$k/)[*-1];+S/$k//}
put (q(get),&q...!(*.sqrt%1))[*-1].sqrt

my &q = {
  $^k; # declare placeholder parameter
  # set default scalar to:
  $_ = ( # a list
    # code block that generates every perfect square
    # larger than the input
    { ++( $ ||= $k.sqrt.Int )**2 }
    ...   # produce a sequence
    /^$k/ # ending when it finds one starting with the argument
  )[*-1]; # last value in sequence

  # take the last value and remove the argument
  # and turn it into a number to remove leading zeros
  +S/$k//
}

put (     # print the result of:
  q(get),     # find the first candidate
  &q          # find the rest of them
  ...         # produce a sequence
  !(*.sqrt%1) # ending with a perfect square
)[*-1]        # last value in sequence
.sqrt         # find the sqrt

ES7, 116 octets

n=>{do{for(i=n;!(r=(''+Math.ceil((i*=10)**0.5)**2)).startsWith(+n););n=r.replace(+n,'');r=n**0.5}while(r%1);return r}

Oui, je pourrais probablement enregistrer un octet en utilisant eval.