Skittles 5 farklı lezzetlerin olduğu renkli şekerlerdir; (p) üple, (g) reen, (y) içi boş, (o) aralığı ve (r) ile temsil edilen üzüm, yeşil elma, limon, portakal ve çilek. Tüm farklı renkleri sıralayarak ve ardından sırayla yiyerek cipsler yerdim. Ofiste birkaç garip görünüme kavuştuktan sonra, şimdi onları normal bir insan gibi yemek gibi davranıyorum. Görevin bu taklit etmektir:

Kodunuz (tam program veya işlev) giriş olarak (makul herhangi bir formatta) bir dizi kızak (10x10) alır. Bu dizi, ayrılmamış skittles yığını temsil eder. Göreviniz en sevdiğiniz renkten en sevdiğiniz renge kadar onları "yemek" etmektir. Tercih ettiğim sipariş üzüm, yeşil elma, limon, portakal, çilek, ancak sürekli olarak uygulandığı sürece herhangi bir sipariş seçmekte özgürsünüz (lütfen gönderiminizde tercihinizi belirtin, böylece sizi yargılayabilirim). Her şeker parçasını yedikten sonra kodunuz (girdiğiniz formatta aynı şekilde) yenen parçanın yerine bir boşluk bırakarak kalan yığını çıkarır. Sadece favori kalıncaya kadar tekrar edeceksin. Yemek için herhangi bir skittle seçebilirsiniz (rastgele veya deterministik olabilir). Sondaki boşluklar muhafaza edilmelidir.

Örneğin, çıktı diziniz şöyle görünebilir (kısalık için 5x5 kullanarak ve boşlukları farklı olarak göstererek .)

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

Bu kod golf , bayt cinsinden en kısa kod kazanır

TL; DR Kuralları:

• Gönderim tam program veya işlev olabilir
• Giriş, makul bir yöntemle (STDIN, fonksiyon argümanları, vb.) Herhangi bir makul formatta (string, list, matrix, vs.) alınabilir. Ancak satırlar arasında bazı sınırlamalar olması gerekir.
• Çıktı, herhangi bir makul yöntemle (STDOUT, fonksiyon dönüşü, vb.) Girdiyle aynı formatta üretilmelidir. Ara çıkış sınırlandırılmış olabilir veya olmayabilir
• İlk çıktı ilk girdi olacak
• Sondaki boşluklar korunmalı
• Herhangi bir renk sırası kullanılabilir (cevabınızdaki liste)
• Mevcut rengin herhangi bir skittle yenebilir
• Son çıktı yalnızca en sevdiğiniz renk ve boşluklar olacaktır
• Mümkünse, gönderinizi test etmek için çevrimiçi bir derleyiciye bir bağlantı ekleyin

Jöle , 16 14  13 bayt

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

TryItOnline!

En çok sevilen, en çok sevdiği kişi için, OKB'leri konusunda ciddi olanlara göre, alfabetiktir!

Girdi ve çıktıları metin olarak alır (yani, satırlar yeni satırlarla sınırlandırılır).

Yönü tersine çevirerek ve farklı bir yöntem kullanarak 3 bayt kaydetti: alfabedeki karakterleri bulmak yerine notlandır.

Nasıl?

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

Tatlar, mücadelede tarif edildiği gibi sıralanır: üzüm, yeşil elma, limon, portakal, çilek.

Ara çıktılar yeni satırlarla ayrılır.

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

Test durumu

Bu test durumu 5x5 örneğini kullanıyor. Başka herhangi bir ızgara boyutu beklendiği gibi çalışmalıdır.

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 bayt

GÜNCELLEME:

• Printf için ham parametreleri kullanarak iki bayt kurtardı;

golfed

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

Stdin'de girdi alır, stdout'a yazdırır. Mor, yeşil, sarı ve turuncu renkte yer.

Eşdeğer bir sed programı olacaktır:

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

Örnek çıktı (sınırlayıcılar yalnızca netlik içindir)

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

Çevrimiçi deneyin!

Python 2, 60 57 56 bayt

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

repl.it

Yeşilleri en sonda bırakarak ters alfabetik sırayla yiyen özyinelemeli işlev.

Girdi s, sıradakinden daha küçük sıra sıralı bir dizedir 'g'(örneğin yeni bir satır veya virgül).

İşlev girişini yazdırır ve ardından o giriş bir 'g' den daha büyük bir şey içeriyorsa, girişi bir boşlukla değiştirilen maksimum karakterin ilk kez görünmesiyle tekrarlar.

(Neredeyse Jelly cevabımın bir limanı .)

Perl, 53 46 + 2 = 48 bayt

İle koş -0n

@Dada sayesinde -10 bayt

Düzenleme: Ayrıca işaret için @Dada sayesinde, giriş ilk çıktı olarak yazdırmayı unuttum. Bu düzeltildi.

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

Bu cevabın içinde bir parça kandırmaca var, bu yüzden olan biteni parçalayacağım.

Her şeyden önce, Perl çok satırlı parametrelerin iletilmesinden hoşlanmaz. Değişken $/, giriş kayıt ayırıcısıdır ve herhangi bir giriş içinde kayıtlı karakterle karşılaştığında, yorumlayıcı bu girişi sonlandırır ve yeni bir giriş başlatır. Varsayılan içerik, newline karakteridir \n, yani çok satırlı bir dizgiyi geçirmenin mümkün olmadığı anlamına gelir. Bunu yapmak $/için içeriğinden ayırmalıyız . -0Bayrağın girdiği yer burasıdır : ayar değişkende -0saklanır ve tercümanın her şeyi bir kerede örtük değişkene okumasını sağlar .null$/$_

Bir sonraki kandırmaca, evalifadedir. Tam olarak ne yapıyoruz eval? Aşağıdaki gibi evalayrılan sprintfifadenin sonucunu veriyoruz :

Geçen ilk şey 4 kez tekrarlanan sprintfdizedir "say while s/%s/./;", yani:

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

Ardından, her bir ifadenin yerine sprintfdört ifadeyle p,o,g,renterpolasyonlu dört korkak karakter geçirilir . Daha sonra elde ettiğimiz şey, işleve iletilen şu dizedir :sprintf%seval

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

Her whiledöngü s/[color]/./, örtük değişkende hangi rengin ilk örneğini $_bir noktayla değiştiren ifadeyi değerlendirir . Eğer bir değiştirme yapılırsa geri döner 1, aksi halde hiçbir şey döndürmez. Yana s///yan etkileri vardır, bu orijinal değişken değiştirir $_içerikleri daha sonra bu basılır say. Bu döngünün dört versiyonu, sadece sarıları bırakarak morları, portakalları, yeşilleri ve kırmızıları değiştirerek gerçekleştirilir.

ySarıların bırakılmasının nedeni , bir korkak olamaz çünkü bu aslında bir işlevdir ve ybu harflerden herhangi birinin yerine bir hata yapmaktır . Bunu, etrafına tırnak işareti koyarak (+2 bayt) veya büyük bir Y kullanarak ve regex'i büyük / küçük harf duyarlı (+1 bayt) yaparak değiştirebilirim, ancak kod golf için her bayt sayılır, bu yüzden gerçekten beğenmeye karar verdim en çok limon cipsleri.

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

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

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

-n0(2 byte ceza) ile çalıştırın .

Görünüşe göre, Skittles'i alfabetik sırayla yemeyi seviyorum çünkü program bu şekilde kısalıyor. Program gerçekten çok fazla açıklamaya ihtiyaç duymuyor: -n0girişi dolaylı olarak okur ( -n"girişi tam olarak okuyun", -0"satırları yeni satırlarda kesme" anlamına gelir);for$x(g..r)ile bir döngü çalışır $xher mektuptan sette giçin rsırayla; say;mutasyonlardan sonra geçerli girişi yazdırır; mümkünse s/$x/ /bir kopyasını $x(özellikle ilkini) bir boşlukla değiştirir; ve &&redodeğiştirme başarılı olursa, parantez içindeki kodu tekrarlayın (döngü sayacını ilerletmeden).

Bu program, uzunluklarını değiştirmeden daha fazla Skittle lezzetine kolayca genelleştirilebilir ve her boyutta bir yığınla çalışır.

İşte test edebileceğiniz bir Ideone bağlantısı. (Ideone, komut satırı seçeneklerini belirlemenize izin vermiyor, bu yüzden başlangıçta -n0ve sonra -M5.010ücretsiz olarak alabileceğiniz bir kaç satır eklemek zorunda kaldım .)

C #, 134 148 bayt

Sipariş: 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;};

@ Poke'nin cevabında benzer şeyler kullandım, şu anda biraz daha uzun olsa da karakter dizisini bir dizgeye dönüştürmem gerekiyor;

Java 7, 139 135 130 151 138 135 bayt

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

Siparişte yemiş: Sarı, Turuncu, Yeşil, Mor, Kırmızı

Bu 2 baskı ifadesinden daha iyi olduğunu düşünüyorum.

C 145 - 5 - 18 - 1 = 121 bayt

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

asılsız + güzel

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

İşte a[][11] , uzunluğu 11 n-sicimlerini alarak, fesih için 1 karakter gerekli, yani teknik olarak sadece 10 karakter görülebilir.

order: alfabetik olarak
bu işlev 'g'verilen girişte denetler ve 1/1 i ortadan kaldırır, ardından 'g'bir sonraki eşleşmeyi (muhtemelen harf 'o') bulana kadar tutma değişkenini arttırır ve sonra eşleşen karakterleri ortadan kaldırır.
Dezavantajı bu fonksiyonun sadece çok dikkatli olmasıdır. Yani, eğer skeçteleriniz 26az harfinden kod adında farklı renklere sahipse , bu fonksiyon da bu girişi üstlenir ...

Oktav, 49 bayt

Skittle'ları alfabetik sırayla, ilk önce en yüksek koddan geçirir.

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

ES6 (Javascript), 72, 71 bayt

DÜZENLEMELER:

• Eksi ile şablon literal kullanılarak 1 bayt, bir

Javascript bir özyinelemeli versiyonu.

golfed

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

Girdi ve çıktı çok satırlı dizelerdir, hapları "mor => turuncu => yeşil => sarı" sırayla yer.

Ölçek

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 bayt

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

Program bu sırada kızak yer Orange Red Green Yellow Purple. - .

Düzenleme - 24 byte azaltmaya yardımcı olan Flp.Tkc'ye teşekkürler !

Giriş - 
ygro goppr rppog rppog alem

Çıktı - 
ygro goppr rppog rppog alem
ygr goppr rppog rppog alem
ygr g ppr rppog rppog alem
ygr g ppr rpp g rppog alem
ygr g ppr rpp g rpp g alem
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 p g g gy
y pp pp p g g gy
y pp pp pp gy
y pp pp pp y
        pp pp pp y
        pp pp pp  

Çok basit göründüğü için daha fazla golf oynayabileceğine inanıyorum.

Vim 57 55 bayt

Satır sınırlayıcımı kaldırarak iki bayttan tasarruf ediyorum. Ne yazık ki, okumayı ve doğruluğunu kontrol etmeyi çok zorlaştırıyor :(.

: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

Oypg siparişte yer alır, tüm r'ler sonunda bırakılır :)

Mathematica, 67 bayt

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

Kırmızıları yer, sonra sararır, sonra portakal, sonra morlar.

Java 7, 125 bayt

Mor, Sarı, Yeşil, Kırmızı, Turuncu. Bu çözümde siparişimi almamdan zevk alıyorum. : 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;
}

Burada dene!

Diğer Java cevabı @Poke tarafından farklı bir yaklaşım. Orijinal dizgenin bir kopyasını alarak başlarız. Her bir rengi tekrar ederek, bir boşluk bulduğu her seferinde değiştiririz, daha sonra turuncudan başka her şeyi yedikten sonra dönen yeni diziyi çıktı dizisine ekleriz.

notlar

Basamaklar arasındaki ayrım çift satırlı yeni bir satırla yapılır \n\n, ancak giriş ızgarası sonunda satır sonunda yeni bir satırla alınabiliyorsa, kısa devre olabilir \n.

Haskell, 60 bayt

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

Giriş, satırların ayrıldığı tek bir dizedir ,. Dönüş değeri, tüm ara adımları içeren bir dizi listesidir. Düzen alfabetik olarak, en büyük ilk, yani yeşil kalır. Kullanım örneği:

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

Basit özyineleme. Giriş listesini geri dönüş değeri için kaydedin, daha büyük olanı gboşlukla değiştirin ve işlevi tekrar çağırın. Temel durum, kaldırılacak öğe kalmamasıdır.

MATL, 24 bayt

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

Çevrimiçi deneyin! Skittles'i ters alfabetik sırayla yemeyi tercih ederim: yeşil en sevdiğim renk. Açıklama:

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

Yaratıcı kurallar kötüye!

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

Bu gönderim birçok şeyin yolunda olduğunu varsayar:

• Giriş ve çıkış büyük harf ( GORPY)
• Girdi, sonuncu girilene kadar ekrana yankılanmayan, art arda 109 tuşlarına basılır. Sonuncusu hariç her satırın sonunda, kullanıcının bir satır başı girmesi gerekir.
• Skittles yığınını birkaç kez basmak yerine, program her adımdan önce 1 saniyelik bir duraklama ile ekranda görüntüler. (QBasic çıktı geri kaydırma işlemine sahip değildir, bu nedenle kümeyi birden çok kez yazdırmak yalnızca son 2 1/2 adımı verir. Ayrıca, bu yöntem Skittles yığınınızın onları yerken nasıl geliştiğinin daha iyi bir tasviridir.)
• Program bir hatayla bitiyor.

Ayrıca küçük harf kullanan ve hata yapmayan 130 baytlık bir sürüme de sahibim.

Burada çalışacak bir örnek var qb64 ile 109değiştirildi 295x5 bir tablo için:

açıklama

DATA 71,89,82,79ASCII kodları saklayan G, Y, R, ve O.

?INPUT$(109) kullanıcıdan 109 tuşa basar ve yazdırır.

Daha sonra sonsuz bir DO ... LOOPyapıya giriyoruz . Her seferinde READ, geçerli Skittle'un ASCII kodunu giriyoruz s. Sonra 1'den 10'a kadar olan satır ve sütunların üzerinden geçiyoruz SCREEN(r,c). Ekrandaki karakterin ASCII kodunu satır satır rsütununda alıyoruz c. Bu akım skittle eşitse s, biz SLEEPbir saniye sonra bir boşluk baskı r,c .

Ana döngü dört kez çalışır, yeşil, sarı, kırmızı ve turuncu Skittles'leri siler. Beşinci yinelemede READhatalar çünkü verilerimiz kalmadı.