Canvas, 19 18 17 bytes

e ∙╋

：r≠＊┤］；Ｌ×⁸↔⁸

Try it here!

Uses the annoyingly long code of ：r≠＊┤］ to remove rs from the input..

05AB1E, 18 bytes

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

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

        2*          #  Multiply that by 2

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

               »    # After the map, join everything by newlines

                    #  i.e. ["oooooo","rrrr","rrrr","oooooo"] → "oooooonrrrrnrrrrnoooooo"

                .c  # Then centralize it (and output implicitly)

                    #  i.e. "oooooonrrrrnrrrrnoooooo" → "oooooon rrrrn rrrrnoooooo"

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^Ãû

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!

R, 119 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

}

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!

Jelly,  16  14 bytes

OḂƇẒẋ€LaØ.¦€⁶Y

Uses 1 for the cream and 0 for the cookie.

Try it online!

How?

OḂƇẒẋ€LaØ.¦€⁶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]

    ẋ€         - repeat each by:

      L        -   length (of 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!

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!

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.

Charcoal, 19 bytes

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

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

Ｆθ

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«→Ｐ⁻Ｌθ²↙

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.

Powershell, 71 bytes

$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

Python 3, 77 bytes

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

Try it online!

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

Dart, 120 106 bytes

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

Try it online!

C (gcc), 135 bytes

#define $ putchar

O(char*r){for(char*e,*o=r;*r;*++r&&$(10))if(*r-111){for($(32,r++),e=o+1;*++e;)$(42);$(32);}else for(e=o;*e++;)$(35);}

Try it online!

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

JavaScript, 72 65 bytes

s=>s.replace(/o|re/g,([x,y])=>(y?`

 `:`

`).padEnd(s.length+!y,x))

Try it online

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"

Pyth, 33 bytes

::z"o"+*lz"="b"re"+.[lz*-lz2"░"db

 :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 both sides with " " to

                     lz              the size of the input string

                  +             b    and a newline added to the end

Try it here!

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

Edit: Here's a for loop, as well (35 bytes):

FNzIqN"o"*lzN)IqN"r".[lz*-lz2Nd

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"

                          *-lz2N     return the character times length - 2

                      .[lz        d  padded on both sides with " " to the input string

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!

Perl 5 -p, 47 bytes

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

Try it online!

SNOBOL4 (CSNOBOL4), 136 bytes

	S =INPUT

	N =SIZE(S)

S	S ('o' | 're') . X REM . S	:F(END)

	OUTPUT =IDENT('o',X) DUPL(X,N)	:S(S)

	OUTPUT =' ' DUPL(0,N - 2) ' '	:(S)

END

Try it online!

PHP, 99 bytes

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

Try it online!

OUCH. PHP's waaaay_too_long function names strike again!

Output:

$php oreo.php oreo

####

 ==

####



$php oreo.php o

#



$php oreo.php rere

 ==

 ==



$ php oreo.php oreoorererereoo

###############

 =============

###############

###############

 =============

 =============

 =============

 =============

###############

###############

Batch, 133 bytes

@set/ps=

@set o=%s:r=o%

@set o=%o:e=o%

@set r=%o:o=-%

@set r= %r:~2%

@set s=%s:e= %

@for %%c in (%s:o=o %)do @call echo %%%%c%%

Takes input on STDIN. Explanation:

@set/ps=

Input the string.

@set o=%s:r=o%

@set o=%o:e=o%

Make a copy of the string with all of the rs and es replaced with os.

@set r=%o:o=-%

@set r= %r:~2%

Make a copy of the string of os, change them to -s and replace the first two with a space.

@set s=%s:e= %

@for %%c in (%s:o=o %)do @call echo %%%%c%%

Change the es into spaces and also add a space after each o, allowing the os and rs to be iterated over, printing the appropriate string each time.

Mathematica, 111 bytes

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

You can try it by going to https://develop.open.wolframcloud.com/app/ and clicking "Create a new notebook" and entering code like the following and then hitting Shift+Enter.

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

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, we don'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"})&

CJam, 27 bytes

q:T'e-{i2%T,'9*_:)2>S+?N}/

Try it online!

Explanation:

q                            read input:                    | "oreoo"

 :T                          store in variable T            | "oreoo", T="oreoo"

   'e-                       remove all 'e' characters:     | "oroo"

      {                  }/  for each character:            | 'o

       i                       get Unicode value:           | 79

        2%                     modulo 2:                    | 1

          T                    push original input:         | 1 "oreoo"

           ,                   get length:                  | 1 5

            '9*                repeat '9' that many times:  | 1 "99999"

               _               duplicate:                   | 1 "99999" "99999"

                :)             increment every character:   | 1 "99999" ":::::"

                  2>           remove first two characters: | 1 "99999" ":::"

                    S+        prepend a space:             | 1 "99999" " :::"

                       ?       conditional:                 | "99999"

                        N      add a newline:               | "99999" N

                             (implicit output)              | "99999" N " :::" N "99999" N "99999" N

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