Los bolos son dulces de colores donde hay 5 sabores distintos; uva, manzana verde, limón, naranja y fresa representados por (p) urple, (g) reen, (y) ellow, (o) range y (r) ed respectivamente. Solía ​​comer bolos clasificando los diferentes colores y luego comiéndolos en secuencia. Después de tener algunas miradas extrañas en la oficina, ahora pretendo comerlas como una persona normal. Su tarea es emular esto:

Su código (programa o función completa) recibirá una matriz de bolos (10x10) como entrada (en cualquier formato razonable). Este conjunto representará una pila de bolos sin clasificar. Su tarea es "comerlos" de su color menos favorito a favorito. Mi orden preferida es la uva, la manzana verde, el limón, la naranja, la fresa, pero usted es libre de elegir cualquier orden siempre que se aplique de manera consistente (indique su preferencia en su presentación para que pueda juzgarlo). Después de comer cada pieza de dulce, su código generará (en el mismo formato que ingresó) la pila restante con la pieza comida reemplazada por un espacio. Repetirás hasta que solo queden tus restos favoritos. Puede elegir cualquier bollo para comer (puede ser aleatorio o determinista). Los espacios finales deben mantenerse.

Por ejemplo, su secuencia de salida podría verse así (usando 5x5 por brevedad y mostrando espacios 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...

Este es el código de golf , por lo que gana el código más corto en bytes

TL; Reglas de DR:

• La presentación puede ser un programa completo o función
• La entrada puede tomarse en cualquier formato razonable (cadena, lista, matriz, etc.) por cualquier método razonable (STDIN, argumentos de función, etc.). Sin embargo, debe haber alguna delimitación entre filas
• La salida debe producirse en el mismo formato que la entrada por cualquier método razonable (STDOUT, retorno de función, ect.). La salida intermedia puede o no estar delimitada
• La primera salida será la primera entrada.
• Los espacios finales deben ser preservados
• Se puede usar cualquier orden de color (enumere en su respuesta)
• Se puede comer cualquier bolo del color actual.
• La última salida será solo su color y espacios favoritos
• Si es posible, incluya un enlace a un compilador en línea para probar su envío

Jalea , 16 14  13 bytes

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

TryItOnline!

¡Lo más a menos favorito, como para cualquier persona seria sobre su TOC, es alfabético!

Toma entradas y salidas como texto (es decir, las filas están delimitadas por nuevas líneas).

Se guardan 3 bytes invirtiendo la dirección y usando un método diferente: subir de nivel en lugar de buscar caracteres del alfabeto.

¿Cómo?

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

Los sabores se ordenan como se describe en el desafío: uva, manzana verde, limón, naranja, fresa.

Las salidas intermedias están separadas por líneas nuevas.

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

Caso de prueba

Este caso de prueba está utilizando el ejemplo 5x5. Cualquier otro tamaño de cuadrícula debería funcionar como se esperaba.

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

Golpetazo, 4846 bytes

ACTUALIZAR:

• Guardado dos bytes mediante el uso de parámetros sin formato para imprimirf;

Golfed

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

Toma entrada en stdin, imprime en stdout. Come púrpura, verde, amarillo y luego naranja.

Un programa sed equivalente sería:

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

Salida de muestra (los delimitadores son solo para mayor claridad)

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

Pruébalo en línea!

Python 2, 60 57 56 bytes

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

repl.it

Función recursiva que come en orden alfabético inverso, dejando los verdes para el final.

La entrada ses una cadena con un delimitador de fila con un ordinal menor que el de un 'g'(por ejemplo, una nueva línea o una coma).

La función imprime su entrada y luego vuelve a aparecer si esa entrada contiene algo mayor que una 'g', pasando la entrada con la primera aparición del carácter máximo reemplazado por un espacio.

(Casi un puerto de mi respuesta Jelly .)

Perl, 53 46 + 2 = 48 bytes

Corre con -0n

-10 bytes gracias a @Dada

Editar: También gracias a @Dada por señalarlo, olvidé imprimir la entrada como la primera salida. Eso ha sido arreglado.

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

Hay un poco de truco involucrado en esta respuesta, así que desglosaré lo que está sucediendo.

En primer lugar, a Perl no le gusta que se pasen parámetros de varias líneas. La variable $/es el separador de registro de entrada, y cada vez que una entrada encuentra el carácter almacenado en ella, el intérprete termina esa entrada y comienza una nueva entrada. El contenido predeterminado es el carácter de nueva línea \n, lo que significa que no es posible pasar una cadena de varias líneas. Para hacer eso, debemos separarnos $/de su contenido. Ahí es donde -0entra la bandera: la configuración -0se almacenará nullen la variable $/, permitiendo que el intérprete lea todo en la variable implícita de una $_vez.

El siguiente truco es la evaldeclaración. ¿Qué es exactamente lo que estamos evalhaciendo? Estamos evalobteniendo el resultado de la sprintfdeclaración, que se desglosa de la siguiente manera:

Lo primero que sprintfse pasa es que la cadena se "say while s/%s/./;"repite 4 veces, entonces:

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

Luego, sprintfse le pasan cuatro caracteres sin palabras p,o,g,r, que se interpolan en la sprintfdeclaración, reemplazando cada instancia de %s. Lo que luego obtenemos es la siguiente cadena, que se pasa a la evalfunción:

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

Cada whileciclo evalúa la expresión s/[color]/./, que reemplaza la primera instancia de cualquier color que sea en la variable implícita $_con un punto. Si se realiza una sustitución, regresa 1, de lo contrario no devuelve nada. Como s///tiene efectos secundarios, modifica la variable original $_, cuyo contenido se imprime a través de say. Se realizan cuatro versiones de este bucle, reemplazando los púrpuras, las naranjas, los verdes y luego los rojos, dejando solo los amarillos.

La razón por la que quedan los amarillos es porque yno puede ser una palabra simple, porque en realidad es una función, y tener una en ylugar de cualquiera de esas letras arrojaría un error. Podría cambiar esto poniendo comillas alrededor (+2 bytes), o usando una Y mayúscula y haciendo que la expresión regular no distinga entre mayúsculas y minúsculas (+1 byte), pero para el código de golf , cada byte cuenta, así que decidí que realmente me gusta bolos de limón más.

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}

Ejecutar con -n0(penalización de 2 bytes).

Aparentemente, me gusta comer Skittles en orden alfabético, porque el programa resulta más corto de esa manera. El programa realmente no necesita mucha explicación: -n0lee la entrada implícitamente ( -nsignifica "leer la entrada implícitamente", -0significa "no romper la entrada en las nuevas líneas"); for$x(g..r)ejecuta un bucle con el $xconjunto de cada letra desde ga rsu vez; say;imprime la entrada actual, después de cualquier mutación; s/$x/ /reemplaza una copia de $x(específicamente, la primera) con un espacio si es posible; y &&redorepite el código dentro de las llaves (sin avanzar el contador de bucle) si el reemplazo fue exitoso.

Este programa se puede generalizar fácilmente a más sabores de Skittle sin cambiar su longitud, y funcionará con un montón de cualquier tamaño.

Aquí hay un enlace de Ideone donde puedes probarlo. (Ideone no le permite especificar opciones de línea de comandos, por lo que tuve que agregar un par de líneas al inicio para establecer -n0y -M5.010obtener de forma gratuita).

C #, 134 148 bytes

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

Usé algunas cosas similares de la respuesta de @ Poke, actualmente un poco más, ya que necesito convertir la matriz de caracteres en una cadena; (

Java 7, 139135 130130138135 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 bolos en el orden: amarillo, naranja, verde, morado, rojo

Supongo que esto es mejor que 2 declaraciones de impresión>.>

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

sin golf + bonita

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

Aquí a[][11]significa tomar n-strings de longitud 11 donde se requiere 1 char para la terminación, por lo que, técnicamente, solo 10 caracteres visibles.

orden: alfabéticamente,
esta función busca 'g'en la entrada dada y la elimina 1/1, luego incrementa la retención de la variable 'g'hasta que encuentra una próxima coincidencia (probablemente letra 'o') y luego elimina esos caracteres coincidentes.
La desventaja es que esta función es demasiado cuidadosa, por lo tanto, si sus skittels eran de 26diferentes colores con el nombre en código de las letras az, esta función también manejará esa entrada ...

Octava, 49 bytes

Come bolos en orden alfabético, primero el código ascii más alto.

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

ES6 (Javascript), 7271 bytes

EDICIONES:

• Menos 1 byte, usando plantilla literal con de

Una versión no recursiva en Javascript.

Golfed

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

La entrada y salida son cadenas multilínea, come pastillas en el orden "púrpura => naranja => verde => amarillo".

Prueba

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

El programa come bolos en este orden - Orange Red Green Yellow Purple.

Editar - ¡Gracias a Flp.Tkc que ayudó a reducir 24 bytes!

Entrada - 
ygro goppr rppog rppog orgía

Salida - 
ygro goppr rppog rppog orgía
ygr goppr rppog rppog orgía
ygr g ppr rppog rppog orgía
ygr g ppr rpp g rppog orgía
ygr g ppr rpp g rpp g orgía
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  

Creo que se puede jugar más, ya que parece muy simple.

Vim 57 55 bytes

Ahorro de dos bytes eliminando mi delimitador de línea. Lamentablemente, es mucho más difícil de leer y verificar la corrección :(.

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

No imprimibles

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

TryItOnline

Come en el orden oypg, dejando todas las r para el final :)

Mathematica, 67 bytes

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

Come rojos, luego amarillos, luego naranjas, luego púrpuras.

Java 7, 125 bytes

Púrpura, amarillo, verde, rojo, naranja. Estoy disfrutando de poder elegir mi pedido en esta solución. :RE

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

Sin golf

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

Pruébalo aquí!

Un enfoque diferente a la otra respuesta Java de @Poke. Comenzamos haciendo una copia de la cadena original. Iterando a través de cada color, lo reemplazamos cada vez que se encuentra con un espacio, luego agregamos el nuevo diseño a la cadena de salida, regresando después de haber comido todo menos naranja.

Notas

La separación entre los pasos se realiza con una nueva línea doble \n\n, pero si la cuadrícula de entrada se puede tomar con una nueva línea al final, se puede acortar a solo \n.

Haskell, 60 bytes

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

La entrada es una sola cadena donde se separan las filas ,. El valor de retorno es una lista de cadenas con todos los pasos intermedios. El orden es alfabético, el más grande primero, por lo que queda verde. Ejemplo 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  ,     ,     

Recurrencia simple Guarde la lista de entrada para el valor de retorno, reemplace el elemento mayor más grande gcon un espacio y vuelva a llamar a la función. El caso base es cuando no queda ningún elemento para eliminar.

MATL, 24 bytes

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

Pruébalo en línea! Prefiero comer mis bolos en orden alfabético inverso: el verde es mi color favorito. Explicación:

                           % 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 reglas creativas!

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

Esta presentación supone que muchas cosas están bien:

• La entrada y la salida son mayúsculas ( GORPY)
• La entrada se toma como 109 pulsaciones de teclas sucesivas, que no se repiten en la pantalla hasta que se ingresa la última. Al final de cada fila, excepto la última, el usuario debe ingresar un retorno de carro.
• En lugar de imprimir el montón de Skittles varias veces, el programa lo muestra en la pantalla con una pausa de 1 segundo antes de cada paso. (QBasic no tiene desplazamiento hacia atrás de salida, por lo que imprimir la pila varias veces solo le daría los últimos 2 1/2 pasos. Además, este método es una descripción mucho mejor de cómo evoluciona su pila de Skittles a medida que los come).
• El programa termina con un error.

También tengo una versión de 130 bytes que usa minúsculas y no produce errores.

Aquí hay una muestra de ejecución en QB64 , con 109cambio a 29una cuadrícula de 5x5:

Explicación

DATA 71,89,82,79almacena los códigos ASCII de G, Y, R, y O.

?INPUT$(109) obtiene 109 pulsaciones de teclas del usuario y las imprime.

Entonces entramos en una DO ... LOOPconstrucción infinita . Cada vez que pasamos, usamos READel código ASCII del Skittle actual s. Luego recorremos las filas y columnas del 1 al 10. SCREEN(r,c)obtiene el código ASCII del personaje en la pantalla en la fila r, columna c. Si esto es igual a la corriente del bolo s, que SLEEPdurante un segundo y luego se imprime en un espacio r, c.

El bucle principal se ejecuta cuatro veces, eliminando los bolos verde, amarillo, rojo y naranja. En la quinta iteración, READerrores porque nos hemos quedado sin datos.