Les quilles sont des bonbons colorés comportant 5 saveurs distinctes; raisin, pomme verte, citron, orange et fraise représentés respectivement par (p), de g (g) reen, de (y) ellow, de (o) et de (r). J'avais l'habitude de manger des quilles en triant toutes les couleurs, puis en les mangeant en séquence. Après avoir eu quelques regards étranges dans le bureau, je fais maintenant semblant de les manger comme une personne normale. Votre tâche consiste à imiter ceci:

Votre code (programme complet ou fonction) recevra un tableau de quilles (10x10) en entrée (dans un format raisonnable). Ce tableau représentera une pile de quilles non triées. Votre tâche consiste à les "manger" de votre couleur préférée à celle que vous préférez le moins. Mon ordre préféré est le raisin, la pomme verte, le citron, l’orange, la fraise, mais vous êtes libre de choisir n’importe quel ordre tant qu’il est systématiquement appliqué (veuillez indiquer votre préférence dans votre mémoire afin que je puisse vous en juger). Après avoir mangé chaque bonbon, votre code sortira (dans le même format que vous le ferez) le tas restant avec le morceau mangé remplacé par un espace. Vous allez répéter jusqu'à ce qu'il ne reste que votre favori. Vous pouvez choisir n'importe quelle quille à manger (aléatoire ou déterministe). Les espaces de fuite doivent être conservés.

Par exemple, votre séquence de sortie pourrait ressembler à ceci (utiliser 5x5 pour être bref et afficher les espaces comme .)

start   1     2     3     4     5        n 
.org. .org. .org. .org. .or.. .or..    ..r..
prgrg .rgrg .rgrg .rgrg .rgrg .r.rg    .r.r.
gggpr gggpr ggg.r ggg.r ggg.r ggg.r    ....r
oyyor oyyor oyyor oyyor oyyor oyyor    ....r
.r.p. .r.p. .r.p. .r... .r... .r...    .r...

C'est le code-golf , donc le code le plus court en octets gagne

Règles TL; DR:

• La soumission peut être un programme complet ou une fonction
• L'entrée peut être prise dans n'importe quel format raisonnable (chaîne, liste, matrice, etc.) par n'importe quelle méthode raisonnable (STDIN, arguments de fonction, etc.). Cependant, il doit y avoir une certaine délimitation entre les rangées
• La sortie doit être produite dans le même format que l’entrée, quelle que soit la méthode choisie (STDOUT, retour de fonction, etc.). La sortie intermédiaire peut être délimitée ou non
• La première sortie doit être la première entrée
• Les espaces de fuite doivent être préservés
• N'importe quel ordre de couleur peut être utilisé (liste dans votre réponse)
• Toute quille de la couleur actuelle peut être mangée
• La dernière sortie sera uniquement votre couleur et vos espaces préférés
• Si possible, incluez un lien vers un compilateur en ligne pour tester votre soumission

Jelly , 16 14  13 bytes

Ṅ⁶ỤṪ$¦µQL>3µ¿

TryItOnline!

La plupart des moins favoris, comme pour toute personne sérieuse au sujet de leur TOC, est alphabétique!

Prend les entrées et les sorties sous forme de texte (les lignes sont délimitées par de nouvelles lignes).

3 octets enregistrés en inversant le sens et en utilisant une méthode différente: rétrogradez plutôt que de rechercher des caractères dans l'alphabet.

Comment?

Ṅ⁶ỤṪ$¦µQL>3µ¿ - Main link: Skittle text
      µ    µ  - monadic chain separation
            ¿ - while
       Q      - unique items
        L     - length
         >3   - greater than 3 (until only new lines, spaces and 'g's remain)
Ṅ             -     print z and a line feed, yield z
    $         -     treat last two links as a monad
  Ụ           -         grade up (get indices of: new lines; spaces; gs; os; ps; rs; ys)
   Ṫ          -         tail (the last of those, so last y if there is one, else last r, ...)
 ⁶            -     space character
     ¦        -     apply at index (replace that index with a space)

JavaScript (ES6), 74 75 74 octets

Les arômes sont commandés comme décrit dans le défi: raisin, pomme verte, citron, orange, fraise.

Les sorties intermédiaires sont séparées par des nouvelles lignes.

f=(s,n=3,r=s)=>(S=s.replace('oygp'[n],' '))!=s&&(r+=`
`+S)||n--?f(S,n,r):r

Cas de test

Ce cas de test utilise l'exemple 5x5. Toute autre taille de grille devrait fonctionner comme prévu.

f=(s,n=3,r=s)=>(S=s.replace('oygp'[n],' '))!=s&&(r+=`
`+S)||n--?f(S,n,r):r

console.log(f(
` org 
prgrg
gggpr
oyyor
 r p 
`))

Frapper, 48, 46 octets

MISE À JOUR:

• Enregistré deux octets en utilisant des paramètres bruts à printf;

Golfé

sed -nz "p;:a;`printf "s/%s/ /p;ta;" p g y o`"

Prend l'entrée à stdin, imprime à stdout. Mange violet, vert, jaune puis orange.

Un programme sed équivalent serait:

p;:a;s/p/ /p;ta;s/g/ /p;ta;s/y/ /p;ta;s/o/ /p;ta

Exemple de sortie (les délimiteurs sont pour plus de clarté)

-----
 org 
prgrg
gggpr
oyyor
 r p 
-----
-----
 org 
 rgrg
gggpr
oyyor
 r p 
-----
-----
 org 
 rgrg
ggg r
oyyor
 r p 
-----
-----
 org 
 rgrg
ggg r
oyyor
 r   
-----
-----
 or  
 rgrg
ggg r
oyyor
 r   
-----
-----
 or  
 r rg
ggg r
oyyor
 r   
-----
-----
 or  
 r r 
ggg r
oyyor
 r   
-----
-----
 or  
 r r 
 gg r
oyyor
 r   
-----
-----
 or  
 r r 
  g r
oyyor
 r   
-----
-----
 or  
 r r 
    r
oyyor
 r   
-----
-----
 or  
 r r 
    r
o yor
 r   
-----
-----
 or  
 r r 
    r
o  or
 r   
-----
-----
  r  
 r r 
    r
o  or
 r   
-----
-----
  r  
 r r 
    r
   or
 r   
-----
-----
  r  
 r r 
    r
    r
 r   
-----

Essayez-le en ligne!

Python 2, 60 57 56 octets

def f(s):print s;q=max(s);q>'g'and f(s.replace(q,' ',1))

repl.it

Fonction récursive qui mange dans l'ordre alphabétique inverse, laissant les verts pour la fin.

L'entrée sest une chaîne avec un séparateur de lignes avec un ordinal inférieur à celui d'un 'g'(par exemple une nouvelle ligne ou une virgule).

La fonction imprime son entrée, puis récursive si cette entrée contient quelque chose de plus grand qu'un 'g', en passant l'entrée avec la première occurrence du caractère maximum remplacé par un espace.

(Presque un port de ma réponse de gelée .)

Perl, 53 46 + 2 = 48 octets

Courir avec -0n

-10 octets grâce à @Dada

Edit: Merci également à @Dada pour l’avoir signalé, j’ai oublié d’imprimer l’entrée comme première sortie. Cela a été corrigé.

say;eval sprintf"say while s/%s/./;"x4,p,o,g,r

Cette réponse comporte quelques astuces, alors je vais expliquer ce qui se passe.

Tout d'abord, Perl n'aime pas que les paramètres multilignes soient transmis. La variable $/est le séparateur d'enregistrement d'entrée et, chaque fois qu'une entrée rencontre le caractère qui y est stocké, l'interpréteur termine cette entrée et commence une nouvelle entrée. Le contenu par défaut est le caractère de nouvelle ligne \n, ce qui signifie qu'il est impossible de passer une chaîne de plusieurs lignes. Pour ce faire, nous devons sortir $/de son contenu. C'est là que le -0drapeau entre en jeu: setting -0sera stocké nulldans la variable $/, permettant à l'interprète de tout lire en une $_fois dans la variable implicite .

Le prochain truc est la evaldéclaration. Qu'est-ce qu'on fait exactement eval? Nous en sommes evalau résultat de la sprintfdéclaration, qui se décompose comme suit:

La première chose qui sprintfest passée est la chaîne "say while s/%s/./;"répétée 4 fois, donc:

say while s/%s/./;say while s/%s/./;say while s/%s/./;say while s/%s/./;

Ensuite, sprintfquatre caractères nus sont passés p,o,g,r, qui sont interpolés dans l’ sprintfinstruction, en remplacement de chaque instance de %s. Ce que nous obtenons alors est la chaîne suivante, qui est transmise à la evalfonction:

say while s/p/./;say while s/o/./;say while s/g/./;say while s/r/./;

Chaque whileboucle évalue l'expression s/[color]/./, qui remplace la première instance de la couleur de la variable implicite $_par un point. Si une substitution est faite, elle retourne 1, sinon elle ne renvoie rien. Depuis s///a des effets secondaires, il modifie la variable d'origine $_, dont le contenu est ensuite imprimé via say. Quatre versions de cette boucle sont effectuées, remplaçant les violets, les oranges, les verts, puis les rouges, ne laissant que les jaunes.

La raison pour laquelle les jaunes sont laissés est parce que yne peut pas être un mot simple, car il s’agit en fait d’une fonction, et avoir une ylettre au lieu d’une de ces lettres jetterait une erreur. Je pourrais changer cela en mettant des guillemets (+2 octets), ou en utilisant un Y majuscule et en rendant la regex insensible à la casse (+1 octet), mais pour le code-golf , chaque octet compte, alors j'ai décidé d' aimer réellement citrons le plus

TL; DR: Grape, Orange, Green Apple, Strawberry, Lemon

Perl, 30 31 33 + 2 = 32 33 35 octets

for$x(g,o,p,r){say;s/$x/ /&&redo}

Courez avec -n0(pénalité de 2 octets).

Apparemment, j'aime bien manger des Skittles dans l'ordre alphabétique, car le programme s'avère plus court. Le programme n'a pas vraiment besoin de beaucoup d'explications: -n0lit l'entrée implicitement ( -nsignifie "lit l'entrée implicitement", -0signifie "ne coupe pas l'entrée sur les nouvelles lignes"); for$x(g..r)exécute une boucle avec un $xensemble de chaque lettre de gà rà tour; say;imprime l’entrée courante, après toutes les mutations; s/$x/ /remplace une copie de $x(plus précisément la première) par un espace si possible; et &&redorépète le code à l'intérieur des accolades (sans avancer le compteur de boucle) si le remplacement a réussi.

Ce programme peut facilement être généralisé à plusieurs saveurs de Skittle sans en changer la longueur, et fonctionnera avec un tas de toute taille.

Voici un lien Ideone où vous pouvez le tester. (Ideone ne vous permet pas de spécifier des options de ligne de commande, je devais donc ajouter quelques lignes au début pour définir -n0et le -M5.010obtenir gratuitement.)

C #, 134 148 octets

Ordre: G -> O -> Y -> P -> R

I=>{var v=new string(I)+";\n";int i,j=0,c;for(;j<4;){c="goyp"[j++];for(i=0;i<I.Length;i++)if(I[i]==c){ I[i]='.';v+=new string(I)+";\n";}}return v;};

Utilisé des éléments similaires de la réponse de @ Poke, actuellement un peu plus long, car je dois convertir le tableau de caractères en chaîne; (

Java 7, 139 135 130 151 138 135 octets

void t(char[]s){int i,j=-1;for(;++j<5;)for(i=-1;++i<109;)if(j>3|s[i]=="yogp!".charAt(j)){System.out.println(s);if(j>3)return;s[i]=32;}}

Mange des quilles dans l'ordre: jaune, orange, vert, violet, rouge

Je suppose que cela vaut mieux que 2 déclarations d'impression>.>

C 145 - 5 - 18 - 1 = 121 octets

#define l(a)for(a=0;a<10;a++)
i,j,k,b='a';F(char a[][11]){while(b++<'x')l(i)l(j)if(a[i][j]==b){a[i][j]=32;l(k)puts(a[k]);puts("");}}  

ungolfed + jolie

#include<stdio.h>
#include<windows.h>
i,j,k;
F(char a[][11])
{
    char b='a';
    while(b++<'x')
        for(i=0;i<10;i++)
            for(j=0;j<10;j++)
                if(a[i][j]==b)
                {
                    system("cls");
                    a[i][j]=32;
                    for(k=0;k<10;k++)
                        puts(a[k]);
                    puts("");
                    Sleep(35);
                }
}
main()
{
    char a[][11]={
            "gggggggggg",
            "goooooooog",
            "goppppppog",
            "goprrrrpog",
            "gopryyrpog",
            "gopryyrpog",
            "goprrrrpog",
            "gopppppppg",
            "goooooooog",
            "gggggggggg"
    };
    for(i=0;a[i][j];)
        puts(a[i++]);
    F(a);
}  

Ici, cela a[][11]signifie prendre des n-chaînes de longueur 11 où 1 caractère est requis pour la terminaison, donc, techniquement, seuls 10 caractères sont visibles.

ordre: alphabétique
cette fonction recherche 'g'dans l'entrée donnée et l'élimine 1/1, puis incrémente la variable 'g'jusqu'à ce qu'elle trouve une correspondance suivante (probablement une lettre 'o'), puis élimine les caractères correspondants.
L'inconvénient est que cette fonction est tout simplement trop prudente. Ainsi, si vos jeux de 26couleurs étaient de couleurs différentes et portent le nom de code des lettres az, cette fonction gérera également cette entrée ...

Octave, 49 octets

Mange les quilles dans l'ordre alphabétique, en commençant par le code ASCII le plus élevé.

A=input("");do [~,p]=max(A(:));A(p)=32 until A<33

ES6 (Javascript), 72, 71 octets

EDITS:

• Moins 1 octet, en utilisant un modèle littéral avec de

Une version non récursive en Javascript.

Golfé

s=>{r=s;for(c of`pogy`)while(s!=(s=s.replace(c,' ')))r+=`
`+s;return r}

L'entrée et la sortie sont des chaînes multilignes, mange des pilules dans l'ordre "violet => orange => vert => jaune".

Tester

S=s=>{r=s;for(c of`pogy`)while(s!=(s=s.replace(c,' ')))r+=`
`+s;return r}

console.log(
S(` org 
prgrg
gggpr
oyyor
 r p `)
);

Python 3 - 141 99 75 octets

s=input();[exec("print(s);s=s.replace(c,' ',1);"*s.count(c))for c in'orgy']

Le programme mange des quilles dans cet ordre - Orange Red Green Yellow Purple.

Edit - Merci à Flp.Tkc qui a aidé à réduire de 24 octets!

Contribution - 
ygro goppr rppog rppog orgie

Sortie - 
ygro goppr rppog rppog orgie
ygr goppr rppog rppog orgie
ygr g ppr rppog rppog orgie
ygr g ppr rpp g rppog orgie
ygr g ppr rpp g rpp g orgie
ygr g ppr rpp g rpp g rgy
yg g ppr rpp g rpp g rgy
yg g pp rpp g rpp g rgy
yg g pp pp g rpp g rgy
yg g pp pp g g ggy
yg g pp pp g pp g gy
yg pp pp g pp g gy
y pp pp g pp g gy
y pp pp pp gp
y pp pp pp gy
y pp pp pp y
        pp pp pp y
        pp pp pp  

Je pense qu’il est possible de jouer davantage au golf, car cela semble très simple.

Vim 57 55 octets

Enregistrement de deux octets en supprimant mon délimiteur de ligne. Malheureusement, il est beaucoup plus difficile de lire et de vérifier l'exactitude :(.

:set ws!
yGP/o
qqnr G9kyGGp@qq@q/y
@q/p
@q/g
@qdG

Unprintables:

:set ws!
yGP^O/o
^Oqq^Hnr G9kyGGp@qq@q/y
^O@q/p
^O@q/g
^O@qdG

TryItOnline

Mange dans l'ordre oypg, laissant tous les r pour la fin :)

Mathematica, 67 octets

Most[#/.(i=0;#:>"."/;i++≤0&/@Characters@"ryop")&~FixedPointList~#]&

Mange des rouges, puis des jaunes, puis des oranges, puis des violets.

Java 7, 125 octets

Violet, Jaune, Vert, Rouge, Orange. J'apprécie de pouvoir choisir ma commande dans cette solution. :RÉ

Golfé

String s(String p){String r=p;for(String c:"pygr".split(""))for(;p.contains(c);r+="\n\n"+p)p=p.replaceFirst(c," ");return r;}

Ungolfed

String s(String p) {
    String r=p;
    for (String c : "pygo".split("")) {
        for (; p.contains(c); r += "\n\n" + p) {
            p = p.replaceFirst(c, " ");
        }
    }
    return r;
}

Essayez-le ici!

Une approche différente de l'autre réponse Java par @Poke. Nous commençons par faire une copie de la chaîne originale. En parcourant chaque couleur, nous la remplaçons chaque fois qu'elle est trouvée par un espace, puis nous ajoutons la nouvelle mise en page à la chaîne de sortie et nous en revenons après avoir mangé tout sauf de l'orange.

Remarques

La séparation entre les étapes est effectuée avec une double ligne \n\n, mais si la grille d’entrée peut être définie avec une nouvelle ligne à la fin, elle peut être raccourcie \n.

Haskell, 60 octets

f x|(a,b:c)<-span(<maximum x)x,b>'g'=(:)<*>f$a++' ':c|1<2=[]

L'entrée est une chaîne unique dans laquelle les lignes sont séparées ,. La valeur de retour est une liste de chaînes avec toutes les étapes intermédiaires. L'ordre est alphabétique, le plus grand en premier, il reste donc des restes verts. Exemple d'utilisation:

*Main> mapM_ putStrLn $ f " org ,prgrg,gggpr,oyyor, r p "
 org ,prgrg,gggpr,o yor, r p 
 org ,prgrg,gggpr,o  or, r p 
 o g ,prgrg,gggpr,o  or, r p 
 o g ,p grg,gggpr,o  or, r p 
 o g ,p g g,gggpr,o  or, r p 
 o g ,p g g,gggp ,o  or, r p 
 o g ,p g g,gggp ,o  o , r p 
 o g ,p g g,gggp ,o  o ,   p 
 o g ,  g g,gggp ,o  o ,   p 
 o g ,  g g,ggg  ,o  o ,   p 
 o g ,  g g,ggg  ,o  o ,     
   g ,  g g,ggg  ,o  o ,     
   g ,  g g,ggg  ,   o ,     
   g ,  g g,ggg  ,     ,     

Récursion simple. Enregistrez la liste d'entrée dans la valeur de retour, remplacez le plus grand élément gpar un espace et appelez à nouveau la fonction. Le cas de base est quand il n'y a plus aucun élément à supprimer.

MATL, 24 octets

`tDX:t2#X>wx32w(10etun2>

Essayez-le en ligne! Je préfère manger mes quilles dans l'ordre alphabétique inverse: le vert est ma couleur préférée. Explication:

                           % Take input implicitly.
`                          % Start do ... while loop
 tD                        % Duplicate skittle pile (nom!), but give away for display
   X:                      % Put skittles in long row (like normal people do)
     t2#X>                 % Get least favourite skittle name and number in the row
          wx               % Discard the skittle name
            32w            % Put an eaten skittle on the stack (ASCII 32)
               (           % Put the eaten skittle back in the row of skittles.
                10e        % Shape the row back into a 10x10 array
                   tun     % Check the number of unique skittles
                      2>   % Loop while this number >2 (eaten skittles + favourite skittles)
                           % Implicit end of do... while loop. 
                           % Display last iteration implicitly, since it's still on the stack.

QBasic, 125 octets

Règles créatives abuser!

DATA 71,89,82,79
?INPUT$(109)
DO
READ s
FOR r=1TO 10
FOR c=1TO 10
IF s=SCREEN(r,c)THEN SLEEP 1:LOCATE r,c:?" "
NEXT
NEXT
LOOP

Cette soumission suppose que beaucoup de choses vont bien:

• Les entrées et sorties sont majuscules ( GORPY)
• La saisie est effectuée sous la forme de 109 pressions de touche successives, qui ne sont pas répercutées sur l'écran tant que la dernière n'est pas entrée. À la fin de chaque ligne, à l'exception de la dernière, l'utilisateur doit entrer un retour à la ligne.
• Au lieu d'imprimer plusieurs fois la pile de quilles, le programme l'affiche à l'écran avec une pause d'une seconde avant chaque étape. (QBasic n’a pas de défilement en sortie, donc imprimer plusieurs fois la pile ne vous donnera que les 2 dernières étapes. En outre, cette méthode illustre bien mieux l’évolution de votre pile de quilles lorsque vous les mangez.)
• Le programme se termine par une erreur.

J'ai aussi une version de 130 octets qui utilise des minuscules et ne commet pas d'erreur.

Voici un exemple d’exécution dans QB64 , 109modifié 29pour une grille 5x5:

Explication

DATA 71,89,82,79stocke les codes ASCII G, Y, Ret O.

?INPUT$(109) obtient 109 pressions de l'utilisateur et les imprime.

Nous entrons ensuite dans une DO ... LOOPconstruction infinie . A chaque passage, nous READintroduisons le code ASCII de la Skittle actuelle s. Ensuite, nous parcourons les lignes et les colonnes de 1 à 10. Nous obtenons SCREEN(r,c)le code ASCII du caractère à l’écran r, ligne , colonne c. Si cela est égal à la Quille actuelle s, nous SLEEPpour une seconde, puis imprimer un espace à r, c.

La boucle principale est exécutée quatre fois, supprimant les quilles vertes, jaunes, rouges et oranges. À la cinquième itération, READerreurs car nous manquons de données.