चारों तरफ सांप

Question

चुनौती

चुनौती सरल है: एक सांप प्रिंट करें ।
आपको सांप की लंबाई इनपुट के रूप में मिलेगी।
लंबाई 2 का एक साँप इस तरह दिखता है:

==(:)-

लंबाई 7 का एक साँप इस तरह दिखता है:

=======(:)-

दूसरे शब्दों में, एक सांप की लंबाई सिर से पहले कितने समान संकेत हैं ।

प्रयोग

मान लीजिए कि मैंने C ++ कार्यान्वयन किया और इसे संकलित किया ./getsnake।
मैं इसे ऐसे ही चला सकता था:

$ ./getsnake 10
==========(:)-

स्पष्टीकरण

• मानक खामियों को अस्वीकार कर दिया जाता है।
• आप किसी भी स्वीकार्य तरीके से इनपुट और आउटपुट प्राप्त कर सकते हैं।
• आप मान सकते हैं कि दिए गए सभी इनपुट सकारात्मक पूर्णांक हैं।
• आप एक नियमित कार्यक्रम के बजाय एक फ़ंक्शन लिख सकते हैं।

Comments

केवल आधे घंटे के लिए सैंडबॉक्स में एक चुनौती छोड़ना थोड़े बेकार है। आपको कुछ प्रतिक्रिया मिली, लेकिन आमतौर पर सैंडबॉक्स में इसे 24-72 घंटों के लिए छोड़ना सबसे अच्छा है। (इसके अलावा, आपको या तो "ऑरिजिंस" भाग को मांस देना चाहिए या इसे हटा देना चाहिए।)

— एल'एंडिया स्ट्रैटन

क्या कोई फ़ंक्शन पर्याप्त है या क्या आप एक पूर्ण कार्यक्रम चाहते हैं?

— बेट्सग जूल

@ फेबसेग फ़ंक्शन पर्याप्त है

— प्रारंभिक

मुझे डर है कि मेरे सभी Squiggly लैंप उत्तर आसानी से इस के लिए पोर्टेबल हैं।

— मैनटवर्क

नकारात्मक पूर्णांक सांप को स्वयं निगलने का कारण बनना चाहिए।

— गिटारपरिकर

Answer 1

हेक्सागोनी , 33 बाइट्स

जीतने वाला नहीं, लेकिन फिर भी मस्त। अधिक गोल्फ पाने में सक्षम हो सकता है।

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

golfed:

61}?.$)@$j;(3<./;.}l/.400;5\j;.'\

प्रारूपित:

    6 1 } ?
   . $ ) @ $
  j ; ( 3 < .
 / ; . } l / .
  4 0 0 ; 5 \
   j ; . ' \
    . . . .

रंगीन ( टिमवी के हेक्सागोनी कलरर का उपयोग करके बनाया गया )

स्पष्टीकरण:

लूप, "=" प्रिंट करें जब तक काउंटर 0 तक न पहुंच जाए।

    6 1 } ?
   . $ . . $
  . . ( . . .
 / . . } . . .
  . . . ; . .
   . . . ' .
    . . . .

प्रिंट करें "("

    . . . .
   . . . . .
  . . . . . .
 / ; . . . . .
  4 . . . . .
   j . . . .
    . . . .

प्रिंट ":"

    . . . .
   . . . . .
  . ; ( 3 < .
 . . . } l / .
  . . . . . .
   . . . . .
    . . . .

प्रिंट ")"

    . . . .
   . . . . .
  j . . . . .
 . . . . . . .
  . . . ; 5 \
   . . . . \
    . . . .

उपरोक्त मूल्य एक साधारण अजगर लिपि का उपयोग कर उत्पन्न किए गए थे। हालांकि, मैं "-" के लिए कमरे से बाहर भाग गया। इसलिए, मुझे अधिक उन्नत चालों का सहारा लेना पड़ा।

जब प्रोग्राम ")" प्रिंट करता है, तो सेल का मान 41 नहीं है, यह 1065 है। हेक्सागोनी सिर्फ छपाई करते समय मूल्य को नियंत्रित करता है। जैसा कि यह पता चला है, (1065 * 1000 + 4)% 256 = 44, 45 से बस एक दूर, ascii मान "-"। फिर, मैं सिर्फ वृद्धि करता हूं, प्रिंट करता हूं, और प्रिंट करने के बाद एक @ कहीं डाल देता हूं।

    . . . .
   . $ ) @ $
  j . . 3 . .
 / . . } . . .
  4 0 0 . 5 \
   . ; . . \
    . . . .

Comments

इसे कैसे एक प्रोग्रामिंग भाषा कहा जा सकता है जब .j4 /; है ... Print "(" ??? .j4 / का कौन सा भाग है? प्रिंट है और कौन सा भाग प्रिंट करने के लिए स्ट्रिंग है?

— फोगमिस्टर

@Fogmeister [भाग 1/2] हेक्सागोनी में, कोई भी वर्णमाला वर्ण वर्तमान स्मृति सेल के मान को उस वर्ण के ascii मान पर सेट करता है। "j" का ascii मान 106 है, इसीलिए यह मेमोरी सेट है। इसके अलावा, और संख्यात्मक चरित्र वर्तमान सेल के मूल्य को 10 से गुणा करते हैं, फिर खुद को इसमें जोड़ते हैं (यह शुरुआत में 61 की तरह संख्याओं के आसान निर्माण की अनुमति देता है।

— ब्लू

[भाग २/२] तो, j4 मेमोरी सेल को १०६४ पर सेट करता है। जब आईपी "/" तक पहुंचता है, तो यह "परावर्तित" होता है, जो वर्तमान मेमोरी सेल% 256 के अनुसार एससीआई वर्ण को प्रिंट करता है। 1064% 256 = 40, के लिए ascii मान "("। मुझे आशा है कि यह आपके प्रश्न का उत्तर देता है।

— ब्लू

धन्यवाद। हाँ, यह करता है। मुझे लगता है कि यह आपके मस्तिष्क के परीक्षण के तरीके के रूप में उपयोग करने के लिए एक भाषा का अधिक है। इसके बजाय कार्यक्रमों को लिखने का एक तरीका है? दिलचस्प।

— Fogmeister

@Fogmeister कई गूढ़ प्रोग्रामिंग भाषाएं हैं जो वास्तविक काम करने के लिए उपयोगी से अधिक मस्तिष्क घुमा अभ्यास हैं, हालांकि यदि आप पर्याप्त प्रयास करते हैं तो वे वास्तविक काम कर सकते हैं।

— 1

Answer 2

दालचीनी गोंद, 7 बाइट्स

0000000: 7043 dc95 6d4f ce                        pC..mO.

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

पुराने pसिंटैक्स के साथ 6 बाइट्स होंगे : /

व्याख्या

Decompresses p~=~(:)-, pमंच तो बस इनपुट पढ़ता है और =n बार दोहराता है ।

Comments

क्या आप इसके लिए भाषा की युक्ति से जुड़ सकते हैं?

— रॉबर्ट फ्रेजर

@RobertFraser मेरे पास वर्तमान में कोई औपचारिक विनिर्देश या कोई दस्तावेज नहीं है, लेकिन आप गीथहब रेपो में स्रोत की जांच कर सकते हैं: github.com/quartata/cinnamon-gum

— एक स्पैगेटो

Answer 3

ब्रायन और चक , 31 बाइट्स

,{-?>}-):(=?
#}<<.{?_<.<.<.<.<.

इनपुट बाइट मान के रूप में , इसलिए इनपुट !33 लंबाई का एक साँप देता है।

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

इसे बीते एक अर्सा हो गया है...

व्याख्या

एक त्वरित ब्रायन और चक प्राइमर:

• कार्यक्रम की पहली पंक्ति ब्रायन है, दूसरी चक है।
• ब्रायन और चक दो ब्रेनफक जैसे उदाहरण हैं। मुख्य पकड़ यह है कि चक का कार्यक्रम ब्रायन का टेप है और इसके विपरीत। टेप हेड / इंस्ट्रक्शन पॉइंटर्स प्रत्येक टेप के पहले सेल पर शुरू होते हैं और ब्रायन पर निष्पादन शुरू होता है।
• आदेशों के लिए, कुछ अंतर हैं। केवल ब्रायन ,(इनपुट) का उपयोग कर सकते हैं और केवल चक .(आउटपुट) का उपयोग कर सकते हैं । के अलावा <और >वहाँ हैं {और }जो अगले शून्य सेल तक टेप सिर को स्थानांतरित करते हैं (या {अगर रास्ते में कोई शून्य सेल नहीं है तो टेप के बाएं छोर के मामले में )। इसके बजाय [...], एकमात्र नियंत्रण प्रवाह है ?जो वर्तमान सेल के गैर-शून्य होने पर नियंत्रण को अन्य उदाहरण पर स्विच करता है। दूसरे सेल पर पहला निष्पादित निर्देश शर्त के बाद एक है। और अंत में, _सुविधा के लिए, नल-बाइट्स के लिए सिर्फ एक उपनाम है।

अब कोड। ब्रायन इसके साथ शुरू होता है:

,{-?

यह चक के पहले सेल में इनपुट को पढ़ता है, फिर टेप हेड को बाईं ओर ले जाता है {(अभी कुछ भी नहीं करता है) और -चक के नियंत्रण को बदलने से पहले इनपुट को घटाता है यदि मान अभी भी शून्य नहीं है। इससे मुख्य लूप शुरू होता है। चक तो इस बिट चलाता है:

}<<.{?

यह ब्रायन पर टेप हेड को बहुत अंत तक ले जाता है, दो कोशिकाओं को बाईं ओर ले जाता है =और टेप हेड से पहले बाईं ओर स्विच करता है और ब्रायन पर वापस नियंत्रण स्थापित करता है। यह है कि आम तौर पर B & C में लूप कैसे काम करते हैं।

एक बार इनपुट शून्य हो जाने के बाद, ?ब्रायन के टेप पर कुछ नहीं होगा। तब ब्रायन इस हिस्से को अंजाम देता है:

>}-):(=?

):(=नहीं, कोई-ऑप्स हैं, इसलिए वास्तविक कोड सिर्फ है >}-?। हम साथ शून्य सेल बंद के लिए कदम >, करने के लिए ऊपर ले जाने के _साथ }, यह घटती यह गैर शून्य और चक करने के लिए स्विच के साथ बनाने के लिए ?। तब चक पर अंतिम बिट चलाया जाता है:

<.<.<.<.<.

यह केवल चक के सामने पाँच वर्णों को मुद्रित करता है, अर्थात =(:)-। ध्यान दें कि हमें एक और प्रिंट करने की आवश्यकता है =क्योंकि मुख्य लूप केवल N-1इनपुट के लिए निष्पादित होता है N।

Comments

100k पर बधाई

— पागल

Answer 4

वी , 8 बाइट्स

Àé=A(:)-

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

V "लैटिन 1" एन्कोडिंग का उपयोग करता है।

स्पष्टीकरण:

À        "Arg1 times:
 é=      "Insert an '='
   A(:)- "Append the head

Comments

मैं 10 बाइट्स गिनता हूं

— ज़ेवी

@zwei मेरा संपादन देखें।

— जेम्स

समझ गया! वह बेहतर है।

— ज़ेवी

Answer 5

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

.+
$*=(:)-

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

यह एक साधारण रेगेक्स प्रतिस्थापन है।

यह मेल खाता है .+जो पूरे इनपुट से मेल खाता है, और फिर इसके साथ प्रतिस्थापन करता है $*=(;)-।

$*रेटिना में एक सुविधा अद्वितीय है: यह चरित्र-पुनरावृत्ति विशेष ऑपरेटर है।

उदाहरण के लिए, 5$*xबन जाएगा xxxxx।

इस मामले में कि पिछला तर्क अनुपस्थित है, पूरे मैच का उपयोग डिफ़ॉल्ट तर्क के रूप में किया जाता है।

Answer 6

पायथन, 21 बाइट्स

lambda n:"="*n+"(:)-"

Ideone यह!

Comments

आप 3 बाइट्स में कटौती कर सकते हैं:"="*input()+"(:)-"

— gowrath

@gowrath तब यह कुछ भी छपाई नहीं होगी

— लीक नून

यदि आप दुभाषिया नं में हैं तो यह इसका उत्पादन करेगा। Op ने कहा कि आप किसी भी तरह से आउटपुट प्राप्त कर सकते हैं।

— गौहर

@gowrath आप यह नहीं मान सकते कि हम REPL में हैं

— लीक नून

क्या यह कोड गोल्फिंग के लिए एक सामान्य नियम है? यहाँ नया :)

— gowrath

Answer 7

हास्केल, 25 बाइट्स

f n=('='<$[1..n])++"(:)-"

'='<$[1..n]के बराबर है replicate n '='।

Answer 8

जावा 8, 52 बाइट्स

n->new String(new char[n]).replace("\0","=")+"(:)-";

परीक्षण सूट। (संकलन> निष्पादन)

जमा करता है ।

पारंपरिक तरीके से, 61 54 53 बाइट्स

केविन क्रूज़सेन के लिए 7 बाइट्स धन्यवाद।

डोम बस्ती के लिए 1 बाइट धन्यवाद।

n->{String s="";for(;n-->0;)s+="=";return s+"(:)-";};

Comments

+1 ओह, और पारंपरिक एक के लिए: के for(int i=0;i<n;i++)लिए गोल्फ हो सकता है for(;n>0;n--), क्योंकि आपको किसी भी चीज के लिए इनपुट की आवश्यकता नहीं है, वैसे भी फॉर-लूप।

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

@ केविनक्रूजसेन धन्यवाद, संपादित

— लीक नून

आपके द्वारा प्रदान किए गए लिंक के माध्यम से परीक्षण करना ऐसा लगता है कि आप लूप के लिए बदल सकते हैं: for(;n-->0;)एक और बाइट को बचाने के लिए!

— डोम हेस्टिंग्स

@DomHastings ने धन्यवाद के साथ संपादित किया

— लीक नून

Answer 9

जेली , 9 बाइट्स

”=x;“(:)-

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

”=x;“(:)-
”=          '='
  x         repeat (argument) that many times
   ;        append
    “(:)-   "(:)-"

Answer 10

सी, 38

f(n){for(;n--;printf(n?"=":"=(:)-"));}

इसे आइडोन पर आज़माएं।

Comments

कम नहीं, लेकिन कूलर f(n){~-printf(n?"=":"=(:)-")||f(~-n);}:।

— orlp

f(n){for(;n;printf(n--?"=":"(:)-"));}1 के लिए।

— आउटगॉल्फ

@ E @Gʀɪᴋᴛʜᴇ - यह सिर का उत्पादन नहीं करता है।

— उल्लू का घोड़ा

@ लोकोडर वेल, सी मेरी प्राथमिक भाषा नहीं है ...

— एरिक आउट द आउटफ्लर

@ E @G golf और यही कारण है कि आपको बिना पढ़े गोल्फ सुझाव नहीं देने चाहिए (विशेषकर यदि यह आपको उत्तर में दिए गए लिंक से अपने सुझाव का परीक्षण करने में 5 सेकंड का समय लगता)।

— मार्टिन एंडर

Answer 11

05AB1E, 10 9 बाइट्स

'=×"ÿ(:)-

व्याख्या

'=         # push equal-sign
  ×        # repeat input nr of times
   "ÿ(:)-  # interpolate snake body with head as a string
           # implicitly display

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

1 बाइट ने अदनान को धन्यवाद दिया।

Comments

'=×"ÿ(:)-9 बाइट्स के लिए :)। यह स्ट्रिंग प्रक्षेप का उपयोग करता है।

— अदनान

@ अदनान: आआह, इसीलिए यही ÿकरता है :)

— एमिगा जूल

Answer 12

जावास्क्रिप्ट, 23 बाइट्स

n=>"=".repeat(n)+"(:)-"

Comments

मैं बस उस कोड को पोस्ट करने वाला था! मुझे इससे हराएं! एक

— उत्थान है

आज मैंने तीर के कार्यों के बारे में सीखा । धन्यवाद। नहीं पता था कि एक चीज़ थी

— bobkingof12vs

आप कार्य के उस उदाहरण को कैसे कहते हैं? मैंने बस कोशिश की n(3)और एक Uncaught ReferenceError: n is not definedत्रुटि प्राप्त की ...

— वैलेस्टेस्ट

@WallyWest - आज़माएंx=n=>"=".repeat(n)+"(:)-"; x(7);

— ईथेड

@eithedog तो क्या इसका उत्तर प्रारंभिक x=और 25 वर्णों में परिवर्तित नहीं होना चाहिए ?

— वैलीवेस्ट

Answer 13

सी #, 28 बाइट्स

n=>new string('=',n)+"(:)-";

Comments

हमेशा लांबा स्निपेट्स द्वारा रुचि रखते हैं। आप इसे कैसे चला सकते हैं?

— downrep_nation

@downrep_nation यह एक इंट में लेता है और स्वचालित रूप से स्ट्रिंग लौटाता है क्योंकि यह केवल एक बयान है

— TheLethalCoder

जवाब एक पूर्ण कार्यक्रम या एक फ़ंक्शन होना चाहिए, न कि केवल एक स्निपेट। इसलिए यह उत्तर अधूरा लगता है।

— raznagul

@raznagul यह एक अनाम फ़ंक्शन है इसलिए यह पूर्ण है

— TheLethalCoder

@ TheLethalCoder: शायद ऑनलाइन लिंक की कोशिश इसे समझने में मदद करेगी। ( csharppad.com )

— raznagul

Answer 14

पायथन , 24 बाइट्स।

print"="*input()+"(:)-"

input() उपयोगकर्ता से इनपुट मिलता है

*, जब तार और पूर्णांक पर उपयोग किया जाता है, तो एक नया स्ट्रिंग बनाता है, जो मूल की सम्मिलित प्रतियों से बना होता है। उदाहरण के लिए: "hello "*3आउटपुट hello hello hello।

गुणा करके =और input(), आपको =उपयोगकर्ता द्वारा निर्दिष्ट लंबाई की एक स्ट्रिंग मिलती है ।

+दो तारों का उपयोग करते हुए , इस मामले में, हमारे शरीर "=…="को हमारे सिर के साथ, "(:)-"साँप बनाने के लिए।

print परिणाम का उत्पादन करता है।

Answer 15

GolfScript, 11 10 बाइट्स

~"="*"(:)-"

इनपुट द्वारा "=" गुणा करें, और सिर जोड़ता है।

-1 लीक नन को धन्यवाद

Answer 16

गणितज्ञ, 21 20 बाइट्स

"="~Table~#<>"(:)-"&

अनाम फ़ंक्शन। इनपुट के रूप में एक नंबर n लेता है , और आउटपुट के रूप में लंबाई n का एक साँप देता है । लंबाई n की "="~Table~#एक सूची बनाता है , और सूची के तत्वों को संक्षिप्त करता है और परिणामी स्ट्रिंग को जोड़ता है।{"=", "=", ..., "="}<>"(:)-""(:)-"

Comments

एक और बाइट द्वारा गोल्फ:"="~Table~#<>"(:)-"&

— LLLAMnYP

Answer 17

आर, 32 27 बाइट्स

यह समाधान बहुत सीधा है, repफ़ंक्शन पहले तत्व ( "=") scan()बार दोहराता है , जो वास्तव में उपयोगकर्ता का इनपुट है।

a=scan();cat(rep("=",a),"(:)-")

संपादित करें :

cat(rep("=",scan()),"(:)-")

scan()सीधे जवाब का उपयोग करते हुए धीरे-धीरे कम जवाब दें ।

वैकल्पिक रूप से,

cat(rep("=",scan()),"(:)-",sep="")

एक गैर कटा हुआ सांप ( 34 बाइट्स ) के लिए

Comments

मैं कहूंगा कि sep=""यहाँ की जरूरत है, एक है कि रेलवे का चक्कर की तरह अन्यथा अपने साँप दिखता है: = = = (:)-।

— 11

यहां निर्मित सांप वास्तव में थोड़ा सा कीमा बनाया हुआ है, लेकिन ओपी की सहमति केवल यह बताती है कि सांप की लंबाई सिर से पहले समान संकेतों की संख्या है। मैं sepएक साइड नोट के रूप में फिर भी जोड़ दूंगा ;)

— Frédéric

Answer 18

बैच, 68 बाइट्स

@set h=(:)-
@for /l %%i in (1,1,%1)do @call set h==%%h%%
@echo %h%

Answer 19

सीजेएम, 13 11 बाइट्स

qi'=*"(:)-"

इसका परीक्षण यहां करें।

-2 बाइट्स क्वार्टाटा के लिए धन्यवाद

Comments

आप '=*इसके बजाय कर सकते हैं {'=}*।

— एक स्पेगेटो

Answer 20

पर्ल 6 ,  16 15  12 बाइट्स

{"{'='x$_}(:)-"}
{'='x$_~'(:)-'}
'='x*~'(:)-'

स्पष्टीकरण:

'=' x * # ｢=｣ string repeated by the only parameter ｢*｣
~        # concatenated with
'(:)-'   # the head

उपयोग:

# store it in the lexical namespace
my &snake = '='x*~'(:)-';

put snake 10;

# put ^5 .map: &snake;
put ^5 .map: '='x*~'(:)-';

==========(:)-
(:)- =(:)- ==(:)- ===(:)- ====(:)- =====(:)-

Answer 21

JAISBaL , 9 बाइट्स

t=*Qb(:)-

वर्बोस:

# \# enable verbose parsing #\
push1 =        \# push = onto the stack #\
mul            \# multiply the top two values of the stack #\
popout         \# pop the top value of a stack and print it #\
print4 (:)-    \# print (:)- #\

JAISBaL-0.0.7 के साथ परीक्षण किया गया (संकलित .jar को सिर्फ धक्का दिया गया था, लेकिन स्रोत थोड़ी देर के लिए बंद हो गया है)

Comments

#भाषा के नाम से पहले का उपयोग करें ताकि यह हर किसी की तरह दिखे।

— माइकल क्लेन

@ मिचेलकेलिन ठीक है

— सुकराती फीनिक्स

Answer 22

PowerShell v2 +, 19 बाइट्स

'='*$args[0]+'(:)-'

पूरा कार्यक्रम। इनपुट लेता है $args[0], शरीर के निर्माण के लिए स्ट्रिंग गुणन का उपयोग करता है, फिर सिर पर निपटने के लिए स्ट्रिंग संयोजन।

PS C:\Tools\Scripts\golfing> .\snakes-all-around.ps1 7
=======(:)-

PS C:\Tools\Scripts\golfing> .\snakes-all-around.ps1 77
=============================================================================(:)-

Comments

आप को "$("="*[int]$args[0])(:)-"

— कुदोस

Answer 23

सी, 46 45 43 बाइट्स

2 बाइट्स उल्लू के लिए धन्यवाद बचा लिया! बचाव के लिए 3 बाइट्स बचाया!

f(n){while(4-printf("=\0(:)-"+2*!n--));}

Ideone पर यह कोशिश करो!

Comments

रहस्यमय -->ऑपरेटर फिर से हमला करता है।

— लीक नन

@LeakyNun 46 बाइट्स संस्करण ऑपरेटर के पास नहीं था, जितना कि मुझे ऑपरेटर को याद था;)

— betseg

आप >0दो बाइट्स हटा सकते हैं और बचा सकते हैं ।

— उल्लू

थोड़ा छोटा:f(n){while(4-printf("=\0(:)-"+2*!n--));}

— rici

Answer 24

चेडर, 15 बाइट्स (नॉनकमेटिंग)

n->'='*n+'(:)-'

सीधा सा जवाब।

Answer 25

सेसोस , 11 बाइट्स

Hexdump:

0000000: aaaa5e a0f7b4 ed4cee 5d3b                         ..^....L.];

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

कोडांतरक:

set numin
add 61
fwd 1
get
jmp,sub 1,rwd 1,put,fwd 1,jnz
add 40,put
rwd 1,sub 3,put
fwd 1,add 1,put
add 4,put

Answer 26

के, 17 बाइट्स

{,[x#"=";"(:)-"]}

उदाहरण;

f:{,[x#"=";"(:)-"]}
-1(f'!10);          /print out the result of calling f where x is 0 1 2 3 4 5....
(:)-
=(:)-
==(:)-
===(:)-
====(:)-
=====(:)-
======(:)-
=======(:)-
========(:)-
=========(:)-

स्पष्टीकरण;

{}                 /function x is implicit and is an int
x#"="              /take (#) x of "=" --> so 3#"=" gives "==="
,[x#"=";"(:)-"]    /comma is a join that takes 2 args --> ,[x;y] gives the concatination of x and y --> "a","abc" is the same as ,["a";"abc"] and gives "aabc"

Comments

क्या है -1(... );?

— 16

एक बाइट को बचाएं:{(x#"="),"(:)-"}

— Adám

धन्यवाद एडम। -1 कंसोल को प्रिंट करता है। -1 "हैलो"; हेलो

— क्रोमोजोर्ज़

लेकिन मुद्रण नहीं है?

— Adám

हां लेकिन इसमें दोहरे उद्धरण शामिल हैं ... "==== (:) -" के बजाय; ===== (:) -

— Chromozorz

Answer 27

पर्ल, 16 + 1 ( -pध्वज) = 17 बाइट्स

$_="="x$_."(:)-"

जरूरत -pझंडा है, तो साथ चलाएँ:

perl -pe '$_="="x$_."(:)-"'

Answer 28

मिन्कोलांग 0.15 , 12 बाइट्स

"=(:)-"nD$O.

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

व्याख्या

"=(:)-"         Push this to the stack in reverse order - ["-",")",":","(","="]
       n        Take number from input
        D       Pop k and duplicate top of stack (the "=") k times
         $O.    Output whole stack as characters and stop.

Answer 29

Befunge-98, 24 बाइट्स

उपयोगकर्ता से संख्यात्मक इनपुट लेता है, फिर सांप को प्रिंट करता है।

'=&:00pk:00gk,"-):("4k,@

Answer 30

मतलाब / ऑक्टेव, 22 बाइट्स

@(n)[~(1:n)+61 '(:)-']

यह एक अनाम फ़ंक्शन है।

Ideone पर इसे आज़माएं ।

व्याख्या

मान लें n= 5।

1:nपंक्ति वेक्टर पैदा करता है [1 2 3 4 5]।

~(1:n)प्रत्येक प्रविष्टि को नकारता है, इसलिए यह देता है [0 0 0 0 0]।

...+6161प्रत्येक प्रविष्टि में जोड़ता है, इसलिए यह देता है [61 61 61 61 61]। 61चरित्र का ASCII मान है =।

[... '(:)-']इस स्ट्रिंग के साथ '(:)-'। यह स्वचालित रूप से संघनन [61 61 61 61 61]से '====='पहले स्ट्रिंग में परिवर्तित हो जाता है।