I birilli sono caramelle colorate in cui ci sono 5 gusti distinti; uva, mela verde, limone, arancia e fragola rappresentate rispettivamente da (p) urple, (g) reen, (y) ellow, (o) range e (r) ed. Mangiavo i birilli ordinando tutti i diversi colori e mangiandoli in sequenza. Dopo aver ottenuto alcuni strani sguardi in ufficio, ora faccio finta di mangiarli come una persona normale. Il tuo compito è emulare questo:

Il tuo codice (programma completo o funzione) riceverà una matrice di birilli (10x10) come input (in qualsiasi formato ragionevole). Questo array rappresenterà un mucchio di birilli non ordinati. Il tuo compito è di "mangiarli" dal tuo colore meno preferito a quello preferito. Il mio ordine preferito è uva, mela verde, limone, arancia, fragola, ma sei libero di scegliere qualsiasi ordine purché sia ​​costantemente applicato (per favore, elenca le tue preferenze nella tua richiesta in modo che io possa giudicarti). Dopo aver mangiato ogni pezzo di caramella il tuo codice produrrà (nello stesso formato in cui prendi l'input) la pila rimanente con il pezzo mangiato sostituito da uno spazio. Ripeterai finché non rimarrà solo il tuo preferito. Puoi scegliere qualsiasi birillo da mangiare (può essere casuale o deterministico). Gli spazi finali devono essere mantenuti.

Ad esempio, la sequenza di output potrebbe apparire così (usando 5x5 per brevità e mostrando spazi come .)

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

Questo è code-golf , quindi vince il codice più breve in byte

TL; Regole DR:

• L'invio può essere un programma o una funzione completi
• L'input può essere preso in qualsiasi formato ragionevole (stringa, elenco, matrice, ecc.) Con qualsiasi metodo ragionevole (STDIN, argomenti di funzione, ecc.). Tuttavia, ci deve essere una certa delimitazione tra le righe
• L'output deve essere prodotto nello stesso formato dell'input con qualsiasi metodo ragionevole (STDOUT, ritorno di funzione, ecc.). L'output intermedio può o non può essere delimitato
• Il primo output deve essere il primo input
• Gli spazi finali devono essere preservati
• È possibile utilizzare qualsiasi ordine di colore (elenco nella risposta)
• Qualunque boccone del colore attuale può essere mangiato
• L'ultimo output deve essere solo il tuo colore e gli spazi preferiti
• Se possibile, includere un collegamento a un compilatore online per testare l'invio

Gelatina , 16 14  13 byte

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

TryItOnline!

Il più preferito, come per chiunque sia serio sul proprio DOC, è alfabetico!

Accetta input e output come testo (ovvero le righe sono delimitate da nuove righe).

3 byte salvati invertendo la direzione e usando un metodo diverso: valutare invece di trovare i caratteri dell'alfabeto.

Come?

Ṅ⁶ỤṪ$¦µ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 byte

I sapori sono ordinati come descritto nella sfida: uva, mela verde, limone, arancia, fragola.

Le uscite intermedie sono separate da nuove righe.

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

Caso di prova

Questo caso di test utilizza l'esempio 5x5. Qualsiasi altra dimensione della griglia dovrebbe funzionare come previsto.

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

bash, 48, 46 byte

AGGIORNARE:

• Salvato due byte utilizzando parametri grezzi per printf;

golfed

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

Riceve input da stdin, stampa su stdout. Mangia viola, verde, giallo e poi arancione.

Un programma sed equivalente sarebbe:

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

Output di esempio (i delimitatori sono solo per chiarezza)

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

Provalo online!

Python 2, 60 57 56 byte

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

repl.it

Funzione ricorsiva che mangia in ordine alfabetico inverso, lasciando i verdi per ultimo.

L'input sè una stringa con un delimitatore di riga con un ordinale inferiore a quello di un 'g'(ad esempio una nuova riga o una virgola).

La funzione stampa il suo input e quindi ricorre se quell'input contiene qualcosa di più grande di una 'g', passando l'input con la prima occorrenza del carattere massimo sostituito da uno spazio.

(Quasi una porta della mia risposta Jelly .)

Perl, 53 46 + 2 = 48 byte

Corri con -0n

-10 byte grazie a @Dada

Modifica: anche grazie a @Dada per averlo sottolineato, ho dimenticato di stampare l'input come primo output. È stato risolto.

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

C'è un po 'di inganno in questa risposta, quindi analizzerò cosa sta succedendo.

Prima di tutto, a Perl non piace il passaggio di parametri multilinea. La variabile $/è il separatore del record di input e ogni volta che un input incontra il carattere in esso memorizzato, l'interprete termina tale input e inizia un nuovo input. Il contenuto predefinito è il carattere di nuova riga \n, il che significa che non è possibile passare una stringa a più righe. Per fare ciò, dobbiamo deselezionare $/dal suo contenuto. È qui -0che entra in gioco il flag: setting -0memorizzerà nullnella variabile $/, permettendo all'interprete di leggere tutto nella variabile implicita $_in una sola volta.

Il prossimo espediente è l' evalaffermazione. Cosa stiamo esattamente evaling? Stiamo evalottenendo il risultato della sprintfdichiarazione, che è suddivisa come segue:

La prima cosa che sprintfviene passata è la stringa "say while s/%s/./;"ripetuta 4 volte, quindi:

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

Quindi, sprintfvengono passati quattro caratteri bareword p,o,g,r, che vengono interpolati sprintfnell'istruzione, sostituendo ciascuna istanza di %s. Ciò che otteniamo quindi è la seguente stringa, che viene passata alla evalfunzione:

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

Ogni whileciclo valuta l'espressione s/[color]/./, che sostituisce la prima istanza di qualunque colore sia nella variabile implicita $_con un punto. Se viene effettuata una sostituzione, questa viene restituita 1, altrimenti non restituisce nulla. Poiché s///ha effetti collaterali, modifica la variabile originale $_, i cui contenuti vengono quindi stampati tramite say. Vengono eseguite quattro versioni di questo ciclo, sostituendo i viola, gli aranci, i verdi e poi i rossi, lasciando solo i gialli.

Il motivo per cui i gialli sono rimasti è perché ynon può essere una parola nuda, perché in realtà è una funzione e avere una yinvece di una di quelle lettere genererebbe un errore. Potrei cambiarlo inserendo delle virgolette (+2 byte) o usando una Y maiuscola e rendendo maiuscole le maiuscole e minuscole (+1 byte), ma per il golf del codice , ogni byte conta, quindi ho deciso che in realtà mi piace birilli al limone di più.

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

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

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

Esegui con -n0(penalità di 2 byte).

Apparentemente, mi piace mangiare i birilli in ordine alfabetico, perché il programma risulta più breve in quel modo. Il programma non ha davvero bisogno di molte spiegazioni: -n0legge l'input in modo implicito ( -nsignifica "leggi input in modo implicito", -0significa "non interrompere l'input su newline"); for$x(g..r)esegue un ciclo con $xset da ogni lettera da ga ra sua volta; say;stampa l'input corrente, dopo eventuali mutazioni; s/$x/ /sostituisce una copia di $x(in particolare, la prima) con uno spazio, se possibile; e &&redoripete il codice all'interno delle parentesi graffe (senza far avanzare il contatore di loop) se la sostituzione ha avuto esito positivo.

Questo programma può essere facilmente generalizzato a più gusti di Skittle senza modificarne la lunghezza e funzionerà con una pila di qualsiasi dimensione.

Ecco un link Ideone dove puoi testarlo. (Ideone non ti consente di specificare le opzioni della riga di comando, quindi ho dovuto aggiungere un paio di righe all'inizio per impostare -n0e -M5.010quello che ottieni gratuitamente.)

C #, 134 148 byte

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

Ho usato alcune cose simili dalla risposta di @Poke, attualmente un po 'più a lungo, poiché ho bisogno di convertire l'array di caratteri in una stringa; (

Java 7, 139 135 130 151 138 135 byte

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

Mangia birilli nell'ordine: giallo, arancione, verde, viola, rosso

Immagino sia meglio di 2 dichiarazioni di stampa>.>

C 145 - 5 - 18 - 1 = 121 byte

#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 + carina

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

Qui a[][11]significa prendere n-stringhe di lunghezza 11 dove è richiesto 1 carattere per la terminazione, quindi tecnicamente solo 10 caratteri visibili.

ordine: in ordine alfabetico
questa funzione controlla 'g'nell'input dato e lo elimina di 1/1, quindi incrementa il mantenimento della variabile 'g'fino a quando non trova una corrispondenza successiva (probabilmente una lettera 'o') e quindi elimina i caratteri corrispondenti.
Il rovescio della medaglia è che questa funzione è fin troppo attenta. Quindi, se i tuoi birilli erano di 26colori diversi con nomi in codice dalle lettere az, questa funzione gestirà anche quell'input ...

Ottava, 49 byte

Mangia birilli in ordine alfabetico, prima il codice ASCII più alto.

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

ES6 (Javascript), 72, 71 byte

Modifiche:

• Meno 1 byte, usando il modello letterale con of

Una versione non ricorsiva in Javascript.

golfed

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

Input e output sono stringhe multilinea, mangia pillole nell'ordine "viola => arancione => verde => giallo".

Test

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 byte

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

Il programma mangia birilli in questo ordine - Orange Red Green Yellow Purple.

Modifica - Grazie a Flp.Tkc che ha contribuito a ridurre 24 byte!

Input - 
ygro goppr rppog rppog orgia

Produzione - 
ygro goppr rppog rppog orgia
ygr goppr rppog rppog orgia
ygr g ppr rppog rppog orgia
ygr g ppr rpp g rppog orgia
ygr g ppr rpp g rpp g orgia
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 pp g rgy
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 g gy
y pp pp pp gy
y pp pp pp y
        pp pp pp y
        pp pp pp  

Credo che possa essere ulteriormente golfato in quanto sembra molto semplice.

Vim 57 55 byte

Salvando due byte rimuovendo il mio delimitatore di linea. Purtroppo rende molto più difficile leggere e verificare la correttezza :(.

: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

Mangia nell'ordine oypg, lasciando tutte le r per la fine :)

Mathematica, 67 byte

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

Mangia rossi, poi gialli, poi arance, poi viola.

Java 7, 125 byte

Viola, Giallo, Verde, Rosso, Arancione. Mi sta godendo il fatto di poter scegliere il mio ordine in questa soluzione. : D

golfed

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

Provalo qui!

Un approccio diverso rispetto all'altra risposta Java di @Poke. Iniziamo facendo una copia della stringa originale. Scorrendo ogni colore, lo sostituiamo ogni volta che viene trovato con uno spazio, quindi aggiungiamo il nuovo layout alla stringa di output, tornando dopo che abbiamo mangiato tutto tranne l'arancione.

Appunti

La separazione tra i passaggi viene eseguita con una nuova riga doppia \n\n, ma se la griglia di input può essere presa con una nuova riga finale alla fine, può essere ridotta a solo \n.

Haskell, 60 byte

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

L'input è una singola stringa in cui le righe sono separate ,. Il valore restituito è un elenco di stringhe con tutti i passaggi intermedi. L'ordine è alfabetico, prima il più grande, quindi il verde rimane. Esempio di utilizzo:

*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  ,     ,     

Ricorsione semplice. Salvare l'elenco di input per il valore restituito, sostituire l'elemento più grande gcon uno spazio e chiamare nuovamente la funzione. Il caso base è quando non è rimasto alcun elemento da rimuovere.

MATL, 24 byte

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

Provalo online! Preferisco mangiare i miei birilli in ordine alfabetico inverso: il verde è il mio colore preferito. Spiegazione:

                           % 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 byte

Abuso di regole creative!

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

Questa presentazione presuppone che molte cose vadano bene:

• Input e output sono in maiuscolo ( GORPY)
• L'immissione viene presa come 109 pressioni di tasti successive, che non fanno eco allo schermo fino a quando non viene immesso l'ultimo. Alla fine di ogni riga tranne l'ultima, l'utente deve inserire un ritorno a capo.
• Invece di stampare più volte il mazzo di birilli, il programma lo visualizza sullo schermo con una pausa di 1 secondo prima di ogni passaggio. (QBasic non ha lo scrollback dell'output, quindi stampare la pila più volte ti darebbe solo gli ultimi 2 1/2 passaggi. Inoltre, questo metodo è una rappresentazione molto migliore di come la tua pila di birilli si evolve mentre le mangi.)
• Il programma termina con un errore.

Ho anche una versione da 130 byte che utilizza lettere minuscole e non presenta errori.

Ecco un esempio di esecuzione in QB64 , 109modificata in 29per una griglia 5x5:

Spiegazione

DATA 71,89,82,79memorizza i codici ASCII di G, Y, Re O.

?INPUT$(109) ottiene 109 tasti premuti dall'utente e li stampa.

Entriamo quindi in un DO ... LOOPcostrutto infinito . Ogni volta, abbiamo READil codice ASCII dell'attuale Skittle in s. Quindi passiamo sopra le righe e le colonne da 1 a 10. SCREEN(r,c)ottiene il codice ASCII del personaggio sullo schermo in riga r, colonna c. Se questo è uguale alla corrente Birillo s, che SLEEPper un secondo e poi stampare uno spazio r, c.

Il ciclo principale viene eseguito quattro volte, rimuovendo i birilli verdi, gialli, rossi e arancioni. Nella quinta iterazione, READerrori perché non disponiamo di dati.