像普通人一样吃吃喝玩乐

47

吃喝玩乐是有5种不同口味的有色糖果。葡萄，青苹果，柠檬，橙和草莓，分别以（p）紫色，（g）reen，（y）黄色，（o）范围和（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，函数返回等）以与输入相同的格式产生输出。中间输出可能有界也可能没有界
  • 第一个输出应为第一个输入
  • 尾随空格必须保留
  • 可以使用任何颜色顺序（答案中列出）
  • 当前颜色的吃喝玩乐
  • 最后的输出应该只是您喜欢的颜色和空格
  • 如果可能，请包含指向在线编译器的链接以测试您的提交
code-golf 
— 温诺
source
4
@MukulKumar，是的，您希望他们在前进的过程中变得更好
— wnnmaw
2
我们可以接受吃喝玩乐作为一个100条吃喝玩乐的字符串，没有换行符或其他东西吗？
— 加布里埃尔·贝纳米
1
中间输出是否需要用任何东西隔开？
— 戳
5
— Digital Trauma
8
我考虑过要参加这项挑战，然后阅读“ 请在您的来文中列出您的偏好，以便我对此做出判断 ”。我认为人们已经对我的喜好做出了判断！
— Toby Speight

Answers:

16

果冻，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)
— 乔纳森·艾伦
source
8

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示例。任何其他网格大小应按预期工作。

显示代码段

— Arnauld
source
8

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

在线尝试！

— 齐柏林飞艇
source
7

Python 2，60 57 56字节

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

代表

递归函数以相反的字母顺序进餐，使果岭处在最后。

输入s是具有行定界符的字符串，该定界符的序号小于'g'（例如，新行或逗号）。

该函数将打印其输入，然后在该输入包含大于'g'的任何内容时进行递归操作，并在输入时将最大字符的第一个出现的位置替换为空格。

（几乎是我的果冻答案的端口。）

— 乔纳森·艾伦
source
6

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字母a 代替任何字母都将引发错误。我可以通过在其周围加上引号（+2个字节）或使用大写字母Y并使正则表达式不区分大小写（+1个字节）来更改它，但是对于code-golf来说，每个字节都很重要，所以我决定我实际上喜欢柠檬吃喝玩乐最多。

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

— 加布里埃尔·贝纳米（Gabriel Benamy）
source
-0标志应为您节省大约10个字节
— 达达
另外，恐怕您错过了比赛规则First output shall be the first input
— Dada
1
对您有好处，因为您牺牲了自己的个人喜好来保存两个字节
— wnnmaw
4

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)运行一个带有$xset 的循环；进行任何突变后，输出当前输入；如果可能，将一个副本（特别是第一个副本）替换为一个空格；和重复括号内的代码（没有前进循环计数器）如果替换成功。grsay;s/$x/ /$x&&redo

该程序可以很容易地推广到Skittle的更多口味，而无需更改其长度，并且可以与任何大小的桩一起使用。

这是一个Ideone链接，您可以在其中进行测试。（Ideone不允许您指定命令行选项，因此我必须在开始设置时添加几行内容，-n0并且-M5.010必须免费获得。）

1
我不确定您是否可以多次打印同一堆吃喝玩乐的东西。（实际上，我认为您不能这样做）也许切换到say;for$x(g..r){say while s/$x/ /}吗？
— 达达
对啊 我本来for$x(p,o,g,r)没有。say while仅增加了一个字节，这是我认为的替代选择，因此我可以简单地更改为该字节。
而且您需要从a开始，say;因为规则说First output shall be the first input
— Dada
哦，在这种情况下，我将返回到for$x(g,o,p,r)首先复制输入的版本。（如果缺少颜色，则需要花费一些额外的时间进行搜索，但是您不会期望在彩虹糖中缺少颜色。）记录下来，say;第一个有37个字节。
但是，Dada的原始注释仍然存在-所显示的代码有时会连续两次打印相同的配置（例如，在绿色的结尾处一次，在橙色的开头处第二次）。
— DLosc
4

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的答案中的一些类似内容，尽管由于我需要将字符数组转换为字符串，但当前的时间更长一些；

— 约德尔
source
哈！击败您3个字符！！！
— Mukul Kumar
4

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条打印语句要好>。>

— 戳
source
1
当然可以，您的函数就在那里被称为skit：P -3！
— 2016年
1
@Yodle oops！哈哈哈
— 戳
1
如果我们总是收到一个10×10格，我可以硬编码的长度，而腋臭使用s.length
— 打个招呼
1
我们是否不需要在吃任何东西之前就开始打印一次：
— Yodle
1
@Yodle这就是为什么我要吃“！” 首先吃喝玩乐；）...等等，我想我打破了这个trick俩
— 戳
4

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]表示取长度为11的n字符串，其中终止需要1个字符，因此从技术上讲，仅10个可见字符。

order：按字母顺序排列，
此函数'g'在给定输入中进行检查并消除其1/1，然后递增保持的变量，'g'直到找到下一个匹配项（可能是letter 'o'），然后消除那些匹配的字符。
缺点是此功能太过小心，因此，如果您的小票是用26字母az代号命名的不同颜色，则此功能也将处理该输入...

— 穆库尔·库马尔（Mukul Kumar）
source
现在远远超过3：P
— Yodle
@Yodle是的..感谢您可以使用定义的宏#define。减少了19个字节
— Mukul Kumar
3

八度，49字节

按字母顺序吃吃喝玩乐，首先是最高的ASCII码。

A=input("");do [~,p]=max(A(:));A(p)=32 until A<33
— 雷纳·P。
source
3

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 `)
);
展开摘要

— 齐柏林飞艇
source
2

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。

编辑 -感谢帮助减少24个字节的Flp.Tkc！

输入- 
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狂欢
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
是pp pp g pp g gy
y pp pp pp gy
y pp pp pp gy
是pp pp pp y
        pp pp pp y
        pp pp pp

我认为它看起来很简单，因此可以进一步打高尔夫球。

— 古鲁帕德·马马达普尔
source
2
看起来这一次只吃一种颜色，而一次只能吃一种颜色
— wnnmaw
1
另外，您将输入作为嵌套列表，但是生成字符串，请修改您的代码，以使输入和输出的格式相同
— wnnmaw
@wnnmaw进行了更改。我希望现在
— 一切都好
1
我知道已经有一个较短的解决方案，但这种算法可以打高尔夫球更要像呆在这。
— FlipTack
3
我喜欢您特别选择导致的顺序orgy。
— 尼克·哈特利
2

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

在线试用

以oypg的顺序进餐，将所有r都放在末尾:)

— nmjcman101
source
1

Mathematica，67个字节

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

先吃红色，然后是黄色，然后是橙色，然后是紫色。

— 郑焕民
source
男孩，我很高兴这里没有内置的功能
— wnnmaw
1

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

在这里尝试！

@Poke对其他Java回答的另一种方法。我们首先制作原始字符串的副本。遍历每种颜色，我们在每次找到颜色时都将其替换为一个空格，然后将新的布局添加到输出字符串，在我们吃掉橙色以外的所有东西后返回。

笔记

步骤之间的分隔是通过双换行符完成的\n\n，但是如果输入网格可以在末尾加上换行符，则可以将其缩写为just \n。

— Xanderhall
source
1

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空格替换较大的最大元素，然后再次调用该函数。基本情况是没有要删除的元素。

— 妮米
source
1

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.
— 桑切斯
source
0

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堆，而是在每个步骤之前暂停一秒钟，将其显示在屏幕上。（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将当前Skittle的ASCII码转换为s。然后，我们在1到10的行和列之间循环。SCREEN(r,c)获得屏幕上第row r列的字符的ASCII码c。如果这是等于当前的撞柱s，我们SLEEP一秒钟，然后打印在一个空间r，c。

主循环运行四次，删除了绿色，黄色，红色和橙色的彩虹糖。在第五次迭代中，READ由于我们没有数据而出错。

— DLosc
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.