Oreoorererereoo

60

Oreoorererereoo

给定与单词“ oreo”相似的输入字符串，请给出与输入字符串一样宽的cookie的ASCII表示形式（以确保cookie的稳定性）。

规则

  • 输入为小写字母，这是一个非空字符串，不包含空格，其中包含字符串“ o”和“ re”的任何组合，并且仅包含那些字符串。
  • 字符串“ o”代表固态饼干，而字符串“ re”代表馅料。
  • 输出必须是与输入字符串一样宽的堆叠cookie。
  • 输出可能不是字符串数组
  • Cookie的每一边必须与填充物重叠一个字符
  • 用于输出的字符不必与下面的输出（█和░）匹配，对于Cookie的两个部分，它们必须是不同的非空白字符
  • 填充左侧的空白填充是必需的，任何结尾的空白都是可选的

例子

Input: oreo
Output:
████
 ░░ 
████

Input: o
Output:
█

Input: re
Output: (two spaces)


Input: rere
Output:
 ░░ 
 ░░ 

Input: oreoorererereoo
Output:
███████████████
 ░░░░░░░░░░░░░ 
███████████████
███████████████
 ░░░░░░░░░░░░░ 
 ░░░░░░░░░░░░░ 
 ░░░░░░░░░░░░░ 
 ░░░░░░░░░░░░░ 
███████████████
███████████████

因为这是代码高尔夫球，所以最短的答案会获胜，祝您好运:)

code-golf  string  ascii-art 
— GammaGames
source
3
“在填充的每一侧都需要空白填充”。这是否实际上意味着在每行填充的末尾都必须有一个空格字符？如果可以，为什么？只要它在视觉上起作用，那么此要求会增加什么挑战？
— ElPedro
@ ElPedro好点，我修改了规则，而@Dennis我修改了规则，因此注释应该可以清理
— GammaGames
@JonathanAllan由于正在打印“ ascii-art”，因此我删除了该规则，好像我忘了更新问题了。现在应该更新。
— GammaGames
很好，谢谢！
— 乔纳森·艾伦
@GammaGames，如果不再需要右边的空格，我假设测试用例的输出re现在应该为1 or 2 spaces，不一定是2？
— Kirill L.

Answers:

15

果冻， 16 14  13 字节

-1感谢外长者埃里克（Erik）

OḂƇẒṁ€aØ.¦€⁶Y

使用1的奶油和0的cookie。

在线尝试！

怎么样？

OḂƇẒṁ€aØ.¦€⁶Y - Main Link: list of characters, V    e.g. 'orereo'
O             - ordinal (vectorises)                     [111,114,101,114,101,111]
  Ƈ           - filter keep those for which:
 Ḃ            -   modulo 2                               [111,    101,    101,111]
   Ẓ          - is prime? (vectorises)                   [  0,      1,      1,  0]
    ṁ€        - mould each like V                        [[0,0,0,0,0,0],[1,1,1,1,1,1],[1,1,1,1,1,1],[0,0,0,0,0,0]]
          €   - for each:
         ¦    -   sparse application...
       Ø.     -   ...to indices: literal [0,1] (0 is the rightmost index, 1 is the leftmost)
      a       -   ...apply: logical AND with:
           ⁶  -               space character           [[0,0,0,0,0,0],[' ',1,1,1,1,' '],[' ',1,1,1,1,' '],[0,0,0,0,0,0]]
            Y - join with newline characters            [0,0,0,0,0,0,'\n',' ',1,1,1,1,' ','\n',' ',1,1,1,1,' ','\n',0,0,0,0,0,0]
              - implicit print                       ...smashes everything together:
              -                                         000000
              -                                          1111 
              -                                          1111 
              -                                         000000

前16个字节：

ḟ”eẋ€Ly@Ø.¦€⁾r Y

用途r为C rEAM和o为C ookie。

在线尝试！

— 乔纳森·艾伦
source
我希望能有一种有趣的果冻语言！
— GammaGames
19

Pepe，364字节

不幸的是，在线解释器不会处理注释，因此所有o字符都将被空格替换。.空格和o都不需要，因此可能是295个字节，但我更喜欢这种方式：

rEeEEeeEeEororEEoreoreeeEeeeeeorEEEEeoREeoreorEeEEeEEEEororEEoreorEEEEEoREeoreorEeEEEeeEeororEEoreoReoREoREEEeoREEEEEoreorEorEEEeorEEEEEoreEoREeoreoREEeoREEEEeEeeoREEEeoREeeEoREEEeoREEEEEEEorEEEeEorEEEeoREoREEEeoREEEEEoREEoReoreorEEEeEoREEEEEEeorEEEeoReEoREoREEEeoREEoReoroReEeoREoREEEeorEEEEeoReeoREEEeoREeeEoREEEeoREEEEEEEoreoReoReoREoREEEeoREEEEEoreeeeeEeEeoRee

在线尝试！

不打高尔夫球

我可能错过了一些带有标志的高尔夫机会，但是我现在已经完成了：

# "function" for 'e'
rEeEEeeEeE rrEE
  re          # remove duplicated argument
  reeeEeeeee  # print space
  rEEEEe      # decrement counter twice
REe re

# "function" for 'o'
rEeEEeEEEE rrEE
  re      # remove duplicated argument
  rEEEEE  # increment counter
REe re

# "function for 'r'
rEeEEEeeEe rrEE
  re Re              # remove duplicated argument & char
  RE REEEe REEEEE    # push 1
  re rE rEEEe rEEEEE # replace 1
  reE                # goto 1
REe re

# Main

REEe REEEEeEee                # read input & reverse
REEEe REeeE REEEe REEEEEEE    # push length-1 & move to r

rEEEeE rEEEe # dummy loop-var (fucking do-whiles...)
RE REEEe REEEEE REE  # while [label-1]

  # Call the right procedure depending on current character,
  # sets stacks up as follows:
  #   R [ .... *currentChar ]
  #   r [ (N-1) *count ]
  Re re          # pop 1 & loop-counter
  rEEEeE         # duplicate counter
  REEEEEEe rEEEe # copy current char to other stack
  ReE            # jeq to 'o'-label or 'e'-label

  # Output currentChar count times:
  RE REEEe REE # while [label-0]:
    Re         #   pop 0
    rReEe      #   print character
    RE REEEe   #   push 0
    rEEEEe     #   decrement counter
  Ree

  REEEe REeeE REEEe REEEEEEE  # push length-1 & move to r
  re Re Re                    # pop 0, counter and 9((((currentChar
  RE REEEe REEEEE             # push 1
  reeeeeEeEe                  # print new-line

Ree
— ბიმო
source
1
— DJMcMayhem
7

Japt -R，16 15字节

re ¬£çX sX²èrÃû

试试吧

                    :Implicit input of string U
re                  :Remove all "e"s
   ¬                :Split to array of characters
    £               :Map each X
     çX             :  Repeat X to the length of U
        s           :  Slice from index
         X²         :   Duplicate X
           èr       :   Count the occurrences of "r"
             Ã      :End map
              û     :Centre pad each element with spaces to the length of the longest
                    :Implicitly join with newlines and output

备择方案

re ¬ËpUÊaD²èrÃû
re ¬£îX rr²i^Ãû
— 毛茸茸
source
6

C＃（Visual C＃交互式编译器），95字节

n=>n.Replace("o",new String('-',n.Length)+"\n").Replace("re"," ".PadRight(n.Length-1,'|')+"\n")

在线尝试！

使用聚合的替代方法，108字节

n=>n.Aggregate("",(d,c)=>d+(c<102?"":c<112?new String('-',n.Length)+"\n":" ".PadRight(n.Length-1,'|')+"\n"))

在线尝试！

— 无知的体现
source
1
现在它修剪尾随空格..
— dzaima
有足够的反馈，我删除了尾随换行规则。随时更新您的条目。
— GammaGames
输入为时，替换将不起作用o，因为n.Length-2将会导致-1。
— 凯文·克鲁伊森
该n.Length-2IS是当输入了re。
— 无知的体现
6

R，106字节

function(s,N=nchar(s)){m=rep(el(strsplit(gsub('re',0,s),'')),e=N)
m[m<1&seq(m)%%N<2]=' '
write(m,1,N,,"")}

在线尝试！

  • -12个字节感谢@Giuseppe

带有解释的先前版本：

R，118字节

function(s,N=nchar(s)){m=t(replicate(N,el(strsplit(gsub('re',0,s),''))))
m[m<1&row(m)%in%c(1,N)]=' '
write(m,1,N,,'')}

在线尝试！

  • -1字节感谢@Giuseppe

展开代码和说明：

function(s){                       # s is the input string, e.g. 'oreo'

  N = nchar(s)                     # store the length of s into N, e.g. 4

  s1 = gsub('re',0,s)              # replace 're' with '0' and store in s1, e.g. 'o0o'

  v = el(strsplit(s1,''))          # split s1 into a vector v of single characters
                                   # e.g. 'o','0','o'

  m = replicate(N,v)               # evaluate N times the vector v and arrange 
                                   # the result into a matrix m (nchar(s1) x N)
                                   # e.g. 
                                   # 'o' 'o' 'o' 'o' 
                                   # '0' '0' '0' '0' 
                                   # 'o' 'o' 'o' 'o' 


  m = t(m)                         # transpose the matrix

  m[m<1 & row(m)%in%c(1,N)] = ' '  # substitute the zeros (i.e. where < 1) 
                                   # on the 1st and last row of the matrix with ' ' (space)
                                   # e.g. 
                                   # 'o' ' ' 'o' 
                                   # 'o' '0' 'o' 
                                   # 'o' '0' 'o' 
                                   # 'o' ' ' 'o'

  write(m,1,N,,'')                 # write the matrix to stdout (write function transposes it)
                                   # e.g.
                                   # oooo
                                   #  00 
                                   # oooo
}
— 数字化
source
— 朱塞佩
aaand 104字节返回行列表，这在这里是不可接受的，但这是一个有趣的想法（本质上是我的SNOBOL提交翻译为R）
— Giuseppe
6

05AB1E，18 17 16 字节

'eKεD'rQ2*Igα×}.c

-1字节感谢@Emigna

使用o此Cookie，并r为馅。

在线尝试或验证所有测试用例。

说明：

'eK                 '# Remove all "e" from the (implicit) input
                     #  i.e. "orereo" → "orro"
   ε         }       # Map all characters to:
    D                #  Duplicate the current character
     'rQ            '#  Check if it's an "r" (1 if truthy; 0 if falsey)
                     #   i.e. "r" → 1
                     #   i.e. "o" → 0
        ·            #  Double that
                     #   i.e. 1 → 2
                     #   i.e. 0 → 0
         Ig          #  Take the length of the input
                     #   i.e. "orereo" → 6
           α         #  Take the absolute difference between the two
                     #   i.e. 2 and 6 → 4
                     #   i.e. 0 and 6 → 6
            ×        #  Repeat the duplicated character that many times
                     #   i.e. "r" and 4 → "rrrr"
                     #   i.e. "o" and 6 → "oooooo"
              .c     # Then centralize it, which also imlicitly joins by newlines
                     # (and the result is output implicitly)
                     #  i.e. ["oooooo","rrrr","rrrr","oooooo"]
                     #   → "oooooo\n rrrr\n rrrr\noooooo"
— 凯文·克鲁伊森
source
创造性的解决方案，但是并不能完全解决问题：oro给出的答案是错误的
— Mark Smit
@MarkSmit oro不是可能的输入，因为该输入仅包含os和res。无论如何，oro由于它输出ooo\n r\nooo，因此似乎仍然可以按照规范正确输出。怎么了
— 凯文·克鲁伊森
这是无效的：“必须在填充的每一侧填充空白”
— NieDzejkob
2*可以是·，可以通过更改».c为.c.B»
— Emigna
@Emigna啊，不敢相信我没想过·，谢谢！:)总是很高兴能在挑战中更改规格，叹气
— 。–
5

视网膜，74 73字节

我觉得我已经很长时间没有发布答案了。好吧，我在这里。另外，视网膜已经发生了很大变化，我觉得我现在很烂。

.+
$0$.0
(\d+)
*
e

o|r
$&¶
_$

+(/_/&`o¶
oo¶
_$

)/_/&`r¶
rr¶
¶$

m`^r

在线尝试！

— mbomb007
source
1
哇，真是疯狂的语言。我喜欢！
— GammaGames
不包括尾部空格..
— dzaima
2
我喜欢的[or]意思是o或r而不是[或]。使我的头受伤。
— nedla2004
@dzaima问题未指定尾随空格。提出了评论，但未给出任何答复。
— mbomb007
@ nedla2004这实际上帮助我注意到了一种保存字节的方法。谢谢。
— mbomb007
5

视网膜，21字节

r

L$`.
$.+*$&
\bee

在线尝试！说明：

r

删除r。

L$`.
$.+*$&

在自己的行上列出每个字母，重复到原始输入的长度。

\bee

将ee每行的前两个s 替换为一个空格。

— 尼尔
source
这违反了规则：“填充的每一侧都必须使用空白填充”
— NieDzejkob
@NieDzejkob很抱歉忽略了该信息，应立即修复。
— 尼尔
FYI尾随空白要求提高了。
— Jacktose
@Neil您应该修复&amp;：P
— 仅ASCII的
5

C（GCC） ，135个 113 109 104字节

#define $ putchar(33
O(char*r){for(char*e,*o=r,x;*r;$-23))for(x=*r++>111,e=x?$-1),r++,o+2:o;*e++;$+x));}

在线尝试！

— 乔纳森·弗雷奇
source
用-D$=putchar
如果您按规则允许添加尾随换行符，则为131个字节。
— NieDzejkob
如果将移至e=o第一个for循环的条件，然后删除else，则为127个字节。
— NieDzejkob
118字节（如果您选择cookie并仔细填写字符）。
— NieDzejkob
— NieDzejkob
4

JavaScript ES6，103个字节

使用替换103字节：

x=>x.replace(/o/g,"-".repeat(s=x.length)+`
`).replace(/re/g," "+"|".repeat(s>1?s-2:0)+` 
`).slice(0,-1)

在线尝试！

使用拆分和映射116个字节：

x=>x.split("re").map(y=>("-"[h='repeat'](r=x.length)+`
`)[h](y.length)).join(" "+"|"[h](r>1?r-2:0)+` 
`).slice(0,-1)

在线尝试！

— fəˈnɛtɪk
source
1
JS，太好了！您提醒我，我要添加一条关于在输出末尾没有行返回的规则，我已经添加了它。对于那个很抱歉！
— GammaGames
3
仅删除最后一个换行符是12个字节
— fəˈnɛtɪk
有足够的反馈，我删除了尾随换行规则。随时更新您的条目。
— GammaGames
3
您可以通过使用带有${"|".repeat(s>1?s-2:0)}和其空格的模板字符串来保存字节，而不是使用" "+"|".repeat(s>1?s-2:0)。
— Ismael Miguel
如果在第一个拆分中对字符串使用反引号，则可以删除其周围的括号。
— skiilaa
4

Python 3，77字节

lambda x:x.replace("o","-"*len(x)+"\n").replace("re"," "+'.'*(len(x)-2)+"\n")

在线尝试！

— Rɪᴋᴇʀ
source
聪明！我确实希望输出不打印空白以进行填​​充（这几乎是oreo ascii），所以我相应地编辑了规则。对于那个很抱歉！我一直很喜欢python答案:)
— GammaGames
@JonathanFrech migth也删除了评论，该方法无效。明天我会更多地打高尔夫球。
— Rɪᴋᴇʀ
您可以删除处的空格+" \n"以保存一个字节。
— 凯文·克鲁伊森
@KevinCruijssen我可以吗？输入程序说整个cookie必须与输入一样宽。
— Rɪᴋᴇʀ
2
我认为这是指尾随空格（在视觉上）与无空格相同。那就是对ASCII艺术挑战的答案之美。如果他们看起来正确，那么他们是正确的:-)
— ElPedro
4

Mathematica，111 91字节

#~StringReplace~{"o"->"O"~Table~(n=StringLength@#)<>"\n","re"->" "<>Table["R",n-2]<>" \n"}&

在线尝试！

由于Misha的编辑，这大大缩短了时间。

我的原始代码：

(z=StringRepeat;n=StringLength@#;#~StringReplace~{"o"->"O"~z~n<>"\n","re"->" "<>If[n>2,z["R",n-2],""]<>" \n"})&

这段代码不是很花哨，但是看起来要从字符串转换然后返回或做其他任何聪明的事情都太昂贵了。

特别是，只有3-4个名为String的命令，我的原始方法根本无法通过尝试抽象字节来节省字节。例如，以下是129个字节：

(w=Symbol["String"<>#]&;z=w@"Repeat";n=w["Length"]@#;#~w@"Replace"~{"o"->"O"~z~n<>"\n","re"->" "<>If[n>2,z["R",n-2],""]<>" \n"})&
— 分数。
source
1
进行了一些改进：StringRepeat可以在Table以后<>将列表转换为字符串；这If是不必要的，因为我们re仅n在至少2 时才采取分支；我们可以通过n仅在使用时定义括号来节省括号。在线尝试！
— Misha Lavrov
@MishaLavrov的If添加是因为StringRepeat会在“ re”的情况下引发错误；不允许您重复一个字符串0次。Table没有这样的限制，所以可以节省很多！
— Mark S.
4

Perl 6、37个字节

{m:g/o|r/>>.&({S/rr/ /.say}o*x.comb)}

在线尝试！

匿名代码块，它接收字符串并打印oreo，并o作为cookie和r奶油。

说明：

{                                   }   # Anonymous code block
 m:g/o|r/                               # Select all o s and r s
         >>.&(                     )    # Map each letter to
                            *x.comb     # The letter padded to the width
               S/rr/ /                  # Substitute a leading rr with a space
                      .say              # And print with a newline
— 乔·金
source
我没有意识到o可以代替∘。打高尔夫球非常好。
— primo
4

Java 11，110字节

s->{int l=s.length();return s.replace("re"," "+"~".repeat(l-(l<2?1:2))+"\n").replace("o","=".repeat(l)+"\n");}

使用=此Cookie，并~为馅。

在线尝试。

说明：

s->{                       // Method with String as both parameter and return-type
  int l=s.length();        //  Get the length of the input
  return s                 //  Return the input
          .replace("re",   //  After we've replaced all "re" with:
            " "            //   A space
            +"~".repeat(l-(l<2?1:2))
                           //   Appended with length-2 amount of "~"
                           //   (or length-1 if the input-length was 1)
            +"\n")         //   Appended with a newline
          .replace("o",    //  And we've also replaced all "o" with:
            "=".repeat(l)  //   Length amount of "="
            +"\n");}       //   Appended with a newline

上面的解决方案使用替换。以下代码代替了输入的字符：

爪哇11，113个 112字节

s->s.chars().forEach(c->{if(c>101)System.out.println((c>111?" ":"")+(""+(char)c).repeat(s.length()-2*(~c&1)));})

-1个字节感谢@Neil。

在线尝试。

说明：

s->                           // Method with String parameter and no return-type
  s.chars().forEach(c->{      //  Loop over the characters as codepoint-integers
    if(c>101)                 //   If it's not an 'e':
      System.out.println(     //    Print with trailing newline:
       (c>111?                //     If it's an 'r'
         " "                  //      Start with a space
        :                     //     Else (it's an 'o' instead)
         "")                  //      Start with an empty string
       +(""+(char)c).repeat(  //     And append the character itself
          .repeat(            //     Repeated the following amount of times:
           s.length()         //      The input-length
           -2*(~c&1)));})     //      Minus 2 if it's an "r", or 0 if it's an "o"
— 凯文·克鲁伊森
source
1
你会用~c&1吗？
— 尼尔
@Neil我确实可以，谢谢。
— 凯文·克鲁伊森
这是无效的：“填充的每一侧都必须使用空白填充”
— NieDzejkob
@NieDzejkob修复..一直很高兴能在挑战中更改规格，叹了口气
— 。–
@KevinCruijssen不再：P
— 仅ASCII的
4

PHP，100 99 93字节

$l=strlen($i=$argv[1]);$r=str_repeat;echo strtr($i,[o=>$r(X,$l)."
",re=>' '.$r(o,$l-2)."
"]);

在线尝试！

哎哟。PHP的waaaay_too_long函数名称再次出现！

输出：

$php oreo.php oreo
XXXX
 oo
XXXX

$php oreo.php o
X

$php oreo.php rere
 oo
 oo

$ php oreo.php oreoorererereoo
XXXXXXXXXXXXXXX
 ooooooooooooo
XXXXXXXXXXXXXXX
XXXXXXXXXXXXXXX
 ooooooooooooo
 ooooooooooooo
 ooooooooooooo
 ooooooooooooo
XXXXXXXXXXXXXXX
XXXXXXXXXXXXXXX
— 640KB
source
无效的奶油色行需要尾随空格
— 仅在
修复了尾随空格。谢谢！
— 640KB
1
哦，天哪，PHP！而且，任何结尾的空格现在都是可选的，有足够多的人指出，由于它正在打印出ascii，因此实际上并不需要它。
— GammaGames
4

PHP，96 87 85字节

感谢@gwaugh -9字节
感谢@manatwork -2字节

<?=strtr($i=$argv[1],[o=>($r=str_repeat)(X,$l=strlen($i))."
",re=>" {$r(o,$l-2)}
"]);

在线尝试！

在线尝试！（87字节）

在线尝试（原始97字节提交）！

和一个递归函数

PHP，135字节

function f($w,$x=0){$f=str_repeat;echo($x<($l=strlen($w)))?($w[$x]=='o')?$f(█,$l)."
".f($w,$x+1):" ".$f(░,$l-2)."
".f($w,$x+2):"";}

在线尝试！（递归）

— 弗朗西斯科·哈恩
source
1
通过结合我们的两次提交中的最好的意见，我可以将其减少到87字节的TIO。您会以协作提交方式参与其中吗？:)
— 640KB
1
我认为我们可以通过使用命令short_tag_open来再删除1个字节，而不是<?=可以使用<?或我误会了？
— 弗朗西斯科·哈恩
1
字符串内插法缩短2个字符：' '.$r(o,$l-2)."␤"→ " {$r(o,$l-2)}␤"。
— manatwork
谢谢@manatwork有时我忘记了如果整个字符串用""istead而不是''
— Francisco Hahn
1
使用$argn以下命令可以缩短3个字节：在线尝试！
— 夜间2
4

Powershell，71 69 66字节

-2字节@Veskah

-3个字节，感谢@AdmBorkBork

$l=$args|% le*
switch($args|% t*y){'o'{'#'*$l}'r'{" "+'%'*($l-2)}}

少打高尔夫的测试脚本：

$f = {

$l=$args|% length
switch($args|% t*y){
    'o'{'#'*$l}
    'r'{" "+'%'*($l-2)}
}

}

@(

,(
'oreo',
'####',
' %%',
'####'
)
,(
'o',
'#'
)
,(
're',
' '
)
,(
'rere',
' %%',
' %%'
)
,(
'oreoorererereoo',
'###############',
' %%%%%%%%%%%%%',
'###############',
'###############',
' %%%%%%%%%%%%%',
' %%%%%%%%%%%%%',
' %%%%%%%%%%%%%',
' %%%%%%%%%%%%%',
'###############',
'###############'
)

) | % {
    $s,$expected = $_
    $result = &$f $s
    "$result"-eq"$expected"
    # $result # uncomment this line to display a result
}

输出：

True
True
True
True
True
— 疯狂的
source
1
看起来您不需要围绕$args 69个字节的
— Veskah
1
的长度[string[]]是[int[]]...的[int[]]是[int]如果阵列只包含一个元素。大！谢谢！
— 疯狂
1
OP更新了挑战，因此您不再需要尾随空格。这意味着您r可以使用" "+'%'*($l-2)-3个字节。
— AdmBorkBork
3

木炭，19字节

Ｆθ≡ιo⟦⭆θ#⟧e«→Ｐ⁻Ｌθ²↙

在线尝试！链接是详细版本的代码。说明：

Ｆθ

遍历输入字符串的字符。

≡ι

打开每个字符。

o⟦⭆θ#⟧

如果是，o则#在其自己的行上打印输入字符串并用s 代替。

e«→Ｐ⁻Ｌθ²↙

如果是e然后向右移动，则打印一行-s，该行比输入字符串的长度小两行，然后向下和向左移动。

— 尼尔
source
3

Bash，87个字节

没有sed：

f(){ printf %$1s|tr \  $2;}
c=${1//o/`f ${#1} B`
}
echo "${c//re/ `f $[${#1}-2] F` 
}"

感谢@manatwork。

使用sed（90个字节）：

f(){ printf %$1s|tr \  $2;}
echo $1|sed "s/o/`f ${#1} B`\n/g;s/re/ `f $[${#1}-2] F` \n/g"
— 绿色
source
您能告诉我们一些样品用法吗？我对您期望2个参数的函数有些困惑。
— manatwork
您将其写入名为的脚本中test.sh。然后，在命令行调用test.sh如下：bash test.sh oreoorererereoo。f需要重复字符$2 $1次数
— 绿色
哎呀。我完全误解了功能f。可以在此处进行一些其他小的更改：在线尝试！
— manatwork
1
— 丹尼斯
1
— Nahuel Fouilleul
3

C＃（Visual C＃交互式编译器），71字节

s=>s.Aggregate("",(a,c)=>a+(c>111?" ":"\n".PadLeft(s.Length+c/5-21,c)))

在线尝试！

毫无疑问，我从《无知的体现》的答案中借鉴了一些想法。

-6个字节，感谢@ASCIIOnly！

总体概念是按照以下规则计算输入字符上的字符串聚合：

  • 如果r遇到，请附加一个空格以缩进。我们知道下一个字符将是e。
  • 如果遇到an o或an e，请通过重复当前字符特定次数并将其放在换行符或某些填充和换行符的前面来生成字符串。
  • 重复的次数取决于输入字符串的长度以及当前行是否缩进。
  • 该PadLeft函数用于生成重复字符串。

结果是所有这些字符串的串联。

— 达娜
source
1
71
— 仅限ASCII
@ASCIIOnly-谢谢：）
— dana
>填充的每一边都需要空白填充
— 仅ASCII格式的
1
— 仅ASCII的
我没有注意到：)尽管，在审查有关1/2的已发布答案时，这样做也有误。好收成！
— dana
3

Pyth，28个字节

FNzIqN"o"*lzN)IqN"r"+d*-lz2N
FNz                              For each value, N, in input
   IqN"o"                        if the character is "o"
         *lzN                    return the character times the length of the input
             )                   end if
              IqN"r"             if the character is "r"
FNzIqN"o"*lzN)IqN"r"+d*-lz2N
                        *-lz2N   return the character times length - 2
                    +d           padded on the left with " "

在这里尝试！这个使用循环。

Pyth，30个字节

（作为字符串替换）

::z"o"+*lz"="b"re"++d*-lz2"~"b
 :z"o"                           With the input, replace "o" with
       *lz"="                    "=" times the length of the input
      +      b                   and a newline added to the end
:             "re"               With the input, replace "re" with
                     *    "~"    "~" times
                      -lz2       the length of the input minus 2
                   +d            padded on the left with " "
                  +          b   and a newline added to the end

在这里尝试！这个使用字符串替换。

我真的很喜欢python（这是我编写原始测试脚本的方式），所以我认为我会做一个有趣的pyth输入：）

— GammaGames
source
1
这不是37个字节吗？我以为Pyth像Python一样使用默认ASCII作为其代码页，如果我没记错的话。因此，即使您的代码是33个字符，两者█也░都是三个字节。还是我在这里想念什么？
— 凯文·克鲁伊森
好话，我没有意识到（我无法在pyio.run上使用pyth，因此我在herokuapp页面上使用了长度计数器）。在for循环中，我可以将字符替换为N，甚至节省一些字节！
— GammaGames
认为发生了类似的事情。:)我曾经遇到过与我的05AB1E答案相同的问题，该答案在其代码页外使用字符。不幸的是，TIO在大多数高尔夫语言中显示的字符和字节相同。对于Java或Python，TIO会正确显示33 chars, 37 bytes，但在TIO上不能以高尔夫语言显示。但是在您的解决方案中，仅更改这些字符确实可以解决问题，因此在这里没什么大不了的。
— 凯文·克鲁伊森
@KevinCruijssen等待，05AB1E没有使用实际的SBCS？
— 仅ASCII的
1
如果您有兴趣，对于我来说，它似乎在TIO上毫不费力。
— NieDzejkob
3

红宝石，62 60字节

->s{s.gsub /./,?r=>" #{(?**z=s.size)[0..-3]}
",?o=>?O*z+?\n}

在线尝试！

使用O的cookie，*为馅。

-1感谢@manatwork指出了一个愚蠢的错误，而另一个-1由于放宽了有关空格的规则。

— 基里尔
source
不需要在.gsub参数周围加上括号。
— manatwork
2

Clojure，137字节

(fn[f](let[w(count f)r #(apply str(repeat % %2))](clojure.string/join"\n"(replace{\o(r w \#)\e(str \ (r(- w 2)\-) \ )}(remove #{\r}f)))))

我没有在高尔夫球版的打印输出中使用漂亮的字符，因为这些字符很昂贵。返回要打印的字符串。

在线尝试！

请参阅下面的说明。

预先打高尔夫球

; Backslashes indicate a character literal
(defn oreo [format-str]
  (let [width (count format-str)

        ; A helper function since Clojure doesn't have built-in string multiplication
        str-repeat #(apply str (repeat % %2))

        ; Define the layers
        cookie (str-repeat width \█)
        cream (str \ (str-repeat (- width 2) \░) \ )]

    (->> format-str ; Take the input string,
         (remove #{\r}) ; remove r for simplcity,
         (replace {\o cookie, \e cream}) ; replace the remaining letters with the layers,
         (clojure.string/join "\n")))) ; and join the layers together with newlines
— 致癌物质
source
2

飞镖，120 106 107字节

f(s)=>s.replaceAll('o',''.padRight(s.length,'#')+'\n').replaceAll('re',' '.padRight(s.length-1,'-')+' \n');

在线尝试！

  • +1字节：添加了尾随空格
— 埃尔坎
source
这是无效的：“填充的每一侧都必须使用空白填充”
— NieDzejkob
哦，没关系，我会尽快纠正。感谢您提供的信息，我错过了
— Elcan
2

Python 2中，77个 76 72字节

lambda i:'\n'.join((x*len(i),' '+x*(len(i)-2))[x>'o']for x in i if'e'<x)

在线尝试！

Cookie的外部是“ o”，填充是“ r”。

— 埃尔佩德罗
source
68个字节。尽管我怀疑您是否真的可以忽略尾随空格，但规范确实说“填充的每一侧都需要空白填充” ...
— Outgolfer的Erik
谢谢@EriktheOutgolfer。以为lambda会更短！猜猜在这种情况下不行。错过了填充上强制尾随空间的要求。确实看不到具有ascii艺术挑战的意义，但是如果OP要求这样做，那么我想我的答案还是无效的。
— ElPedro
现在已更正...
— ElPedro
为什么将其恢复到76？刚放+' '完(l-2)。另外，您有错字，*' '必须为+' '。
— 埃里克（Erik）
这就是我对当前解决方案所做的。明天（今天晚些时候）将仔细研究您的提示。这已经很晚了，我整天都在铲雪，太累了打高尔夫球。尽管感谢您的提示:)
— ElPedro
2

x86-64机器码（Linux），97个字节

0000000000000000 <oreo_asm>:
   0:   56                      push   %rsi
   1:   57                      push   %rdi

0000000000000002 <len>:
   2:   48 ff c7                inc    %rdi
   5:   80 3f 00                cmpb   $0x0,(%rdi)
   8:   75 f8                   jne    2 <len>
   a:   49 89 fc                mov    %rdi,%r12
   d:   5f                      pop    %rdi
   e:   49 29 fc                sub    %rdi,%r12
  11:   4d 31 f6                xor    %r14,%r14
  14:   eb 18                   jmp    2e <outer_loop.skip>

0000000000000016 <extra>:
  16:   41 c6 01 20             movb   $0x20,(%r9)
  1a:   c6 03 20                movb   $0x20,(%rbx)
  1d:   49 ff ce                dec    %r14
  20:   eb 06                   jmp    28 <outer_loop>

0000000000000022 <newline>:
  22:   c6 06 0a                movb   $0xa,(%rsi)
  25:   48 ff c6                inc    %rsi

0000000000000028 <outer_loop>:
  28:   49 ff c6                inc    %r14
  2b:   48 ff c7                inc    %rdi

000000000000002e <outer_loop.skip>:
  2e:   44 8a 07                mov    (%rdi),%r8b
  31:   41 80 f8 65             cmp    $0x65,%r8b
  35:   74 df                   je     16 <extra>
  37:   45 84 c0                test   %r8b,%r8b
  3a:   74 23                   je     5f <done>
  3c:   48 89 f3                mov    %rsi,%rbx

000000000000003f <inner_loop>:
  3f:   44 88 06                mov    %r8b,(%rsi)
  42:   49 89 f1                mov    %rsi,%r9
  45:   48 ff c6                inc    %rsi
  48:   48 31 d2                xor    %rdx,%rdx
  4b:   48 89 f0                mov    %rsi,%rax
  4e:   48 2b 04 24             sub    (%rsp),%rax
  52:   4c 29 f0                sub    %r14,%rax
  55:   49 f7 f4                div    %r12
  58:   48 85 d2                test   %rdx,%rdx
  5b:   74 c5                   je     22 <newline>
  5d:   eb e0                   jmp    3f <inner_loop>

000000000000005f <done>:
  5f:   5e                      pop    %rsi
  60:   c3                      retq

这个x86-64函数接收指向rsi中输入字符串的指针，并从rdi中的指针开始构建输出（这是用于从Linux上的C函数传递前两个参数的寄存器）。为了方便起见，我为此编写了一个C ++包装器，它也可以很好地清理输入并输出输出。该代码可以在这里找到。这也显示了我为此功能编写的原始nasm语法程序集（以及我首先使用的非Golf版本）。

需要注意的是，此代码不尊重任何被调用方保存的寄存器，这意味着如果在调用此函数后运行一段时间，C ++代码可能会崩溃。在我的机器上没有，但这令人惊讶。我也不添加空字节来分隔输出字符串，而是为输出字符串分配的空间已预先填充了字节。（如果不允许这样做，我可以以3个字节为代价添加空终止符）。

这段代码的逻辑本质上是计算字符串的长度，然后为输入字符串中看到的每个'o'和'r'字符构建一条该长度的行，然后为看到的任何'e'字符替换第一个前一行的最后一个字符以及空格字符。

我在网上找不到任何地方可以编译和运行C ++和nasm源代码的混合，因此我可能为此编写一些小型包装代码以证明其有效。否则，您应该能够使用我在命令中给出的链接中的makefile进行编译和运行：

$ make oreo ASM_FILE=oreo_golf.nasm
$ ./oreo oreoorererereoo --use_asm

我能够将程序集格式化为gcc可以接受的格式，因此请在线尝试！

— 达维
source
1
哦，我的，现在这是条目！
— GammaGames
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.