Invali Inval Inval non valido


27

Questa idea si basa vagamente sul messaggio di chat di @ TùxCräftîñg .

Dai un'occhiata alla sequenza di esempio seguente:

INVALID0, INVALID1, INVALID2 INVALID3, INVALID4...INVALID9

Dopo INVALID9, continua così:

INVALI0, INVALI1, INVALI2, INVALI3...INVALI9

E dopo INVALI9, è così:

INVAL0, INVAL1, INVAL2, INVAL3...INVAL9

Dopo, INVAL9è così:

INVA0, INVA1, INVA2, INVA3, ...INVA9

Nota come abbiamo continuato a rimuovere una lettera dalla parola INVALIDogni volta.

Continuerai a ripetere questo fino a quando non raggiungi una singola lettera, cioè la lettera I:

I0, I1, I2, I3, I4...I9

Ora, il tuo compito è, prendere un input di una parola e produrre una sequenza da essa come nell'esempio sopra. Il codice deve inoltre funzionare con singole lettere e in tal caso la sequenza risultante sarà più breve.

Puoi scegliere qualsiasi formato di input e output che preferisci (con o senza un separatore, come desideri), ma devi specificare quale hai scelto.

La sequenza deve essere nell'ordine esatto specificato.

Il codice più breve, in byte, che completa con successo questa sfida, vince la sfida.

Sequenza completa nell'esempio sopra:

INVALID0, INVALID1, INVALID2, INVALID3, INVALID4, INVALID5, INVALID6, INVALID7, INVALID8, INVALID9, INVALI0, INVALI1, INVALI2, INVALI3, INVALI4, INVALI5, INVALI6, INVALI7, INVALI8, INVALI9, INVAL0, INVAL1, INVAL2, INVAL3, INVAL4, INVAL5, INVAL6, INVAL7, INVAL8, INVAL9, INVA0, INVA1, INVA2, INVA3, INVA4, INVA5, INVA6, INVA7, INVA8, INVA9, INV0, INV1, INV2, INV3, INV4, INV5, INV6, INV7, INV8, INV9, IN0, IN1, IN2, IN3, IN4, IN5, IN6, IN7, IN8, IN9, I0, I1, I2, I3, I4, I5, I6, I7, I8, I9

Altri esempi:

Input: MAYBE(maiuscole e minuscole non contano)

Produzione:

MAYBE0, MAYBE1, MAYBE2, MAYBE3, MAYBE4, MAYBE5, MAYBE6, MAYBE7, MAYBE8, MAYBE9, MAYB0, MAYB1, MAYB2, MAYB3, MAYB4, MAYB5, MAYB6, MAYB7, MAYB8, MAYB9, MAY0, MAY1, MAY2, MAY3, MAY4, MAY5, MAY6, MAY7, MAY8, MAY9, MA0, MA1, MA2, MA3, MA4, MA5, MA6, MA7, MA8, MA9, M0, M1, M2, M3, M4, M5, M6, M7, M8, M9


Ingresso: AFTER

Produzione:

AFTER0, AFTER1, AFTER2, AFTER3, AFTER4, AFTER5, AFTER6, AFTER7, AFTER8, AFTER9, AFTE0, AFTE1, AFTE2, AFTE3, AFTE4, AFTE5, AFTE6, AFTE7, AFTE8, AFTE9, AFT0, AFT1, AFT2, AFT3, AFT4, AFT5, AFT6, AFT7, AFT8, AFT9, AF0, AF1, AF2, AF3, AF4, AF5, AF6, AF7, AF8, AF9, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9


Ingresso: WHAT ARE YOU DOING

WHAT ARE YOU DOING0, WHAT ARE YOU DOING1, WHAT ARE YOU DOING2, WHAT ARE YOU DOING3, WHAT ARE YOU DOING4, WHAT ARE YOU DOING5, WHAT ARE YOU DOING6, WHAT ARE YOU DOING7, WHAT ARE YOU DOING8, WHAT ARE YOU DOING9, WHAT ARE YOU DOIN0, WHAT ARE YOU DOIN1, WHAT ARE YOU DOIN2, WHAT ARE YOU DOIN3, WHAT ARE YOU DOIN4, WHAT ARE YOU DOIN5, WHAT ARE YOU DOIN6, WHAT ARE YOU DOIN7, WHAT ARE YOU DOIN8, WHAT ARE YOU DOIN9, WHAT ARE YOU DOI0, WHAT ARE YOU DOI1, WHAT ARE YOU DOI2, WHAT ARE YOU DOI3, WHAT ARE YOU DOI4, WHAT ARE YOU DOI5, WHAT ARE YOU DOI6, WHAT ARE YOU DOI7, WHAT ARE YOU DOI8, WHAT ARE YOU DOI9, WHAT ARE YOU DO0, WHAT ARE YOU DO1, WHAT ARE YOU DO2, WHAT ARE YOU DO3, WHAT ARE YOU DO4, WHAT ARE YOU DO5, WHAT ARE YOU DO6, WHAT ARE YOU DO7, WHAT ARE YOU DO8, WHAT ARE YOU DO9, WHAT ARE YOU D0, WHAT ARE YOU D1, WHAT ARE YOU D2, WHAT ARE YOU D3, WHAT ARE YOU D4, WHAT ARE YOU D5, WHAT ARE YOU D6, WHAT ARE YOU D7, WHAT ARE YOU D8, WHAT ARE YOU D9, WHAT ARE YOU 0, WHAT ARE YOU 1, WHAT ARE YOU 2, WHAT ARE YOU 3, WHAT ARE YOU 4, WHAT ARE YOU 5, WHAT ARE YOU 6, WHAT ARE YOU 7, WHAT ARE YOU 8, WHAT ARE YOU 9, WHAT ARE YOU0, WHAT ARE YOU1, WHAT ARE YOU2, WHAT ARE YOU3, WHAT ARE YOU4, WHAT ARE YOU5, WHAT ARE YOU6, WHAT ARE YOU7, WHAT ARE YOU8, WHAT ARE YOU9, WHAT ARE YO0, WHAT ARE YO1, WHAT ARE YO2, WHAT ARE YO3, WHAT ARE YO4, WHAT ARE YO5, WHAT ARE YO6, WHAT ARE YO7, WHAT ARE YO8, WHAT ARE YO9, WHAT ARE Y0, WHAT ARE Y1, WHAT ARE Y2, WHAT ARE Y3, WHAT ARE Y4, WHAT ARE Y5, WHAT ARE Y6, WHAT ARE Y7, WHAT ARE Y8, WHAT ARE Y9, WHAT ARE 0, WHAT ARE 1, WHAT ARE 2, WHAT ARE 3, WHAT ARE 4, WHAT ARE 5, WHAT ARE 6, WHAT ARE 7, WHAT ARE 8, WHAT ARE 9, WHAT ARE0, WHAT ARE1, WHAT ARE2, WHAT ARE3, WHAT ARE4, WHAT ARE5, WHAT ARE6, WHAT ARE7, WHAT ARE8, WHAT ARE9, WHAT AR0, WHAT AR1, WHAT AR2, WHAT AR3, WHAT AR4, WHAT AR5, WHAT AR6, WHAT AR7, WHAT AR8, WHAT AR9, WHAT A0, WHAT A1, WHAT A2, WHAT A3, WHAT A4, WHAT A5, WHAT A6, WHAT A7, WHAT A8, WHAT A9, WHAT 0, WHAT 1, WHAT 2, WHAT 3, WHAT 4, WHAT 5, WHAT 6, WHAT 7, WHAT 8, WHAT 9, WHAT0, WHAT1, WHAT2, WHAT3, WHAT4, WHAT5, WHAT6, WHAT7, WHAT8, WHAT9, WHA0, WHA1, WHA2, WHA3, WHA4, WHA5, WHA6, WHA7, WHA8, WHA9, WH0, WH1, WH2, WH3, WH4, WH5, WH6, WH7, WH8, WH9, W0, W1, W2, W3, W4, W5, W6, W7, W8, W9

Classifica


1
Potresti pubblicare l'intera sequenza tutta in una volta? Forse con qualche altro campione? Inoltre, cosa può contenere l'input?
DJMcMayhem

1
La mancanza di un separatore (ad es. INVALID0INVALID1INVALID2) È un formato di output valido?
DLosc,

@DLosc Sì, lo è.
Buffer Over Leggi il

3
Solo per questo, in genere è sconsigliato accettare una risposta così rapidamente dopo aver pubblicato la sfida. Accettare troppo presto può scoraggiare gli utenti dal pubblicare nuove risposte. Questo non vuol dire che non puoi mantenere la risposta accettata, ma ti incoraggio ad aspettare più a lungo la prossima volta.
DJMcMayhem

@DJMcMayhem Okay!
Buffer Over Leggi il

Risposte:


5

Gelatina , 7 byte

ḣJṚp⁵Ḷ¤

Provalo online!

Come funziona

ḣJṚp⁵Ḷ¤  Main link. Argument: s (string)

 J       Yield all (1-based) indices of s.
ḣ        Head; for each index k, take the first k characters of s.
  Ṛ      Reverse the result.
      ¤  Combine the two links to the left into a niladic chain.
    ⁵      Yield 10.
     Ḷ     Unlength; yield [0, ..., 9].
   p     Return the Cartesian product of the prefixes and the range.
         (implicit) Print the Cartesian product without separators.

6
7 byte Voglio solo sapere come qualcuno ha avuto l'idea di far funzionare questo codice esatto con il codice golf.
Hayak

8

05AB1E , 10 8 byte

.pžmâ€JR

Spiegazione

.p        # get prefixes of input
  žmâ     # cartesian product with [9..0]
     €J   # join each
       R  # reverse

Provalo online!

Salvato 2 byte grazie ad Adnan


1
.pè equivalente a Œ¹g£:).
Adnan,

1
@Adnan: Seriamente, come avrei potuto dimenticarlo di nuovo! Grazie! Sembra che dovrei fare una pausa: P
Emigna,

8

Javascript (ES6), 53 47 byte

f=(s,n=0)=>s&&s+n+f(n-9?s:s.slice(0,-1),++n%10)

Risparmiato 6 byte grazie a Peanut & Neil

Output: tutte le parole come una singola stringa senza separatore.

Esempio

var f=(s,n=0)=>s&&s+n+f(n-9?s:s.slice(0,-1),++n%10)

document.getElementsByTagName('div')[0].innerHTML = f('INVALID')
<div style="word-wrap:break-word"></div>


Salva un byte, riducendolo a 52 byte , per non utilizzare i separatori (che è consentito) non aggiungendo uno spazio tra gli elementi nel modello. Provalo qui!
Hayak

Non puoi usare s&&invece di s?... :''?
Neil,

Inoltre, è possibile ridurlo a 49 byte rimuovendo la +''parte dall'ultimo codice che ho pubblicato. Provalo qui!
Hayak

Sto usando Firefox e il testo non è separato da spazi. Non è richiesto per la domanda, ma ho pensato di farti sapere.
Buffer Over Leggi il

1
@TheBitByte - Mio male. Non c'è più un separatore (come suggerito da Peanut) ma ho dimenticato di aggiornare la mia risposta di conseguenza. Grazie per averlo notato!
Arnauld,

7

Perl, 29 byte

Include +1 per -n

Esegui con input su STDIN:

perl -nE '/^.+(?{map{say$&.$_}0..9})^/' <<< PERL

Solo il codice:

/^.+(?{map{say$&.$_}0..9})^/

Codice molto bello. Non capisco questo ultimo ^però ... Sembra che faccia lo stesso lavoro di (*FAIL), ma non vedo perché. Potresti spiegare?
Dada,

@Dada Sì, forzare un fallimento è esattamente ciò che fa. Dal momento che corrispondeva ad almeno 1 carattere dall'inizio della stringa, non può più essere all'inizio, quindi ^la partita fallisce, il che costringe la regex prima di tornare indietro
Ton Hospel,

Ok grazie. Mi aspettavo che funzionasse con qualsiasi personaggio che non fosse nell'input, ma sembra funzionare solo con ^... Voglio dire con il tuo esempio, perché ,/non funziona, ma ^/funziona?
Dada,

È un dettaglio dell'implementazione dell'ottimizzatore regex. Se si inserisce un carattere specifico non nella stringa, è abbastanza intelligente sapere che il regex non può mai corrispondere e la vera corrispondenza del regex non viene nemmeno avviata. ^va oltre l'attuale comprensione dell'ottimizzatore. Ognuno dei due comportamenti potrebbe cambiare in futuro ..
Ton Hospel

Ok ho capito, pensavo fosse qualcosa del genere ma non ne ero sicuro. Grazie mille
Dada,

6

Haskell, 47 43 byte

f""=[]
f x=map((x++).show)[0..9]++f(init x)

Esempio di utilizzo: f "IN"-> ["IN0","IN1","IN2","IN3","IN4","IN5","IN6","IN7","IN8","IN9","I0","I1","I2","I3","I4","I5","I6","I7","I8","I9"].

Semplice approccio ricorsivo. Aggiungi ogni cifra alla parola e aggiungi una chiamata ricorsiva con l'ultima lettera rimossa.


6

Pyth, 9 byte

sM*_._QUT

Un programma che accetta l'input di una stringa tra virgolette su STDIN e stampa un elenco di stringhe.

Provalo online

Come funziona

sM*_._QUT  Program. Input: Q
    ._     List of prefixes of Q
   _       Reverse
       UT  Unary range up to 10, yielding [0, 1, 2, ..., 9]
  *        Cartesian product of the above two
sM         Map concatenate over the above
           Implicitly print

5

Pip , 12 11 byte

Prende la parola come argomento cmdline. Uscite senza separatori.

Wa&Oa.,tDQa

Provalo online!

Spiegazione:

             Implicit: a = 1st cmdline arg, t = 10
Wa           While a (i.e. while it's not the empty string)
   Oa.,t     Concatenate range(10) to a and output
               (Pip concatenates a string to a range itemwise)
  &          The output operation is &-ed to the loop condition to save on curly braces
        DQa  Dequeue from a, removing the final character on each iteration

4

V , 20 byte

A0òYpó.10/0/e
$hòd

Provalo online!

Poiché questo contiene caratteri non stampabili, ecco il formato leggibile:

A0<esc>òYp<C-a>ó.10/0/e
$hòd

Ed ecco un hexdump:

0000000: 4130 1bf2 5970 01f3 2e31 302f 302f 650a  A0..Yp...10/0/e.
0000010: 2468 f264                                $h.d

Spiegazione:

A0<esc>                 "Append a '0' to the input
       ò                "Recursively:
        Yp              "  Yank this line and paste it
          <C-a>         "  Increment the first number on this line
               ó        "  Substitute:
                .10     "    Any single character followed by '10'
                   /0   "    Replace it with a '0'
                     /e "    Ignore errors if this is not found
$h                      "  Move to the end of the end of this line than back one.
                        "  This makes it so the loop ends once there is only one
                        "  character on this line.
  ò                     "End the loop
   d                    "Delete a line (since we create one too many)  

4

Bash + coreutils, 54 byte:

for i in `seq ${#1} 1`;{ printf "${1:0:i}%s " {0..9};}

Passa semplicemente attraverso una sequenza [Length of Input,1]e durante ogni iterazione, genera la parola di input per la lunghezza dei valori del valore di iterazione corrente 9per ogni numero [0,9]aggiunto a ciascuna delle 9copie della parola. Eseguire all'interno di un file e la parola o le parole tra virgolette, ad es bash A.sh "blah blah blah".


4

Floroide - 50 47 31 byte

f=Ba:aM[a+b KbIhd]+f(a[:-1])H[]

Attualmente utilizza un metodo simile a quello utilizzato da @JonathanAllan nel suo secondo metodo ricorsivo.

Potrebbe essere stato questo se avrei realizzato il prodotto cartesiano con più attenzione nella lingua: Bc:ca([c]+[c[:-a-1]KaIw(Z(c)-1)],hd).

Casi test

Input: ABC
Output: ['ABC0', 'ABC1', 'ABC2', 'ABC3', 'ABC4', 'ABC5', 'ABC6', 'ABC7', 'ABC8', 'ABC9', 'AB0', 'AB1', 'AB2', 'AB3', 'AB4', 'AB5', 'AB6', 'AB7', 'AB8', 'AB9', 'A0', 'A1', 'A2', 'A3', 'A4', 'A5', 'A6', 'A7', 'A8', 'A9']

Input: M
Output: ['M0', 'M1', 'M2', 'M3', 'M4', 'M5', 'M6', 'M7', 'M8', 'M9']

3

(lambdabot) Haskell - 49 byte

f q=[x++show n|x<-reverse.tail$inits q,n<-[0..9]]

Lambdabot è un bot IRC su #haskell; importa automaticamente un gruppo di moduli, incluso Data.Listdove si trova inits. E poiché una lingua è definita dalla sua implementazione, posso chiamare questo lambkabot haskell e non pagare i byte per le importazioni.

Haskell normale:

import Data.List
f q=[x++show n|x<-reverse.tail$inits q,n<-[0..9]]

Sei sicuro che tailsfunzioni?
Bergi,

@Bergi, mi sono completamente dimenticato delle importazioni, grazie per
averlo

Non intendevo l'importazione, intendevo dire che produce un output errato:INVALID, NVALID, VALID, ALID, LID, ID, D,
Bergi,

@Bergi, Yikes! Hai ragione. Altri 8 byte per me allora
BlackCap

3

Braingasm , 34 33 31 28 byte

Allo stato attuale, il Braingasm è semplicemente glorificato, con alcune funzionalità extra ( come, 3? ). Ho trascorso gran parte del tempo di sviluppo a renderlo il più "intraprendente" possibile, invece di aggiungere effettivamente funzionalità ...

Ad ogni modo, il seguente codice dovrebbe funzionare con l'ultima istantanea di sviluppo. Prende l'input senza newline da stdin, like $ echo -n INVALID | braingasm invalid.bge stampa su stdout.

,[>,]#[48+10[#<[.>]<+]0,<0,]

Spiegazione:

,[>,]                 lay down the input on the tape
#[                    (length of input - 1) times do
  48+                   add '0' at the end of the tape
  10[                   10 times do
     #<[.>]               move to start of tape, then print the tape
     <+                   increase the number at the end of the tape
  ]                     done printing current word with 0 through 9
  0,                    erase the number by writing 0 onto it
  <0,                   likewise, remove one character
]                     done

modifica: Apparentemente è OK saltare la stringa vuota come delimitatore


2

Python 2, 53 55 byte

+2 byte: la dichiarazione f è necessaria con la ricorsione (come sottolineato da Anguria distruttibile)

f=lambda s:s and[s+`n`for n in range(10)]+f(s[:-1])or[]

Ritorna alla stringa vuota (producendo un elenco vuoto), taglia un carattere alla volta e antepone con un elenco di dieci della stringa corrente con le cifre da 0-9 a ciascuna.

Test su ideone

Python 3, 54 56 byte

f=lambda s:s and[s+n for n in'0123456789']+f(s[:-1])or[]

Test su ideone


2
Sono abbastanza sicuro che se la tua lambda include una chiamata a se stessa, devi avere la f=parte (un po 'come non puoi supporre che le variabili abbiano valori)
Destructible Lemon

2

Swift 3, 150 byte

Non è la soluzione più breve, ma non è terribile per Swift

func a(s: String){var c=s.characters,r="";while(c.count>0){var k = "";for d in c{k+=String(d)};for i in 0...9{r+="\(k)\(i) "};c.removeLast()};print(r);}

Provalo online su IBM Swift Sandbox

Ungolfed

func a(s s: String){
    var c = s.characters, r = ""
    while(c.count > 0){
        var k = ""
        for d in c{
            k+=String(d)
        }
        for i in 0...9{
            r+="\(k)\(i) "
        }
        c.removeLast()
    }
    print(r)
}

2

Ruby, 51

Nessun separatore utilizzato.

->s{(10*n=s.size).times{|i|print s[0,n-i/10],i%10}}

Aggiungi quanto segue i%10per i separatori:

,$/per newline, ,?|per |(simile per qualsiasi carattere stampabile), ,' 'per spazio.

Nel programma di test

f=->s{(10*n=s.size).times{|i|print s[0,n-i/10],i%10}}

f[gets.chomp]

2

PHP, 64 56 byte

for($i=9;$a=substr($argv[1].a,0,-++$i/10);)echo$a.$i%10;

for(;$a=substr($argv[1].a,$i=0,-++$l);)for(;$i<10;)echo $a.$i++;


Bel modo di prevenire un altro for-loop. È possibile salvare un byte, eliminando lo spazio dopo eco
aross

2

Haskell, 49 46 byte

f=(>>=(<$>['0'..'9']).snoc).reverse.tail.inits

È possibile salvare un byte inserendo la mappa della f=(>>=(mappa ['0'..'9']).snoc).tail.reverse.inits. 3 usando fmap:f=(>>=(<$>['0'..'9']).snoc).tail.reverse.inits
BlackCap

Oh, e se lo fai reverse.tail.initsinvece di tail.reverse.initsottenere anche l'output corretto;)
BlackCap

@BlackCap: Grazie, mi sono davvero chiesto perché non ci sia una mappa (f) capovolta nella libreria standard, ma non ho pensato alle sezioni. Per quanto riguarda tail, suppongo di voler dire init, ma scambiarlo con il rovescio funziona bene anche :-)
Bergi,

2

C #, 107 102 byte

string f(string i){var o="";while(i!=""){for(int k=0;k<=9;)o+=i+k++;i=i.Remove(i.Length-1);}return o;}

Ungolfed

string f(string i)
{
   string o = "";
   while(i != "")
   {
      for (int k = 0; k <= 9;)
         o += i + k++;
      i = i.Remove(i.Length - 1);
   }
   return o;
}

1
Puoi giocare un po 'rimuovendolo k++nel for-loop e aggiungendolo ++dopo l'uso di k, quindi in questo modo: string f(string i){var o="";while(i!=""){for(int k=0;k<=9;)o+=i+k+++",";i=i.Remove(i.Length-1);}return o;}Inoltre, le virgole non sono richieste dalla sfida di OP, anche se se preferisci puoi ovviamente mantenerle. Senza questo è:string f(string i){var o="";while(i!=""){for(int k=0;k<=9;)o+=i+k++;i=i.Remove(i.Length-1);}return o;}
Kevin Cruijssen,

2

Rubino, 90 85 byte

f=->s{if s=="";return[];end;(0..9).map{|i|s+i.to_s}+f[s.chars.take(s.length-1).join]}

Se la stringa è vuota, restituisce un array vuoto. Altrimenti, genera la stringa + il numero in ciascun numero da 0 a 9 e chiama fcon la stringa senza l'ultimo carattere.

5 byte salvati grazie a @LevelRiverSt


Suppongo che non hai mai giocato a golf a Ruby prima. Controlla la mia risposta a questa domanda (o molte altre risposte di Ruby su questo sito) per vedere il modo golfy di definire una funzione senza includere quelle dispendiose defe end. Puoi creare una lambda in modo da non dover nemmeno dargli un nome, purché tu assegni una variabile e la chiami con gli argomenti tra parentesi quadre.
Level River St,

@LevelRiverSt L'uso di una lambda è più lungo di 1 byte
TuxCrafting

Ok, mi sono perso il fatto che devi nominarlo perché è ricorsivo. Ma f=->s{if s=="";return[];end;(0..9).map{|i|s+i.to_s}+f[s.chars.take(s.length-1).join]}è ancora più breve di 5 byte.
Level River St

@LevelRiverSt Oh, non sapevo della ->sintassi
TuxCrafting

f=->s{s==""&&(return[]);(0..9).map{|i|s+i.to_s}+f[s.chars.take(s.length-1).join]}salva altri 4 byte. Ruby valuta le espressioni booleane da sinistra a destra e non valuta i termini successivi a meno che non sia necessario per determinare il risultato. La stessa tecnica del golf può essere utilizzata in C. Non so perché in questo caso siano richiesti i ()dintorni return[].
Level River St

2

Perl 6, 32 = 31 byte + 1 per -p

Non sono così abile con Perl 6, quindi potrebbero esserci modi per ridurlo ancora di più.

$_= ~((~$_,*.chop...^!*)X~ ^10)

Usa -pper valutare una volta per ogni riga di input. La riga viene inserita $_e dopo l'esecuzione del programma, viene stampata $_.

La (~$_,*.chop...^!*)è una lista in cui viene stringata il primo elemento ( ~) di ingresso, ciascun elemento successivo viene ottenuta tagliando l'ultimo carattere fuori la precedente ( *.chop) e che continua fino a quando la stringa è vuota ( !*), escludendo il caso stringa vuota (la ^a ...^) .

X~genera tutte le coppie degli elenchi a sinistra e a destra, utilizzando l'operazione specificata, in questo caso, la concatenazione di stringhe ( ~) su di essi.^10è un elenco di 0, 1, ... 9.

Infine, l'elenco viene nuovamente sottoposto a stringhe con ~, fornendo le parole richieste con spazio come separatore.


2

PowerShell v2 +, 60 byte

param($n)$n.length..1|%{$i=$_-1;0..9|%{-join$n[0..$i]+"$_"}}

Passa dalla lunghezza della stringa di input a 1. Ad ogni iterazione, imposta helper $iuguale al numero corrente meno 1. Ciò è necessario perché .lengthè il numero totale di caratteri, ma l'indicizzazione di una stringa è basata su 0. Quindi, passiamo da 0a a9 . Ogni loop interno, suddivide la stringa di input in $nbase al valore del nostro loop esterno, -joinlo riporta in una stringa e concatena la stringa sul conteggio del loop interno. Ogni singolo risultato del loop viene inserito nella pipeline e l'output è implicito al completamento del programma.

PS C:\Tools\Scripts\golfing> .\invalid-invali-inval.ps1 'foo'
foo0
foo1
foo2
foo3
foo4
foo5
foo6
foo7
foo8
foo9
fo0
fo1
fo2
fo3
fo4
fo5
fo6
fo7
fo8
fo9
f0
f1
f2
f3
f4
f5
f6
f7
f8
f9

2

Dyalog APL , 14 11 byte

Restituisce un elenco di stringhe.

,⎕D∘.,⍨⌽,\⍞

, listify (trasforma la tabella in list)

⎕D tutte le cifre

∘.,⍨ aggiunto a tutti (ovvero facendo tutte le combinazioni con)

l'elenco invertito di

,\ la concatenazione cumulativa di

l'inserimento del testo

ProvaAPL online!


Fisso. Uso una
piastra di cottura

2

Groovy (58 byte)

Non ho idea del motivo per cui mi sto nemmeno preoccupando di pubblicare una risposta Groovy ... La dimensione minima richiesta per un golf Groovy è 2 in base alla necessità di una chiusura, quindi la migliore risposta qui è il doppio della mia dimensione minima.

   {s->(s.length()-1..0).each{c->10.times{print s[0..c]+it}}}

Provalo qui: https://groovyconsole.appspot.com/script/5148433803378688


2

Lotto, 85 83 byte

@for /l %%i in (0,1,9)do @echo %1%%i
@set s=%1
@if not "%s:~,-1%"=="" %0 %s:~,-1%

2

Java 7, 105 98 byte

void c(String s){for(int x=0,l=s.length();x<l*10;)System.out.print(s.substring(0,l-x/10)+x++%10);}

-7 byte grazie a @Poke .

Ungolfed :

void c(String s){
  for(int x = 0, l = s.length(); x < l*10; ){
    System.out.print(s.substring(0, l - x/10) + x++ % 10);
  }
}

Codice di prova:

Provalo qui.

class M{
  static void c(String s){for(int x=0,l=s.length();x<l*10;)System.out.print(s.substring(0,l-x/10)+x++%10);}

  public static void main(String[] a){
    c("INVALID");
    System.out.println();
    c("MAYBE");
    System.out.println();
    c("AFTER");
    System.out.println();
    c("WHAT ARE YOU DOING");
  }
}

Produzione:

INVALID0INVALID1INVALID2INVALID3INVALID4INVALID5INVALID6INVALID7INVALID8INVALID9INVALID0INVALID1INVALID2INVALID3INVALID4INVALID5INVALID6INVALID7INVALID8INVALID9INVALI0INVALI1INVALI2INVALI3INVALI4INVALI5INVALI6INVALI7INVALI8INVALI9INVAL0INVAL1INVAL2INVAL3INVAL4INVAL5INVAL6INVAL7INVAL8INVAL9INVA0INVA1INVA2INVA3INVA4INVA5INVA6INVA7INVA8INVA9INV0INV1INV2INV3INV4INV5INV6INV7INV8INV9IN0IN1IN2IN3IN4IN5IN6IN7IN8IN9I0I1I2I3I4I5I6I7I8I9
MAYBE0MAYBE1MAYBE2MAYBE3MAYBE4MAYBE5MAYBE6MAYBE7MAYBE8MAYBE9MAYBE0MAYBE1MAYBE2MAYBE3MAYBE4MAYBE5MAYBE6MAYBE7MAYBE8MAYBE9MAYB0MAYB1MAYB2MAYB3MAYB4MAYB5MAYB6MAYB7MAYB8MAYB9MAY0MAY1MAY2MAY3MAY4MAY5MAY6MAY7MAY8MAY9MA0MA1MA2MA3MA4MA5MA6MA7MA8MA9M0M1M2M3M4M5M6M7M8M9
AFTER0AFTER1AFTER2AFTER3AFTER4AFTER5AFTER6AFTER7AFTER8AFTER9AFTER0AFTER1AFTER2AFTER3AFTER4AFTER5AFTER6AFTER7AFTER8AFTER9AFTE0AFTE1AFTE2AFTE3AFTE4AFTE5AFTE6AFTE7AFTE8AFTE9AFT0AFT1AFT2AFT3AFT4AFT5AFT6AFT7AFT8AFT9AF0AF1AF2AF3AF4AF5AF6AF7AF8AF9A0A1A2A3A4A5A6A7A8A9
WHAT ARE YOU DOING0WHAT ARE YOU DOING1WHAT ARE YOU DOING2WHAT ARE YOU DOING3WHAT ARE YOU DOING4WHAT ARE YOU DOING5WHAT ARE YOU DOING6WHAT ARE YOU DOING7WHAT ARE YOU DOING8WHAT ARE YOU DOING9WHAT ARE YOU DOING0WHAT ARE YOU DOING1WHAT ARE YOU DOING2WHAT ARE YOU DOING3WHAT ARE YOU DOING4WHAT ARE YOU DOING5WHAT ARE YOU DOING6WHAT ARE YOU DOING7WHAT ARE YOU DOING8WHAT ARE YOU DOING9WHAT ARE YOU DOIN0WHAT ARE YOU DOIN1WHAT ARE YOU DOIN2WHAT ARE YOU DOIN3WHAT ARE YOU DOIN4WHAT ARE YOU DOIN5WHAT ARE YOU DOIN6WHAT ARE YOU DOIN7WHAT ARE YOU DOIN8WHAT ARE YOU DOIN9WHAT ARE YOU DOI0WHAT ARE YOU DOI1WHAT ARE YOU DOI2WHAT ARE YOU DOI3WHAT ARE YOU DOI4WHAT ARE YOU DOI5WHAT ARE YOU DOI6WHAT ARE YOU DOI7WHAT ARE YOU DOI8WHAT ARE YOU DOI9WHAT ARE YOU DO0WHAT ARE YOU DO1WHAT ARE YOU DO2WHAT ARE YOU DO3WHAT ARE YOU DO4WHAT ARE YOU DO5WHAT ARE YOU DO6WHAT ARE YOU DO7WHAT ARE YOU DO8WHAT ARE YOU DO9WHAT ARE YOU D0WHAT ARE YOU D1WHAT ARE YOU D2WHAT ARE YOU D3WHAT ARE YOU D4WHAT ARE YOU D5WHAT ARE YOU D6WHAT ARE YOU D7WHAT ARE YOU D8WHAT ARE YOU D9WHAT ARE YOU 0WHAT ARE YOU 1WHAT ARE YOU 2WHAT ARE YOU 3WHAT ARE YOU 4WHAT ARE YOU 5WHAT ARE YOU 6WHAT ARE YOU 7WHAT ARE YOU 8WHAT ARE YOU 9WHAT ARE YOU0WHAT ARE YOU1WHAT ARE YOU2WHAT ARE YOU3WHAT ARE YOU4WHAT ARE YOU5WHAT ARE YOU6WHAT ARE YOU7WHAT ARE YOU8WHAT ARE YOU9WHAT ARE YO0WHAT ARE YO1WHAT ARE YO2WHAT ARE YO3WHAT ARE YO4WHAT ARE YO5WHAT ARE YO6WHAT ARE YO7WHAT ARE YO8WHAT ARE YO9WHAT ARE Y0WHAT ARE Y1WHAT ARE Y2WHAT ARE Y3WHAT ARE Y4WHAT ARE Y5WHAT ARE Y6WHAT ARE Y7WHAT ARE Y8WHAT ARE Y9WHAT ARE 0WHAT ARE 1WHAT ARE 2WHAT ARE 3WHAT ARE 4WHAT ARE 5WHAT ARE 6WHAT ARE 7WHAT ARE 8WHAT ARE 9WHAT ARE0WHAT ARE1WHAT ARE2WHAT ARE3WHAT ARE4WHAT ARE5WHAT ARE6WHAT ARE7WHAT ARE8WHAT ARE9WHAT AR0WHAT AR1WHAT AR2WHAT AR3WHAT AR4WHAT AR5WHAT AR6WHAT AR7WHAT AR8WHAT AR9WHAT A0WHAT A1WHAT A2WHAT A3WHAT A4WHAT A5WHAT A6WHAT A7WHAT A8WHAT A9WHAT 0WHAT 1WHAT 2WHAT 3WHAT 4WHAT 5WHAT 6WHAT 7WHAT 8WHAT 9WHAT0WHAT1WHAT2WHAT3WHAT4WHAT5WHAT6WHAT7WHAT8WHAT9WHA0WHA1WHA2WHA3WHA4WHA5WHA6WHA7WHA8WHA9WH0WH1WH2WH3WH4WH5WH6WH7WH8WH9W0W1W2W3W4W5W6W7W8W9

1
È possibile salvare 7 byte combinando i cicli for e facendo qualche logica aggiuntiva per determinare implicitamente il suffisso e la sottostringa. void c(String s){for(int x=0,l=s.length();x<l*10;)System.out.print(s.substring(0,l-x/10)+x++%10);}
Colpisce il

1

Python 3, 62 byte

lambda x:[(x+" ")[:~i//10]+str(i%10)for i in range(len(x)*10)]

Non usa la ricorsione come l'altra risposta.

Il motivo per cui "" x+" "è lì: -0 è ancora zero, e quindi non possiamo usare la notazione meno per ottenere tutta la stringa in questo modo, quindi il più alto che possiamo andare è meno uno, quindi "" è pad la stringa,


1

C, 72 , 70 byte

j;F(char*s,int l){while(l--)for(j=0;j<10;)printf("%.*s%d",l+1,s,j++);}

Accetta le stringhe come coppie puntatore / dimensione. Test principale:

int main() {
  F("INVALID", 7); putchar('\n');
  F("MAYBE", 5); putchar('\n');
  F("AFTER", 5); putchar('\n');
  F("WHAT ARE YOU DOING", 18); putchar('\n');
}

1

Retina , 37 byte

Il conteggio dei byte presuppone la codifica ISO 8859-1.

M&!r`.+
m`$
0
%{`$
¶$%`
T`w`d`.$
G10`

Provalo online!

Spiegazione

M&!r`.+

Ottieni tutti i prefissi dell'input abbinando e stampando tutte le corrispondenze sovrapposte da destra.

m`$
0

Aggiungi a 0a ciascuna riga.

%{`$
¶$%`

Il { indica che i restanti tre fasi vengono eseguite in un ciclo finché non riescono a modificare la stringa. Il %dice che dovrebbero essere applicati a ciascuna linea separatamente.

Lo stage stesso duplica semplicemente l'ultima riga (inizialmente questa è solo la riga su cui viene eseguita, ma ogni iterazione delle tre fasi aggiunge un'altra riga).

T`w`d`.$

Incrementa la cifra nell'ultima riga eseguendo la seguente sostituzione del carattere:

from: _0123456789AB...
to:   0123456789

E infine:

G10`

Mantieni solo le prime 10 righe, in modo da rimuovere la riga che abbiamo appena aggiunto dopo INPUT9.


1

Scala, 73 70 byte

def g(s:String):String=if(s=="")""else(0 to 9 flatMap(s+_))++g(s.init)

Chiamalo come f("INVALID") . Restituisce una sequenza di caratteri.

Spiegazione

def g(s:String):String= //defines a method g taking a String as a parameter
                        //and returning a String
if(s=="")""             //guard to prevent infinite recursion
else
    (0 to 9             //create a Range from 0 to 9 (inclusive)
    flatMap(            //map:
        s+_                 //append each number to the string
    ))                  //and flatten
    ++ g(s.init)        //concatenate with g applied to everything but the last element of s

Soluzione alternativa, 73 byte

(s:String)=>s.scanLeft("")(_+_).tail.reverse.flatMap(x=>(0 to 9)map(x+_))

definisce una funzione anonima. Per chiamarlo, scrivi

val f = ...

e chiamalo così

f("INVALID")

Restituisce una sequenza di stringhe, che apparirà così quando stampata:

Vector(INVALID0, INVALID1, INVALID2, INVALID3, INVALID4, INVALID5, INVALID6, INVALID7, INVALID8, INVALID9, INVALI0, INVALI1, INVALI2, INVALI3, INVALI4, INVALI5, INVALI6, INVALI7, INVALI8, INVALI9, INVAL0, INVAL1, INVAL2, INVAL3, INVAL4, INVAL5, INVAL6, INVAL7, INVAL8, INVAL9, INVA0, INVA1, INVA2, INVA3, INVA4, INVA5, INVA6, INVA7, INVA8, INVA9, INV0, INV1, INV2, INV3, INV4, INV5, INV6, INV7, INV8, INV9, IN0, IN1, IN2, IN3, IN4, IN5, IN6, IN7, IN8, IN9, I0, I1, I2, I3, I4, I5, I6, I7, I8, I9)

Spiegazione

s.scanLeft("")(_+_)    //accumulate letters from left to right -> Vector("", "I", "IN", "INV", "INVA", "INVAL", "INVALI", "INVALID")
.tail                  //drop the first element
.reverse               //reverse it
.flatMap(x =>          //map each element called x
    (0 to 9)           //create a Range from 0 to 9 (inclusive)
    map(x+_)           //append each number to x
)                      //and flatten

La tua soluzione ricorsiva è di 3 byte in meno rispetto a quella iterativa
TuxCrafting

Hai ragione, devo averlo ottimizzato dopo il conteggio.
corvus_192,

1

CJam, 29 28 byte

ls_,,:)W%]~{_[X<aA*A,]zo}fX;

Spiegazione:

ls                              read input as string
  _                             duplicate input
   ,,                           create range of length input
      :)W%]                     add 1 to all elements and reverse
           ~                    dump array on stack
            {            }fX    for loop
             _                  duplicate input string
              [X<aA*            slice input string and multiply by 10
                    A,]         range(10)
                       zo       zip array and print (no separator)
                            ;   clear stack

Provalo online

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.