59
\$\begingroup\$

Oreoorererereoo

Given an input string that is similar to the word "oreo", give an ASCII representation of the cookie that is as wide as the input string (to ensure cookie stability).

Rules

  • The input is lowercase, a non-empty string with no whitespace containing any combination of the strings "o" and "re", and containing only those strings.
  • The string "o" represents the solid cookie, while the string "re" represents the filling.
  • The output must be a stacked cookie that is as wide as the input string.
  • The output may not be an array of strings
  • The cookie must overlap the filling by one character on each side
  • The characters used for the output don't have to match the output below (█ and ░), they just have to be different non-whitespace characters for the two parts of the cookie
  • The whitespace padding on the left side of the filling is required, and any trailing whitespace is optional

Examples

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

Input: o
Output:
█

Input: re
Output: (two spaces)


Input: rere
Output:
 ░░ 
 ░░ 

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

Since this is code golf the shortest answer wins, good luck :)

\$\endgroup\$
  • 3
    \$\begingroup\$ "The whitespace padding on each side of the filling is required". Does this actually mean that there must be a space character at the end of each line of filling? If so why? As long as it works visually then what does this requirement add to the challenge? \$\endgroup\$ – ElPedro Jan 6 at 0:23
  • \$\begingroup\$ @ ElPedro Good point, I modified the rules and @Dennis I edited the rules so the comments should be okay to clean up \$\endgroup\$ – GammaGames Jan 7 at 3:22
  • \$\begingroup\$ @JonathanAllan Since it's printing "ascii-art" I removed that rule, it looks like I forgot to update the question. Should be updated now. \$\endgroup\$ – GammaGames Jan 7 at 16:05
  • \$\begingroup\$ Awesome, thanks! \$\endgroup\$ – Jonathan Allan Jan 7 at 16:18
  • \$\begingroup\$ @GammaGames, if whitespace on the right is not required anymore, I assume the output for test case re should be now acceptable as 1 or 2 spaces, not necessarily 2? \$\endgroup\$ – Kirill L. Jan 10 at 8:24

44 Answers 44

15
\$\begingroup\$

Jelly,  16 14  13 bytes

-1 Thanks to Erik the Outgolfer

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

Uses 1 for the cream and 0 for the cookie.

Try it online!

How?

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

Previous 16 byter:

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

Uses r for the cream and o for the cookie.

Try it online!

\$\endgroup\$
  • \$\begingroup\$ I was hoping for a Jelly entry, such an interesting language! \$\endgroup\$ – GammaGames Jan 4 at 17:39
18
+50
\$\begingroup\$

Pepe, 364 bytes

Unfortunately the online interpreter does not take care of compressing comments, hence all o characters will be replaced by a space.. Neither the spaces nor the o are necessary, so this could be 295 bytes, but I like it more this way:

rEeEEeeEeEororEEoreoreeeEeeeeeorEEEEeoREeoreorEeEEeEEEEororEEoreorEEEEEoREeoreorEeEEEeeEeororEEoreoReoREoREEEeoREEEEEoreorEorEEEeorEEEEEoreEoREeoreoREEeoREEEEeEeeoREEEeoREeeEoREEEeoREEEEEEEorEEEeEorEEEeoREoREEEeoREEEEEoREEoReoreorEEEeEoREEEEEEeorEEEeoReEoREoREEEeoREEoReoroReEeoREoREEEeorEEEEeoReeoREEEeoREeeEoREEEeoREEEEEEEoreoReoReoREoREEEeoREEEEEoreeeeeEeEeoRee

Try it online!

Ungolfed

There might be some golfing oppurtunities with flags which I missed, but I'm done for now:

# "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
\$\endgroup\$
9
\$\begingroup\$

Canvas, 19 18 17 bytes

e ∙╋
:r≠*┤];L×⁸↔⁸

Try it here!

Uses the annoyingly long code of :r≠*┤] to remove rs from the input..

\$\endgroup\$
  • \$\begingroup\$ That's a handy feature, and cool language! \$\endgroup\$ – GammaGames Jan 4 at 1:48
7
\$\begingroup\$

Japt -R, 16 15 bytes

re ¬£çX sX²èrÃû

Try it

                    :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

Alternatives

re ¬ËpUÊaD²èrÃû
re ¬£îX rr²i^Ãû
\$\endgroup\$
6
\$\begingroup\$

C# (Visual C# Interactive Compiler), 95 bytes

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

Try it online!

Alternative using Aggregate, 108 bytes

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

Try it online!

\$\endgroup\$
  • 1
    \$\begingroup\$ now it trims trailing spaces.. \$\endgroup\$ – dzaima Jan 4 at 1:50
  • \$\begingroup\$ There was enough feedback that I removed the trailing newline rule. Feel free to update your entry. \$\endgroup\$ – GammaGames Jan 4 at 4:40
  • \$\begingroup\$ Your replace doesn't work when the input is o, since the n.Length-2 will result in -1. \$\endgroup\$ – Kevin Cruijssen Jan 4 at 10:18
  • \$\begingroup\$ The n.Length-2 is is for when the input has re. \$\endgroup\$ – Embodiment of Ignorance Jan 4 at 16:27
6
\$\begingroup\$

R, 106 bytes

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,,"")}

Try it online!

  • -12 bytes thanks to @Giuseppe

Previous version with explanation :

R, 118 bytes

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,,'')}

Try it online!

  • -1 byte thanks to @Giuseppe

Unrolled code and explanation :

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
}
\$\endgroup\$
  • \$\begingroup\$ 106 bytes \$\endgroup\$ – Giuseppe Jan 4 at 22:40
  • \$\begingroup\$ aaand 104 bytes returning a list of lines, which isn't acceptable here, but it's an interesting idea (essentially my SNOBOL submission translated to R) \$\endgroup\$ – Giuseppe Jan 4 at 23:11
6
\$\begingroup\$

05AB1E, 18 17 16 bytes

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

-1 byte thanks to @Emigna

Uses o for the cookie and r for the filling.

Try it online or verify all test cases.

Explanation:

'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"
\$\endgroup\$
  • \$\begingroup\$ Creative solution, But it does not solve the problem entirely: oro would give a wrong answer \$\endgroup\$ – Mark Smit Jan 6 at 9:15
  • \$\begingroup\$ @MarkSmit oro isn't a possible input, since the input will only contain os and res. Regardless, oro still seems to output correctly following the spec, since it outputs ooo\n r\nooo. What is wrong about it? \$\endgroup\$ – Kevin Cruijssen Jan 6 at 10:44
  • \$\begingroup\$ This is invalid: "The whitespace padding on each side of the filling is required" \$\endgroup\$ – NieDzejkob Jan 6 at 15:14
  • \$\begingroup\$ 2* can be · and the missing whitespace can be fixed by changing ».c to .c.B» \$\endgroup\$ – Emigna Jan 7 at 9:29
  • \$\begingroup\$ @Emigna Ah, can't believe I haven't thought about ·, thanks! :) And always nice to have changing specs during the challenge, sigh.. \$\endgroup\$ – Kevin Cruijssen Jan 7 at 9:40
5
\$\begingroup\$

Retina, 74 73 bytes

I feel like I haven't posted an answer in a very long time. Well, here I am. Also, Retina has changed a lot, and I feel like I suck at it now.

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

o|r
$&¶
_$

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

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

m`^r
 

Try it online!

\$\endgroup\$
  • 1
    \$\begingroup\$ Whoa, what a crazy looking language. I like it! \$\endgroup\$ – GammaGames Jan 4 at 1:58
  • \$\begingroup\$ doesn't include trailing whitespaces.. \$\endgroup\$ – dzaima Jan 4 at 2:00
  • 2
    \$\begingroup\$ I like how [or] means o or r instead of [ or ]. Makes my head hurt. \$\endgroup\$ – nedla2004 Jan 4 at 2:43
  • \$\begingroup\$ @dzaima The question does not specify that trailing whitespaces are required. A comment asked, but no reply was given. \$\endgroup\$ – mbomb007 Jan 4 at 19:44
  • \$\begingroup\$ @nedla2004 That actually helped me notice a way to save a byte. Thanks. \$\endgroup\$ – mbomb007 Jan 4 at 19:44
5
\$\begingroup\$

Retina, 21 bytes

r

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

Try it online! Explanation:

r

Delete the rs.

L$`.
$.+*$&

List each letter on its own line repeated to the length of the original input.

\bee
 

Replace the first two ees on each line with a space.

\$\endgroup\$
  • \$\begingroup\$ This breaks the rules: "The whitespace padding on each side of the filling is required" \$\endgroup\$ – NieDzejkob Jan 6 at 15:16
  • \$\begingroup\$ @NieDzejkob Sorry for overlooking that, should be fixed now. \$\endgroup\$ – Neil Jan 6 at 16:14
  • \$\begingroup\$ FYI trailing whitespace requirement lifted. \$\endgroup\$ – Jacktose Jan 8 at 0:26
  • \$\begingroup\$ @Neil You should fix that &amp; :P \$\endgroup\$ – ASCII-only Jan 8 at 0:35
5
\$\begingroup\$

C (gcc), 135 113 109 104 bytes

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

Try it online!

\$\endgroup\$
  • \$\begingroup\$ Shave off a few bytes with -D$=putchar \$\endgroup\$ – user77406 Jan 4 at 13:55
  • \$\begingroup\$ 131 bytes if you add a trailing newline as allowed by the rules. \$\endgroup\$ – NieDzejkob Jan 6 at 13:54
  • \$\begingroup\$ 127 bytes if you move the e=o to the condition of the first for loop and then remove the else. \$\endgroup\$ – NieDzejkob Jan 6 at 14:20
  • \$\begingroup\$ 118 bytes if you choose the cookie and filling characters carefully. \$\endgroup\$ – NieDzejkob Jan 6 at 14:58
  • \$\begingroup\$ 113 bytes \$\endgroup\$ – NieDzejkob Jan 6 at 15:02
4
\$\begingroup\$

JavaScript ES6, 103 bytes

Using replace 103 bytes:

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

Try it online!

Using split and map 116 bytes:

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

Try it online!

\$\endgroup\$
  • 1
    \$\begingroup\$ JS, nice! You reminded me that I was going to add a rule about not having line returns at the end of the output, I've added it. Sorry about that! \$\endgroup\$ – GammaGames Jan 4 at 1:45
  • 3
    \$\begingroup\$ just removing the final newline is 12 bytes \$\endgroup\$ – fəˈnɛtɪk Jan 4 at 1:51
  • \$\begingroup\$ There was enough feedback that I removed the trailing newline rule. Feel free to update your entry. \$\endgroup\$ – GammaGames Jan 4 at 4:44
  • 3
    \$\begingroup\$ You can save a byte by using a template string with ${"|".repeat(s>1?s-2:0)} and its whitespaces, instead of using " "+"|".repeat(s>1?s-2:0). \$\endgroup\$ – Ismael Miguel Jan 4 at 10:26
  • \$\begingroup\$ If you use backticks for the string in the first split, you can remove the parentheses around it. \$\endgroup\$ – skiilaa Jan 11 at 19:56
4
\$\begingroup\$

Perl 5 -p, 47 bytes

s|o|X x($i=y///c).$/|ge;s|re|$".O x($i-2).$/|ge

Try it online!

\$\endgroup\$
  • \$\begingroup\$ This breaks the rules: "The whitespace padding on each side of the filling is required" \$\endgroup\$ – NieDzejkob Jan 6 at 15:16
  • \$\begingroup\$ with some variations tio.run/##K0gtyjH9/… \$\endgroup\$ – Nahuel Fouilleul Jan 7 at 15:16
4
\$\begingroup\$

Python 3, 77 bytes

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

Try it online!

\$\endgroup\$
  • \$\begingroup\$ Clever! I did intend the output to not be printing whitespace for the filling (it's pretty much oreo ascii), so I have edited the rules accordingly. Sorry about that! And I always love a python answer :) \$\endgroup\$ – GammaGames Jan 4 at 4:50
  • \$\begingroup\$ @JonathanFrech migth as well delete the comments, that approach was invalidated. I'll work on golfing more tomorrow. \$\endgroup\$ – Rɪᴋᴇʀ Jan 4 at 4:55
  • \$\begingroup\$ You can remove the space at +" \n" to save a byte. \$\endgroup\$ – Kevin Cruijssen Jan 4 at 10:37
  • \$\begingroup\$ @KevinCruijssen can I? The input program says the whole cookie must be as wide as the input. \$\endgroup\$ – Rɪᴋᴇʀ Jan 4 at 16:18
  • 2
    \$\begingroup\$ I interpreted that as meaning that a trailing space is the same (visually) as no space. That's the beauty of answers to ascii art challenges. If they look right they are right :-) \$\endgroup\$ – ElPedro Jan 4 at 21:33
4
\$\begingroup\$

Mathematica, 111 91 bytes

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

Try It Online!

This was majorly shortened thanks to Misha's edits.


My original code:

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

This code is not very fancy but it seems too expensive to convert away from strings and then back or to do anything else clever.

In particular, with only 3-4 commands that have the name String, my original approach couldn't save bytes at all by trying to abstract that away. For example, the following is 129 bytes:

(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"})&
\$\endgroup\$
  • 1
    \$\begingroup\$ A few improvements: StringRepeat can be Table since <> will convert the list into a string later; the If is unnecessary since we take the re branch only when n is at least 2; we can save on parentheses by defining n only when we use it. Try it online! \$\endgroup\$ – Misha Lavrov Jan 5 at 20:32
  • \$\begingroup\$ @MishaLavrov The If was added because StringRepeat would throw an error on the case of "re"; it doesn't allow you to repeat a string 0 times. Table has no such limitation, so that's a big save! \$\endgroup\$ – Mark S. Jan 5 at 21:33
4
\$\begingroup\$

Perl 6, 37 bytes

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

Try it online!

Anonymous code block that takes a string and prints the oreo, with o as the cookie and r as the cream.

Explanation:

{                                   }   # 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
\$\endgroup\$
  • \$\begingroup\$ I didn't realize o could be used in place of . Very nicely golfed. \$\endgroup\$ – primo Jan 16 at 13:22
4
\$\begingroup\$

Java 11, 110 bytes

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

Uses = for the cookie and ~ for the filling.

Try it online.

Explanation:

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

The above solution uses a replace. The following maps over the characters of the input instead:

Java 11, 113 112 bytes

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

-1 byte thanks to @Neil.

Try it online.

Explanation:

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"
\$\endgroup\$
  • 1
    \$\begingroup\$ Can you use ~c&1? \$\endgroup\$ – Neil Jan 4 at 11:34
  • \$\begingroup\$ @Neil I indeed can, thanks. \$\endgroup\$ – Kevin Cruijssen Jan 4 at 11:57
  • \$\begingroup\$ This is invalid: "The whitespace padding on each side of the filling is required" \$\endgroup\$ – NieDzejkob Jan 6 at 15:15
  • \$\begingroup\$ @NieDzejkob Fixed.. Always nice to have changing specs during the challenge, sigh.. \$\endgroup\$ – Kevin Cruijssen Jan 7 at 9:43
  • \$\begingroup\$ @KevinCruijssen not anymore :P \$\endgroup\$ – ASCII-only Jan 7 at 23:32
4
\$\begingroup\$

JavaScript, 72 65 64 bytes

s=>s.replace(/.e?/g,([x,y])=>(y?`
 `:`
`).padEnd(s.length+!y,x))

Try it online

\$\endgroup\$
4
\$\begingroup\$

Powershell, 71 69 66 bytes

-2 bytes thanks @Veskah

-3 bytes thanks @AdmBorkBork

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

Less golfed test script:

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

Output:

True
True
True
True
True
\$\endgroup\$
  • 1
    \$\begingroup\$ Looks like you don't need parens around the $args 69 bytes \$\endgroup\$ – Veskah Jan 4 at 23:30
  • 1
    \$\begingroup\$ The length of [string[]] is an [int[]]... The [int[]] is [int] if the array contains one element only. Great! Thanks! \$\endgroup\$ – mazzy Jan 5 at 8:55
  • 1
    \$\begingroup\$ The OP updated the challenge so you don't need trailing spaces anymore. This means your r can be " "+'%'*($l-2) instead for -3 bytes. \$\endgroup\$ – AdmBorkBork Jan 18 at 20:19
3
\$\begingroup\$

Charcoal, 19 bytes

Fθ≡ιo⟦⭆θ#⟧e«→P⁻Lθ²↙

Try it online! Link is to verbose version of code. Explanation:

Fθ

Loop through the characters of the input string.

≡ι

Switch on each character.

o⟦⭆θ#⟧

If it's an o then print the input string replaced with #s on its own line.

e«→P⁻Lθ²↙

If it's an e then move right, print a line of -s that's two less than the length of the input string, then move down and left.

\$\endgroup\$
3
\$\begingroup\$

Bash, 87 bytes

Without sed:

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

Thanks to @manatwork.

With sed (90 bytes):

f(){ printf %$1s|tr \  $2;}
echo $1|sed "s/o/`f ${#1} B`\n/g;s/re/ `f $[${#1}-2] F` \n/g"
\$\endgroup\$
  • \$\begingroup\$ Could you show us some sample usage? I'm a bit confused by your function expecting 2 parameters. \$\endgroup\$ – manatwork Jan 6 at 18:34
  • \$\begingroup\$ You write that into a script called test.sh. Then, you call test.sh from the command line as follows: bash test.sh oreoorererereoo. f is needed to repeat the character $2 $1 number of times \$\endgroup\$ – Green Jan 6 at 18:41
  • \$\begingroup\$ Oops. I completely misunderstood function f. Some further minor changes could be made there: Try it online! \$\endgroup\$ – manatwork Jan 6 at 18:55
  • 1
    \$\begingroup\$ 75 bytes. \$\endgroup\$ – Dennis Jan 7 at 4:15
  • 1
    \$\begingroup\$ 60 bytes \$\endgroup\$ – Nahuel Fouilleul Jan 8 at 8:27
3
\$\begingroup\$

C# (Visual C# Interactive Compiler), 71 bytes

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

Try it online!

Borrowed some ideas from on Embodiment of Ignorance's answer for sure.

-6 bytes thanks to @ASCIIOnly!

The overall concept is to compute a string aggregate over the input characters following these rules:

  • If an r is encountered, append a single space character for indentation. We know the next character will be an e.
  • If an o or an e is encountered, generate a string by repeating the current character a specific number of times and prepending it to a newline or some padding and a newline.
  • The number of times to repeat is determined by length of input string and whether the current line is indented.
  • The PadLeft function is used to generate the repeating character string.

The result is the concatenation of all of these strings.

\$\endgroup\$
  • 1
    \$\begingroup\$ 71 \$\endgroup\$ – ASCII-only Jan 5 at 1:09
  • \$\begingroup\$ @ASCIIOnly - Thanks :) \$\endgroup\$ – dana Jan 5 at 1:57
  • \$\begingroup\$ > The whitespace padding on each side of the filling is required \$\endgroup\$ – ASCII-only Jan 5 at 4:57
  • 1
    \$\begingroup\$ 85? \$\endgroup\$ – ASCII-only Jan 5 at 5:01
  • \$\begingroup\$ I didn't notice that :) Although, in reviewing the posted answers about 1/2 have done this incorrectly as well. Good catch though! \$\endgroup\$ – dana Jan 5 at 5:08
3
\$\begingroup\$

PHP, 100 99 93 bytes

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

Try it online!

OUCH. PHP's waaaay_too_long function names strike again!

Output:

$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
\$\endgroup\$
  • \$\begingroup\$ Invalid, cream lines need a trailing space \$\endgroup\$ – ASCII-only Jan 5 at 5:03
  • \$\begingroup\$ Fixed the trailing space. Thanks! \$\endgroup\$ – 640KB Jan 5 at 12:09
  • 1
    \$\begingroup\$ Oh boy, PHP! Also any trailing whitespace is now optional, there were enough people that pointed out that since it's printing out ascii it shouldn't really be required. \$\endgroup\$ – GammaGames Jan 7 at 3:26
3
\$\begingroup\$

Pyth, 28 bytes

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

Try it here! This one uses a loop.

Pyth, 30 bytes

(As string replace)

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

Try it here! This one uses string replacement.

I really like python (it's what I wrote my original test scripts in), so I thought I'd do a pyth entry for fun :)

\$\endgroup\$
  • 1
    \$\begingroup\$ Isn't this 37 bytes? I thought Pyth uses default ASCII as its codepage just like Python, if I remember correctly. So even though your code is 33 characters, both and are three bytes each. Or am I missing something here? \$\endgroup\$ – Kevin Cruijssen Jan 4 at 7:05
  • \$\begingroup\$ Good call, I didn't realize that (I couldn't get pyth to work on tio.run, so I used the length counter on the herokuapp page). In the for loop I could just replace the character with N, even saving a few bytes! \$\endgroup\$ – GammaGames Jan 4 at 14:38
  • \$\begingroup\$ Thought something like that happened. :) I once had the same issue with a 05AB1E answer of mine that was using characters outside its code page. Unfortunately TIO displays chars and bytes the same for most golfing languages. For Java or Python TIO will correctly state 33 chars, 37 bytes, but not in golfing languages on TIO. But in your solutions just changing those characters indeed fixes the issue, so it's not that big of a deal here. \$\endgroup\$ – Kevin Cruijssen Jan 4 at 14:41
  • \$\begingroup\$ @KevinCruijssen Wait, 05AB1E doesn't use an actual SBCS? \$\endgroup\$ – ASCII-only Jan 6 at 1:08
  • 1
    \$\begingroup\$ If you're interested, it seems to work effortlessly on TIO for me. \$\endgroup\$ – NieDzejkob Jan 9 at 16:07
3
\$\begingroup\$

PHP, 96 87 85 bytes

Thanks to @gwaugh -9 Bytes
Thanks to @manatwork -2 Bytes

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

Try it online!

Try it online! (87 Bytes)

Try it online (original 97 bytes submition)!


And a recursive function

PHP, 135 bytes

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

Try it online! (recursive)

\$\endgroup\$
  • 1
    \$\begingroup\$ by combining the best of our two submissions I was able to get it down to 87 bytes TIO. Would you be game to go in with this as a collaborative submission? :) \$\endgroup\$ – 640KB Jan 9 at 16:55
  • 1
    \$\begingroup\$ I think we can remove 1 more byte by using the command short_tag_open, and instead of <?= we can use <?, or am i mistaken? \$\endgroup\$ – Francisco Hahn Jan 9 at 18:46
  • 1
    \$\begingroup\$ 2 characters shorter with string interpolation: ' '.$r(o,$l-2)."␤"" {$r(o,$l-2)}␤". \$\endgroup\$ – manatwork Jan 9 at 18:48
  • \$\begingroup\$ Thanks @manatwork sometimes i forgot php vars are evaluated in a string if the entire string is declared with "" istead of '' \$\endgroup\$ – Francisco Hahn Jan 9 at 18:58
3
\$\begingroup\$

Ruby, 62 60 bytes

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

Try it online!

Uses O for the cookie, * for the filling.

-1 thanks to @manatwork pointing out a silly mistake and another -1 due to relaxation of the rules about whitespaces.

\$\endgroup\$
  • \$\begingroup\$ No need for parenthesis around .gsub's parameters. \$\endgroup\$ – manatwork Jan 9 at 20:54
2
\$\begingroup\$

C# (.NET Core), 143 bytes

Without LINQ.

p=>{var q="";foreach(char c in p){if(c!='e'){for(var j=0;j<p.Length;j++)q+=(j<1|j>p.Length-2)&c>'q'?" ":c<'p'?"█":"░";q+="\n";}}return q;};

Try it online!

\$\endgroup\$
2
\$\begingroup\$

Clojure, 137 bytes

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

I'm not using the nice characters in the printout in the golfed version since those are expensive. Returns a string to be printed.

Try it online!

See below for explanation.

Pre-golfed:

; 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
\$\endgroup\$
2
\$\begingroup\$

Dart, 120 106 107 bytes

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

Try it online!

  • +1 byte : Added trailing whitespace
\$\endgroup\$
  • \$\begingroup\$ This is invalid: "The whitespace padding on each side of the filling is required" \$\endgroup\$ – NieDzejkob Jan 6 at 15:15
  • \$\begingroup\$ Oh, never mind then, I'll correct it soon. Thanks for the info, I missed it \$\endgroup\$ – Elcan Jan 6 at 22:14
2
\$\begingroup\$

Python 2, 77 76 72 bytes

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

Try it online!

The outer part of the cookie is 'o' and the filling is 'r'.

\$\endgroup\$
  • \$\begingroup\$ 68 bytes. Although I doubt if you can really omit the trailing spaces, the spec does say "The whitespace padding on each side of the filling is required"... \$\endgroup\$ – Erik the Outgolfer Jan 5 at 22:35
  • \$\begingroup\$ Thanks @EriktheOutgolfer. Thought a lambda would be shorter! Guess in this case not. Had missed the requirement about the mandatory trailing space on the filling. Really can't see the point with an ascii art challenge but if that's what OP requires then I guess my answer is invalid anyway. \$\endgroup\$ – ElPedro Jan 6 at 0:13
  • \$\begingroup\$ Now corrected... \$\endgroup\$ – ElPedro Jan 6 at 0:18
  • \$\begingroup\$ Why bring it back to 76? Just put +' ' after (l-2). Also, you have a typo, *' ' must be +' '. \$\endgroup\$ – Erik the Outgolfer Jan 6 at 0:23
  • \$\begingroup\$ That's what I did with my current solution. Will take a closer look at your hints tomorrow (later today). It's late here and I have been shoveling snow all day so too tired for golf. Thanks for the tips though :) \$\endgroup\$ – ElPedro Jan 6 at 0:27
2
\$\begingroup\$

x86-64 machine code (Linux), 97 bytes

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

This x86-64 function takes in the pointer to the input string in rsi and builds the output starting at the pointer in rdi (these are the registers used to pass the first two arguments from a C function on Linux). For convenience, I've written a C++ wrapper for this which also does nice input sanitization and prints the output. That code can be located here. This also shows the original nasm syntax assembly I wrote for this function (as well as the non-golfed version I got working first).

A few things to note is that this code doesn't respect any callee saved registers, which means that the C++ code likely will crash if run for a while after calling this function. On my machine it doesn't, but that's rather surprising. I also don't add a null byte to delimit the output string, and instead the space allocated for the output string is pre-filled with bytes. (If this isn't allowed I can add the null terminator at a cost of 3 bytes).

The logic for this code is essentially counting the length of the string, then building a line of this length for each 'o' and 'r' characters seen in the input string, and then for any 'e' character seen, replacing the first and last characters on the previous line with space characters.

I can't find anywhere online to compile and run a mix of C++ and nasm source code, so I might write some small wrapper code for this to prove it works. Otherwise you should be able to compile and run this with the makefile in the link I gave with the command:

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

I was able to format the assembly to something acceptable by gcc, so try it online!

\$\endgroup\$
  • 1
    \$\begingroup\$ Oh my, now this is an entry! \$\endgroup\$ – GammaGames Jan 8 at 15:09

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.