Oreoorererereoo

Biorąc pod uwagę ciąg wejściowy podobny do słowa „oreo”, podaj ASCII reprezentację pliku cookie, która jest tak szeroka jak ciąg wejściowy (aby zapewnić stabilność pliku cookie).

Zasady

• Dane wejściowe to małe litery, niepuste ciągi bez białych znaków, zawierające dowolną kombinację ciągów „o” i „re” oraz zawierające tylko te ciągi.
• Ciąg „o” reprezentuje stały plik cookie, a ciąg „re” reprezentuje wypełnienie.
• Dane wyjściowe muszą być skumulowanym plikiem cookie, który jest tak szeroki jak łańcuch wejściowy.
• Dane wyjściowe nie mogą być tablicą ciągów
• Ciasteczko musi nakładać się na wypełnienie po jednym znaku z każdej strony
• Znaki użyte w danych wyjściowych nie muszą pasować do danych wyjściowych poniżej (█ i ░), muszą po prostu być różnymi znakami spacji dla dwóch części pliku cookie
• Wymagane jest wypełnienie białych znaków po lewej stronie wypełnienia, a wszelkie końcowe białe znaki są opcjonalne

Przykłady

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

Input: o
Output:
█

Input: re
Output: (two spaces)


Input: rere
Output:
 ░░ 
 ░░ 

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

Ponieważ jest to kod golfowy, wygrywa najkrótsza odpowiedź, powodzenia :)

Galaretka ,  16 14  13 bajtów

-1 Dzięki Erik the Outgolfer

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

Wykorzystuje 1krem i 0ciasteczko.

Wypróbuj online!

W jaki sposób?

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

Poprzednie 16 bajtów:

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

Zastosowania rdla rkamery i odla co Okie.

Wypróbuj online!

Pepe , 364 bajty

Niestety interpreter online nie zajmuje się kompresowaniem komentarzy, dlatego wszystkie oznaki zostaną zastąpione spacją. Ani spacje, ani te nie osą konieczne, więc może to być 295 bajtów, ale bardziej podoba mi się to w ten sposób:

rEeEEeeEeEororEEoreoreeeEeeeeeorEEEEeoREeoreorEeEEeEEEEororEEoreorEEEEEoREeoreorEeEEEeeEeororEEoreoReoREoREEEeoREEEEEoreorEorEEEeorEEEEEoreEoREeoreoREEeoREEEEeEeeoREEEeoREeeEoREEEeoREEEEEEEorEEEeEorEEEeoREoREEEeoREEEEEoREEoReoreorEEEeEoREEEEEEeorEEEeoReEoREoREEEeoREEoReoroReEeoREoREEEeorEEEEeoReeoREEEeoREeeEoREEEeoREEEEEEEoreoReoReoREoREEEeoREEEEEoreeeeeEeEeoRee

Wypróbuj online!

Bez golfa

Mogą pojawić się szanse na grę w golfa z flagami które mi umknęły, ale na razie skończę:

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

Płótno , 19 18 17 bajtów

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

Wypróbuj tutaj!

Używa denerwująco długiego kodu ：r≠＊┤］do usunięcia rs z wejścia.

Japt -R , 16 15 bajtów

re ¬£çX sX²èrÃû

Spróbuj

                    :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

Alternatywy

re ¬ËpUÊaD²èrÃû
re ¬£îX rr²i^Ãû

C # (interaktywny kompilator Visual C #) , 95 bajtów

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

Wypróbuj online!

Alternatywnie przy użyciu Aggregate, 108 bajtów

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

Wypróbuj online!

R , 106 bajtów

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

Wypróbuj online!

• -12 bajtów dzięki @Giuseppe

Poprzednia wersja z wyjaśnieniem:

R , 118 bajtów

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

Wypróbuj online!

• -1 bajt dzięki @Giuseppe

Kod i objaśnienie:

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 bajtów

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

-1 bajt dzięki @Emigna

Wykorzystuje ociasteczko i rnadzienie.

Wypróbuj online lub sprawdź wszystkie przypadki testowe .

Wyjaśnienie:

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

Retina , 74 73 bajty

Wydaje mi się, że nie opublikowałem odpowiedzi od bardzo dawna. Cóż, oto jestem. Ponadto Retina bardzo się zmieniła i mam wrażenie, że jestem do niej teraz do niczego.

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

o|r
$&¶
_$

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

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

m`^r
 

Wypróbuj online!

Retina , 21 bajtów

r

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

Wypróbuj online! Wyjaśnienie:

r

Usuń rs.

L$`.
$.+*$&

Wymień każdą literę w wierszu powtórzonym na długość oryginalnego tekstu.

\bee
 

Zastąp pierwsze dwa ees w każdej linii spacją.

C (gcc) , 135 113 109 104 bajtów

• Zaoszczędź dwadzieścia dwa dwadzieścia siedem bajtów dzięki NieDzejkobowi .
• Zaoszczędzone cztery bajty dzięki pułapkowi cat .

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

Wypróbuj online!

JavaScript ES6, 103 bajty

Używając zamień 103 bajty:

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

Wypróbuj online!

Korzystanie z podziału i odwzorowania 116 bajtów:

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

Wypróbuj online!

Perl 5 -p , 47 bajtów

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

Wypróbuj online!

Python 3 , 77 bajtów

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

Wypróbuj online!

Mathematica, 111 91 bajtów

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

Wypróbuj online!

Zostało to Majorly skrócony dzięki Misha „s edycji .

Mój oryginalny kod:

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

Ten kod nie jest zbyt wymyślny, ale wydaje się zbyt drogi, aby przekonwertować go z łańcuchów, a następnie wrócić lub zrobić cokolwiek sprytniejszego.

W szczególności, mając tylko 3-4 polecenia o nazwie String, moje oryginalne podejście nie mogło w ogóle zaoszczędzić bajtów, próbując to wyodrębnić. Na przykład następujące to 129 bajtów:

(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 bajtów

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

Wypróbuj online!

Anonimowy blok kodu, który pobiera ciąg i wypisuje oreo, z ojak cookie ir krem.

Wyjaśnienie:

{                                   }   # 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 bajtów

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

Wykorzystuje =ciasteczko i ~nadzienie.

Wypróbuj online.

Wyjaśnienie:

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

Powyższe rozwiązanie wykorzystuje zamiennik. Zamiast tego następujące znaki nad znakami wejściowymi:

Java 11, 113 112 bajtów

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

-1 bajt dzięki @Neil .

Wypróbuj online.

Wyjaśnienie:

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 bajty

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

Wypróbuj online!

OUCH Nazwy funkcji waaaay_too_long w PHP znów uderzają!

Wynik:

$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 bajtów

Dzięki @gwaugh -9 Bytes
Dzięki @manatwork -2 Bytes

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

Wypróbuj online!

Wypróbuj online! (87 bajtów)

Wypróbuj online (oryginalne przesłanie 97 bajtów)!

PHP , 135 bajtów

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

Wypróbuj online! (rekurencyjny)

JavaScript, 72 65 64 bajtów

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

Wypróbuj online

PowerShell, 71 69 66 bajtów

-2 bajty dzięki @ Veskah

-3 bajty dzięki @AdmBorkBork

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

Skrypt testu mniej golfowego:

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

Wynik:

True
True
True
True
True

Węgiel drzewny , 19 bajtów

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

Wypróbuj online!Link jest do pełnej wersji kodu. Wyjaśnienie:

Ｆθ

Pętlę przez znaki ciągu wejściowego.

≡ι

Włącz każdą postać.

o⟦⭆θ#⟧

Jeśli tak, oto wypisz ciąg wejściowy zamieniony na# na s we własnej linii.

e«→Ｐ⁻Ｌθ²↙

Jeśli jest eto ruch w prawo, wydrukuj wiersz -s, który jest o dwa mniejszy niż długość ciągu wejściowego, a następnie przesuń w dół i w lewo.

Bash, 87 bajtów

Bez sed:

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

Dzięki @manatwork.

Z sed(90 bajtów):

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

C # (interaktywny kompilator Visual C #) , 71 bajtów

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

Wypróbuj online!

Na pewno pożyczyłem kilka pomysłów z odpowiedzi na Embodiment of Ignorance .

-6 bajtów dzięki @ASCIIOnly!

Ogólna koncepcja polega na obliczeniu agregacji ciągów znaków wejściowych zgodnie z następującymi regułami:

• W przypadku rnapotkania dodaj pojedynczy znak spacji dla wcięcia. Wiemy, że następną postacią będzie e.
• Jeśli an olub ane napotkania należy wygenerować ciąg, powtarzając bieżący znak określoną liczbę razy i dodając go do nowej linii lub dopełnienia i nowej linii.
• Liczba powtórzeń zależy od długości ciągu wejściowego i tego, czy bieżąca linia jest wcięta.
• PadLeftFunkcja służy do wygenerowania powtarzający się ciąg znaków.

Rezultatem jest połączenie wszystkich tych ciągów.

Pyth , 28 bajtów

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

Wypróbuj tutaj! Ten używa pętli.

Pyth, 30 bajtów

(Jako ciąg zamień)

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

Wypróbuj tutaj! Ten wykorzystuje zamianę ciągu.

Naprawdę lubię Pythona (w tym napisałem moje oryginalne skrypty testowe), więc pomyślałem, że dla zabawy zrobię wpis pyta :)

Rubin , 62 60 bajtów

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

Wypróbuj online!

Wykorzystuje Ociasteczko, *do napełniania.

-1 dzięki @manatwork wskazując głupie pomyłki i kolejne -1 z powodu złagodzenia zasad dotyczących białych znaków.

C # (.NET Core) , 143 bajty

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

Wypróbuj online!

Clojure , 137 bajtów

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

Nie używam ładnych postaci na wydruku w wersji golfowej, ponieważ są one drogie. Zwraca ciąg do wydrukowania.

Wypróbuj online!

Wyjaśnienia poniżej.

Gra w golfa:

; 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 bajtów

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

Wypróbuj online!

• +1 bajt: Dodano końcowe białe znaki

Python 2 , 77 76 72 bajtów

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

Wypróbuj online!

Zewnętrzna część pliku cookie to „o”, a nadzienie to „r”.

kod maszynowy x86-64 (Linux), 97 bajtów

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

Ta funkcja x86-64 pobiera wskaźnik do ciągu wejściowego w rsi i buduje dane wyjściowe, zaczynając od wskaźnika w rdi (są to rejestry używane do przekazania pierwszych dwóch argumentów z funkcji C w systemie Linux). Dla wygody napisałem do tego opakowanie C ++, które również robi dobrą dezynfekcję danych wejściowych i drukuje dane wyjściowe. Ten kod można znaleźć tutaj . Pokazuje to również oryginalny zestaw składni nasm, który napisałem dla tej funkcji (a także wersję bez gry w golfa, którą zacząłem działać jako pierwszy).

Należy zauważyć, że ten kod nie respektuje żadnych rejestrów zapisanych przez odbiorcę, co oznacza, że ​​kod C ++ prawdopodobnie zawiedzie, jeśli zostanie uruchomiony przez chwilę po wywołaniu tej funkcji. Na mojej maszynie tak nie jest, ale to raczej zaskakujące. Nie dodam również bajtu zerowego, aby rozgraniczać ciąg wyjściowy, a zamiast tego miejsce przydzielone dla ciągu wyjściowego jest wstępnie wypełnione bajtami. (Jeśli nie jest to dozwolone, mogę dodać terminator zerowy kosztem 3 bajtów).

Logika tego kodu zasadniczo liczy długość łańcucha, następnie buduje linię o tej długości dla każdego znaku „o” i „r” widocznego w ciągu wejściowym, a następnie dla każdego znaku „e”, zastępując pierwszy i ostatnie znaki w poprzednim wierszu ze spacjami.

Nie mogę znaleźć nigdzie online, aby skompilować i uruchomić mieszankę kodu źródłowego C ++ i nasm, więc mogę napisać mały kod opakowujący, aby udowodnić, że działa. W przeciwnym razie powinieneś być w stanie skompilować i uruchomić to z makefile w linku, który podałem za pomocą polecenia:

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

Byłem w stanie sformatować zespół na coś akceptowalnego przez gcc, więc wypróbuj go online!