Cela a été inspiré par une partie du problème d'équipe n ° 6 du concours ARML 2016.

Voici le défi:

Vous obtenez une "séquence générique", qui est une séquence de chiffres et un autre caractère. Une chaîne correspond à cette séquence générique par le pseudocode suivant:

w = wildcard
s = string
# s matches w iff
for all 0 >= i > wildcard.length, w[i] == '?' or s[i] == w[i]

Où '?' est un personnage de votre choix.

En termes de regex, imaginez juste l' '?'être '.'.

Le défi consiste à trouver tous les nombres carrés (l'exigence est jusqu'à 1 million) dont les représentations de chaînes décimales correspondent à cette séquence générique. Le "caractère générique" peut être n'importe quel caractère ASCII de votre choix, tant qu'il ne s'agit pas d'un chiffre, évidemment.

Par exemple, 4096correspond à 4**6et 4*9*mais 4114ne correspond pas non plus.

Contribution

L'entrée sera donnée sous la forme d'une séquence correspondant à l'expression régulière [0-9?]+. Il peut s'agir d'une chaîne, d'un tableau de caractères ou d'un tableau d'octets de caractères en ASCII.

Production

La sortie sera une liste / ensemble / tableau de nombres que vous voulez, qui sont des carrés parfaits et correspondent à la séquence générique.

Exemples d'entrées valides:

1234567*90
1234567?90
1234567u90
['1', '2', '3', '4', '5', '6', '7', '*', '9', '0']
[49, 50, 51, 52, 53, 54, 55, 42, 57, 48]
[1, 2, 3, 4, 5, 6, 7, '*', 9, 0]

Exemples de sorties valides:

[1, 4, 9]
1 4 9
1, 4, 9
1-4-9

etc.

Caractéristiques

• Vous ne pouvez pas utiliser les fonctions intégrées pour trouver une liste de carrés dans une certaine plage
• Les échappatoires standard s'appliquent
• Vous devez être capable de gérer jusqu'à 1 000 000 (1 million)
• S'il est fourni avec l'entrée 1******, il est correct d'imprimer [1000000]. Il est également correct d'imprimer[1000000, 1002001, 1004004, 1006009, 1008016, 1010025, ...]
• Les séquences génériques ne commenceront jamais par le caractère générique; c'est-à-dire qu'ils correspondront toujours à des chaînes de même longueur.

Cas de test

4**6  ->  [4096, 4356]
1**1  ->  [1521, 1681]
1**  ->  [100, 121, 144, 169, 196]
9****9  ->  [908209, 915849, 927369, 935089, 946729, 954529, 966289, 974169, 986049, 994009]
9*9***  ->  [919681, 929296]
1**0*  ->  [10000, 10201, 10404, 10609, 12100, 14400, 16900, 19600]
9***4  ->  [91204, 94864, 97344]

Gagnant

Soumission la plus courte (valide) (en état de fonctionnement) avant le 14 février, départage par la première soumission gagnante.

05AB1E , 22 octets

Probablement beaucoup de place pour l'amélioration ici.
Tout non-chiffre est correct en tant que caractère générique.

3°LnvyS¹)ø€Æ0QPyg¹gQ&—

Essayez-le en ligne!

Explication à venir après un nouveau golf.

Mathematica, 44 octets

Print@@@IntegerDigits[Range@1*^3^2]~Cases~#&

L'entrée est une liste de chiffres avec un _(sans guillemets) comme caractère générique. par exemple{4, _, _, 6}

Explication

Range@1*^3

Générer une liste {1, 2, 3, ... , 1000}

... ^2

Carré. (liste de tous les carrés de 1 à 1 000 000)

IntegerDigits[ ... ]

Divisez chaque carré en une liste de chiffres.

... ~Cases~#

Trouvez ceux qui correspondent au modèle spécifié par l'entrée.

Print@@@ ...

Imprimez-les.

Brachylog , 23 octets

@e:{@$|,}a#0:{c.~^#I,}f

Essayez-le en ligne!

Explication

@e                        Split into a list of characters
  :{@$|,}a                Replace each digit char by the corresponding digit, and each things
                            that are ot digits into variables
          #0              All elements of the resulting list must be digits
            :{       }f   Output is the result of finding all...
              c.            ...concatenations of those digits which...
               .~^#I,       ...result in a number which is the square of an integer #I

Format d'entrée différent, 13 octets

Selon ce que vous considérez comme valide, vous pouvez le faire:

#0:{c.~^#I,}f

Essayez-le en ligne!

qui est fondamentalement la deuxième partie de la réponse ci-dessus, avec une liste en entrée contenant des chiffres et des variables où se trouvent les caractères génériques.

Je ne considère pas cela comme valide car il n'y a que 26 noms de variables dans Brachylog (les lettres majuscules), donc cela ne fonctionnerait pas si vous aviez plus de 26 wilcards.

Perl 6 , 30 26 octets

Merci à @ b2gills pour -4 octets!

{grep /^<$_>$/,map * **2,^1e4}

{grep /^<$_>$/,(^1e4)»²}

Utilise le point comme caractère générique, de sorte que l'entrée peut être utilisée comme expression régulière:

{                            }   # a lambda
                         ^1e4    # range from 0 to 9999
               map * **2,        # square each value
 grep /      /,                  # filter numbers that match this regex:
        <$_>                     #   lambda argument eval'ed as sub-regex
       ^    $                    #   anchor to beginning and end

Essayez-le en ligne .

Une variante qui accepte l'astérisque comme caractère générique (comme suggéré par une révision précédente de la description de la tâche) serait de 42 octets:

{grep /^<{.trans("*"=>".")}>$/,(^1e4)»²}

Rubis, 54 octets

Fonction qui prend un argument de chaîne. Essayez-le en ligne.

->s{(0..1e3).map{|i|"#{i**2}"[/^#{s.tr ?*,?.}$/]}-[p]}

Lot, 109 octets

@for /l %%i in (0,1,999)do @set/aj=%%i*%%i&call copy nul %%j%%.%%j%%$>nul
@for %%s in (%1.%1$)do @echo %%~ns

Utilise ?comme caractère générique. Fonctionne en créant 1000 fichiers. Le nom du fichier est le numéro carré et l'extension du fichier est le numéro carré avec un $suffixe. Cela est dû au fait que la correspondance de motifs de Batch compte les ?s de fin comme facultatifs, ainsi 1?les deux 1et 16; la $force donc la correspondance à être exacte. Cependant, nous ne voulons pas sortir le $, donc nous ne faisons que sortir le nom du fichier sans extension.

JavaScript (ES6), 68 66 octets

EDIT: J'ai mis à jour ma solution ci-dessous après avoir été inspiré par la réponse de JungHwan Min . Il est désormais compatible ES6.

Prend l'entrée au format '1..4'où .est le caractère générique.

Au lieu d'itérer à 1e6 et d'enracinement carré celui-ci itère à 1e3 et carrés.

p=>[...Array(1e3)].map((_,n)=>''+n*n).filter(n=>n.match(`^${p}$`))

F=p=>[...Array(1e3)].map((_,n)=>''+n*n).filter(n=>n.match(`^${p}$`))

const update = () => {
  console.clear();
  console.log(F(input.value));
}

submit.onclick = update;
update();

<input id="input" type="text" value="9....9" style="width: 100%; box-sizing: border-box" /><button id="submit">submit</button>

JavaScript (ES7), 71 69 octets

p=>[...Array(1e6).keys()].filter(n=>n**.5%1?0:(''+n).match(`^${p}$`))

Crée un tableau de nombres de 0 à 1e6, puis le filtre par des nombres carrés et correspondant au modèle.

Il est horriblement lent car il itère toujours à 1e6.

F=p=>[...Array(1e6).keys()].filter(n=>n**.5%1?0:(''+n).match(`^${p}$`))

const update = () => {
  console.clear();
  console.log(F(input.value));
}

submit.onclick = update;
update();

<input id="input" type="text" value="9....9" style="width: 100%; box-sizing: border-box" /><button id="submit">submit</button>

Perl, 42 45 38 octets

EDIT: clarification par Alex, nous pouvons utiliser le point comme caractère générique qui supprime l'opération y //.

perl -pe 's|.*|@{[grep/^$&$/,map$_*$_,1..1e3]}|'

EDIT: solution qui utilise l'astérisque comme caractère générique et attend la séquence de caractères génériques sur STDIN

perl -pe 'y/*/./;s|.*|@{[grep/^$&$/,map$_*$_,1..1e3]}|'

Celui-ci laisse sans aucun doute beaucoup de place à l'amélioration, c'est assez simple. L'expression générique est attendue comme argument de ligne de commande, avec le caractère générique point (quoi d'autre?).

say"@{[grep/^$ARGV[0]$/,map$_*$_,1..1e3]}"

Python 3-98 97 octets

import re;print(re.findall(r"\b"+input()+r"\b",("\n".join([str(x*x) for x in range(1,1001)]))))

Nécessite une entrée comme «4..6».

k - 28 caractères

{s(&:)($:s:s*s:!1001)like x}

Utilise ?comme caractère générique. La likefonction utilise ?comme caractère générique, et cette fonction fait une liste des 1001 premiers carrés (à inclure dans 1M), les convertit tous en chaînes, puis vérifie où ils correspondent au modèle.

    {s(&:)($:s:s*s:!1001)like x} "1??"
100 121 144 169 196

utilitaires bash + Unix, 33 octets

dc<<<'0[2^pv1+lax]dsax'|grep ^$1$

Cela utilise '.' comme caractère générique.

Le programme DC imprime les nombres carrés dans une boucle infinie:

0     Push 0 on the stack.

[     Start a macro (called a).

2^    Square the number at the top of the stack.

p     Print the number at the top of the stack, followed by a newline.

v     Replace the number at the top of the stack (a square number) with its square root.

1+    Increment the number at the top of the stack.

lax   Run the macro again (looping).

]     End of the macro.

dsax  Store the macro in register a and run it.

La sortie cc est dirigée vers grep, qui imprime uniquement les carrés qui correspondent au modèle requis.

Cela fonctionne lorsque je l'exécute sur un système Linux ou OS X réel (mais cela ne fonctionne pas sur TIO, probablement parce que le programme dc essaie de récurer pour toujours, et je soupçonne que TIO manque d'espace sur la pile pour la récursivité et / ou a un problème avec le tuyau sans fin).