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

Ваш код (полная программа или функция) получит массив кеглей (10x10) в качестве входных данных (в любом приемлемом формате). Этот массив будет представлять кучу несортированных кеглей. Ваша задача - «съесть» их от вашего наименее любимого до любимого цвета. Мой предпочтительный заказ - виноград, зеленое яблоко, лимон, апельсин, клубника, но вы можете выбрать любой заказ, если он постоянно исполняется (пожалуйста, укажите ваши предпочтения в заявке, чтобы я мог судить вас за это). После того, как вы съели каждый кусочек конфеты, ваш код выведет (в том же формате, в котором вы вводите) оставшуюся кучу с заменой съеденного кусочка пробелом. Вы будете повторять, пока не останется только ваш любимый. Вы можете выбрать любой кегель (может быть случайным или детерминированным). Конечные пробелы должны быть сохранены.

Например, ваша выходная последовательность может выглядеть следующим образом (для краткости используется 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, функция return и т. Д.). Промежуточный вывод может быть или не быть разделен
• Первый выход должен быть первым входом
• Конечные пробелы должны быть сохранены
• Можно использовать любой порядок цветов (укажите в своем ответе)
• Любая кегля текущего цвета может быть съедена
• Последний вывод должен быть только ваш любимый цвет и пробелы
• Если возможно, включите ссылку на онлайн-компилятор, чтобы проверить вашу заявку

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

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

TryItOnline!

Наиболее или менее любимым, как и любой, кто серьезно относится к их ОКР, является алфавитный!

Принимает ввод и вывод в виде текста (т.е. строки разделяются новыми строками).

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, 4846 байтов

ОБНОВИТЬ:

• Сохранены два байта с использованием необработанных параметров для printf;

Golfed

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флаг: setting -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 байта).

Видимо, я люблю есть кегли в алфавитном порядке, потому что программа получается короче. Программа на самом деле не нуждается в большом объяснении: -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("");}}  

негольфированный + симпатичный

#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 видимых символов.

order: алфавитный:
эта функция проверяет данные 'g'в заданном входе и удаляет их 1/1, затем увеличивает переменную, удерживая ее, 'g'пока не найдет следующее совпадение (возможно, букву 'o'), а затем удалит эти совпадающие символы.
Недостатком является то, что эта функция слишком осторожна. Так что, если ваши skittels имели 26разные цвета с кодовым именем из букв az, эта функция также будет обрабатывать этот ввод ...

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

Ест кегли в алфавитном порядке, сначала самый высокий код ascii.

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

ES6 (Javascript), 7271 байт

правок:

• Минус 1 байт, используя шаблонный литерал с из

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

Golfed

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

Вход - 
igro goppr rppog rppog оргия

Выход - 
igro goppr rppog rppog оргия
ygr goppr rppog rppog оргия
ygr g ppr rppog rppog orgy
ygr g ppr rpp g rppog оргия
ygr g ppr rpp g rpp g оргия
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, оставляя все на конец :)

Mathematica, 67 байт

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

Питается красными, затем желтыми, затем апельсинами, затем пурпурными.

Java 7, 125 байт

Фиолетовый, Желтый, Зеленый, Красный, Оранжевый. Мне нравится, что я могу выбрать свой заказ в этом решении. : 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;
}

Попробуй это здесь!

Другой подход к другому ответу 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 последовательных нажатий клавиш, которые не отображаются на экране до тех пор, пока не будет введен последний. В конце каждой строки, кроме последней, пользователь должен ввести возврат каретки.
• Вместо того, чтобы печатать стопку кегли несколько раз, программа отображает ее на экране с паузой в 1 секунду перед каждым шагом. (QBasic не имеет выходного прокрутки, поэтому многократная печать стопки даст вам только последние 2 1/2 шага. Кроме того, этот метод гораздо лучше показывает, как ваша кучка кеглей эволюционирует по мере того, как вы их едите.)
• Программа заканчивается с ошибкой.

У меня также есть 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ошибки, потому что у нас нет данных.