Invalid Invali Invali

27

Cette idée est vaguement basée sur le message de discussion de @ TùxCräftîñg .

Jetez un œil à l'exemple de séquence ci-dessous:

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

Après INVALID9, ça continue comme ça:

INVALI0, INVALI1, INVALI2, INVALI3...INVALI9

Et après INVALI9, c'est comme ça:

INVAL0, INVAL1, INVAL2, INVAL3...INVAL9

Après, INVAL9c'est comme ça:

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

Remarquez comment nous avons continué à retirer une lettre du mot à INVALIDchaque fois.

Vous continuerez à répéter ceci jusqu'à ce que vous atteigniez une seule lettre, c'est-à-dire la lettre I:

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

Maintenant, votre tâche est de prendre une entrée d'un mot et d'en produire une séquence comme l'exemple ci-dessus. Votre code doit également fonctionner avec des lettres simples, et dans ce cas, la séquence résultante sera plus courte.

Vous pouvez choisir n'importe quel format d'entrée et de sortie que vous préférez (avec ou sans séparateur, comme vous le souhaitez), mais vous devez spécifier celui que vous avez choisi.

La séquence doit être dans l'ordre spécifié exact.

Le code le plus court, en octets, qui réussit ce défi, remporte le défi.

Séquence complète dans l'exemple ci-dessus:

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

Autres exemples:

Entrée: MAYBE(les majuscules et les minuscules n'ont pas d'importance)

Sortie:

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


Contribution: AFTER

Sortie:

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


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

Classement

Tampon sur lecture
la source
1
Pourriez-vous publier la séquence complète en une seule fois? Peut-être avec quelques échantillons supplémentaires? De plus, que peut éventuellement contenir l'entrée?
DJMcMayhem
1
Un manque de séparateur (par exemple INVALID0INVALID1INVALID2) est-il un format de sortie valide?
DLosc
@DLosc Oui, ça l'est.
Mémoire tampon
3
Juste pour que vous le sachiez, il est généralement déconseillé d'accepter une réponse si rapidement après avoir posté le défi. Accepter trop tôt peut décourager les utilisateurs de publier de nouvelles réponses. Cela ne veut pas dire que vous ne pouvez pas conserver la réponse acceptée, mais je vous encourage à attendre plus longtemps la prochaine fois.
DJMcMayhem
@DJMcMayhem Okay!
Mémoire tampon

Réponses:

5

Gelée , 7 octets

ḣJṚp⁵Ḷ¤

Essayez-le en ligne!

Comment ça marche

ḣ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.
Dennis
la source
6
7 octets. Je veux juste savoir comment quelqu'un a eu l'idée de faire fonctionner ce code exact avec le code golf.
haykam
8

05AB1E , 10 8 octets

.pžmâ€JR

Explication

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

Essayez-le en ligne!

Enregistré 2 octets grâce à Adnan

Emigna
la source
1
.pest équivalent à Œ¹g£:).
Adnan
1
@Adnan: Sérieusement, comment aurais-je pu oublier ça à nouveau! Merci! On dirait que je devrais faire une pause: P
Emigna
8

Javascript (ES6), 53 47 octets

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

6 octets enregistrés grâce à Peanut & Neil

Sortie: tous les mots en une seule chaîne sans séparateur.

Exemple

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>

Arnauld
la source
Vous permet d'économiser un octet, en le réduisant à 52 octets , pour ne pas utiliser de séparateurs (ce qui est autorisé) en n'ajoutant pas d'espace entre les éléments du modèle. Essayez-le ici!
haykam
Ne pouvez-vous pas utiliser à la s&&place de s?... :''?
Neil
En outre, vous pouvez le réduire à 49 octets en supprimant la +''partie du dernier code que j'ai publié. Essayez-le ici!
haykam
J'utilise Firefox et le texte n'est pas séparé par des espaces. Ce n'est pas obligatoire pour la question, mais j'ai pensé que je vous le ferais savoir.
Mémoire tampon
1
@TheBitByte - Mon mauvais. Il n'y a plus de séparateur (comme suggéré par Peanut) mais j'ai oublié de mettre à jour ma réponse en conséquence. Merci d'avoir remarqué!
Arnauld
7

Perl, 29 octets

Comprend +1 pour -n

Exécuter avec entrée sur STDIN:

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

Juste le code:

/^.+(?{map{say$&.$_}0..9})^/
Ton Hospel
la source
Très beau code. ^Mais je ne comprends pas ça en dernier ... On dirait que ça fait le même travail que (*FAIL)moi, mais je ne vois pas pourquoi. Pourriez-vous expliquer?
Dada
@Dada Oui, forcer un échec est exactement ce qu'il fait. Puisqu'il correspondait à au moins 1 caractère depuis le début de la chaîne, il ne peut plus être au début, ce qui ^entraîne l'échec de la correspondance, ce qui force le regex avant cela à revenir en arrière
Ton Hospel
OK merci. Je m'attendais à ce qu'il fonctionne avec n'importe quel personnage qui n'est pas dans l'entrée, mais il semble ne fonctionner qu'avec ^... Je veux dire avec votre exemple, pourquoi ,/ne fonctionne pas, mais le ^/fait-il?
Dada
C'est un détail d'implémentation de l'optimiseur d'expression régulière. Si vous mettez un caractère spécifique qui n'est pas dans la chaîne, il est suffisamment intelligent pour savoir que l'expression régulière ne peut jamais correspondre et que la correspondance réelle d'expression régulière n'est même pas démarrée. ^dépasse la compréhension actuelle de l'optimiseur. L'un ou l'autre des deux comportements pourrait changer à l'avenir ..
Ton Hospel
Ok je comprends, je pensais que c'était quelque chose comme ça mais je n'en étais pas sûr. Merci beaucoup
Dada
6

Haskell, 47 43 octets

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

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

Approche récursive simple. Ajoutez chaque chiffre au mot et ajoutez un appel récursif avec la dernière lettre supprimée.

nimi
la source
6

Pyth, 9 octets

sM*_._QUT

Un programme qui prend l'entrée d'une chaîne entre guillemets sur STDIN et imprime une liste de chaînes.

Essayez-le en ligne

Comment ça marche

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
TheBikingViking
la source
5

Pip , 12 11 octets

Prend le mot comme argument cmdline. Sorties sans séparateurs.

Wa&Oa.,tDQa

Essayez-le en ligne!

Explication:

             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
DLosc
la source
4

V , 20 octets

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

Essayez-le en ligne!

Puisqu'il contient des caractères non imprimables, voici le format lisible:

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

Et voici un hexdump:

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

Explication:

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)  
DJMcMayhem
la source
4

Bash + coreutils, 54 octets:

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

Boucle simplement à travers une séquence [Length of Input,1]et pendant chaque itération, sort le mot d'entrée à la longueur des 9temps de valeur d'itération en cours avec chaque nombre [0,9]ajouté à chacune des 9copies du mot. Exécutez-le dans un fichier et le ou les mots entre guillemets, c'est-à-dire bash A.sh "blah blah blah".

R. Kap
la source
4

Floroid - 50 47 31 octets

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

Utilise actuellement une méthode similaire à celle utilisée par @JonathanAllan sur sa deuxième méthode récursive.

Aurait pu être cela si je l' aurais mis en œuvre le produit cartésien plus attentivement dans la langue: Bc:ca([c]+[c[:-a-1]KaIw(Z(c)-1)],hd).

Cas de 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']
Yytsi
la source
3

(lambdabot) Haskell - 49 octets

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

Lambdabot est un bot IRC chez #haskell; il importe automatiquement un tas de modules, y compris celui Data.Listqui est en initsdirect. Et parce qu'un langage est défini par son implémentation, je peux appeler ce haskell lambdabot et ne pas payer les octets pour les importations.

Haskell régulier:

import Data.List
f q=[x++show n|x<-reverse.tail$inits q,n<-[0..9]]
BlackCap
la source
Êtes-vous sûr de tailstravailler?
Bergi
@Bergi, totalement oublié les importations, merci de l'avoir signalé :)
BlackCap
Je ne parlais pas de l'importation, je voulais dire qu'elle produisait la mauvaise sortie:INVALID, NVALID, VALID, ALID, LID, ID, D,
Bergi
@Bergi, Yikes! Tu as raison. 8 octets de plus pour moi alors
BlackCap
3

braingasm , 34 33 31 28 octets

À son état actuel, le braingasme est juste un coup de cerveau glorifié avec quelques fonctionnalités supplémentaires ( comme, 3? ). J'ai passé la majeure partie du temps de développement à le rendre aussi "entreprenant" que possible, au lieu d'ajouter réellement des fonctionnalités ...

Quoi qu'il en soit, le code suivant devrait fonctionner avec le dernier instantané de développement. Il prend les entrées sans saut de ligne de stdin, like $ echo -n INVALID | braingasm invalid.bg, et les imprime sur stdout.

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

Explication:

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

edit: Apparemment, il est OK de sauter utiliser une chaîne vide comme délimiteur

daniero
la source
2

Python 2, 53 55 octets

+2 octets: déclarer f est nécessaire avec la récursivité (comme indiqué par @Destructible Watermelon)

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

Revient à la chaîne vide (produisant une liste vide), coupe un caractère à la fois et ajoute une liste de dix de la chaîne actuelle avec les chiffres 0 à 9 ajoutés à chacun.

Test sur ideone

Python 3, 54 56 octets

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

Test sur ideone

Jonathan Allan
la source
2
Je suis assez sûr que si votre lambda inclut un appel à lui-même, vous devez avoir la f=partie (un peu comme la façon dont vous ne pouvez pas supposer que les variables ont des valeurs)
Destructible Lemon
2

Swift 3, 150 octets

Pas tout à fait la solution la plus courte, mais pas terrible pour 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);}

Testez cela en ligne dans le bac à sable IBM Swift

Non 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)
}
Jojodmo
la source
2

Rubis, 51

Aucun séparateur utilisé.

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

Ajoutez ce qui suit i%10pour les séparateurs:

,$/pour la nouvelle ligne, ,?|pour |(similaire pour tout caractère imprimable), ,' 'pour l'espace.

En programme de test

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

f[gets.chomp]
Level River St
la source
2

PHP, 64 56 octets

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

Crypto
la source
Belle façon d'empêcher une autre boucle for. Vous pouvez enregistrer un octet en supprimant l'espace après l'écho
aross
2

Haskell, 49 46 octets

f=(>>=(<$>['0'..'9']).snoc).reverse.tail.inits
Bergi
la source
Vous pouvez enregistrer un octet en ajoutant la carte f=(>>=(map ['0'..'9']).snoc).tail.reverse.inits. 3 en utilisant fmap:f=(>>=(<$>['0'..'9']).snoc).tail.reverse.inits
BlackCap
Oh, et si vous le faites à la reverse.tail.initsplace, tail.reverse.initsvous obtenez également la sortie correcte;)
BlackCap
@BlackCap: Merci, je me suis vraiment demandé pourquoi il n'y avait pas de carte inversée (f) dans la bibliothèque standard, mais je n'ai pas pensé aux sections. En ce qui concerne tail, je suppose que je voulais dire init, mais l'échanger avec le revers fonctionne bien non plus :-)
Bergi
2

C #, 107 102 octets

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

Non 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;
}
Omer Kahoot
la source
1
Vous pouvez le jouer un peu en supprimant k++la boucle for et en l'ajoutant ++après l'utilisation de k, comme ceci: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;} En outre, les virgules ne sont pas requises par le défi OP, bien que si vous préférez, vous pouvez bien sûr les conserver. Sans c'est ça: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

Rubis, 90 85 octets

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

Si la chaîne est vide, retournez un tableau vide. Sinon, générez la chaîne + le numéro dans chaque numéro de 0 à 9 et appelez favec la chaîne sans le dernier caractère.

5 octets enregistrés grâce à @LevelRiverSt

TuxCrafting
la source
Je suppose que vous n'avez jamais joué au golf à Ruby auparavant. Vérifiez ma réponse à cette question (ou de nombreuses autres réponses Ruby sur ce site) pour voir la manière golfique de définir une fonction sans inclure celles qui sont inutiles defet end. Vous pouvez créer un lambda de sorte que vous n'ayez même pas à lui donner de nom, tant que vous attribuez à une variable et l'appelez avec les arguments entre crochets.
Level River St
@LevelRiverSt L'utilisation d'un lambda dure 1 octet de plus
TuxCrafting
Ok, j'ai raté le fait que vous ayez besoin de le nommer car c'est récursif. Mais f=->s{if s=="";return[];end;(0..9).map{|i|s+i.to_s}+f[s.chars.take(s.length-1).join]}est encore plus court de 5 octets.
Level River St
@LevelRiverSt Oh, je ne connaissais pas la ->syntaxe
TuxCrafting
f=->s{s==""&&(return[]);(0..9).map{|i|s+i.to_s}+f[s.chars.take(s.length-1).join]}enregistre encore 4 octets. Ruby évalue les expressions booléennes de gauche à droite et n'évalue pas les termes ultérieurs, sauf si cela est nécessaire pour déterminer le résultat. La même technique de golf peut être utilisée en C. Je ne sais pas pourquoi le ()tour return[]est nécessaire dans ce cas.
Level River St
2

Perl 6, 32 = 31 octets + 1 pour -p

Je ne suis pas très compétent avec Perl 6, donc il peut y avoir des moyens de le réduire encore plus.

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

Il utilise -ppour évaluer une fois pour chaque ligne d'entrée. La ligne est placée dans $_et après l'exécution du programme, elle s'imprime $_.

Il (~$_,*.chop...^!*)s'agit d'une liste dans laquelle le premier élément est ~entrée stringified ( ), chaque élément suivant est obtenu en coupant le dernier caractère du précédent ( *.chop) et qui continue jusqu'à ce que la chaîne soit vide (!* ), à l'exclusion du cas de chaîne vide ( ^in ...^) .

X~ génère toutes les paires de listes à gauche et à droite, en utilisant l'opération spécifiée, dans ce cas, la concaténation de chaînes (~ ) sur elles. ^10est une liste de 0, 1, ... 9.

Enfin, la liste est de nouveau stringifiée avec ~, donnant les mots requis avec un espace comme séparateur.

Ramillies
la source
2

PowerShell v2 +, 60 octets

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

Boucles de la longueur de la chaîne d'entrée à 1. À chaque itération, définissez helper $iégal au nombre actuel moins 1. Ceci est nécessaire car .lengthcorrespond au nombre total de caractères, mais l'indexation d'une chaîne est basée sur 0. Ensuite, nous bouclons de 0à 9. Chaque boucle interne, tranche la chaîne d'entrée en $nfonction de la valeur de notre boucle externe, la -joinremet en chaîne et concatène la chaîne sur le nombre de boucles internes. Chaque résultat de boucle individuel est placé sur le pipeline et la sortie est implicite à la fin du programme.

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
AdmBorkBork
la source
2

Dyalog APL , 14 11 octets

Renvoie la liste des chaînes.

,⎕D∘.,⍨⌽,\⍞

, listify (transformer le tableau en liste)

⎕D tous les chiffres

∘.,⍨ annexé à tous (c'est-à-dire faire toutes les combinaisons avec)

la liste inversée de

,\ la concaténation cumulative de

la saisie de texte

TryAPL en ligne!

Adam
la source
Fixé. J'utilise un passe-partout et j'ai oublié de le remplir.
Adám
2

Groovy (58 octets)

Je ne sais même pas pourquoi je prends la peine de poster une réponse Groovy ... La taille minimale requise pour un golf Groovy est de 2 en fonction de la nécessité d'une fermeture, donc la meilleure réponse ici est le double de ma taille minimale.

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

Essayez-le ici: https://groovyconsole.appspot.com/script/5148433803378688

Urne de poulpe magique
la source
2

Lot, 85 83 octets

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

Java 7, 105 98 octets

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 octets grâce à @Poke .

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

Code de test:

Essayez-le ici.

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

Sortie:

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
Kevin Cruijssen
la source
1
Vous pouvez enregistrer 7 octets en combinant les boucles for et en faisant une logique supplémentaire pour déterminer implicitement le suffixe et la sous-chaîne. 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);}
Poke
1

Python 3, 62 octets

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

N'utilise pas la récursivité comme l'autre réponse.

La raison pour laquelle le "" x+" "est là: -0 est toujours nul, et donc nous ne pouvons pas utiliser la notation moins pour obtenir toute la chaîne de cette manière, donc le plus haut que nous pouvons aller est de moins un, donc le "" est de remplir la chaîne,

Citron destructible
la source
1

C, 72 , 70 octets

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

Prend les chaînes sous forme de paires pointeur / taille. Test 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');
}
Stefano Sanfilippo
la source
1

Rétine , 37 octets

Le nombre d'octets suppose un codage ISO 8859-1.

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

Essayez-le en ligne!

Explication

M&!r`.+

Obtenez tous les préfixes de l'entrée en faisant correspondre et en imprimant toutes les correspondances qui se chevauchent depuis la droite.

m`$
0

Ajoutez un 0à chaque ligne.

%{`$
¶$%`

Le {indique que les trois étapes restantes sont exécutées en boucle jusqu'à ce qu'elles ne changent pas la chaîne. Le %dit qu'ils doivent être appliqués à chaque ligne séparément.

L'étape elle-même reproduit simplement la dernière ligne (initialement, c'est juste la ligne sur laquelle elle est exécutée, mais chaque itération des trois étapes ajoute une autre ligne).

T`w`d`.$

Incrémentez le chiffre de la dernière ligne en effectuant la substitution de caractères suivante:

from: _0123456789AB...
to:   0123456789

Et enfin:

G10`

Conservez uniquement les 10 premières lignes afin de supprimer la ligne que nous venons d'ajouter INPUT9.

Martin Ender
la source
1

Scala, 73 70 octets

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

Appelez ça comme f("INVALID"). Renvoie une séquence de caractères.

Explication

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

Solution alternative, 73 octets

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

définit une fonction anonyme. Pour l'appeler, écrivez

val f = ...

et l'appelle comme ça

f("INVALID")

Il renvoie une séquence de chaînes, qui ressemblera à ceci lors de l'impression:

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)

Explication

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
corvus_192
la source
Votre solution récursive est de 3 octets de moins que la solution itérative
TuxCrafting
Vous avez raison, j'ai dû l'optimiser après avoir compté.
corvus_192
1

CJam, 29 28 octets

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

Explication:

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

Essayez-le en ligne

Neorej
la source