Kegel sind farbige Bonbons mit 5 verschiedenen Geschmacksrichtungen. Trauben, grüner Apfel, Zitrone, Orange und Erdbeere, dargestellt durch (p) urple, (g) reen, (y) ellow, (o) range bzw. (r) ed. Ich aß Kegel, indem ich die verschiedenen Farben sortierte und sie dann der Reihe nach aß. Nachdem ich im Büro ein paar seltsame Blicke auf mich gezogen habe, tue ich jetzt so, als würde ich sie wie einen normalen Menschen essen. Ihre Aufgabe ist es, dies zu emulieren:

Ihr Code (volles Programm oder Funktion) erhält eine Reihe von Kegeln (10x10) als Eingabe (in jedem vernünftigen Format). Dieses Array wird einen Stapel von unsortierten Kegeln darstellen. Ihre Aufgabe ist es, sie von Ihrer Lieblingsfarbe zu Ihrer Lieblingsfarbe zu "essen". Meine bevorzugte Bestellung ist Traube, grüner Apfel, Zitrone, Orange, Erdbeere, aber Sie können jede Bestellung frei wählen, solange sie konsequent durchgesetzt wird (bitte geben Sie Ihre Präferenz in Ihrer Bestellung an, damit ich Sie danach beurteilen kann). Nachdem Sie jedes Bonbonstück gegessen haben, gibt Ihr Code (im selben Format, in dem Sie es eingegeben haben) den verbleibenden Stapel aus, wobei das gegessene Stück durch ein Leerzeichen ersetzt wird. Sie werden wiederholen, bis nur noch Ihr Favorit übrig ist. Sie können jeden Kegel zum Essen wählen (kann zufällig oder deterministisch sein). Nachgestellte Leerzeichen müssen eingehalten werden.

Ihre Ausgabesequenz könnte beispielsweise so aussehen (verwenden Sie 5x5 für die Kürze und zeigen Sie Leerzeichen als .)

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

Das ist Code-Golf , also gewinnt der kürzeste Code in Bytes

TL; DR-Regeln:

• Die Einreichung kann ein vollständiges Programm oder eine Funktion sein
• Die Eingabe kann in jedem vernünftigen Format (Zeichenfolge, Liste, Matrix usw.) mit jeder vernünftigen Methode (STDIN, Funktionsargumente usw.) erfolgen. Es muss jedoch eine gewisse Abgrenzung zwischen den Zeilen geben
• Die Ausgabe muss in demselben Format erfolgen wie die Eingabe mit einer angemessenen Methode (STDOUT, Funktionsrückgabe usw.). Die Zwischenausgabe kann begrenzt sein oder nicht
• Erster Ausgang soll der erste Eingang sein
• Nachgestellte Leerzeichen müssen erhalten bleiben
• Jede Farbreihenfolge kann verwendet werden (Liste in Ihrer Antwort)
• Jeder Kegel der aktuellen Farbe kann gegessen werden
• Die letzte Ausgabe soll nur Ihre Lieblingsfarbe und -räume sein
• Fügen Sie nach Möglichkeit einen Link zu einem Online-Compiler hinzu, um Ihre Einreichung zu testen

Jelly , 16 14  13 Bytes

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

TryItOnline!

Die meisten bis wenigsten Favoriten, wie für jeden, der es mit seiner Zwangsstörung ernst meint, sind alphabetisch!

Übernimmt Ein- und Ausgaben als Text (dh die Zeilen werden durch neue Zeilen getrennt).

3 Bytes gespart durch Richtungsumkehr und Verwendung einer anderen Methode: Steigern statt Zeichen aus dem Alphabet zu finden.

Wie?

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

Die Aromen werden wie in der Herausforderung beschrieben bestellt: Traube, grüner Apfel, Zitrone, Orange, Erdbeere.

Zwischenausgaben werden durch Zeilenumbrüche getrennt.

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

Testfall

In diesem Testfall wird das 5x5-Beispiel verwendet. Alle anderen Rastergrößen sollten wie erwartet funktionieren.

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, 4846 Bytes

AKTUALISIEREN:

• Zwei Bytes mit Raw-Parametern für printf gespeichert;

Golf gespielt

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

Übernimmt die Eingabe bei Standard, druckt auf Standardausgabe. Isst lila, grün, gelb und dann orange.

Ein äquivalentes Sed- Programm wäre:

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

Beispielausgabe (Begrenzer dienen nur der Übersichtlichkeit)

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

Probieren Sie es 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

Rekursive Funktion, die in umgekehrter alphabetischer Reihenfolge isst und die Grüns zum Schluss stehen lässt.

Die Eingabe sist eine Zeichenfolge mit einem 'g'Zeilentrennzeichen, dessen Ordnungszahl kleiner als die von a ist (z. B. eine neue Zeile oder ein Komma).

Die Funktion gibt ihre Eingabe aus und wiederholt sie, wenn diese Eingabe etwas enthält, das größer als ein 'g' ist. Dabei wird die Eingabe mit dem ersten Vorkommen des durch ein Leerzeichen ersetzten Maximalzeichens übergeben.

(Fast ein Port meiner Gelee-Antwort .)

Perl, 53 46 + 2 = 48 Bytes

Laufen Sie mit -0n

-10 Bytes dank @Dada

Bearbeiten: Auch dank @Dada für den Hinweis habe ich vergessen, die Eingabe als erste Ausgabe zu drucken. Das wurde behoben.

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

Mit dieser Antwort ist ein bisschen Trick verbunden, also werde ich aufschlüsseln, was los ist.

Erstens mag Perl nicht, dass mehrzeilige Parameter übergeben werden. Die Variable $/ist das Trennzeichen für Eingabedatensätze. Wenn eine Eingabe auf das darin gespeicherte Zeichen stößt, beendet der Interpreter diese Eingabe und beginnt mit einer neuen Eingabe. Der Standardinhalt ist das Newline-Zeichen \n. Das bedeutet, dass die Übergabe einer mehrzeiligen Zeichenfolge nicht möglich ist. Dazu müssen wir uns $/von deren Inhalten distanzieren . Hier kommt das -0Flag ins Spiel: Die Einstellung -0wird nullin der Variablen gespeichert $/, sodass der Interpreter alles $_auf einmal in die implizite Variable einlesen kann .

Der nächste Trick ist die evalAussage. Was genau machen wir eval? Wir führen evaldas Ergebnis der sprintfAnweisung an, die sich wie folgt zusammensetzt:

Das erste, was übergeben sprintfwird, ist die Zeichenfolge, die "say while s/%s/./;"viermal wiederholt wird.

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

Anschließend werden sprintfvier Bareword-Zeichen übergeben, p,o,g,rdie in die sprintfAnweisung interpoliert werden und jede Instanz von ersetzen %s. Was wir dann bekommen, ist der folgende String, der an die evalFunktion übergeben wird:

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

Jede whileSchleife wertet den Ausdruck aus s/[color]/./, der die erste Instanz einer beliebigen Farbe in der impliziten Variablen $_durch einen Punkt ersetzt. Wenn eine Ersetzung vorgenommen wird, wird sie zurückgegeben 1, andernfalls wird nichts zurückgegeben. Da s///es Nebenwirkungen hat, ändert es die ursprüngliche Variable $_, deren Inhalt dann über gedruckt wird say. Es werden vier Versionen dieser Schleife ausgeführt, wobei die Purpur-, Orangen-, Grün- und dann die Rottöne ersetzt werden und nur die Gelben übrig bleiben.

Der Grund, warum die Gelben übrig bleiben, ist, dass es ysich nicht um ein Barewort handeln kann, da es sich tatsächlich um eine Funktion handelt. Wenn Sie yanstelle eines dieser Buchstaben einen Buchstaben verwenden, wird ein Fehler ausgegeben . Ich könnte dies ändern, indem ich Anführungszeichen setze (+2 Bytes) oder ein Y in Großbuchstaben schreibunabhängig mache (+1 Byte), aber für Code-Golf zählt jedes Byte, also habe ich entschieden, dass ich es wirklich mag Zitronenkegel am meisten.

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}

Laufen Sie mit -n0(2-Byte-Strafe).

Anscheinend esse ich gerne Kegel in alphabetischer Reihenfolge, weil das Programm dadurch kürzer wird. Das Programm braucht nicht wirklich viel Erklärung: -n0liest die Eingabe implizit ( -nbedeutet "Eingabe implizit lesen", -0bedeutet "Eingabe in Zeilenumbrüchen nicht unterbrechen"); for$x(g..r)führt $xnacheinander eine Schleife mit set aus jedem Buchstaben von gbis raus; say;druckt die aktuelle Eingabe nach Mutationen aus; s/$x/ /ersetzt eine Kopie $x(insbesondere die erste) durch ein Leerzeichen, wenn dies möglich ist; und &&redowiederholt den Code in geschweiften Klammern (ohne den Schleifenzähler vorzustellen), wenn der Austausch erfolgreich war.

Dieses Programm kann ohne Änderung der Länge problemlos auf weitere Geschmacksrichtungen von Skittle verallgemeinert werden und funktioniert mit einem Stapel beliebiger Größe.

Hier ist ein Ideone-Link, über den Sie es testen können. (Ideone nicht zulässt , dass Sie Befehlszeilenoptionen angeben, so dass ich am Anfang zu Satz ein paar Zeilen hinzuzufügen hatte -n0und das , -M5.010dass Sie kostenlos.)

C #, 134 148 Bytes

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

Ich habe einige ähnliche Dinge aus der Antwort von @ Poke verwendet, die derzeit allerdings etwas länger sind, da ich das Zeichen-Array in einen String umwandeln muss.

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

Isst Kegel in der Reihenfolge: Gelb, Orange, Grün, Lila, Rot

Ich denke, das ist besser als 2 print-Anweisungen>.>

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 + hübsch

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

Hier a[][11]bedeutet das Verwenden von n-Strings der Länge 11, bei denen 1 Zeichen für die Terminierung erforderlich ist, also technisch gesehen nur 10 sichtbare Zeichen.

order: alphabetical
Diese Funktion überprüft 'g'die angegebene Eingabe und eliminiert sie um 1/1. Dann erhöht sie die Variable, 'g'bis sie eine nächste Übereinstimmung (wahrscheinlich einen Buchstaben 'o') findet, und eliminiert dann diese übereinstimmenden Zeichen.
Der Nachteil ist, dass diese Funktion einfach zu vorsichtig ist. Wenn Ihre Kegel 26verschiedene Farben haben, die mit dem Codenamen az bezeichnet sind, übernimmt diese Funktion auch diese Eingabe ...

Oktave, 49 Bytes

Isst Kegel in alphabetischer Reihenfolge, höchster ASCII-Code zuerst.

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

ES6 (Javascript), 7271 Bytes

EDITS:

• Minus 1 Byte, wenn Template-Literal mit of verwendet wird

Eine nicht rekursive Version in Javascript.

Golf gespielt

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

Eingabe und Ausgabe sind mehrzeilige Zeichenfolgen, die Pillen in der Reihenfolge "lila => orange => grün => gelb" essen.

Prüfung

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

Programm isst Kegel in dieser Reihenfolge - Orange Red Green Yellow Purple.

Bearbeiten - Vielen Dank an Flp.Tkc, der dazu beigetragen hat, 24 Bytes zu reduzieren!

Eingabe - 
ygro goppr rppog rppog Orgie

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

Ich glaube, es kann weiter Golf gespielt werden, da es sehr einfach aussieht.

Vim 57 55 Bytes

Speichern von zwei Bytes durch Entfernen des Zeilenbegrenzers. Leider ist es sehr viel schwieriger zu lesen und auf Richtigkeit zu prüfen :(.

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

Unbedruckbares:

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

TryItOnline

Isst in der Reihenfolge oypg und lässt alle rs für das Ende :)

Mathematica, 67 Bytes

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

Isst Rot, dann Gelb, dann Orangen, dann Purpur.

Java 7, 125 Bytes

Lila, Gelb, Grün, Rot, Orange. Es freut mich, dass ich meine Bestellung in dieser Lösung abholen kann. : D

Golf gespielt

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

Probieren Sie es hier aus!

Ein anderer Ansatz zur anderen Java-Antwort von @Poke. Wir beginnen damit, eine Kopie der ursprünglichen Zeichenfolge zu erstellen. Wir durchlaufen jede Farbe und ersetzen sie jedes Mal, wenn sie durch ein Leerzeichen gefunden wird. Anschließend hängen wir das neue Layout an die Ausgabezeichenfolge an und kehren zurück, nachdem wir alles außer Orange gegessen haben.

Anmerkungen

Die Trennung zwischen den Schritten erfolgt mit einem doppelten Zeilenumbruch \n\n. Wenn das Eingaberaster jedoch am Ende mit einem abschließenden Zeilenumbruch versehen werden kann, kann der Kurzschluss auf "Nur" erfolgen \n.

Haskell, 60 Bytes

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

Die Eingabe ist eine einzelne Zeichenfolge, bei der die Zeilen durch voneinander getrennt sind ,. Rückgabewert ist eine Liste von Strings mit allen Zwischenschritten. Die Reihenfolge ist alphabetisch, die größte zuerst, also bleibt grün. Anwendungsbeispiel:

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

Einfache Rekursion. Speichern Sie die Eingabeliste für den Rückgabewert, ersetzen Sie das größte Element gdurch ein Leerzeichen und rufen Sie die Funktion erneut auf. Basisfall ist, wenn kein zu entfernendes Element mehr vorhanden ist.

MATL, 24 Bytes

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

Probieren Sie es online! Ich esse meine Kegel lieber in umgekehrter alphabetischer Reihenfolge: Grün ist meine Lieblingsfarbe. Erläuterung:

                           % 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

Missbrauch kreativer Regeln!

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

Diese Einreichung setzt voraus, dass viele Dinge in Ordnung sind:

• Eingabe und Ausgabe sind in Großbuchstaben ( GORPY)
• Die Eingabe erfolgt durch 109 aufeinanderfolgende Tastendrücke, die erst bei der letzten Eingabe auf dem Bildschirm wiedergegeben werden. Am Ende jeder Zeile mit Ausnahme der letzten muss der Benutzer einen Wagenrücklauf eingeben.
• Anstatt den Kegelstapel mehrmals zu drucken, zeigt das Programm ihn vor jedem Schritt mit einer Pause von 1 Sekunde auf dem Bildschirm an. (QBasic hat kein Scrollback für die Ausgabe. Wenn Sie den Stapel also mehrmals drucken, erhalten Sie nur die letzten 2 1/2 Schritte. Außerdem ist diese Methode eine viel bessere Darstellung der Entwicklung Ihres Kegelstapels, während Sie ihn essen.)
• Das Programm endet mit einem Fehler.

Ich habe auch eine 130-Byte-Version, die Kleinbuchstaben verwendet und keinen Fehler macht.

Hier ist ein Beispiellauf in QB64 , 109der 29für ein 5x5-Raster geändert wurde :

Erläuterung

DATA 71,89,82,79speichert den ASCII - Codes von G, Y, R, und O.

?INPUT$(109) Erhält 109 Tastendrücke vom Benutzer und druckt sie aus.

Wir geben dann ein unendliches DO ... LOOPKonstrukt ein. Bei jedem Durchlauf geben wir READden ASCII-Code des aktuellen Kegels ein s. Dann durchlaufen wir Zeilen und Spalten von 1 bis 10. SCREEN(r,c)Ermittelt den ASCII-Code des Zeichens auf dem Bildschirm in Zeile r, Spalte c. Wenn dies auf die aktuelle Kittle gleich s, wir SLEEPfür eine Sekunde und dann einen Raum Druck bei r, c.

Die Hauptschleife wird viermal ausgeführt und entfernt die grünen, gelben, roten und orangefarbenen Kegel. Bei der fünften Iteration treten READFehler auf, weil wir keine Daten mehr haben.