Кеглі - кольорові цукерки, де є 5 різних ароматів; винограду, зеленого яблука, лимона, апельсина та полуниці, представлених (p) urple, (g) reen, (y) ellow, (o) діапазону та (r) ed відповідно. Я їв кеглі, сортуючи всі різні кольори, потім їв їх послідовно. Отримавши кілька дивних поглядів в офісі, я зараз роблю вигляд, що їмо їх, як звичайну людину. Ваше завдання - наслідувати це:

Ваш код (повна програма чи функція) отримає масив кеглі (10х10) як вхідний (у будь-якому розумному форматі). Цей масив буде представляти купу несортованих кеглі. Ваше завдання - "з'їсти" їх від вашого найменш улюбленого до улюбленого кольору. Моє вподобане замовлення - виноград, зелене яблуко, лимон, апельсин, полуниця, але ви можете вибирати будь-яке замовлення до тих пір, поки воно послідовно виконується (будь-ласка, перелічіть свої переваги в поданні, щоб я міг судити вас за це). Після з'їдання кожного цукерки ваш код видасть (у тому самому форматі, який ви введете), що залишився ворс із з'їденим шматочком заміниться пробілом. Ви будете повторювати, поки не залишиться тільки ваш улюблений. Ви можете вибрати будь-яку кеглі, яку можна їсти (може бути випадковою чи детермінованою). Необхідно зберегти проміжки.

Наприклад, ваша вихідна послідовність може виглядати приблизно так (використовуючи 5x5 для стислості та показу пробілів як .)

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

Це код-гольф , тому найкоротший код у байтах виграє

TL; DR Правила:

• Подання може бути повною програмою або функцією
• Введення може бути здійснено у будь-якому розумному форматі (рядок, список, матриця тощо) будь-яким розумним методом (STDIN, аргументи функції тощо). Однак між рядками має бути деяке розмежування
• Вихід повинен бути зроблений у тому ж форматі, що і введення будь-яким розумним методом (STDOUT, повернення функції, тощо). Проміжний вихід може бути або не може бути обмежений
• Перший вихід має бути першим входом
• Задні місця повинні бути збережені
• Може використовуватися будь-яке кольорове замовлення (список у вашій відповіді)
• Будь-яка ковзанка поточного кольору може бути з'їдена
• Останній вихід має бути лише улюбленим кольором та пробілами
• Якщо можливо, включіть посилання на онлайн-компілятор, щоб перевірити ваше подання

Желе , 16 14  13 байт

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

СпробуйтеItOnline!

Більшість з найменш улюблених, як для всіх, хто серйозно ставиться до свого OCD, є алфавітом!

Вводить і виводить як текст (тобто рядки розмежовані новими рядками).

3 байти, збережені шляхом зміни зворотного напрямку та використанням іншого методу: оцінюйте, а не знаку символів з алфавіту.

Як?

Ṅ⁶ỤṪ$¦µ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 байт

Ароматизатори упорядковані так, як описано в виклику: виноград, зелене яблуко, лимон, апельсин, полуниця.

Проміжні виходи розділені новими рядками.

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

Тестовий випадок

У цьому тестовому випадку використовується приклад 5x5. Будь-який інший розмір сітки повинен працювати, як очікувалося.

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 байт

ОНОВЛЕННЯ:

• Збережено два байти, використовуючи необроблені параметри для printf;

Гольф

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

Здійснює введення при stdin, друкує до stdout. Їсть фіолетовий, зелений, жовтий, а потім помаранчевий.

Еквівалентною програмою sed буде:

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

Вибірка зразка (роздільники призначені лише для ясності)

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

Спробуйте в Інтернеті!

Python 2, 60 57 56 байт

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

repl.it

Рекурсивна функція, яка їсть у зворотному алфавітному порядку, залишаючи зелень останньою.

Введення s- це рядок з роздільником рядків, порядковий менший, ніж розмір рядка 'g'(наприклад, новий рядок або кома).

Функція друкує свій вхід, а потім повторюється, якщо цей вхід містить щось більше, ніж 'g', передаючи вхід з першим появою максимального символу, заміненого пробілом.

(Майже порт моєї відповіді на желе .)

Perl, 53 46 + 2 = 48 байт

Бігайте з -0n

-10 байт завдяки @Dada

Редагувати: Також завдяки @Dada за вказівку на це я забув надрукувати вхід як перший вихід. Це було виправлено.

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

У цій відповіді є трохи хитрощів, тож я розберу те, що відбувається.

Перш за все, Perl не любить передавання багаторядкових параметрів. Змінна $/є роздільником запису вхідних даних, і кожного разу, коли будь-який вхід стикається з символом, що зберігається в ньому, інтерпретатор припиняє цей вхід і починає новий вхід. Вміст за замовчуванням - це символ нового рядка \n, а це означає, що передача багаторядкового рядка неможлива. Для цього нам слід зняти $/його вміст. Ось тут і з'являється -0прапор: налаштування -0буде зберігатися nullу змінній $/, що дозволяє перекладачеві прочитати все в неявну змінну $_одразу.

Наступний трюк - це evalтвердження. Тільки що саме ми eval? Ми отримуємо evalрезультат sprintfтвердження, яке розбивається так:

Перше, що sprintfпередається - це рядок, "say while s/%s/./;"повторений 4 рази, так:

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

Потім sprintfпередаються чотири символи барево p,o,g,r, які інтерполюються у sprintfвисловлювання, замінюючи кожен екземпляр %s. Потім ми отримуємо наступний рядок, який передається evalфункції:

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

Кожен whileцикл оцінює вираз s/[color]/./, який замінює перший екземпляр будь-якого кольору він у неявній змінній $_періодом. Якщо буде зроблена підміна, вона повертається 1, інакше нічого не повертає. Оскільки s///має побічні ефекти, він змінює оригінальну змінну $_, вміст якої потім надрукується через say. Виконуються чотири версії цієї петлі, замінюючи фіолетові, апельсини, зелень, а потім червоні, залишаючи лише жовті.

Причина того, що жовті yлишаються, полягає в тому, що не може бути голословою, адже це насправді функція, а наявність yзамість будь-якої з цих літер призведе до помилки. Я міг би змінити це, поставивши навколо нього лапки (+2 байти), або використовуючи велику Y і зробивши невідчутливий регістр (+1 байт), але для коду-гольфу кожен байт рахується, тому я вирішив, що мені насправді подобається лимонні ковзани найбільше.

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

Perl, 30 31 33 + 2 = 32 33 35 байт

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

Виконати з -n0(2 байт штрафу).

Мабуть, я люблю їсти Skittles в алфавітному порядку, тому що програма виходить таким чином коротшим. Програмі насправді не потрібно багато пояснень: -n0читається вхідно неявно ( -nозначає "читати вхід неявно", -0означає "не порушувати введення на нові рядки"); for$x(g..r)запускає цикл з $xнабором від кожної літери від gпо rчерзі; say;друкує поточний вхід після будь-яких мутацій; s/$x/ /замінює одну копію $x(конкретно першої) пробілом, якщо це можливо; і &&redoповторює код всередині дужок (без просування лічильника циклу), якщо заміна була успішною.

Цю програму можна легко узагальнити до більшої кількості смаків Skittle, не змінюючи її довжини, і буде працювати з ворсом будь-якого розміру.

Ось посилання на Ideone, де ви можете його протестувати. (Ideone не дозволяє вказувати параметри командного рядка, тому мені довелося додати пару рядків на початку, щоб встановити -n0та те, -M5.010що ви отримаєте безкоштовно.)

C #, 134 148 байт

Замовлення: 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, на даний момент трохи довше, оскільки мені потрібно перетворити масив символів у рядок; (

Java 7, 139 135 130 151 138 135 байт

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

Їсть кеглі в порядку: жовтий, помаранчевий, зелений, фіолетовий, червоний

Я думаю, це краще, ніж 2 друковані заяви>.>

C 145 - 5 - 18 - 1 = 121 байт

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

unolfolf + досить

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

Тут a[][11]мається на увазі взяття n-рядків довжиною 11, де для завершення потрібен 1 знак, технічно лише 10 видимих ​​символів.

Порядок: в алфавітному порядку
ця функція перевіряється 'g'на даному вході та усуває її 1/1, потім збільшує утримування змінної, 'g'поки вона не знайде наступну відповідність (ймовірно, букву 'o'), а потім усуне ці відповідні символи.
Мінус полягає в тому, що ця функція є надто обережною. Отже, якщо ваші кеглі були 26різного кольору з кодовою назвою з букв az, ця функція також буде обробляти цей вхід ...

Октава, 49 байт

Їсть кеглі в алфавітному порядку, перш за все найвищий код.

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

ES6 (Javascript), 72, 71 байт

ЗМІНИ:

• Мінус 1 байт, за допомогою шаблону літерал з

Нерекурсивна версія в JavaScript.

Гольф

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

Введення та вихід - це рядкові рядки, їдять таблетки у порядку "фіолетовий => оранжевий => зелений => жовтий".

Тест

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 байт

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

Програма їсть кеглі в такому порядку - Orange Red Green Yellow Purple.

Редагувати - Дякую Flp.Tkc, який допоміг скоротити 24 байти!

Введення - 
ygro goppr rppog rppog оргія

Вихід - 
ygro goppr rppog rppog оргія
ygr goppr rppog rppog оргія
ygr g ppr rppog rppog оргія
ygr g ppr rpp g rppog оргія
ygr g ppr rpp g rpp g orgy
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
        п. п. п. у
        п. п. п  

Я вважаю, що це може бути додатково гольф, оскільки це виглядає дуже просто.

Vim 57 55 байт

Збереження двох байтів, видаливши розділовий рядок. На жаль, це набагато складніше читати та перевіряти правильність :(.

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

Недруковані матеріали:

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

TryItOnline

Їсть у порядку oypg, залишаючи всі r для кінця :)

Математика, 67 байт

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

Їсть червоні, потім жовті, потім апельсини, потім фіолетові.

Java 7, 125 байт

Фіолетовий, Жовтий, Зелений, Червоний, Помаранчевий. Мені подобається, що я можу вибрати своє замовлення в цьому рішенні. : D

Гольф

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

Безумовно

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

Спробуйте тут!

Інший підхід до іншої відповіді Java від @Poke. Почнемо з виготовлення копії оригінального рядка. Ітератуючи кожен колір, ми замінюємо його щоразу, коли він знайдений пробілом, а потім додаємо новий макет до вихідного рядка, повертаючись після того, як ми з'їли все, крім помаранчевого.

Примітки

Розмежування між кроками робиться подвійним новим рядком \n\n, але якщо вхідну сітку можна взяти з кінцевою новою лінією в кінці, її можна скоротити до просто \n.

Haskell, 60 байт

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

Введення - це один рядок, де рядки розділені ,. Повернене значення - це список рядків з усіма проміжними кроками. Порядок в алфавітному порядку, найбільший перший, тому зеленим залишається. Приклад використання:

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

Проста рекурсія. Збережіть список введення для повернення значення, замініть найбільший елемент gна пробіл та зателефонуйте знову. Базовий випадок - це коли для видалення не залишилося жодного елемента.

MATL, 24 байти

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

Спробуйте в Інтернеті! Я вважаю за краще їсти кеглі в зворотному алфавітному порядку: зелений - це мій улюблений колір. Пояснення:

                           % 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 байт

Творчі правила зловживають!

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

Це подання передбачає, що багато речей:

• Вхід і вихід великі літери ( GORPY)
• Введення приймається за 109 послідовних натискань клавіш, які не лунають на екрані до введення останнього. В кінці кожного рядка, окрім останнього, користувач повинен ввести повернення перевезення.
• Замість того, щоб надрукувати купу Skittles кілька разів, програма виводить її на екран із 1-секундною паузою перед кожним кроком. (У QBasic відсутня прокрутка виводу, тому друк ворсу кілька разів дасть вам лише останні 2 1/2 кроків. Також цей спосіб набагато краще зображує те, як розвивається ваша купу Skittles під час їх поїдання.)
• Програма закінчується помилкою.

У мене також є 130-байтна версія, яка використовує малі регістри і не помиляється.

Ось зразок запуску у QB64 із 109зміною на 29сітку 5x5:

Пояснення

DATA 71,89,82,79зберігає ASCII коди G, Y, Rі O.

?INPUT$(109) отримує від користувача 109 натискань клавіш і роздруковує їх.

Потім вводимо нескінченну DO ... LOOPконструкцію. Кожен раз, коли ми READперетворюємо ASCII код поточного Skittle в s. Потім ми переводимо рядки та стовпці від 1 до 10. SCREEN(r,c)отримує код ASCII символу на екрані в рядку r, стовпці c. Якщо це так само поточного кеглю s, ми в SLEEPпротягом однієї секунди , а потім надрукувати пробіл в r, c.

Основна петля працює чотири рази, видаляючи зелені, жовті, червоні та помаранчеві кеглі. На п'ятій ітерації READпомилки, оскільки ми не маємо даних.