Esta idea se basa libremente en el mensaje de chat de @ TùxCräftîñg .

Eche un vistazo a la secuencia de ejemplo a continuación:

INVALID0` INVALID1` INVALID2 INVALID3` INVALID4` ...INVALID9

Después INVALID9, continúa así:

INVALI0` INVALI1` INVALI2` INVALI3` ...INVALI9

Y después INVALI9, es así:

INVAL0` INVAL1` INVAL2` INVAL3` ...INVAL9

Después, INVAL9es así:

INVA0` INVA1` INVA2` INVA3` ...INVA9

Observe cómo seguimos eliminando una letra de la palabra INVALIDcada vez.

Seguirás repitiendo esto hasta llegar a una sola letra, es decir, la letra I:

I0` I1` I2` I3` I4...I9

Ahora, su tarea es tomar una entrada de una palabra y producir una secuencia a partir de ella como en el ejemplo anterior. Su código también debe funcionar con letras individuales, y en ese caso la secuencia resultante será más corta.

Puede elegir cualquier formato de entrada y salida que prefiera (con o sin separador, según lo desee), pero debe especificar cuál ha elegido.

La secuencia debe estar en el orden exacto especificado.

El código más corto, en bytes, que completa con éxito este desafío, gana el desafío.

Secuencia completa en el ejemplo anterior:

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

Otros ejemplos:

Entrada: MAYBE(mayúsculas y minúsculas no importan)

Salida:

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

Entrada: AFTER

Salida:

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

Entrada: 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

Tabla de clasificación

var QUESTION_ID=92156,OVERRIDE_USER=58717;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;

body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>

Jalea , 7 bytes

ḣJṚp⁵Ḷ¤

Pruébalo en línea!

Cómo funciona

ḣ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.

05AB1E , 10 8 bytes

.pžmâ€JR

Explicación

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

Pruébalo en línea!

Guardado 2 bytes gracias a Adnan

Javascript (ES6), 53 47 bytes

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

Guardado 6 bytes gracias a Peanut & Neil

Salida: todas las palabras como una sola cadena sin separador.

Ejemplo

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>

Perl, 29 bytes

Incluye +1 para -n

Ejecutar con entrada en STDIN:

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

Solo el código:

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

Haskell, 47 43 bytes

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

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

Enfoque recursivo simple. Agregue cada dígito a la palabra y agregue una llamada recursiva con la última letra eliminada.

Pyth, 9 bytes

sM*_._QUT

Un programa que toma la entrada de una cadena entre comillas en STDIN e imprime una lista de cadenas.

Pruébalo en línea

Cómo funciona

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

Pip , 12 11 bytes

Toma la palabra como argumento cmdline. Salidas sin separadores.

Wa&Oa.,tDQa

Pruébalo en línea!

Explicación:

             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

V , 20 bytes

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

Pruébalo en línea!

Como esto contiene caracteres no imprimibles, aquí está el formato legible:

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

Y aquí hay un hexdump:

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

Explicación:

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)  

Bash + coreutils, 54 bytes:

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

Simplemente recorre una secuencia [Length of Input,1]y durante cada iteración, envía la palabra de entrada a la longitud del valor de iteración actual 9multiplicado por cada número [0,9]adjunto a cada una de las 9copias de la palabra. Ejecútelo dentro de un archivo y la palabra o palabras entre comillas, es decir bash A.sh "blah blah blah".

Floroid - 50 47 31 bytes

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

Actualmente usa un método similar al que @JonathanAllan usa en su segundo método recursivo.

Podría haber sido esto si yo hubiera aplicado el producto cartesiano con más cuidado en el lenguaje: Bc:ca([c]+[c[:-a-1]KaIw(Z(c)-1)],hd).

Casos de prueba

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

(lambdabot) Haskell - 49 bytes

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

Lambdabot es un bot de IRC en #haskell; importa automáticamente un montón de módulos, incluido Data.Listcuál es el lugar donde initsvive. Y debido a que un idioma se define por su implementación, puedo llamar a este lambdabot haskell y no pagar los bytes por las importaciones.

Haskell regular:

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

braingasm , 34 33 31 28 bytes

En su estado actual, el braingasm es un glorificado brainfuck con unos pocos ( características adicionales ( ¿3? ). He pasado la mayor parte del tiempo de desarrollo haciéndolo lo más "emprendedor" posible, en lugar de agregar funciones ...

De todos modos, el siguiente código debería funcionar con la última instantánea de desarrollo. Se necesita una entrada sin línea nueva desde stdin, like $ echo -n INVALID | braingasm invalid.bge imprime en stdout.

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

Explicación:

,[>,]                 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

editar: aparentemente está bien omitir el uso de cadenas vacías como delimitador

Python 2, 53 55 bytes

+2 bytes: declarar f es necesario con recursividad (como lo señaló @Destructible Watermelon)

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

Recurre a la cadena vacía (produciendo una lista vacía), corta un carácter a la vez y antepone una lista de diez de la cadena actual con los dígitos 0-9 añadidos a cada uno.

Prueba de ideona

Python 3, 54 56 bytes

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

Prueba de ideona

Swift 3, 150 bytes

No es la solución más corta, pero no es terrible para 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);}

Pruebe esto en línea en el IBM Swift Sandbox

Sin golf

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)
}

Rubí, 51

No se utiliza separador.

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

Agregue lo siguiente i%10para los separadores:

,$/para nueva línea, ,?|para |(similar a cualquier carácter imprimible), ,' 'para espacio.

En programa de prueba

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

f[gets.chomp]

PHP, 64 56 bytes

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++;

Haskell, 49 46 bytes

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

C #, 107 102 bytes

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;}

Sin golf

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;
}

Ruby, 90 85 bytes

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

Si la cadena está vacía, devuelve una matriz vacía. De lo contrario, genere la cadena + el número en cada número del 0 al 9, y llame fcon la cadena sin el último carácter.

Guardado 5 bytes gracias a @LevelRiverSt

Perl 6, 32 = 31 bytes + 1 para -p

No soy tan competente con Perl 6, por lo que puede haber formas de reducirlo aún más.

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

Se utiliza -ppara evaluar una vez para cada línea de entrada. La línea se coloca $_y, una vez que se ejecuta el programa, se imprime $_.

La (~$_,*.chop...^!*)es una lista donde se ingresa el primer elemento stringified ( ~), cada elemento subsiguiente se obtiene cortando el último carácter del anterior ( *.chop) y eso continúa hasta que la cadena está vacía ( !*), excluyendo el caso de cadena vacía ( ^in ...^) .

X~genera todos los pares de las listas a la izquierda y a la derecha, utilizando la operación especificada, en este caso, la concatenación de cadenas ( ~) en ellas. ^10es una lista de 0, 1, ... 9.

Finalmente, la lista se vuelve a encadenar con ~, dando las palabras requeridas con espacio como separador.

PowerShell v2 +, 60 bytes

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

Recorre desde la longitud de la cadena de entrada hasta 1. En cada iteración, establezca un ayudante $iigual al número actual menos 1. Esto es necesario porque .lengthes el número total de caracteres, pero indexar una cadena se basa en 0. Luego, pasamos de 0a 9. Cada bucle interno, corta la cadena de entrada en $nfunción del valor de nuestro bucle externo, -joinvuelve a formar una cadena y concatena la cadena en el recuento del bucle interno. Cada resultado de bucle individual se coloca en la tubería y la salida está implícita al finalizar el programa.

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

Dyalog APL , 14 11 bytes

Devuelve la lista de cadenas.

,⎕D∘.,⍨⌽,\⍞

, listify (hacer tabla en lista)

⎕D todos los dígitos

∘.,⍨ agregado a todos (es decir, haciendo todas las combinaciones con)

⌽ la lista invertida de

,\ la concatenación acumulativa de

⍞ la entrada de texto

TryAPL en línea!

Groovy (58 bytes)

No tengo idea de por qué me molesto en publicar una respuesta Groovy ... El tamaño mínimo requerido para un golf Groovy es 2 basado en la necesidad de un cierre, por lo que la mejor respuesta aquí es el doble de mi tamaño mínimo.

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

Pruébelo aquí: https://groovyconsole.appspot.com/script/5148433803378688

Lote, 85 83 bytes

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

Java 7, 105 98 bytes

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 bytes gracias a @Poke .

Sin golf :

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);
  }
}

Código de prueba:

Pruébalo aquí

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");
  }
}

Salida:

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

Python 3, 62 bytes

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

No usa la recursividad como la otra respuesta.

La razón por la que "" x+" "está ahí es: -0 sigue siendo cero, por lo que no podemos usar la notación menos para obtener toda la cadena de esta manera, de modo que lo más alto que podamos llegar sea menos uno, por lo que "" es rellenar la cuerda,

C, 72 , 70 bytes

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

Toma cadenas como pares de puntero / tamaño. Prueba principal:

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');
}

Retina , 37 bytes

El recuento de bytes asume la codificación ISO 8859-1.

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

Pruébalo en línea!

Explicación

M&!r`.+

Obtenga todos los prefijos de la entrada haciendo coincidir e imprimiendo todas las coincidencias superpuestas desde la derecha.

m`$
0

Agrega a 0a cada línea.

%{`$
¶$%`

El {indica que las tres etapas restantes se ejecutan en un bucle hasta que no pueden cambiar la cadena. El %dice que deben aplicarse a cada línea por separado.

La etapa misma simplemente duplica la última línea (inicialmente esta es solo la línea en la que se ejecuta, pero cada iteración de las tres etapas agrega otra línea).

T`w`d`.$

Incremente el dígito en la última fila realizando la siguiente sustitución de caracteres:

from: _0123456789AB...
to:   0123456789

Y finalmente:

G10`

Mantenga solo las primeras 10 líneas, para que eliminemos la línea que acabamos de agregar después INPUT9.

Scala, 73 70 bytes

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

Llámalo como f("INVALID"). Devuelve una secuencia de caracteres.

Explicación

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

Solución alternativa, 73 bytes.

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

define una función anónima Para llamarlo, escribe

val f = ...

y llamarlo así

f("INVALID")

Devuelve una secuencia de cadenas, que se verá así cuando se imprima:

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)

Explicación

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

CJam, 29 28 bytes

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

Explicación:

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

Pruébalo en línea