Esto fue inspirado por parte de la competencia ARML 2016 Equipo Problema # 6.

Aquí está el desafío:

Te dan una "secuencia comodín", que es una secuencia de dígitos y otro carácter. Una cadena coincide con esta secuencia comodín mediante el siguiente pseudocódigo:

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

Dónde '?' es un personaje de tu elección.

En términos de expresiones regulares, solo imagínense el '?'ser '.'.

El desafío es encontrar todos los números cuadrados (el requisito es de hasta 1 millón) cuyas representaciones de cadenas decimales coinciden con esta secuencia comodín. El "carácter comodín" puede ser cualquier carácter ASCII de su elección, siempre que no sea un dígito, obviamente.

Por ejemplo, 4096partidos 4**6y 4*9*aunque 4114no coincide tampoco.

Entrada

La entrada se dará como una secuencia que coincida con la expresión regular [0-9?]+. Puede ser una cadena, una matriz de caracteres o una matriz de bytes de los caracteres en ASCII.

Salida

La salida será una lista / conjunto / conjunto de números delimitados por lo que desee que sean cuadrados perfectos y coincidan con la secuencia de comodines.

Ejemplos de entradas válidas:

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]

Ejemplos de salidas válidas:

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

etc.

Especificaciones

• No puede usar los builtins para encontrar una lista de cuadrados en un cierto rango
• Se aplican lagunas estándar
• Debe poder manejar hasta 1 000 000 (1 millón)
• Si se proporciona con la entrada 1******, es correcto imprimir [1000000]. También es correcto imprimir[1000000, 1002001, 1004004, 1006009, 1008016, 1010025, ...]
• Las secuencias comodín nunca comenzarán con el carácter comodín; es decir, siempre coincidirán con cadenas de la misma longitud.

Casos de prueba

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]

Victorioso

Envío más corto (válido) (en funcionamiento) antes del 14 de febrero, desempate por el ganador más temprano.

05AB1E , 22 bytes

Probablemente hay mucho margen de mejora aquí.
Cualquier no dígito está bien como comodín.

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

Pruébalo en línea!

Explicación por venir después de más golf.

Mathematica, 44 bytes

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

La entrada es una lista de dígitos con un _(sin comillas) como comodín. p.ej{4, _, _, 6}

Explicación

Range@1*^3

Generar lista {1, 2, 3, ... , 1000}

... ^2

Encuadrelo. (lista de todos los cuadrados del 1 al 1,000,000)

IntegerDigits[ ... ]

Divide cada cuadrado en una lista de dígitos.

... ~Cases~#

Encuentra los que coinciden con el patrón especificado por la entrada.

Print@@@ ...

Imprimirlos.

Brachylog , 23 bytes

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

Pruébalo en línea!

Explicación

@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

Formato de entrada diferente, 13 bytes

Dependiendo de lo que considere válido como entrada, puede hacer esto:

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

Pruébalo en línea!

que es básicamente la segunda parte de la respuesta anterior, con una lista como entrada que contiene dígitos y variables donde están los comodines.

Sin embargo, no considero esto válido porque solo hay 26 nombres de variables en Brachylog (las letras mayúsculas), por lo que esto no funcionaría si tuviera más de 26 wilcards.

Perl 6 , 30 26 bytes

¡Gracias a @ b2gills por -4 bytes!

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

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

Utiliza el punto como carácter comodín, de modo que la entrada puede usarse como una expresión regular:

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

Pruébalo en línea .

Una variante que acepte el asterisco como comodín (como sugiere una revisión previa de la descripción de la tarea) sería de 42 bytes:

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

Ruby, 54 bytes

Función que toma un argumento de cadena. Pruébalo en línea.

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

Lote, 109 bytes

@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

Usos ?como comodín. Funciona creando 1000 archivos. El nombre del archivo es el número cuadrado y la extensión del archivo es el número cuadrado con un $sufijo. Esto se debe a que la coincidencia de patrones de Batch cuenta los ?s finales como opcionales, por 1?lo que coincidirá con ambos 1y 16; $Por lo tanto, obliga a que la coincidencia sea exacta. Sin embargo, no queremos generar el $, por lo que solo mostramos el nombre del archivo sin extensión.

JavaScript (ES6), 68 66 bytes

EDITAR: Actualicé mi solución a continuación después de inspirarme con la respuesta de JungHwan Min . Ahora es compatible con ES6.

Toma entrada en el formato '1..4' donde .está el comodín.

En lugar de iterar a 1e6 y enraizamiento cuadrado, este itera a 1e3 y cuadrados.

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 bytes

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

Crea una matriz de números del 0 al 1e6 y luego la filtra por números que son cuadrados y coinciden con el patrón.

Es terriblemente lento porque siempre itera a 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 bytes

EDITAR: aclaración de Alex, podemos usar el punto como carácter comodín que elimina la operación y //.

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

EDITAR: solución que utiliza el asterisco como carácter comodín y espera la secuencia comodín en STDIN

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

Sin duda, esto deja mucho margen de mejora, es bastante sencillo. La expresión comodín se espera como argumento de línea de comando, con el carácter comodín de punto (¿qué más?).

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

Python 3 - 98 97 bytes

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

Requiere una entrada como '4..6'.

k - 28 caracteres

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

Se utiliza ?como carácter comodín. La likefunción se usa ?como comodín, y esta función hace una lista de los primeros 1001 cuadrados (para incluir 1M), los convierte a todos en cadenas y luego comprueba dónde coinciden con el patrón.

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

bash + utilidades Unix, 33 bytes

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

Esto usa '.' como el carácter comodín.

El programa de CC imprime los números cuadrados en un bucle infinito:

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 salida de CC se canaliza a grep, que imprime solo los cuadrados que coinciden con el patrón requerido.

Esto funciona cuando lo ejecuto en un sistema Linux o OS X real (pero no funciona en TIO, probablemente porque el programa de CC intenta repetirse para siempre, y sospecho que TIO se queda sin espacio de pila para la recursión y / o tiene un problema con la tubería interminable).