यह रॉकेट साइंस नहीं है

59

एक प्रोग्राम या फ़ंक्शन लिखें जो एकल-पंक्ति स्ट्रिंग में लेता है। आप यह मान सकते हैं कि इसमें केवल मुद्रण योग्य ASCII शामिल है । जैसे ASCII कला रॉकेट का एक स्ट्रिंग प्रिंट या वापस करना

  |
 /_\
 |E|
 |a|
 |r|
 |t|
 |h|
 |_|
/___\
 VvV

धड़ पर ऊपर से नीचे तक लिखे गए इनपुट स्ट्रिंग के साथ। इस मामले में इनपुट था Earth। रॉकेट की ऊँचाई (लपटों सहित) हमेशा स्ट्रिंग की लंबाई पाँच से अधिक होती है।

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

और ज्यादा उदाहरण:

[empty string]

  |
 /_\
 |_|
/___\
 VvV

a

  |
 /_\
 |a|
 |_|
/___\
 VvV

|0

  |
 /_\
 |||
 |0|
 |_|
/___\
 VvV

\/\

  |
 /_\
 |\|
 |/|
 |\|
 |_|
/___\
 VvV

 _ _ [note trailing space]

  |
 /_\
 | |
 |_|
 | |
 |_|
 | |
 |_|
/___\
 VvV

    [4 spaces]

  |
 /_\
 | |
 | |
 | |
 | |
 |_|
/___\
 VvV

SPACEY

  |
 /_\
 |S|
 |P|
 |A|
 |C|
 |E|
 |Y|
 |_|
/___\
 VvV

लीडरबोर्ड

कोड स्निपेट दिखाएं

code-golf  string  ascii-art 
— केल्विन के शौक
स्रोत
1
संबंधित । ऐसे और भी लोग हो सकते हैं जो इतने करीब हैं कि यह एक डुबकी के रूप में गिना जाता है।
— पीटर टेलर
2
@ सिफा रिक्त स्थान हाँ। अन्य व्हाट्सएप को नहीं। जैसा कि जुड़ा विकी इंगित करता है।
— केल्विन के
6
डी'ओह, मैंने शीर्षक देखा और मस्तिष्क की सर्जरी के बारे में कुछ उम्मीद की। :(
17
और अगर आकाश में नीचे बिंदु आप आज अंतरिक्ष में नहीं जाएंगे।
— एस्ट्रोडन
4
"इसने केर्बल स्पेस प्रोग्राम में काम किया ..."
— मैजिक ऑक्टोपस

जवाबों:

55

एक्सेल VBA, 142 179 175 160 155 बाइट्स

निर्देश:

एक्सेल की वर्कशीट को सेट करें जहाँ सेल A1 आउटपुट के रूप में इनपुट और कॉलम C है। कॉलम C में केंद्र में पाठ संरेखण सेट करें । निम्नलिखित कोड को तत्काल विंडो में लिखें और चलाएँ:

[C1]="|":[C2]="/_\":T=[A1]&"_":For i=1To Len(T):Cells(i+2,3)="|"&Mid(T,i,1)&"|":Next:Cells(i+2,3)="/__\":Cells(i+3,3)="VvV":[C:C].HorizontalAlignment=-4108

कोड को अनफ़ाल्ट किया गया:

Sub R()
    [C1] = "|"
    [C2] = "/_\"
    T = [A1]&"_"

    For i = 1 To Len(T)
        Cells(i + 2, 3) = "|" & Mid(T, i, 1) & "|"
    Next

    Cells(i + 2, 3) = "/__\"
    Cells(i + 3, 3) = "VvV"
    [C:C].HorizontalAlignment = -4108   'Set the text alignment in column C to center
End Sub

आउटपुट:

यहाँ छवि विवरण दर्ज करें

नोट: फ़ॉन्ट और रंग केवल एक व्यक्तिगत पसंद है।

Edc65 के सुझाव के कारण 15 बाइट बच गईं। धन्यवाद।

टेलरसकोट के सुझाव के कारण 5 बाइट बच गईं। धन्यवाद।

— अनास्तासिया-रोमानोवा ova
स्रोत
"_"T को जोड़कर 15 बाइट्स बचाएं । इस तरह[C1]="|":[C2]="/_\":T=[A1]&" ":For i=1To Len(T):Cells(i+2,3)="|"&Mid(T,i,1)&"|":Next:Cells(i+2,3)="/__\":Cells(i+4,3)="VvV":Columns(3).HorizontalAlignment=-4108
— edc65
(ठीक है, मेरे कोड में कोई त्रुटि है और इसे संपादित करने के लिए बहुत देर हो चुकी है। लेकिन आपको इसका विचार है)
— edc65
@ edc65 मुझे यह विचार नहीं आया। आपका कोड मेरे साथ बिल्कुल वैसा ही है, इसलिए मुझे 15 बाइट बचाने के लिए क्या संपादित करना चाहिए?
— अनस्तासिया-रोमानोवा
1
154 बाइट्स:[C:C].HorizontalAlignment=-4108:[C1]="|":[C2]="/_\":T=[A1]&"_":For i=1To Len(T):Cells(i+2,3)="|"&Mid(T,i,1)&"|":Next:Cells(i+2,3)="/__\":Cells(i+3,3)="VvV
— टेलर स्कॉट
1
या आप इसे 151 बाइट्स तक ले जा सकते हैं, केंद्र के पहलू को ध्यान में रखते हुए[C:C].HorizontalAlignment=3:[C1]="|":[C2]="/_\":T=[A1]&"_":For i=1To Len(T):Cells(i+2,3)="|"&Mid(T,i,1)&"|":Next:Cells(i+2,3)="/___\":Cells(i+3,3)="VvV
— टेलर स्कॉट
30

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

"  |\n /_\\".say;" |$_|".say for slurp.chomp.comb;" |_|\n/___\\\n VvV".say;
— bb94
स्रोत
101
slurp.chomp.comb... पर्ल अजीब है।
— मेगो
14
Slurp !!! Chomp !!! COMB !! यहाँ पर्ल राक्षस आता है!
— stommestack
ध्यान दें कि एक फ़ंक्शन और कॉन्कैनेटेशन का उपयोग करके आप बहुत कटौती कर सकते हैं: {[~] " |\n /_\\\n",|(" |$_|\n"for $_.comb)," |_|\n/___\\\n VvV"}65 बाइट्स
— user0721090601
लेकिन आप JS के: tio.run/…
— user0721090601
22

जावास्क्रिप्ट (ईएस 6), 54

सरल

x=>`  |
 /_\\
 |${[...x+'_'].join`|
 |`}|
/___\\
 VvV`

परीक्षा

f=x=>`  |
 /_\\
 |${[...x+'_'].join`|
 |`}|
/___\\
 VvV`

function update() {
  O.textContent=f(I.value)
}

update()
<input id=I value='hello' oninput='update()'><pre id=O></pre>
स्निपेट का विस्तार करें

— edc65
स्रोत
16

दरअसल, 40 बाइट्स

"/___\
 VvV",'_o"|
 |"j'|o" |"+"  |
 /_\

हाँ, उन नए समाचारों को माना जाता है।

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

व्याख्या:

नई रूपरेखाओं को \nआसान प्रारूपण द्वारा दर्शाया गया है

"/___\\n VvV",'_o"|\n |"j'|o" |"+"  |\n /_\
"/___\\n VvV"                                create the bottom of the rocket
             ,'_o                            get input, append a "_" (for the last section before the jets)
                 "|\n |"j                    insert "|\n |" between every pair of characters
                         '|o                 append "|"
                            " |"+            prepend " |"
                                 "  |\n /_\  create the nose cone
— मेगो
स्रोत
12
आपका कार्यक्रम विस्फोट वाले रॉकेट के समान निराशाजनक रूप से दिखता है।
— corsiKa
15

सी, 83 , 82 बाइट्स

F(char*c){for(puts("  |\n /_\\");*c;printf(" |%c|\n",*c++));puts(" |_|\n/___\\\n VvV");}

टेस्ट मुख्य:

int main() {
  F("");
  F("a");
  F("|0");
  F("\\/\\");
  F(" _ _ ");
  F("    ");
  F("SPACEY");
}
— स्टेफानो सैनफिलिपो
स्रोत
7
मैंने अपना स्वयं का सी समाधान काम किया, और यह बिल्कुल आपके, चरित्र के लिए चरित्र बन गया। मुझ से +1।
— कोडी
फोन पर और एसएसएच के लिए बहुत आलसी, इसलिए यह अप्रयुक्त है, लेकिन काम करना चाहिए। 2 बाइट्स बचाता है (यदि मैं सही ढंग से गिना जाता हूं):F(char*c){for(puts(" |\n /_\\");*c;printf(" |%c|\n",*c++),puts(" |_|\n/___\\\n VvV");}
— अल्ग्मेयर
@algmyr वास्तव में एक बाइट बचाता है, क्योंकि अंतिम putsको केवल एक बार निष्पादित किया जाना है, प्रत्येक के बाद नहीं printf। लेकिन हाँ, 1 बाइट बच गई, याय!
— स्टेफानो सैनफिलिपो
सही। मुझे लगता है कि जब मैं सो रहा होगा गोल्फ पर मैं दोषी हूँ।
— अल्जाइमर
क्या यह 88 बाइट्स नहीं है?
— गैस्ट्रोपनर
10

पायथन 2, 93 66 62 61 बाइट्स

एक FGITW। शायद भारी गोल्फ हो सकता है। सुझाव का स्वागत करते हैं।

संपादित करें: 27 बाइट्स मीगो के लिए धन्यवाद। TheBikingViking के लिए 4 बाइट्स धन्यवाद। User3030010 के लिए 1 बाइट धन्यवाद।

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

lambda x:r"""  |
 /_\
 |%s|
/___\
 VvV"""%"|\n |".join(x+"_")
— Sherlock9
स्रोत
9

PHP, 73 72 69 62 बाइट्स

  |
 /_\
 |<?=join('|
 |',str_split($argv[1]._))?>|
/___\
 VvV

स्क्रिप्ट को कॉल करने पर स्ट्रिंग को कमांड लाइन से पहले तर्क के रूप में प्रिंट करने के लिए ले जाता है।

सुधार:

  1. पहले तर्क में एक वास्तविक LF newline के साथ \ n को बदलकर एक बाइट को सहेजा गया join।
  2. इनपुट के लिए एकल अंडरस्कोर के साथ रॉकेट बेस को जोड़कर तीन और बाइट्स को बचाया
  3. इस्माइल मिगुएल का धन्यवाद : इस तथ्य का लाभ उठाकर 7 और बाइट्स सहेजे गए कि PHP "हाइपरटेक्स्ट प्रीप्रोसेसर" हुआ करता था, इसलिए आप जितना चाहें उतना टेक्स्ट आउटपुट कर सकते हैं और बीच में कहीं कोड शुरू कर सकते हैं।

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

यह मजेदार था! :-)

नमूना कॉल:

php rocket.php ""
php rocket.php EARTH
php rocket.php "This is a very long rocket"
— YetiCGN
स्रोत
— इस्माइल मिगुएल
अच्छा गोल्फ! मैं उस संभावना के बारे में पूरी तरह भूल गया। धन्यवाद!
— यतिसीजीएन
आपका स्वागत है। इसके अलावा, मैंने पहली पंक्ति में 2 बाइट्स बचाए। आपके पास उस पर 2 अतिरिक्त अनुगामी स्थान थे। वह कुछ ऐसा था जिसकी मुझे उम्मीद नहीं थी, मुझे कहना होगा।
— इस्माईल मिगुएल
1
मुझे पता है, यह वास्तव में गूंगा था, लेकिन वास्तव में बहुत मुश्किल था। मैंने केवल एक बार ध्यान दिया था कि मैं आपके उन्नत संस्करण पर 64 बाइट के साथ आया था और यह पता लगाना था कि क्यों।
— यतिसीजीएन २ '
8

brainfuck , 179 बाइट्स

>-[-[-<]>>+<]>-..[->+>++++<<]>>----.<<++++++++++.>.>>>+[-[--<]>>--]<.[-<+<++>>]<<+.---.<,[<<<.>.>.>.<.>,]<<<.[->>>+<<<]>.>.>>+++.<<.>.>>.<...---.<.<<.>>>------.[-<<<+<+>>>>]<<<.<.

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

— लीक नयन
स्रोत
@ user00001 यह वाक्यांश दुनिया भर में सभी मुसलमानों द्वारा उपयोग किया जाता है, न कि केवल आतंकवादी। क्या आप वास्तव में सोचते हैं कि आतंकवादी सभी मुसलमानों का प्रतिनिधित्व करते हैं?
— लीक नून
1
@ user00001 हालांकि, यह वाक्यांश "अल्लाहु अकबर" अभी भी मुस्लिम समुदायों में उपयोग में है। प्रतिक्रिया संभवतः उस स्वर पर निर्भर करती है जिसमें यह चिल्लाया जाता है। यदि यह सामान्य स्वर में चिल्लाया जाता था, तो लोग शायद यह मान लेंगे कि किसी की दुर्घटना हुई थी और दर्द में चिल्ला रहा था। हम में से एक झुंड शायद शोर की ओर देखने लगेगा कि क्या हम मदद कर सकते हैं। // यदि यह कठोर लहजे में था, और आप ढीली जैकेट पहने हुए थे, और आप कुछ संदिग्ध कर रहे थे, तो आप ...
— लीक नून
8

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

-2 बाइट्स @ValueInk
-5 बाइट्स द्वारा यह मानकर कि इनपुट में कोई नईलाइन नहीं है, जैसा कि @manworkwork द्वारा सुझाया गया है। उदाहरण के लिए echo -n, उदाहरण के लिए न्यूलाइन-कम इनपुट प्रदान किया जा सकता है echo -n hey | ruby rocket.rb।

puts'  |
 /_\
 |'+gets.chars*'|
 |'+'|
 |_|
/___\
 VvV'
पुराना संस्करण, इनपुट में न्यूलाइन मानता है:

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

puts'  |
 /_\
 |'+gets.chop.chars*'|
 |'+'|
 |_|
/___\
 VvV'
— daniero
स्रोत
प्रश्न के स्वामी की टिप्पणी के अनुसार इनपुट में न्यूलाइन वर्ण नहीं होगा, इसलिए आप हटा सकते हैं .chop।
— मैनटवर्क
@manatwork नीट, धन्यवाद :)
— daniero
आप एकल उद्धरण तार का उपयोग करते हैं, तो आप दोनों अपने को बदलने के लिए सक्षम होना चाहिए \\ के साथ \ । (एकल उद्धृत स्ट्रिंग्स में, वर्णों को छोड़कर नहीं किया जाता है, इसके लिए \'।
— मूल्य इंक
7

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

f s="  |\n /_\\\n |"++((:"|\n |")=<<s)++"_|\n/___\\\n VvV"
— XNOR
स्रोत
7

रेटिना , 44 37 बाइट्स

मार्टिन एंडर को 7 बाइट्स धन्यवाद।

$
_
.
¶ |$0|
$
¶/___\¶ VvV
^
  |¶ /_\

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

— लीक नयन
स्रोत
नीचे एक पंक्ति में एक अंतर छोड़ता है :( "स्पेस, अंतिम सीमा के लिए"
— xQbert
@xQbert मेरे लिए काम करता है, क्या आप एक TIO लिंक संलग्न कर सकते हैं?
— लीक नून
अजीब है, यह अब मेरे लिए ठीक काम करता है ... आह मेरी त्रुटि अंत में एक नई रेखा थी।
— xQbert
रेटिना एकमात्र ऐसी भाषा है जो मुझे पता है कि एक अनुगामी न्यूलाइन जोड़ने से कार्यक्रम पूरी तरह से बदल सकता है।
— caird coinheringaahing
6

जेली , 37 36 बाइट्स

;”_⁾ |;ЀŒB;“/___\“ VvV”“  |“ /_\”;Y

मौजूदा प्रविष्टि के रूप में समान स्कोर, लेकिन एक मजेदार नई सुविधा का उपयोग करता है - ŒB, का वेक्टराइज़्ड संस्करण ŒḄ, जिसे उछाल के रूप में जाना जाता है। शेख़ी एक सूची के माध्यम से अपने अंत तक जा रही है और फिर वापस x[:-1]+x[::-1]जैसे:bounce("codegolf") == "codegolflogedoc" :।

डेनिस के लिए -1 बाइट धन्यवाद (उछाल के वेक्टर संस्करण का उपयोग करें)

कैसे?

;”_⁾ |;ЀŒB;“/___\“ VvV”“  |“ /_\”;Y - argument: a string, S
                        “  |“ /_\”   - the top of the rocket ["  |", " /_\"] 
;”_                                  - concatenate to make S=S+"_"
   ⁾ |;                              - concatenate to make c=" |"+c
       Ѐ                            - map over right argument i.e. for c in S
         ŒB                          - bounce! With vectorisation c[:-1]+c[::-1]
                                       e.g. " |B" -> " |B| "
           ;                         - concatenate with
            “/___\“ VvV”             - the bottom of the rocket ["/___\", " VvV"]
                                  ;  - concatenate the top with everything else
                                   Y - join with line feeds

यह TryItOnline पर परीक्षण करें

— जोनाथन एलन
स्रोत
2
ŒBके लिए छोटा है ŒḄ€।
— डेनिस
5

वी , 41, 39 बाइट्स

ys$_òlé
òÎá|I |
Hr/$r\YO  |GpX2á_o VvV

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

ध्यान दें कि किसी कारण के लिए, ऑनलाइन दुभाषिया अप्रत्याशित परिणाम पैदा कर रहा था, इसलिए मैंने ऑनलाइन दुभाषिया के लिए एक डिबग संस्करण को धक्का दिया जो बहुत धीमा चलता है। यह अब सही परिणाम प्रस्तुत करना चाहिए।

चूँकि इस कार्यक्रम में अनपेक्षित वर्ण हैं, यहाँ एक हेक्सडंप है:

0000000: 7973 245f f26c e90a f2ce e17c 4920 7c0a  ys$_.l.....|I |.
0000010: 4872 2f24 725c 594f 2020 7c1b 4770 5832  Hr/$r\YO  |.GpX2
0000020: e15f 6f20 5676 56                        ._o VvV
— DJMcMayhem
स्रोत
यह अच्छा है, लेकिन यह "स्पेस, अंतिम सीमा" में रिक्त स्थान को संभाल नहीं पाता है।
— 20:15 बजे xQbert
5

आर, 163 बाइट्स

v=c();l="\n";for(i in 1:nchar(a<-scan(,"")))v=c(v,paste0(" |",strsplit(a,"")[[1]][i],"|",l,collapse=""));cat("  |",l," /_\\",l,v," |_|",l,"/___\\",l," VvV",sep="")

अघोषित:

v=c()     #Empty vector
l="\n"    #Line break

for(i in 1:nchar(a<-scan(,"")))                  #For the number of character of the input
    v=c(v, paste0(" |",strsplit(a,"")[[1]][i],"|","\n",collapse=""))
    #This part cut the input into its letters, paste each letter between `|`'s, 
    #and a line break

cat("  |",l," /_\\",l,v," |_|",l,"/___\\",l," VvV",sep="") #Puts everything in the STDOUT,
                                                           #with spaces where needed

मैं वास्तव में इस तथ्य को पसंद नहीं करता कि मुझे अंतिम पंक्ति में कुछ स्थान डालना था, लेकिन हे!

— फ़्रेडरिक
स्रोत
5

PowerShell v2 +, 59 55 51 बाइट्स

"  |
 /_\"
$args|% t*y|%{" |$_|"}
" |_|
/___\
 VvV"

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

Write-Outputनिष्पादन के अंत में डिफ़ॉल्ट को प्रत्येक तत्व के बीच एक नई रेखा से चिपकाने के लिए दुरुपयोग करता है , क्योंकि ये सभी पाइपलाइन पर केवल शाब्दिक तार हैं। एकमात्र "मुश्किल" बिट $argsरॉकेट के शरीर को प्राप्त करने के लिए चार-सरणी के रूप में इनपुट के प्रत्येक तत्व के माध्यम से एक लूप है ।

कुछ बाइट्स को बचाने के लिए कॉनरॉल्स डब्ल्यू द्वारा इंगित शाब्दिक नईलाइन्स का उपयोग करता है।
-4 अधिक बाइट्स Veskah के लिए धन्यवाद।

— AdmBorkBork
स्रोत
आप 3 को बचाने के लिए स्ट्रिंग में वास्तविक न्यूलाइन्स डाल सकते हैं, शेल और \r
— आइस को
— Veskah
4

पॉवरशेल, 70 बाइट्स

"  |`n /_\`n$(([char[]]$a|%{" |$_|"})-join("`n"))`n |_|`n/___\`n VvV

इनपुट के लिए $ a सेट करें।

यदि इसे एक चर के अलावा अन्य इनपुट लेना पड़ता है तो उसे इसमें डाला जा सकता है:

"Hello World"|%{"  |`n /_\`n$(([char[]]$_|%{" |$_|"})-join("`n"))`n |_|`n/___\`n VvV "}

उदाहरण:

  |
 /_\
 |H|
 |e|
 |l|
 |l|
 |o|
 | |
 |W|
 |o|
 |r|
 |l|
 |d|
 |_|
/___\
 VvV
— Chirishman
स्रोत
4

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

"  |
 /_\\
 |"<>(#<>"|
 |"&/@#)<>"_|
/___\\
 VvV"&

अनाम फ़ंक्शन। इनपुट के रूप में वर्णों की एक सूची लेता है और आउटपुट के रूप में एक स्ट्रिंग लौटाता है।

— LegionMammal978
स्रोत
4

PHP, 108 100 88 बाइट्स

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

-12 बाइट्स यतिसीजीएन को धन्यवाद

echo'  | 
 /_\\
';foreach(str_split($argv[1])as$c){echo" |$c|
";}echo' |_|
/___\\
 VvV';

बहुत सीधा

Ideone

— Sefa
स्रोत
1
आप foreach(str_split($a)as$c)लूप के लिए दूसरे के बजाय का उपयोग करके बहुत सारे बाइट्स बचा सकते हैं । यदि आप दोहरे उद्धरण चिह्नों का उपयोग करते हैं, तो आप $ c को सीधे स्ट्रिंग में रख सकते हैं:echo" |$c| ....";
— बिजनेस कैट
@BusinessCat सच है, धन्यवाद कि कोष्ठक की व्याख्या नहीं की जा रही सरणी शैली के साथ दोहरे उद्धरण काम नहीं कर रहे थे
— Sefa
नियमित अभिव्यक्ति के बारे में क्या? function f($a){echo' |.␤ /_\\␤',preg_replace('/./',' |$0|␤',$a),' |_|␤/___\\␤ VvV';}
— manatwork
1
यहां तक ​​कि इसके चारों ओर एक समारोह क्यों रखा? जगह $aके साथ $argv[1]और कमांड लाइन से चल रहा है यह बहुत कम कर देता है।
— यतिसीजीएन २
@ मैनटवर्क यह शायद एक वैध विकल्प है, लेकिन चूंकि मैं इसे नहीं समझता और यह मेरी जैसी भावना में नहीं है, इसलिए मैं इसे पोस्ट करने दूंगा।
— सेफा
4

सी #, 106 97 80 74 बाइट्स

s=>$@"  |
 /_\
 |{string.Join("|\n |",s.ToCharArray())}|
 |_|
/___\
 VvV";

मेरे पास उपरोक्त प्रयास करने के लिए C # 6 नहीं है, लेकिन मुझे विश्वास है कि यह काम करेगा

केविन क्रूज़सेन की बदौलत 7 बाइट्स बचाए

17 बाइट्स बचाने के लिए मुझे सही दिशा में इंगित करने के लिए मैनटवर्क का धन्यवाद

दूध की बदौलत 6 बाइट्स बचाए

— TheLethalCoder
स्रोत
+1। Btw, अनुगामी using System.Linq;s=>$(" |\n /_\\\n{string.Join("",s.Select(c=>" |"+c+"|\n"))} |_|\n/___\\\n VvV");
— व्हाट्सएप
1
@KevinCruijssen मैं अपने पिछले उत्तर के लिए आपकी टिप्पणियों के बाद इसे अपडेट करने की प्रक्रिया में था :) धन्यवाद मदद के लिए
— TheLethalCoder
आप अंदर एक एकल स्ट्रिंग शाब्दिक का उपयोग करके कुछ वर्णों को बचा सकते हैं Select: " |"+c+"|\n"→ इसके c+"|\n |"बाद {}से `` `को स्थानांतरित करने के साथ ।
— मैनटवर्क 13
@manatwork मुझे लगता है कि काम करने के लिए प्रतीत नहीं हो सकता
— TheLethalCoder
1
नई लाइन 1 बाइट की तुलना में \n2 बाइट्स है। तो आप नई लाइनों के साथ उन्हें बदलकर 5 और बाइट्स बचाएंगे। हां, यदि आप विजुअल स्टूडियो का उपयोग कर रहे हैं तो डिफ़ॉल्ट रूप से नई लाइनें 2 बाइट्स होंगी, लेकिन आप हेक्स एडिटर में सोर्स फाइल खोल सकते हैं (विजुअल स्टूडियो में एक है) और कैरिज रिटर्न कैरेक्टर को हटा दें। आउटपुट अभी भी वही होगा।
— दूध
4

सी,  131  , 121 बाइट्स

#define P printf
main(){char s[99],*p=s;gets(s);P("  |\n /_\\\n");while(*p)P(" |%c|\n",*p++);P(" |_|\n/___\\\n VvV\n");}
— RosLuP
स्रोत
आप p=sप्रारंभ में, और pअंदर का उपयोग करके तीन वर्णों को निकाल सकते हैं scanf:main(){char s[99],*p=s;scanf("%s",p);P(" |\n /_\\\n");while(*p)P(" |%c|\n",*p++);P(" |_|\n/___\\\n VvV\n");}
— Quentin
ठीक है .... मुझे नहीं पता कि "स्कैनफ़ ("% s ", & s)" के बजाय "स्कैनफ़ ("% s ", s)" सही परिणाम अंत में प्रिंट करें ... क्योंकि अंत में स्कैनफ़ नहीं मिलता है रिक्त स्थान मैं पसंद करता हूँ खतरे () ...
— RosLuP
2
कृपया अपने पदों के लिए बर्बरता न करें। धन्यवाद!
— 17
3

05AB1E , 50 47 43 37 बाइट्स

I'_J"  |
 /_\"svy" |ÿ|"}"/___\
 VvV"»

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

अदनान के लिए धन्यवाद 9 बाइट्स बचाए।

— Emigna
स्रोत
स्ट्रिंग भी 05AB1E: p में इस तरह से newlines स्वीकार कर सकते हैं ।
— अदनान
@ अदनान नाइस, धन्यवाद! किसी भी विचार कैसे खाली इनपुट के आसपास बेहतर पाने के लिए?
— एमिगा
मैं IðJकार्यक्रम की शुरुआत के साथ एक दृष्टिकोण के बारे में सोच रहा था , जिसमें धड़ का आधार भी शामिल है।
— अदनान
@ अदनान महान विचार। मैंने «बहुत किस्मत के बिना पहले भी यही कोशिश की थी। हालांकि यह बहुत बेहतर है।
— एमिगा
हटाने Uऔर बदलने के Xसाथ sएक बाइट भी बचाता है :)।
— अदनान
3

कोटलिन, 68 बाइट्स

{"""  |
 /_\${it.replace(Regex("."),"\n |\$0|")}
 |_|
/___\
 VvV"""}

बहुत सीधा। मल्टीलाइन स्ट्रिंग और रेगेक्स रिप्लेसमेंट का उपयोग करता है। यह (String)->Stringप्रकार के साथ एक लंबोदर है । परीक्षा:

fun main(args: Array<String>) {
    val function : (String)->String = {"""  |
 /_\${it.replace(Regex("."),"\n |\$0|")}
 |_|
/___\
 VvV"""}
    println(function(" _ _ "))
}
— JustACluelessNewbie
स्रोत
3

गेमा, 50 अक्षर

\A=  |\n\ /_\\\n
?=\ |?|\n
\Z=\ |_|\n/___\\\n\ VvV

नमूना रन:

bash-4.3$ echo -n gema | gema '\A=  |\n\ /_\\\n;?=\ |?|\n;\Z=\ |_|\n/___\\\n\ VvV'
  |
 /_\
 |g|
 |e|
 |m|
 |a|
 |_|
/___\
 VvV
— आदमी काम पर है
स्रोत
3
मुझे लगता है कि रॉकेट के आधार से पहले आप `| _ |` को याद कर रहे हैं
— TheLethalCoder
आउच। गूंगा चूक गया। धन्यवाद @TheLethalCoder।
— मैनटवर्क
1
+1 मुझे एक नई (मेरे लिए) (गैर-गोल्फिंग) भाषा से परिचित कराने के लिए।
— जॉर्डन
3

BASH 84 70

14 मैनटवर्क के लिए धन्यवाद

(cat&&echo _)|sed 's~.~ |&|\n~g;1s~^~  |\n /_\\\n~;$s~$~/___\\\n VvV~'

आधे से अधिक बाइट्स नाक, और इंजन को जोड़ने के लिए हैं।

— रिले
स्रोत
क्यों grep? (cat&&echo _)|sed 's~.~ |&|\n~g;1s~^~ |\n /_\\\n~;$s~$~/___\\\n VvV~'। असल में मैं उपयोग करने के लिए कोई कारण नहीं देखते हैं catऔर echoया तो। शुद्ध sedसमाधान में बदल जाएगा ।
— manatwork
साथ शुद्ध sed, आप किसी भी उत्पादन नहीं मिलता है, तो आप इनपुट की जरूरत नहीं है
— रिले
रवींद्र। तुम सही हो। क्षमा करें, मैं आवश्यकता के उस हिस्से को भूल गया।
— manatwork
@ मैनटवर्क मैं अपनी पहली कोशिश में इसके बारे में भी भूल गया।
— रिले
भविष्य के संदर्भ के लिए, <प्री> <कोड> टैग का उपयोग करने से बचें। भविष्य में कोड से पहले के 4 रिक्त स्थान का उपयोग करें, क्योंकि यह ऑटो-मार्केड स्वरूपण से बच जाता है। मैंने स्ट्राइकथ्रू के कारण मौजूदा प्रारूपण को बनाए रखा है, लेकिन आप इतिहास को संपादित करने के साथ-साथ इसे देखने के लिए उत्सुक लोगों को भी छोड़ सकते हैं।
— एडिसन क्रम्प
3

GolfScript, 61 51 बाइट्स

मेरा पहला कोड गोल्फ, मुझे उम्मीद है कि यह काफी अच्छा है।

"  |
 /_\\
"\1/.,{" |"\(\"|
"\}\*" |_|
/___\\
 VvV"

व्याख्या

"  |\n /_\\\n"   # Push the rocket's head
\                # Swap the head with the user's string
1/               # The string is converted into an array
.,               # Push array length
{" |"\           # Push the rocket's body and swap
(\               # Array's first element cut out
"|\n"\           # Push rocket's body and swap
}\*              # Repeat for array length times
" |_|\n/___\\\n VvV" # Push rocket's bottom

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

— FedeWar
स्रोत
3

विम, ४१ ३ ९ बाइट्स

यहाँ <End>वस्तुतः "एंड" कुंजी है।

i <End>_:s/./ |&|\r/g
/___\
 VvVggxo /_\

अनपेक्षित वस्तुएं:

i <End>_^O:s/./ |&|\r/g
/___\
 VvV^[ggxo /_\^[
— nmjcman101
स्रोत
3

GNU sed , 54 49 48 बाइट्स

यह इस साइट पर एक चुनौती का मेरा पहला जवाब था। समाधान सरल है, मुख्य रूप से मुद्रण, इसलिए मैंने यह सुनिश्चित करने में कुछ समय बिताया कि इसे अब और नहीं चलाया जा सकता है।

s:.:\n |&|:g
s::  |& /_\\&:
a\ |_|\n/___\\\n VvV

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

तेजी से आगे आधे साल बाद, मैंने स्क्रिप्ट को फिर से लिखा, अच्छे उपाय के लिए एक चाल का इस्तेमाल किया और इसे 1 बाइट से भी छोटा कर दिया। अब यह प्रगति है!

स्पष्टीकरण: प्रत्येक चरण में पैटर्न स्थान स्पष्टता के लिए उल्लेख किया गया है, इनपुट उदाहरण "गो"

s:.:\n |&|:g
   # turn each input char into a section of the rocket (\n |G|\n |O|)
s::  |& /_\\&:
   # 's::' is a trick; the search part is actually the one from the previous 's'
   #command, i.e. a char. Only the first char, '\n', the modifier 'g' is not
   #inherited. The replace part is the head of the rocket. (  |\n /_\\n |G|\n |O|)
a\ |_|\n/___\\\n VvV
   # append the tail of the rocket, plus implicit printing at the end

  |
 /_\
 |G|
 |O|
 |_|
/___\
 VvV
— seshoumara
स्रोत
3

लूआ, 83 , 92 बाइट्स

function f(x)return' |\n /_\\\n'..x:gsub('(.)',' |%1|\n')..' |_|\n/___\\\n VvV'end

print('  |\n /_\\\n'..(arg[1] and arg[1]:gsub('(.)',' |%1|\n') or '')..' |_|\n/___\\\n VvV')
— नोलन
स्रोत
यदि मैं आपके उत्तर में कोई इनपुट नहीं जोड़ता। यह काम नहीं करता।
— नोलन
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.