Skittles são doces coloridos, onde existem 5 sabores distintos; uva, maçã verde, limão, laranja e morango representados por (p) uple, (g) reen, (y) ellow, (o) range e (r) ed, respectivamente. Eu costumava comer skittles, classificando todas as cores diferentes e depois comendo em sequência. Depois de receber alguns olhares estranhos no escritório, agora finjo comê-los como uma pessoa normal. Sua tarefa é emular isso:

Seu código (programa ou função completo) receberá uma variedade de pinos (10x10) como entrada (em qualquer formato razoável). Essa matriz representará uma pilha de skittles não classificados. Sua tarefa é "comê-los" da sua cor menos favorita à favorita. Meu pedido preferido é uva, maçã verde, limão, laranja, morango, mas você pode escolher qualquer pedido desde que seja sempre aplicado (liste sua preferência em sua inscrição para que eu possa julgá-lo). Depois de comer cada pedaço de doce, seu código produzirá (no mesmo formato que você digitou) a pilha restante com o pedaço comido substituído por um espaço. Você repetirá até que apenas restem os seus favoritos. Você pode escolher qualquer bolinho para comer (pode ser aleatório ou determinístico). Espaços à direita devem ser mantidos.

Por exemplo, sua sequência de saída pode ficar assim (usando 5x5 por questões de brevidade e mostrando espaços como .)

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

Isso é código-golfe , então o código mais curto em bytes ganha

Regras TL; DR:

• O envio pode ser um programa ou função completo
• A entrada pode ser obtida em qualquer formato razoável (string, lista, matriz, etc.) por qualquer método razoável (STDIN, argumentos de função, etc.). No entanto, deve haver alguma delimitação entre linhas
• A saída deve ser produzida no mesmo formato da entrada por qualquer método razoável (STDOUT, retorno da função, ect.). Saída intermediária pode ou não ser delimitada
• A primeira saída será a primeira entrada
• Os espaços à direita devem ser preservados
• Qualquer ordem de cores pode ser usada (lista na sua resposta)
• Qualquer pino da cor atual pode ser consumido
• A última saída será apenas sua cor e espaços favoritos
• Se possível, inclua um link para um compilador online para testar seu envio

Geléia , 16 14  13 bytes

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

TryItOnline!

O favorito dos menos favorecidos, assim como para qualquer pessoa que seja séria sobre o TOC, é alfabético!

Recebe entradas e saídas como texto (ou seja, as linhas são delimitadas por novas linhas).

3 bytes salvos invertendo a direção e usando um método diferente: classifique mais do que localize caracteres do alfabeto.

Quão?

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

Os sabores são pedidos conforme descrito no desafio: uva, maçã verde, limão, laranja, morango.

As saídas intermediárias são separadas por novas linhas.

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

Caso de teste

Este caso de teste está usando o exemplo 5x5. Qualquer outro tamanho de grade deve funcionar conforme o esperado.

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

Bater, 48., 46 bytes

ATUALIZAR:

• Salva dois bytes usando parâmetros brutos para printf;

Golfe

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

Recebe entrada em stdin, imprime em stdout. Come roxo, verde, amarelo e depois laranja.

Um programa sed equivalente seria:

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

Saída de amostra (os delimitadores são apenas para clareza)

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

Experimente online!

Python 2, 60 57 56 bytes

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

repl.it

Função recursiva que come em ordem alfabética inversa, deixando os verdes para o final.

Entrada sé uma sequência com um delimitador de linha com um ordinal menor que o de a 'g'(por exemplo, uma nova linha ou vírgula).

A função imprime sua entrada e depois se repete se essa entrada contiver algo maior que um 'g', passando a entrada com a primeira ocorrência do caractere máximo substituído por um espaço.

(Quase um porto da minha resposta Jelly .)

Perl, 53 46 + 2 = 48 bytes

Correr com -0n

-10 bytes graças a @Dada

Edit: Também obrigado a @Dada por apontá-lo, esqueci de imprimir a entrada como a primeira saída. Isso foi consertado.

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

Há um pouco de truque envolvido nesta resposta, então vou detalhar o que está acontecendo.

Primeiro de tudo, o Perl não gosta de passar parâmetros de várias linhas. A variável $/é o separador de registro de entrada e, sempre que uma entrada encontra o caractere armazenado, o intérprete finaliza essa entrada e inicia uma nova entrada. O conteúdo padrão é o caractere de nova linha \n, o que significa que não é possível transmitir uma sequência de várias linhas. Para fazer isso, devemos remover $/o conteúdo. É aí que o -0sinalizador entra: a configuração -0será armazenada nullna variável $/, permitindo que o intérprete leia tudo na variável implícita de $_uma só vez.

O próximo truque é a evalafirmação. Exatamente o que exatamente estamos evaling? Estamos evalobtendo o resultado da sprintfdeclaração, que é dividida da seguinte forma:

A primeira coisa que sprintfé passada é a sequência "say while s/%s/./;"repetida 4 vezes, portanto:

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

Em seguida, sprintfsão passados ​​quatro caracteres de palavra de barra p,o,g,r, que são interpolados na sprintfinstrução, substituindo cada instância de %s. O que obtemos então é a seguinte string, que é passada para a evalfunção:

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

Cada whileloop avalia a expressão s/[color]/./, que substitui a primeira instância de qualquer cor que estiver na variável implícita $_por um ponto. Se uma substituição for feita, ela retornará 1, caso contrário, ela não retornará nada. Como s///tem efeitos colaterais, modifica a variável original $_, cujo conteúdo é impresso via say. São executadas quatro versões desse loop, substituindo os roxos, as laranjas, os verdes e depois os vermelhos, deixando apenas os amarelos.

A razão pela qual os amarelos são deixados é porque ynão pode ser uma palavra de barra, porque na verdade é uma função, e ter uma yletra em vez de uma dessas letras geraria um erro. Eu poderia mudar isso colocando aspas (+2 bytes) ou usando Y maiúsculo e tornando o regex sem distinção entre maiúsculas e minúsculas (+1 byte), mas para código-golfe , cada byte conta, então decidi que realmente gostava skittles de limão mais.

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

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

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

Corra com -n0(penalidade de 2 bytes).

Aparentemente, eu gosto de comer Skittles em ordem alfabética, porque o programa fica mais curto dessa maneira. O programa realmente não precisa de muita explicação: -n0lê a entrada implicitamente ( -nsignifica "ler entrada implicitamente", -0significa "não interromper a entrada em novas linhas"); for$x(g..r)executa um loop com o $xconjunto de cada letra de gpara rpor sua vez; say;imprime a entrada atual, após qualquer mutação; s/$x/ /substitui uma cópia $x(especificamente a primeira) por um espaço, se possível; e &&redorepete o código dentro dos colchetes (sem avançar o contador de loop) se a substituição tiver sido bem-sucedida.

Este programa pode ser facilmente generalizado para mais sabores do Skittle sem alterar seu comprimento e funcionará com uma pilha de qualquer tamanho.

Aqui está um link Ideone onde você pode testá-lo. (O Ideone não permite que você especifique opções de linha de comando; portanto, tive que adicionar algumas linhas no início da configuração -n0e as -M5.010que você obtém gratuitamente.)

C #, 134 148 bytes

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

Usou algumas coisas semelhantes da resposta de @ Poke, atualmente um pouco mais longa, já que eu preciso converter a matriz de caracteres em uma string; (

Java 7, 139 135 130 151 138 135 bytes

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

Come skittles na ordem: amarelo, laranja, verde, roxo, vermelho

Eu acho que isso é melhor do que 2 declarações de impressão>.>

C 145 - 5 - 18 - 1 = 121 bytes

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

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

Aqui a[][11]significa pegar n-strings de comprimento 11 onde 1 caractere é necessário para a terminação, portanto, tecnicamente apenas 10 caracteres visíveis.

ordem: alfabética
essa função verifica 'g'a entrada fornecida e a elimina 1/1, em seguida, incrementa a retenção da variável 'g'até encontrar uma próxima correspondência (provavelmente letra 'o') e elimina os caracteres correspondentes.
A desvantagem é que essa função é muito cuidadosa. Portanto, se seus skittels fossem de 26cores diferentes, com o codinome das letras az, essa função também manipulará essa entrada ...

Oitava, 49 bytes

Come skittles em ordem alfabética, o código ASCII mais alto primeiro.

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

ES6 (Javascript), 72, 71 bytes

EDITAR% S:

• Menos 1 byte, usando o modelo literal com de

Uma versão não recursiva em Javascript.

Golfe

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

Entrada e saída são cadeias de linhas múltiplas, tomam pílulas na ordem "roxo => laranja => verde => amarelo".

Teste

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 bytes

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

Programa come skittles nesta ordem - Orange Red Green Yellow Purple.

Editar - Obrigado ao Flp.Tkc, que ajudou a reduzir 24 bytes!

Entrada - 
ygro goppr rppog rppog orgia

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

Eu acredito que pode ser ainda mais jogado, pois parece muito simples.

Vim 57 55 bytes

Salvando dois bytes removendo meu delimitador de linha. Infelizmente, torna muito mais difícil ler e verificar a exatidão :(.

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

Não imprimíveis:

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

TryItOnline

Come na ordem oypg, deixando todos os r's para o final :)

Mathematica, 67 bytes

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

Come vermelhos, depois amarelos, laranjas e roxos.

Java 7, 125 bytes

Roxo, Amarelo, Verde, Vermelho, Laranja. Estou gostando de poder escolher meu pedido nesta solução. : D

Golfe

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

Experimente aqui!

Uma abordagem diferente da outra resposta Java do @Poke. Começamos fazendo uma cópia da string original. Iterando através de cada cor, substituí-lo sempre que encontrar um espaço e anexar o novo layout à sequência de saída, retornando depois que comemos tudo, menos o laranja.

Notas

A separação entre as etapas é feita com uma nova linha dupla \n\n, mas se a grade de entrada puder ser obtida com uma nova linha à direita no final, ela poderá ser reduzida para apenas \n.

Haskell, 60 bytes

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

Entrada é uma única sequência na qual as linhas são separadas ,. Valor de retorno é uma lista de cadeias com todas as etapas intermediárias. A ordem é alfabética, a maior em primeiro lugar, então o verde permanece. Exemplo de uso:

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

Recursão simples. Salve a lista de entrada para o valor de retorno, substitua o maior elemento maior gpor um espaço e chame a função novamente. O caso base é quando não há nenhum elemento a ser removido.

MATL, 24 bytes

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

Experimente online! Prefiro comer meus skittles em ordem alfabética inversa: verde é minha cor favorita. Explicação:

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

Abuso de regras criativas!

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

Este envio pressupõe que muitas coisas estão bem:

• Entrada e saída estão em maiúsculas ( GORPY)
• A entrada é tomada como 109 pressionamentos de tecla sucessivos, que não são repetidos na tela até que o último seja inserido. No final de cada linha, exceto a última, o usuário deve inserir um retorno de carro.
• Em vez de imprimir a pilha Skittles várias vezes, o programa a exibe na tela com uma pausa de 1 segundo antes de cada etapa. (O QBasic não possui retorno de saída, portanto, imprimir a pilha várias vezes forneceria apenas os últimos 2 1/2 passos. Além disso, esse método é uma representação muito melhor de como a pilha de Skittles evolui à medida que você as come.)
• O programa termina com um erro.

Eu também tenho uma versão de 130 bytes que usa letras minúsculas e não erro.

Aqui está um exemplo de execução no QB64 , 109alterado para 29para uma grade 5x5:

Explicação

DATA 71,89,82,79armazena os códigos ASCII de G, Y, R, e O.

?INPUT$(109) obtém 109 pressionamentos de tecla do usuário e os imprime.

Em seguida, inserimos uma DO ... LOOPconstrução infinita . A cada vez, READinserimos o código ASCII do Skittle atual s. Em seguida, fazemos um loop sobre linhas e colunas de 1 a 10. SCREEN(r,c)obtém o código ASCII do caractere na tela na linha r, coluna c. Se esta é igual à corrente Skittle s, que SLEEPpor um segundo e, em seguida, imprimir um espaço no r, c.

O loop principal é executado quatro vezes, removendo os Skittles verdes, amarelos, vermelhos e laranja. Na quinta iteração, READerros porque estamos sem dados.