Oreoorererereoo

एक इनपुट स्ट्रिंग को देखते हुए जो "oreo" शब्द के समान है, कुकी का ASCII प्रतिनिधित्व दें जो इनपुट स्ट्रिंग (कुकी स्थिरता सुनिश्चित करने के लिए) के समान चौड़ी हो।

नियम

इनपुट लोअरकेस है, एक गैर-रिक्त स्ट्रिंग जिसमें कोई भी व्हाट्सएप नहीं होता है जिसमें स्ट्रिंग्स "ओ" और "री" का कोई संयोजन होता है, और केवल उन स्ट्रिंग्स होते हैं।
स्ट्रिंग "ओ" ठोस कुकी का प्रतिनिधित्व करता है, जबकि स्ट्रिंग "री" भरने का प्रतिनिधित्व करता है।
आउटपुट एक स्टैक्ड कुकी होना चाहिए जो इनपुट स्ट्रिंग जितनी चौड़ी हो।
आउटपुट स्ट्रिंग्स का एक सरणी नहीं हो सकता है
कुकी को प्रत्येक तरफ एक वर्ण द्वारा भरने को ओवरलैप करना चाहिए
आउटपुट के लिए उपयोग किए जाने वाले वर्णों का आउटपुट (░ और they) से नीचे का मिलान नहीं होता है, उन्हें बस कुकी के दो भागों के लिए अलग-अलग गैर-व्हाट्सएप वर्ण होना चाहिए।
भरने के बाईं ओर व्हाट्सएप पैडिंग की आवश्यकता होती है, और किसी भी अनुगामी व्हाट्सएप वैकल्पिक है

उदाहरण

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

Input: o
Output:
█

Input: re
Output: (two spaces)


Input: rere
Output:
 ░░ 
 ░░ 

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

चूंकि यह कोड गोल्फ का सबसे छोटा उत्तर जीतता है, इसलिए शुभकामनाएं :)

code-golf string ascii-art

— GammaGames
स्रोत

3

"भरने के प्रत्येक पक्ष पर व्हाट्सएप पैडिंग आवश्यक है"। क्या वास्तव में इसका मतलब यह है कि भरने की प्रत्येक पंक्ति के अंत में एक अंतरिक्ष चरित्र होना चाहिए? यदि हां तो क्यों? जब तक यह दृष्टिगत रूप से काम करता है तब तक यह आवश्यकता चुनौती के लिए क्या करती है?

— एलपेड्रो

@ ElPedro अच्छा बिंदु, मैंने नियमों को संशोधित किया और @ डेनिस ने नियमों को संपादित किया ताकि टिप्पणियाँ ठीक हो जाएं

— गामागेम

@JonathanAllan चूंकि यह "अस्की-आर्ट" प्रिंट कर रहा है, इसलिए मैंने उस नियम को हटा दिया, ऐसा लग रहा है कि मैं प्रश्न को अपडेट करना भूल गया। अब अद्यतन किया जाना चाहिए।

— गामागेम

बहुत अच्छे धन्यवाद!

— जोनाथन एलन

@GammaGames, अगर दाईं ओर व्हाट्सएप की आवश्यकता नहीं है, तो मुझे लगता है कि परीक्षण मामले के लिए आउटपुट reअब स्वीकार्य होना चाहिए 1 or 2 spaces, जरूरी नहीं कि 2?

— किरिल एल।

15

जेली , 16 14 13 बाइट्स

-1 धन्यवाद आउटगीर को

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 बटर:

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

का उपयोग करता है rग के लिए rईएएम और oग के लिए oOkie।

इसे ऑनलाइन आज़माएं!

— जोनाथन एलन
स्रोत

मैं एक जेली प्रविष्टि के लिए उम्मीद कर रहा था, ऐसी दिलचस्प भाषा!

— गामागेम

19

पेपे , 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

— ბიმო
स्रोत

1

मैंने आपसे बातचीत करने के लिए इस बातचीत को आगे बढ़ाया ।

— DJMcMayhem

9

कैनवस , 19 18 17 बाइट्स

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

यहाँ कोशिश करो!

इनपुट से s ：r≠＊┤］को निकालने के लिए कष्टप्रद लंबे कोड का उपयोग करता है r।।

— dzaima
स्रोत

यह एक आसान विशेषता है, और शांत भाषा है!

— गामागेम

7

जाप `-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^Ãû

— झबरा
स्रोत

6

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 95 बाइट्स

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

इसे ऑनलाइन आज़माएं!

एग्रीगेट, 108 बाइट्स का उपयोग करके वैकल्पिक

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

इसे ऑनलाइन आज़माएं!

— अज्ञान का अवतार
स्रोत

1

अब यह

— ट्राइसिंग

पर्याप्त प्रतिक्रिया थी कि मैंने अनुगामी न्यूलाइन नियम को हटा दिया। अपनी प्रविष्टि को अद्यतन करने के लिए स्वतंत्र महसूस करें।

— गामागेम

जब इनपुट होगा o, तो आपकी जगह काम नहीं करती । n.Length-2-1

— केविन क्रूज़सेन

n.Length-2तब होता है जब इनपुट है के लिए है re।

— अज्ञानता

6

आर , 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 को धन्यवाद

स्पष्टीकरण के साथ पिछला संस्करण:

आर , 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 बाइट @ @iuseppe के लिए धन्यवाद

अनियंत्रित कोड और स्पष्टीकरण:

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
}

— digEmAll
स्रोत

106 बाइट्स

— Giuseppe

aaand 104 बाइट्स लाइनों की सूची है, जो यहां स्वीकार्य नहीं है लौटने, लेकिन यह एक दिलचस्प विचार (अनिवार्य रूप से मेरी SNOBOL प्रस्तुत आर के अनुवाद) है

— ग्यूसेप

6

05AB1E , 18 17 16 बाइट्स

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

-1 बाइट @ इग्निना के लिए धन्यवाद

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"

— केविन क्रूज़सेन
स्रोत

रचनात्मक समाधान, लेकिन यह पूरी तरह से समस्या को हल नहीं करता है: ओरो एक गलत जवाब देगा

— मार्क स्मिट

@MarkSmit oroसंभव इनपुट नहीं है, क्योंकि इनपुट में केवल os और res होंगे। भले ही,oro अभी भी सही ढंग से कल्पना के बाद उत्पादन करने के लिए लगता है, क्योंकि यह आउटपुट हैooo\n r\nooo । इसके बारे में क्या गलत है?

— केविन क्रूज़सेन

यह अमान्य है: "भरने के प्रत्येक पक्ष पर

— व्हाट्सएप पैडिंग

2*हो सकता है ·और गायब ».c.c.B»

— व्हाट्सएप

@Eigna आह, मैं विश्वास नहीं कर सकता के बारे में सोचा नहीं है ·, धन्यवाद! :) और हमेशा चुनौती के दौरान बदलते चश्मे के लिए अच्छा है, आह ..

— केविन क्रूज़सेन

5

रेटिना , 74 73 बाइट्स

मुझे ऐसा लगता है कि मैंने बहुत लंबे समय में उत्तर पोस्ट नहीं किया है। खैर, मैं यहाँ हूँ। इसके अलावा, रेटिना बहुत बदल गया है, और मुझे लगता है कि मैं इसे अब चूसता हूं।

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

o|r
$&¶
_$

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

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

m`^r

इसे ऑनलाइन आज़माएं!

— mbomb007
स्रोत

1

वाह, क्या एक पागल लग रही भाषा। मुझें यह पसंद है!

— गामागेम

इसमें

— व्हॉट्सएप को

2

मुझे पसंद है कैसे [or]मतलब है oया rबजाय [या ]। मेरा सिर दुखता है।

— nedla2004

@dzaima यह प्रश्न निर्दिष्ट नहीं करता है कि अनुगामी व्हाट्सएप की आवश्यकता है। एक टिप्पणी पूछी गई, लेकिन कोई जवाब नहीं दिया गया।

— mbomb007

@ nedla2004 जो वास्तव में मुझे एक बाइट को बचाने के लिए नोटिस करने में मदद करता है। धन्यवाद।

— mbomb007

5

रेटिना , 21 बाइट्स

r

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

इसे ऑनलाइन आज़माएं! स्पष्टीकरण:

एस हटाएं r।

L$`.
$.+*$&

मूल इनपुट की लंबाई के लिए दोहराए गए प्रत्येक अक्षर को अपनी लाइन पर सूचीबद्ध करें।

\bee

eeप्रत्येक दो लाइन पर पहले दो एस को एक स्थान से बदलें ।

— नील
स्रोत

यह नियमों को तोड़ता है: "भरने के प्रत्येक पक्ष पर

— व्हाट्सएप पैडिंग

@NieDzejkob की अनदेखी के लिए क्षमा करें, अब ठीक किया जाना चाहिए।

— नील

FYI करें अनुगामी व्हाट्सएप आवश्यकता को उठाया।

— जैकटोज़ Jack

@ नील आपको ठीक करना चाहिए &: पी

— एएससीआईआई-केवल

5

C (gcc) , 135 113 109 104 बाइट्स

सहेजा ~~बाईस~~ सत्ताईस बाइट्स करने के लिए धन्यवाद NieDzejkob ।
छत के लिए धन्यवाद चार बाइट्स बचाता है ।

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

इसे ऑनलाइन आज़माएं!

— जोनाथन फ्रेच
स्रोत

कुछ बाइट्स शेव करें-D$=putchar

131 बाइट्स यदि आप नियमों के अनुसार एक अनुगामी न्यूलाइन जोड़ते हैं।

— 13

127 बाइट्स यदि आप e=oलूप के लिए पहले की स्थिति को स्थानांतरित करते हैं और फिर दूसरे को हटा दें।

— NieDzejkob

118 बाइट्स यदि आप कुकी चुनते हैं और पात्रों को ध्यान से भरते हैं।

— 14

113 बाइट्स

— NieDzejkob

4

जावास्क्रिप्ट ईएस 6, 103 बाइट्स

103 बाइट्स की जगह:

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

इसे ऑनलाइन आज़माएं!

विभाजन और नक्शा 116 बाइट्स का उपयोग करना:

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

इसे ऑनलाइन आज़माएं!

— fənɛtɪk
स्रोत

1

जेएस, अच्छा! आपने मुझे याद दिलाया कि मैं आउटपुट के अंत में लाइन रिटर्न नहीं होने के बारे में एक नियम जोड़ने जा रहा था, मैंने इसे जोड़ा है। उसके लिए माफ़ करना!

— गामागेम

3

बस अंतिम न्यूलाइन को हटाकर 12 बाइट्स हैं

— fɛnɪt Jank

पर्याप्त प्रतिक्रिया थी कि मैंने अनुगामी न्यूलाइन नियम को हटा दिया। अपनी प्रविष्टि को अद्यतन करने के लिए स्वतंत्र महसूस करें।

— गामागेम

3

आप एक बाइट को उपयोग ${"|".repeat(s>1?s-2:0)}करने के बजाय, उसके और उसके व्हाट्सएप के साथ एक टेम्पलेट स्ट्रिंग का उपयोग करके बचा सकते हैं " "+"|".repeat(s>1?s-2:0)।

— इस्माईल मिगुएल

यदि आप पहले विभाजन में स्ट्रिंग के लिए बैकटिक्स का उपयोग करते हैं, तो आप इसके चारों ओर कोष्ठक हटा सकते हैं।

— स्कीइला

4

पर्ल 5 `-p` , 47 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— Xcali
स्रोत

यह नियमों को तोड़ता है: "भरने के प्रत्येक पक्ष पर

— व्हाट्सएप पैडिंग

कुछ रूपांतरों के साथ tio.run/##K0gtyjH9/...

— Nahuel Fouilleul

4

पायथन 3 , 77 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— Rɪᴋᴇʀ
स्रोत

चालाक! मैंने आउटपुट को व्हाट्सएप को फिलिंग के लिए नहीं प्रिंट करने का इरादा किया (यह बहुत ही ओरिओ आस्की है), इसलिए मैंने उसके अनुसार नियमों को संपादित किया है। उसके लिए माफ़ करना! और मुझे हमेशा एक अजगर जवाब पसंद है :)

— GammaGames

@JonathanFrech माइग्रेशन टिप्पणियों को हटाने के साथ-साथ उस दृष्टिकोण को अमान्य कर दिया गया था। मैं कल और अधिक गोल्फिंग पर काम करूँगा।

— R

आप +" \n"एक बाइट को बचाने के लिए स्थान को हटा सकते हैं ।

— केविन क्रूज़सेन

@ केविनक्रूजसेन मैं कर सकता हूं? इनपुट प्रोग्राम कहता है कि पूरी कुकी इनपुट की तरह चौड़ी होनी चाहिए।

— R

2

मैंने व्याख्या की कि इसका अर्थ यह है कि अनुगामी स्थान वैसा ही है (नेत्रहीन) जैसा कि कोई स्थान नहीं है। यह आस्की कला चुनौतियों के जवाब की सुंदरता है। यदि वे सही दिखते हैं तो वे सही हैं :-)

— ElPedro

4

गणितज्ञ, 111 91 बाइट्स

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

यह ऑनलाइन की कोशिश करो!

मीशा के संपादन की बदौलत इसे छोटा कर दिया गया ।

मेरा मूल कोड:

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

यह कोड बहुत फैंसी नहीं है, लेकिन यह बहुत महंगा लगता है कि तार से दूर और फिर वापस या कुछ और चतुर करने के लिए।

विशेष रूप से, केवल 3-4 आदेशों के साथ जिनका नाम स्ट्रिंग है, मेरे मूल दृष्टिकोण को दूर करने की कोशिश करके बाइट्स को बिल्कुल भी नहीं बचा सकता है। उदाहरण के लिए, निम्नलिखित 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"})&

— निशान।
स्रोत

1

कुछ सुधार: StringRepeatहो सकता है Tableके बाद से <>एक स्ट्रिंग बाद में सूची में परिवर्तित कर देंगे; Ifअनावश्यक के बाद से हम ले reशाखा केवल जब nकम से कम 2 है, nजब हम इसका उपयोग करते हैं तो हम केवल परिभाषित करके कोष्ठकों पर बचत कर सकते हैं । इसे ऑनलाइन आज़माएं!

— मिशा लावरोव

@MishaLavrov Ifइसलिए जोड़ा गया क्योंकि StringRepeat"पुनः" के मामले में एक त्रुटि होगी; यह आपको 0 बार एक स्ट्रिंग दोहराने की अनुमति नहीं देता है। Tableऐसी कोई सीमा नहीं है, इसलिए यह एक बड़ी बचत है!

— मार्क एस।

4

पर्ल 6 , 37 बाइट्स

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

इसे ऑनलाइन आज़माएं!

अनाम कोड ब्लॉक जो एक स्ट्रिंग लेता है और oकुकी के rरूप में और क्रीम के रूप में oreo को प्रिंट करता है ।

व्याख्या:

{                                   }   # 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

— मजाक कर रहा है
स्रोत

मुझे नहीं पता था कि oइसका इस्तेमाल किया जा सकता है ∘। बहुत अच्छी तरह से गोल्फ।

— प्रिमो

4

जावा 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

उपरोक्त समाधान एक प्रतिस्थापन का उपयोग करता है। इनपुट के वर्णों के बजाय निम्नलिखित नक्शे:

जावा 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 बाइट @ @ नील को धन्यवाद ।

इसे ऑनलाइन आज़माएं।

व्याख्या:

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"

— केविन क्रूज़सेन
स्रोत

1

क्या आप उपयोग कर सकते हैं ~c&1?

— नील

@ नील मैं वास्तव में, धन्यवाद कर सकता हूं।

— केविन क्रूज़सेन

यह अमान्य है: "भरने के प्रत्येक पक्ष पर

— व्हाट्सएप पैडिंग

@NieDzejkob फिक्स्ड .. हमेशा चुनौती के दौरान बदलते चश्मे के लिए अच्छा है, आह ..

— केविन क्रूज़सेन

@ केविनक्रूजसेन अब नहीं: पी

— एएससीआईआई-केवल

4

PHP ,100 99 93 बाइट्स

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

इसे ऑनलाइन आज़माएं!

ओह। PHP का waaaay_too_long फ़ंक्शन नाम फिर से हड़ताल करता है!

आउटपुट:

$php oreo.php oreo
XXXX
 oo
XXXX

$php oreo.php o
X

$php oreo.php rere
 oo
 oo

$ php oreo.php oreoorererereoo
XXXXXXXXXXXXXXX
 ooooooooooooo
XXXXXXXXXXXXXXX
XXXXXXXXXXXXXXX
 ooooooooooooo
 ooooooooooooo
 ooooooooooooo
 ooooooooooooo
XXXXXXXXXXXXXXX
XXXXXXXXXXXXXXX

— 640KB
स्रोत

अमान्य, क्रीम लाइनों को एक अनुगामी स्थान चाहिए

— ASCII-only

अनुगामी स्थान निश्चित किया। धन्यवाद!

— 640KB

1

अरे लड़का, PHP! इसके अलावा किसी भी अनुगामी व्हाट्सएप अब वैकल्पिक है, वहाँ काफी लोग थे जो बताते हैं कि चूंकि यह आस्की को प्रिंट कर रहा है इसलिए इसे वास्तव में आवश्यक नहीं होना चाहिए।

— गामागेम

4

PHP , 96 87 85 बाइट्स

@Gwaugh -9 बाइट्स
के लिए धन्यवाद @manatwork -2 बाइट्स के लिए धन्यवाद

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

इसे ऑनलाइन आज़माएं!

इसे ऑनलाइन आज़माएं! (87 बाइट्स)

इसे ऑनलाइन आज़माएं (मूल 97 बाइट सबमिशन)!

और एक पुनरावर्ती कार्य

PHP , 135 बाइट्स

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

इसे ऑनलाइन आज़माएं! (पुनरावर्ती)

— फ्रांसिस्को हैन
स्रोत

1

हमारे दो सबमिशन में से सर्वश्रेष्ठ को मिलाकर मैं इसे 87 बाइट्स टीआईओ में लाने में सक्षम था । क्या आप सहयोगी प्रस्तुति के रूप में इसके साथ जाने के लिए खेल होंगे? :)

— 640KB

1

मुझे लगता है कि हम कमांड short_tag_open का उपयोग करके 1 और बाइट निकाल सकते हैं, और इसके बजाय <?=हम उपयोग कर सकते हैं <?, या मैं गलत है?

— फ्रांसिस्को हैन

1

2 स्ट्रिंग प्रक्षेप के साथ छोटे अक्षर: ' '.$r(o,$l-2)."␤"→ " {$r(o,$l-2)}␤"।

— मैनटवर्क

धन्यवाद @manatwork कभी-कभी मैं भूल गया php vars का मूल्यांकन एक स्ट्रिंग में किया जाता है यदि पूरे स्ट्रिंग को ""istead''

— फ्रांसिस्को हैन

1

यह 3 बाइट्स का उपयोग करके छोटा हो सकता है $argn: इसे ऑनलाइन आज़माएं!

— Night2

4

जावास्क्रिप्ट, 72 65 64 बाइट्स

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

इसे ऑनलाइन आज़माएं

— झबरा
स्रोत

4

पॉवरशेल, owers१ ६ ९ 66 बाइट्स

-2 बाइट्स धन्यवाद @Veskah

-3 बाइट्स धन्यवाद @AdmBorkBork

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

कम गोल्फ परीक्षण स्क्रिप्ट:

$f = {

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

}

@(

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

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

आउटपुट:

True
True
True
True
True

— Mazzy
स्रोत

1

ऐसा लगता है कि आपको $args

— 23

1

की लंबाई [string[]]एक है [int[]]खेल है ... [int[]]है [int]यदि सरणी केवल एक ही तत्व शामिल है। महान! धन्यवाद!

— माज़ी

1

ओपी ने चुनौती को अपडेट किया ताकि आपको अब और रिक्त स्थान की आवश्यकता न हो। इसका मतलब यह है कि आपके बजाय -3 बाइट्स के लिए rहो सकता है " "+'%'*($l-2)।

— AdmBorkBork

3

चारकोल , 19 बाइट्स

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

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

Ｆθ

इनपुट स्ट्रिंग के पात्रों के माध्यम से लूप।

≡ι

प्रत्येक वर्ण पर स्विच करें।

o⟦⭆θ#⟧

यदि यह oतत्कालीन इनपुट स्ट्रिंग #को अपनी लाइन पर s के साथ प्रतिस्थापित करता है, तो प्रिंट करें ।

e«→Ｐ⁻Ｌθ²↙

यदि यह एक eदाईं ओर है, तो -s की एक लाइन प्रिंट करें जो इनपुट स्ट्रिंग की लंबाई से दो कम है, फिर नीचे जाएं और बाएं।

— नील
स्रोत

3

बैश, 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"

— हरा
स्रोत

क्या आप हमें कुछ नमूना उपयोग दिखा सकते हैं? मैं आपके फ़ंक्शन द्वारा 2 मापदंडों की अपेक्षा करके थोड़ा भ्रमित हूं।

— मैनटवर्क

आप इसे एक स्क्रिप्ट में लिखते हैं test.sh। उसके बाद, आप के रूप में इस कमांड लाइन से test.sh फोन: bash test.sh oreoorererereoo। fको वर्ण $2 $1संख्या को दोहराने की आवश्यकता है

— Green

उफ़। मैं पूरी तरह से गलत समझा समारोह एफ। कुछ और मामूली बदलाव किए जा सकते हैं: इसे ऑनलाइन आज़माएं!

— मैनटवर्क

1

75 बाइट्स।

— डेनिस

1

60 बाइट्स

— नहुएल फौलीउल

3

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 71 बाइट्स

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

इसे ऑनलाइन आज़माएं!

से कुछ विचारों को उधार लिया सुनिश्चित करने के लिए अज्ञानता के जवाब के अवतार ।

-6 बाइट्स @ASCIIOnly को धन्यवाद!

समग्र अवधारणा इन नियमों के बाद इनपुट वर्णों पर एक स्ट्रिंग कुल गणना करने के लिए है:

यदि एक rका सामना करना पड़ा है, तो इंडेंटेशन के लिए एक एकल स्थान चरित्र जोड़ें । हमें पता है कि अगला चरित्र एक होगाe ।
यदि a oया ae का सामना करना पड़ा है, तो वर्तमान वर्ण को एक विशिष्ट संख्या को दोहराकर एक स्ट्रिंग को उत्पन्न करें और इसे एक नई पंक्ति या कुछ पैडिंग और एक नई पंक्ति में प्रस्तुत करें।
बार-बार दोहराने की संख्या इनपुट स्ट्रिंग की लंबाई से निर्धारित होती है और क्या वर्तमान लाइन इंडेंट है।
PadLeftसमारोह दोहराई जाने वाली चरित्र स्ट्रिंग उत्पन्न करने के लिए प्रयोग किया जाता है।

परिणाम इन सभी तारों का संघटन है।

— दाना
स्रोत

1

71

— ASCII- केवल

@ASCIIOnly - धन्यवाद :)

— दाना

> भरने के प्रत्येक पक्ष पर व्हाट्सएप पैडिंग आवश्यक है

— एएससीआईआई-केवल

1

85?

— एएससीआईआई-केवल

मैंने यह नहीं देखा कि :) यद्यपि, पोस्ट किए गए उत्तरों की समीक्षा में 1/2 के बारे में गलत तरीके से किया है। हालांकि अच्छी पकड़!

— दाना

3

पायथ , 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 " "

यहाँ यह कोशिश करो! यह एक लूप का उपयोग करता है।

पायथ, 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

यहाँ यह कोशिश करो! यह एक स्ट्रिंग प्रतिस्थापन का उपयोग करता है।

मुझे वास्तव में अजगर पसंद है (यह वही है जो मैंने अपनी मूल परीक्षण स्क्रिप्ट में लिखा है), इसलिए मैंने सोचा कि मैं :) के लिए एक अजगर प्रवेश करूंगा

— GammaGames
स्रोत

1

क्या यह 37 बाइट्स नहीं है? मैंने सोचा कि पायथ डिफ़ॉल्ट रूप से ASCII का उपयोग करता है, जैसे कि मैं सही ढंग से याद करूं तो पायथन की तरह इसका कोडपेज। तो भले ही अपने कोड 33 वर्ण, है दोनों █और ░तीन बाइट्स प्रत्येक रहे हैं। या मुझसे यहां कुछ छूट रहा है?

— केविन क्रूज़सेन

अच्छी कॉल, मुझे महसूस नहीं हुआ कि (मैं tio.run पर काम करने के लिए अजगर नहीं मिल सकता, इसलिए मैंने हरोकू पेज पर लंबाई काउंटर का उपयोग किया)। लूप के लिए मैं सिर्फ चरित्र को बदल सकता था N, यहां तक कि कुछ बाइट्स भी बचा सकता था!

— गामागेम्स

सोचा ऐसा ही कुछ हुआ है। :) मेरे पास एक बार 05AB1E उत्तर के साथ एक ही मुद्दा था जो मेरे कोड पृष्ठ के बाहर वर्णों का उपयोग कर रहा था। दुर्भाग्य से टीआईओ सबसे गोल्फ भाषाओं के लिए चार्ट और बाइट्स को प्रदर्शित करता है। जावा या पायथन टीआईओ के लिए सही ढंग से राज्य होगा 33 chars, 37 bytes, लेकिन टीआईओ पर गोल्फ भाषाओं में नहीं। लेकिन आपके समाधान में सिर्फ उन पात्रों को बदलना वास्तव में समस्या को ठीक करता है, इसलिए यह यहाँ एक बड़ी बात नहीं है।

— केविन क्रूज़सेन

@KevinCruijssen रुको, 05AB1E एक वास्तविक SBCS का उपयोग नहीं करता है?

— ASCII- केवल

1

यदि आप रुचि रखते हैं, तो यह मेरे लिए TIO पर सहजता से काम करता है ।

— 16

3

रूबी , 62 60 बाइट्स

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

इसे ऑनलाइन आज़माएं!

भरने के लिए Oकुकी का उपयोग करता है *।

-1 धन्यवाद @manatwork एक मूर्खतापूर्ण गलती की ओर इशारा करता है और दूसरा -1 व्हाट्सएप के बारे में नियमों में छूट के कारण।

— किरिल एल।
स्रोत

कोई .gsubपैरामीटर के लिए कोष्ठक की जरूरत है ।

— मैनटवर्क

2

सी # (.NET कोर) , 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;};

इसे ऑनलाइन आज़माएं!

— डेस्ट्रोइगो
स्रोत

2

क्लोजर , 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)))))

मैं महंगा संस्करण में प्रिंटआउट में अच्छे पात्रों का उपयोग नहीं कर रहा हूं क्योंकि वे महंगे हैं। मुद्रित होने के लिए एक स्ट्रिंग देता है।

इसे ऑनलाइन आज़माएं!

स्पष्टीकरण के लिए नीचे देखें।

पूर्व 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

— कैरिजेनिकेट
स्रोत

2

डार्ट , 120 106 107 बाइट्स

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

इसे ऑनलाइन आज़माएं!

+1 बाइट: व्हाट्सएप के पीछे जोड़ा गया

— एलकान
स्रोत

यह अमान्य है: "भरने के प्रत्येक पक्ष पर व्हाट्सएप पैडिंग आवश्यक है"

— NieDzejkob

ओह, फिर कोई बात नहीं, मैं इसे जल्द ही ठीक कर दूंगा। जानकारी के लिए धन्यवाद, मैंने इसे याद किया

— एलकैन

2

पायथन 2 , 77 76 72 बाइट्स

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

इसे ऑनलाइन आज़माएं!

कुकी का बाहरी हिस्सा 'ओ' है और फिलिंग 'आर' है।

— एलपेड्रो
स्रोत

68 बाइट्स । हालांकि मुझे संदेह है कि क्या आप वास्तव में अनुगामी स्थानों को छोड़ सकते हैं, कल्पना कहती है " भरने के प्रत्येक पक्ष पर व्हाट्सएप पैडिंग आवश्यक है" ...

— आउटगोल्फ़र

साभार @EriktheOutgolfer सोचा एक मेमना छोटा होगा! इस मामले में अनुमान नहीं। भरने पर अनिवार्य अनुगामी स्थान के बारे में आवश्यकता को याद किया था। वास्तव में इस बिंदु को एक अस्सी कला चुनौती के साथ नहीं देखा जा सकता है, लेकिन अगर ओपी को इसकी आवश्यकता है, तो मुझे लगता है कि मेरा उत्तर वैसे भी अमान्य है।

— एलपेड्रो

अब सही किया ...

— एलपेड्रो

इसे 76 में वापस क्यों लाया जाए? बस के +' 'बाद डाल दिया (l-2)। साथ ही आपके पास एक टाइपो *' 'होना चाहिए +' '।

— आउटगोल्फर

यही मैंने अपने वर्तमान समाधान के साथ किया। कल (बाद में आज) अपने संकेतों पर करीब से नज़र डालेंगे। यहां देर हो चुकी है और मैं पूरे दिन बर्फ की बौछार कर रहा हूं ताकि गोल्फ के लिए बहुत थकान हो। सुझावों के लिए धन्यवाद हालांकि :)

— एलपेड्रो

2

x86-64 मशीन कोड (लिनक्स), 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 फ़ंक्शन पॉइंटर को आरएसआई में इनपुट स्ट्रिंग में ले जाता है और आरडी में पॉइंटर पर शुरू होने वाले आउटपुट का निर्माण करता है (ये रजिस्टर लिनक्स पर सी फ़ंक्शन से पहले दो तर्कों को पारित करने के लिए उपयोग किए जाते हैं)। सुविधा के लिए, मैंने इसके लिए एक C ++ रैपर लिखा है जो अच्छा इनपुट सैनिटाइजेशन करता है और आउटपुट प्रिंट करता है। वह कोड यहां स्थित हो सकता है । यह मूल nasm सिंटैक्स असेंबली को भी दिखाता है जो मैंने इस फ़ंक्शन के लिए लिखा था (साथ ही गैर-गोल्फ संस्करण जिसे मैंने पहले काम किया था)।

ध्यान देने वाली कुछ बातें यह है कि यह कोड किसी भी कैली सेव किए गए रजिस्टरों का सम्मान नहीं करता है, जिसका अर्थ है कि इस फ़ंक्शन को कॉल करने के बाद थोड़ी देर के लिए चलने पर सी ++ कोड दुर्घटनाग्रस्त हो जाएगा। मेरी मशीन पर यह नहीं है, लेकिन यह आश्चर्यजनक है। मैं आउटपुट स्ट्रिंग को सीमांकित करने के लिए एक नल बाइट भी नहीं जोड़ता हूं, और इसके बजाय आउटपुट स्ट्रिंग के लिए आवंटित स्थान पूर्व बाइट्स से भरा हुआ है। (यदि यह अनुमति नहीं है तो मैं 3 बाइट्स की लागत पर शून्य टर्मिनेटर जोड़ सकता हूं)।

इस कोड के लिए तर्क अनिवार्य रूप से स्ट्रिंग की लंबाई की गिनती कर रहा है, फिर इनपुट स्ट्रिंग में देखे गए प्रत्येक 'ओ' और 'आर' वर्णों के लिए इस लंबाई की एक पंक्ति का निर्माण कर रहा है, और फिर किसी भी 'ई' वर्ण के लिए देखा गया है, पहले की जगह और अंतरिक्ष वर्णों के साथ पिछली पंक्ति के अंतिम अक्षर।

मुझे C ++ और nasm स्रोत कोड के मिश्रण को संकलित करने और चलाने के लिए कहीं भी ऑनलाइन नहीं मिल सकता है, इसलिए मैं इसे काम करने के लिए कुछ छोटे आवरण कोड लिख सकता हूं। अन्यथा आप इसे उस लिंक के साथ संकलित करने और चलाने में सक्षम होना चाहिए जो मैंने कमांड के साथ दिया था:

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

मैं gcc द्वारा स्वीकार्य कुछ के लिए विधानसभा को प्रारूपित करने में सक्षम था, इसलिए इसे ऑनलाइन आज़माएं!

— डेवी
स्रोत

1

ओह माय, अब यह एक प्रविष्टि है!

— गामागेम

Oreoorererereoo

Oreoorererereoo

नियम

उदाहरण

जेली , 16 14 13 बाइट्स

कैसे?

पेपे , 364 बाइट्स

Ungolfed

कैनवस , 19 18 17 बाइट्स

जाप -R , 16 15 बाइट्स

वैकल्पिक

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 95 बाइट्स

एग्रीगेट, 108 बाइट्स का उपयोग करके वैकल्पिक

आर , 106 बाइट्स

आर , 118 बाइट्स

05AB1E , 18 17 16 बाइट्स

रेटिना , 74 73 बाइट्स

रेटिना , 21 बाइट्स

C (gcc) , 135 113 109 104 बाइट्स

जावास्क्रिप्ट ईएस 6, 103 बाइट्स

103 बाइट्स की जगह:

विभाजन और नक्शा 116 बाइट्स का उपयोग करना:

पर्ल 5 -p , 47 बाइट्स

पायथन 3 , 77 बाइट्स

गणितज्ञ, 111 91 बाइट्स

पर्ल 6 , 37 बाइट्स

व्याख्या:

जावा 11, 110 बाइट्स

जावा 11, 113 112 बाइट्स

PHP ,100 99 93 बाइट्स

PHP , 96 87 85 बाइट्स

PHP , 135 बाइट्स

जावास्क्रिप्ट, 72 65 64 बाइट्स

पॉवरशेल, owers१ ६ ९ 66 बाइट्स

चारकोल , 19 बाइट्स

बैश, 87 बाइट्स

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 71 बाइट्स

पायथ , 28 बाइट्स

पायथ, 30 बाइट्स

रूबी , 62 60 बाइट्स

सी # (.NET कोर) , 143 बाइट्स

क्लोजर , 137 बाइट्स

डार्ट , 120 106 107 बाइट्स

पायथन 2 , 77 76 72 बाइट्स

x86-64 मशीन कोड (लिनक्स), 97 बाइट्स

जाप `-R` , 16 15 बाइट्स

पर्ल 5 `-p` , 47 बाइट्स