Questo è stato ispirato da una parte del concorso ARML 2016 Team Problem # 6.

Ecco la sfida:

Ti viene data una "sequenza di caratteri jolly", che è una sequenza di cifre e un altro carattere. Una stringa corrisponde a questa sequenza di caratteri jolly con il seguente pseudocodice:

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

Dove '?' è un personaggio a tua scelta.

In termini di regex, immagina '?'di essere '.'.

La sfida è trovare tutti i numeri quadrati (il requisito è fino a 1 milione) le cui rappresentazioni di stringhe decimali corrispondono a questa sequenza di caratteri jolly. Il "carattere jolly" può essere qualsiasi carattere ASCII di tua scelta, purché non sia una cifra, ovviamente.

Ad esempio, 4096partite 4**6e 4*9*ma 4114non corrisponde neanche.

Ingresso

L'input verrà dato come una sequenza corrispondente alla regex [0-9?]+. Può essere una stringa, una matrice di caratteri o una matrice di byte dei caratteri in ASCII.

Produzione

L'output sarà un elenco / insieme / matrice di numeri delimitati da qualsiasi valore, che siano quadrati perfetti e corrispondano alla sequenza di caratteri jolly.

Esempi di input validi:

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]

Esempi di output validi:

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

eccetera.

specificazioni

• Non puoi usare i builtin per trovare un elenco di quadrati in un certo intervallo
• Si applicano scappatoie standard
• Devi essere in grado di gestire fino a 1 000 000 (1 milione)
• Se fornito con l'input 1******, è corretto stampare [1000000]. È anche corretto stampare[1000000, 1002001, 1004004, 1006009, 1008016, 1010025, ...]
• Le sequenze di caratteri jolly non inizieranno mai con il carattere jolly; cioè, corrisponderanno sempre a stringhe della stessa lunghezza.

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

vincente

Invio più breve (valido) (funzionante) entro il 14 febbraio, vincita alla prima presentazione vincente.

05AB1E , 22 byte

Probabilmente qui c'è molto margine di miglioramento.
Qualsiasi non cifra va bene come carattere jolly.

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

Provalo online!

Spiegazione a venire dopo ulteriore golf.

Mathematica, 44 byte

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

L'input è un elenco di cifre con un _(senza virgolette) come carattere jolly. per esempio{4, _, _, 6}

Spiegazione

Range@1*^3

Genera elenco {1, 2, 3, ... , 1000}

... ^2

Square it. (elenco di tutti i quadrati da 1 a 1.000.000)

IntegerDigits[ ... ]

Dividi ogni quadrato in un elenco di cifre.

... ~Cases~#

Trova quelli che corrispondono al modello specificato dall'input.

Print@@@ ...

Stampali.

Brachylog , 23 byte

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

Provalo online!

Spiegazione

@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

Diverso formato di input, 13 byte

A seconda di ciò che ritieni valido come input, puoi farlo:

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

Provalo online!

che è fondamentalmente la seconda parte della risposta sopra, con un elenco come input contenente cifre e variabili in cui si trovano i caratteri jolly.

Non lo considero valido perché ci sono solo 26 nomi di variabili in Brachylog (le lettere maiuscole), quindi questo non funzionerebbe se avessi più di 26 wilcard.

Perl 6 , 30 26 byte

Grazie a @ b2gills per -4 byte!

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

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

Utilizza il punto come carattere jolly, in modo che l'input possa essere utilizzato come regex:

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

Provalo online .

Una variante che accetta l'asterisco come carattere jolly (come suggerito da una precedente revisione della descrizione dell'attività) sarebbe 42 byte:

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

Rubino, 54 byte

Funzione che accetta un argomento stringa. Provalo online.

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

Lotto, 109 byte

@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

Utilizza ?come jolly. Funziona creando 1000 file. Il nome del file è il numero quadrato e l'estensione del file è il numero quadrato con un $suffisso. Questo perché la corrispondenza del modello di Batch conta il trascinamento di ?s come facoltativo, quindi 1?corrisponderà a entrambi 1e 16; il$ costringe quindi la partita per essere esatti. Tuttavia, non vogliamo produrre l'output $, quindi produciamo solo il nome del file senza estensione.

JavaScript (ES6), 68 66 byte

EDIT: aggiornata la mia soluzione di seguito dopo essere stata ispirata da risposta JungHwan Min . Ora è conforme ES6.

Accetta input nel formato in '1..4'cui. trova il carattere jolly.

Invece di iterare su 1e6 e il rooting quadrato, questo scorre su 1e3 e quadrati.

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 byte

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

Crea un array di numeri da 0 a 1e6, quindi lo filtra per numeri quadrati e corrispondenti al modello.

È orrendamente lento perché scorre sempre fino 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 byte

EDIT: chiarimento di Alex, possiamo usare il punto come carattere jolly che rade l'operazione y //.

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

EDIT: soluzione che utilizza l'asterisco come carattere jolly e prevede la sequenza di caratteri jolly su STDIN

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

Questo lascia indubbiamente molto margine di miglioramento, è piuttosto semplice. L'espressione jolly è prevista come argomento della riga di comando, con il carattere jolly punto (cos'altro?).

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

Python 3 - 98 97 byte

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

Richiede input come '4..6'.

k - 28 caratteri

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

Utilizza ?come carattere jolly. La likefunzione utilizza ?come carattere jolly e questa funzione crea un elenco dei primi 1001 quadrati (da includere in 1M), li lancia tutti in stringhe e quindi controlla dove corrispondono al modello.

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

bash + utility Unix, 33 byte

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

Questo usa '.' come carattere jolly.

Il programma dc stampa i numeri quadrati in un ciclo 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.

L'output in cc viene convogliato su grep, che stampa solo i quadrati che corrispondono al modello richiesto.

Funziona quando lo eseguo su un vero sistema Linux o OS X (ma non funziona su TIO, probabilmente perché il programma dc tenta di ricorrere per sempre, e sospetto che TIO esaurisca lo spazio dello stack per la ricorsione e / o abbia un problema con la pipe infinita).