तरक्की करें!

12

यह मेरा दोस्त थॉमस है। वह आधा पेड़ है, आधा इमोटिकॉन है।

|    |
| :D |
|    |

वह अकेला है। चलो उसे कुछ दोस्त बनाते हैं!

इनपुट के रूप में एक पाठ आधारित इमोटिकॉन को देखते हुए (जैसे ಠ_ಠ, :P, >_>, नहीं 😀, 🤓, या 🐦), उत्पादन इसी treemote।

एक ट्रेमोटे की लंबाई यह है कि यह कितने वर्ण है (मूल रूप से स्ट्रिंग्स के लिए सबसे अधिक अंतर्निहित लंबाई कार्य)। तो ಠ_ಠलंबाई 3 है।

लंबाई के ट्रेमोट के लिए सिंटैक्स nनिम्नानुसार है:

|< 2+n spaces>| * ceil(n/2)
| <emote> | (note the spaces)
|< 2+n spaces>| * ceil(n/2)

तो लंबाई 3 के किसी भी प्रकार की तरह दिखेगा:

|     |
|     |
| ಠ_ಠ |
|     |
|     |

उसके पास ceil(n/2)दोनों तरफ अलग-अलग ट्रंक सेगमेंट हैं, जिनमें से प्रत्येक के 2 + nअंदर रिक्त स्थान है।

चुनौती: पाठ-आधारित इमोटिकॉन को देखते हुए, संबंधित treemote का उत्पादन करें।

अन्य नियम:

  • यह कोड-गोल्फ है , जिसका मतलब है कि मैं चाहता हूं कि आप शॉर्ट कोड लिखें।
  • मानक खामियों को दूर किया।
  • जब तक आपकी भाषा उन्हें संभाल नहीं पाती है, तब तक आपको गैर-एससीआई वर्णों का समर्थन करना चाहिए।

परीक्षण के मामलों:

^_^

|     |
|     |
| ^_^ |
|     |
|     |

\o/

|     |
|     |
| \o/ |
|     |
|     |


(✿◠‿◠)

|        |
|        |
|        |
| (✿◠‿◠) |
|        |
|        |
|        |


D:

|    |
| D: |
|    |


( ͡° ͜ʖ ͡°)


|             |
|             |
|             |
|             |
|             |
|             |
| ( ͡° ͜ʖ ͡°) |
|             |
|             |
|             |
|             |
|             |
|             |
code-golf  ascii-art 
— Rɪᴋᴇʀ
स्रोत
अनुगामी newlines की अनुमति है?
— आर। काप
हम मान लेते हैं कि 1-चार इमोटिकॉन्स मौजूद नहीं हैं?
— एडम
"पाठ-आधारित इमोटिकॉन" से क्या आपका मतलब आस्की इमोटिकॉन से है?
— डाउनगेट
@Downgoat नहीं। देखिए ಠ_ಠटेस्ट का मामला।
— R
6
शायद 3 के अलावा एक लंबाई के साथ एक परीक्षण मामला जोड़ सकते हैं ...
— SuperJedi224

जवाबों:

4

05AB1E , 27 25 बाइट्स

कोड:

g©Ìð×"|ÿ|
"®;îש„| ¹s¶®J

स्पष्टीकरण:

g                  # Push the length of the input string.
 ©                 # Copy that to the register.
  Ì                # Increment by 2.
   ð×              # Multiply by spaces.
     "|ÿ|\n"       # ÿ is used for interpolation and push the string "|spaces|\n".
                   #
 ®                 # Retrieve the value from the register.
  ;î               # Divide by 2 and round up.
    ×              # Multiply that by "|spaces|".
     ©             # Copy this into the register.
      „|           # Push the string "| ".
         Â         # Bifurcate, pushing the string and the string reversed.
          ¹s       # Push input and swap.
            ¶      # Push a newline character.
             ®J    # Retrieve the value from the register and join everything in the stack.
                   # Implicitly output this.

CP-1252 एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं! ।

— अदनान
स्रोत
इनपुट ( ͡° ͜ʖ ͡°)करने से मजेदार परिणाम मिलते हैं।
— शॉन वाइल्ड
@ शॉन गिल्ड हाँ, यह एक अजीब परीक्षा का मामला है, क्योंकि ( ͡° ͜ʖ ͡°)स्वयं 11 वर्ण लंबा है, लेकिन यह 8 वर्ण लंबा दिखता है ।
— अदनान १
4

पायथन 3.5, 76 75 73 बाइट्स:

( एक टिप के लिए ब्लू का धन्यवाद जिसने 2 बाइट्स बचाए! )

def i(n):q=len(n);z=('|'+' '*(2+q)+'|\n')*-(-q//2);print(z+'| '+n+' |\n'+z)

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

इसके अलावा, यहां एक नॉनकमेटिंग पायथन 2.7.5 संस्करण है क्योंकि यह 87 बाइट्स में अधिक लंबा है ।

def i(n):q=len(n.decode('utf-8'));z=('|'+' '*(2+q)+'|\n')*-(-q/2);print z+'| '+n+' |\n'+z

ऐसा इसलिए है क्योंकि पायथन 2 की डिफ़ॉल्ट एन्कोडिंग है ascii, और इसलिए, ಠ128 यूनिकोड बिंदु सीमा के बाहर के वर्ण जैसे कि 1 बाइट ( list('ಠ')पैदावार ['\xe0', '\xb2', '\xa0']) से अधिक है । केवल इसके लिए मैं जो सोच सकता था, वह यह था कि पहले इनपुट का उपयोग करके डीकोड किया जाए utf-8, और फिर इस utf-8डिकोडेड स्ट्रिंग के साथ आगे बढ़ें ।

इस पायथन 2 संस्करण ऑनलाइन की कोशिश करो! (Ideone)

— आर। कप
स्रोत
आप 2 बाइट्स के लिए चारों ओर (- (- q // 2)) पार्स से छुटकारा पा सकते हैं। मुझे लगता है कि आप पायथन 2.7 पर स्विच करके 2 और बाइट्स बचा सकते हैं। इसे दूसरे / // की आवश्यकता नहीं है, और प्रिंट स्टेटमेंट में केवल एक स्थान है।
— ब्लू
@ मुझे बताओ, तुम सही हो, मैं उन दूसरे जोड़े को हटा सकती हूं। हालांकि, मैं है दूसरे की जरूरत /में //ऐसा करने के लिए प्लस्तर लगाना विभाजन।
— आर। काप
जैसा मैं कह रहा था, अजगर में 2.7 पूर्णांक विभाजन 1 /
— ब्लू
@ ओह, मैंने मान लिया कि आप कह रहे हैं कि मुझे अजगर की आवश्यकता नहीं है। 3. ठीक है, उस स्थिति में, फिर मैं अजगर पर स्विच कर दूंगा। सुझावों के लिए धन्यवाद! :)
— आर। काप
@Blue यदि ऐसा है, तो आप पायथन 2 में फ्लोट डिवीजन कैसे करते हैं?
— आर। काप
3

डायलाग एपीएल , 37 34 33 बाइट्स

{↑'|'{⍺⍵⍺}¨b,(⊂⍵),b←' '/⍨⌈0.5×≢⍵}

क्रोम उपयोगकर्ता: फुटनोट देखें *

परीक्षण के मामलों

      f←{↑'|'{⍺⍵⍺}¨b,(⊂⍵),b←' '/⍨⌈0.5×≢⍵}

      f,'☺' ⍝ the , is necessary to create a 1 char string instead of a character scalar
|   |
| ☺ |
|   |
      f':D'
|    |
| :D |
|    |
      f'^_^'
|     |
|     |
| ^_^ |
|     |
|     |

* Chrome दो अक्षरों ≢⍵(U + 2262, U + 2375) को ≢⍵(U + 2261, U + 0338, U + 2375) के बजाय ̸≡⍵(U + 0338, U + 2262, U + 2375) के रूप में गलत बताता है , इसलिए यहाँ एक है Chrome के लिए प्रदर्शन संस्करण:{↑'|'{⍺⍵⍺}¨b,(⊂⍵),b←' '/⍨⌈0.5×̸̸≡⍵}

— एडम
स्रोत
1
+1 आपके कोड के भीतर इमोटिकॉन्स होने के लिए {¨} Valueb
— वैल्यू इंक
3
आह, {⍺⍵⍺}¨b"APL प्रोग्रामर अपने पांचवें कप कॉफी पर एक अंगूठे दे रहा है" इमोटिकॉन।
— लिन
2

वी, 60 57 बाइट्स

I| A |ByWo=ceil(len(""")/2.0)
 dF.d0kwviWr Yu@-pH@-P

दुर्भाग्य से, वी के पास गणितीय कार्यों के संदर्भ में कुछ भी नहीं है। डिवाइड और सीविल फंक्शंस ने बाइट काउंट को काफी बढ़ा दिया।

चूँकि इसमें बहुत बुरा निशानियों का समूह है, यहाँ एक प्रतिवर्ती हेक्सडंप है:

00000000: 497c 201b 4120 7c1b 4279 576f 123d 6365  I| .A |.ByWo.=ce
00000010: 696c 286c 656e 2822 1222 2229 2f32 2e30  il(len("."")/2.0
00000020: 290d 201b 6446 2e64 306b 7776 6957 7220  ). .dF.d0kwviWr 
00000030: 5975 402d 7048 402d 50                   Yu@-pH@-P

स्पष्टीकरण:

I| A |                                #Add surrounding bars
      B                               #Move back
       yW                             #Yank a word
         o                            #Open a new line
          <C-r>=                      #Evaluate

          <C-r>"                      #Insert the yanked text into our evaluation
ceil(len("      ")/2.0)<cr>           #Evaluate ceil(len(text)/2) and insert it

 dF.                                  #Append a space and delete backward to a (.)
                                      #By default, this will be in register "-
    d0                                #Delete this number into register a
      kw                              #Move up, and forward a word
        viWr                          #Replace the emoticon with spaces
             Yu                       #Yank this line, and undo 
                                      #(so we can get the emoticon back)
               @-p                    #Paste this text "- times.
                  H                   #Move to the beginning
                   @-P                #Paste this text "- times behind the cursor.
— जेम्स
स्रोत
गणित संचालक होते तो कितने बाइट होते?
— अदनान १
@ अदनान कहना मुश्किल है, क्योंकि मुझे नहीं पता कि वे वास्तव में क्या दिखेंगे। वैकल्पिक रूप से मैं लगभग 30 बाइट कहूँगा?
— जेम्स
2

विट्टी, 43 बाइट्स

IV2m3mz4m2m
3mV\D4m
V1+2/\[1m]
' || '
}}ZaO

स्पष्टीकरण:

IV2m3mz4m2m

I            Grab the length of the input string.
 V           Save that value to a global final variable.
  2m         Call the method at line index 2.
    3m       Call the method at line index 3.
      z      Push the entire input to the stack.
       4m    Call the method at line index 4.
         2m  Call the method at line index 2.

3mV\D4m

3m           Call the method at line index 3.
  V          Push the global variable to the stack.
   \D        Duplicate the top item on the stack that many times.
     4m      Call the method at line index 4.

V1+2/\[1m]

V            Push the global variable to the stack.
 1+          Add one to the top value.
             REASONING: We want ceil(V/2), and since repeat commands follow the floor value of repeats, we want ceil(V/2)+.5, so we add one to make this work right.
   2/        Divide by two.
     \[1m]   Call method 1 that top value of the stack times.

' || '

' || '       Push ' || ', the string, to the stack.

}}ZaO

}}           Push the bottom item of the stack to the top twice.
  Z          Output everything in the stack.
   aO        Output a newline.

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

ध्यान दें, TIO में बग के कारण, यूनिकोड वर्णों के साथ इनपुट काम नहीं करेगा। आपको इसके बजाय स्थानीय संस्करण का उपयोग करना होगा। धन्यवाद, @ डेनिस!

— एडिसन क्रम्प
स्रोत
1

रूबी, 57 बाइट्स

पूर्णांक विभाजन ट्रिक्स का उपयोग करता है और रूबी के putsकार्य में quirks का लाभ लेता है।

->e{s=e.size+1;puts k=[?|+' '*-~s+?|]*(s/2),"| #{e} |",k}
— मान स्याही
स्रोत
1

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

e=>(a=`| ${" ".repeat(n=e.length)} |
`.repeat(Math.ceil(n/2)))+`| ${e} |
${a}`
— कोनोर ओ ब्रायन
स्रोत
आप की जरूरत नहीं है f=, कि आप 2 बाइट्स बचाता है। eटेम्पलेट के अंदर और aबाहर जाकर 2 अन्य बाइट्स सहेजें । दोहराने में 2 जोड़ने के बजाय रिक्त स्थान डालकर एक और 2 बाइट्स बचाएं। 2 से विभाजित करने के लिए बिट शिफ्टिंग का उपयोग करके बाइट्स के एक और गुच्छा को बचाएं।
— नील
मुझे नहीं लगता कि यह काम करता है, यह सिर्फ दोहराने के स्रोत कोड मुद्रित करने के लिए कोशिश करता है
— Bálint
फिर से कोशिश करें, मैंने इसे @ Bálint
— Conor O'Brien
1

> <> , 103 बाइट्स

i:0(?\
}$&1[\~rl:::2%+*:2,
1-:?!\" "$
]{\  \~
?!\$}1-:
~&\
?!\l$:@-[l2)
~]\
}}\" || "
?!\ol
8.>]l?!;ao2

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

यह समाधान उस अवलोकन पर आधारित है जिसमें प्रत्येक रेखा शामिल है | <x> |, जहां <x>मध्य रेखा में पैटर्न है, और अन्य लाइनों में समान संख्या में रिक्त स्थान है।

nSTDIN से इनपुट (लंबाई ) को पढ़ने के बाद , प्रोग्राम n*(n+(n%2))रिक्त स्थान को धकेलता है। स्टैक को कई बार आधा घुमाया जाता है। इसके बाद, सभी लेकिन nवर्णों को एक नए स्टैक में खींचा जाता है, जिसमें स्टैक का एक स्टैक होता है, जिसमें या तो nरिक्त स्थान या पैटर्न ही होता है (मध्य स्टैक में)। आउटपुट स्टेप में, वर्तमान स्टैक की सामग्री मुद्रित की जाती है, |और उसके चारों ओर |।

— सोक
स्रोत
1

सी, 89 बाइट्स

f;main(int c,char**a){for(c=strlen(*++a)+1;f<(c|1);)printf("|%*s |\n",c,f++==c/2?*a:"");}

यकीन नहीं होता कि यह गैर-अस्सी इमोटिकॉन को संभाल लेगा ...।

— aragaer
स्रोत
क्या आप इसे गैर-अस्की इमोटिकॉन्स के साथ परीक्षण कर सकते हैं?
— R
कोशिश की गई और परिणाम अच्छा नहीं रहा - strlenपहले शून्य बाइट तक बाइट्स गिना जाता है और परिणामस्वरूप गैर-एससीआई इमोटिकॉन्स वे जितना व्यापक हैं, उससे अधिक व्यापक माना जाता है।
— आर्गेनर
1

PowerShell v3 +, 72 बाइट्स

param($a)$b=("| "+(" "*($l=$a.length))+" |`n")*($l+1-shr1);"$b| $a |";$b

इनपुट स्ट्रिंग लेता है $a। के $bरूप में (खाली पाइप समाप्त स्ट्रिंग ( $a.lengthबीच में रिक्त स्थान के साथ ) और एक अनुगामी newline) बार-बार (लंबाई + 1 स्थानांतरित सही एक बिट, यानी, दो और छत से विभाजित) बार। फिर $b, अपने स्वयं के पाइप के साथ इनपुट स्ट्रिंग की प्रतियां और $bफिर से फिर से प्रतियां की आउटपुट देता है ।

बिट-शिफ्ट -shrऑपरेटर के लिए v3 + की आवश्यकता होती है ।

उदाहरण

PS C:\Tools\Scripts\golfing> .\grow-a-treemote.ps1 '>:-|'
|      |
|      |
| >:-| |
|      |
|      |


PS C:\Tools\Scripts\golfing> .\grow-a-treemote.ps1 '>:`-('
|       |
|       |
|       |
| >:`-( |
|       |
|       |
|       |
— AdmBorkBork
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.