Oreoorererereoo

กำหนดสตริงอินพุตที่คล้ายกับคำว่า "oreo" ให้แสดง ASCII ของคุกกี้ที่มีความกว้างเท่ากับสตริงอินพุต (เพื่อให้แน่ใจว่ามีความเสถียรของคุกกี้)

กฎระเบียบ

• อินพุตเป็นตัวพิมพ์เล็กสตริงที่ไม่ว่างโดยไม่มีช่องว่างที่มีการรวมกันของสตริง "o" และ "re" และมีเฉพาะสตริงเหล่านั้น
• สตริง "o" แสดงถึงคุกกี้ที่เป็นของแข็งในขณะที่สตริง "re" หมายถึงการเติม
• ผลลัพธ์จะต้องเป็นคุกกี้แบบเรียงซ้อนที่มีความกว้างเท่ากับสตริงอินพุต
• ผลลัพธ์อาจไม่ใช่อาร์เรย์ของสตริง
• คุกกี้จะต้องซ้อนทับการเติมโดยตัวละครตัวหนึ่งในแต่ละด้าน
• อักขระที่ใช้สำหรับการส่งออกไม่จำเป็นต้องตรงกับผลลัพธ์ด้านล่าง (█และ,) พวกเขาต้องเป็นอักขระที่ไม่ใช่ช่องว่างที่แตกต่างกันสำหรับสองส่วนของคุกกี้
• ช่องว่างภายในช่องว่างทางด้านซ้ายของการกรอกข้อมูลที่จำเป็นและช่องว่างใด ๆ ต่อท้ายเป็นตัวเลือก

ตัวอย่าง

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

Input: o
Output:
█

Input: re
Output: (two spaces)


Input: rere
Output:
 ░░ 
 ░░ 

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

เนื่องจากนี่คือรหัสกอล์ฟคำตอบที่สั้นที่สุดชนะโชคดี :)

เยลลี่ ,  16 14  13 ไบต์

-1 ขอบคุณ Erik the Outgolfer

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

ใช้1สำหรับครีมและ0คุกกี้

ลองออนไลน์!

อย่างไร?

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 byter ก่อนหน้า:

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

ใช้rสำหรับ c ream และoสำหรับ c ookie

ลองออนไลน์!

Pepe , 364 ไบต์

น่าเสียดายที่ล่ามออนไลน์ไม่สนใจที่จะบีบอัดความคิดเห็นดังนั้นoตัวละครทุกตัวจะถูกแทนที่ด้วยช่องว่าง .. ไม่oจำเป็นต้องเว้นวรรคหรือช่องว่างดังนั้นนี่อาจเป็น 295 ไบต์ แต่ฉันชอบวิธีนี้มากกว่า:

rEeEEeeEeEororEEoreoreeeEeeeeeorEEEEeoREeoreorEeEEeEEEEororEEoreorEEEEEoREeoreorEeEEEeeEeororEEoreoReoREoREEEeoREEEEEoreorEorEEEeorEEEEEoreEoREeoreoREEeoREEEEeEeeoREEEeoREeeEoREEEeoREEEEEEEorEEEeEorEEEeoREoREEEeoREEEEEoREEoReoreorEEEeEoREEEEEEeorEEEeoReEoREoREEEeoREEoReoroReEeoREoREEEeorEEEEeoReeoREEEeoREeeEoREEEeoREEEEEEEoreoReoReoREoREEEeoREEEEEoreeeeeEeEeoRee

ลองออนไลน์!

Ungolfed

อาจมีโอกาสเล่นกอล์ฟที่มีธงซึ่งฉันพลาด แต่ตอนนี้ฉันทำไปแล้ว:

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

Canvas , 19 18 17 ไบต์

e ∙╋
：r≠＊┤］；Ｌ×⁸↔⁸

ลองที่นี่!

ใช้รหัสยาวที่น่ารำคาญของ：r≠＊┤］การลบrs ออกจากอินพุต

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

C # (Visual C # Interactive Compiler) , 95 ไบต์

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

ลองออนไลน์!

ทางเลือกโดยใช้ Aggregate, 108 ไบต์

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

ลองออนไลน์!

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
}

05AB1E , 18 17 16 ไบต์

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

-1 ไบต์ขอบคุณ@Emigna

ใช้oสำหรับคุกกี้และ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"

เรติน่า , 74 73 ไบต์

ฉันรู้สึกว่าฉันยังไม่ได้โพสต์คำตอบในเวลานานมาก ดีที่นี่ฉัน นอกจากนี้จอประสาทตาก็เปลี่ยนไปมากและฉันรู้สึกเหมือนฉันดูดมันตอนนี้

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

o|r
$&¶
_$

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

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

m`^r
 

ลองออนไลน์!

เรติน่า 21 ไบต์

r

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

ลองออนไลน์! คำอธิบาย:

r

ลบrs

L$`.
$.+*$&

รายการตัวอักษรแต่ละตัวในบรรทัดของตัวเองซ้ำแล้วซ้ำอีกตามความยาวของการป้อนข้อมูลเดิม

\bee
 

แทนที่สองees แรกในแต่ละบรรทัดด้วยช่องว่าง

C (gcc) , 135 113 109 104 ไบต์

• ที่บันทึกไว้ยี่สิบสองยี่สิบเจ็ดไบต์ขอบคุณที่NieDzejkob
• ที่บันทึกไว้สี่ไบต์ขอบคุณที่ceilingcat

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

ลองออนไลน์!

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)

ลองออนไลน์!

Perl 5 -p , 47 ไบต์

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

ลองออนไลน์!

Python 3 , 77 ไบต์

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

ลองออนไลน์!

Mathematica, 111 91 ไบต์

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

ลองออนไลน์!

นี้ถูกตัดให้สั้นลงอย่างมากขอบคุณที่Misha 's แก้ไข

รหัสเดิมของฉัน:

(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"})&

Perl 6 , 37 ไบต์

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

ลองออนไลน์!

บล็อกรหัสไม่ระบุชื่อที่ใช้สตริงและพิมพ์ oreo ด้วยoเป็นคุกกี้และ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

Java 11, 110 ไบต์

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

ใช้=สำหรับคุกกี้และ~สำหรับการกรอก

ลองออนไลน์

คำอธิบาย:

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

วิธีการแก้ปัญหาข้างต้นใช้แทน แม็พต่อไปนี้เหนืออักขระของอินพุตแทน:

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

PHP ,100 99 93 ไบต์

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

ลองออนไลน์!

OUCH ฟังก์ชัน waaaay_too_long ของ PHP หยุดทำงานอีกครั้ง!

เอาท์พุท:

$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

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

ลองออนไลน์! (recursive)

JavaScript, 72 65 64 ไบต์

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

ลองออนไลน์

Powershell, 71 69 66 ไบต์

-2 ไบต์ขอบคุณ @Veskah

-3 ไบต์ขอบคุณ @AdmBorkBork

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

สคริปต์ทดสอบ golfed น้อย:

$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

ถ่าน 19 ไบต์

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

ลองออนไลน์! การเชื่อมโยงคือการใช้รหัสเวอร์ชันอย่างละเอียด คำอธิบาย:

Ｆθ

วนซ้ำอักขระของสตริงอินพุต

≡ι

เปิดใช้ตัวละครแต่ละตัว

o⟦⭆θ#⟧

ถ้ามันเป็นoแล้วพิมพ์สตริงใส่แทนที่ด้วย#s ในบรรทัดของตัวเอง

e«→Ｐ⁻Ｌθ²↙

หากเป็นeไปทางขวาให้พิมพ์บรรทัด-ที่มีความยาวน้อยกว่าความยาวของสตริงที่ป้อนสองเส้นจากนั้นเลื่อนลงและไปทางซ้าย

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"

C # (Visual C # Interactive คอมไพเลอร์) , 71 ไบต์

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

ลองออนไลน์!

ยืมความคิดบางอย่างจากคำตอบของศูนย์รวมแห่งความไม่รู้แน่นอน

-6 ไบต์ขอบคุณ @ASCIIOnly!

แนวคิดโดยรวมคือการคำนวณสตริงการรวมเหนืออักขระอินพุตตามกฎเหล่านี้:

• หากrพบเจอให้เพิ่มอักขระเว้นวรรคหนึ่งตัวเพื่อเยื้อง เรารู้ว่าตัวละครต่อไปจะเป็นeเรารู้ว่าตัวอักษรถัดไปจะเป็น
• หากoหรือeเกิดขึ้นให้สร้างสตริงโดยการทำซ้ำอักขระปัจจุบันตามจำนวนครั้งที่ต้องการและเติมลงในการขึ้นบรรทัดใหม่หรือการเติมบางส่วนและการขึ้นบรรทัดใหม่
• จำนวนครั้งที่จะทำซ้ำจะถูกกำหนดโดยความยาวของสตริงป้อนข้อมูลและระบุว่าบรรทัดปัจจุบันมีการย่อหน้า
• PadLeftฟังก์ชั่นที่ใช้ในการสร้างตัวอักษรซ้ำ

ผลลัพธ์คือการต่อกันของสตริงทั้งหมดเหล่านี้

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

ลองที่นี่! อันนี้ใช้การแทนที่สตริง

ฉันชอบงูใหญ่ (มันเป็นสิ่งที่ฉันเขียนสคริปต์การทดสอบดั้งเดิมของฉันใน) ดังนั้นฉันคิดว่าฉันจะทำรายการ Pyth เพื่อความสนุกสนาน :)

Ruby , 62 60 ไบต์

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

ลองออนไลน์!

ใช้Oสำหรับคุกกี้*สำหรับการกรอก

-1 ด้วย @manatwork ชี้ให้เห็นถึงความผิดพลาดที่โง่เขลาและอีก -1 เนื่องจากการผ่อนคลายของกฎเกี่ยวกับพื้นที่ว่าง

C # (. NET Core) , 143 ไบต์

ไม่มี 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;};

ลองออนไลน์!

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

ฉันไม่ได้ใช้ตัวละครที่น่ารักในงานพิมพ์ในเวอร์ชั่นกอล์ฟเนื่องจากมีราคาแพง ส่งคืนสตริงที่จะพิมพ์

ลองออนไลน์!

ดูคำอธิบายด้านล่าง

Pre-แข็งแรงเล่นกอล์ฟ:

; 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

Dart , 120 106 107 ไบต์

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

ลองออนไลน์!

• +1 ไบต์: เพิ่มช่องว่างต่อท้าย

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)

ลองออนไลน์!

ส่วนด้านนอกของคุกกี้คือ 'o' และการเติมคือ 'r'

รหัสเครื่อง 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 (นี่คือรีจิสเตอร์ที่ใช้เพื่อส่งอาร์กิวเมนต์สองตัวแรกจากฟังก์ชัน C บน Linux) เพื่อความสะดวกฉันได้เขียนตัวห่อหุ้ม C ++ สำหรับสิ่งนี้ซึ่งทำให้การป้อนข้อมูลถูกสุขลักษณะและพิมพ์ผลลัพธ์ รหัสนั้นสามารถอยู่ที่นี่ที่นี่สิ่งนี้ยังแสดงให้เห็นถึงการประกอบไวยากรณ์ nasm เดิมที่ฉันเขียนสำหรับฟังก์ชั่นนี้

สิ่งที่ควรทราบคือรหัสนี้ไม่เกี่ยวข้องกับการลงทะเบียนที่บันทึกไว้ซึ่งหมายถึงว่ารหัส C ++ มีแนวโน้มที่จะล้มเหลวหากเรียกใช้ชั่วขณะหลังจากเรียกใช้ฟังก์ชันนี้ บนเครื่องของฉันมันไม่ได้ แต่มันค่อนข้างน่าแปลกใจ ฉันยังไม่ได้เพิ่มไบต์ว่างเพื่อกำหนดเขตเอาท์พุทแทนและพื้นที่ที่จัดสรรสำหรับสตริงเอาต์พุตจะเต็มไปด้วยไบต์ (หากไม่ได้รับอนุญาตฉันสามารถเพิ่ม null terminator ได้ที่ราคา 3 ไบต์)

ตรรกะสำหรับรหัสนี้คือการนับความยาวของสตริงจากนั้นสร้างบรรทัดที่มีความยาวนี้สำหรับอักขระ 'o' และ 'r' แต่ละตัวที่เห็นในสตริงอินพุตและจากนั้นสำหรับอักขระ 'e' ที่เห็นแทนที่แรก และอักขระตัวสุดท้ายในบรรทัดก่อนหน้าด้วยอักขระเว้นวรรค

ฉันไม่สามารถหาที่ใดก็ได้ทางออนไลน์เพื่อรวบรวมและเรียกใช้รหัสแหล่ง C ++ และ nasm ผสมกันดังนั้นฉันอาจเขียนโค้ดตัวเล็ก ๆ เพื่อพิสูจน์สิ่งนี้ มิฉะนั้นคุณควรจะสามารถคอมไพล์และรันไฟล์นี้ด้วย makefile ในลิงค์ที่ฉันให้ไว้กับคำสั่ง:

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

ฉันสามารถจัดรูปแบบแอสเซมบลีเป็นสิ่งที่ยอมรับโดย gcc ดังนั้นลองออนไลน์!