रॉक-एंड-रोल के संस्थापक पिता चक बेरी का आज निधन हो गया।

उनके प्रसिद्ध गीत " जॉनी बी। गोदे " के कोरस पर विचार करें :

Go, go
Go Johnny go, go
Go Johnny go, go
Go Johnny go, go
Go Johnny go, go
Johnny B. Goode

^{(ऐसे और भी तरीके हैं , जिन पर इसे रोक दिया गया है, लेकिन उपरोक्त चुनौती के उद्देश्यों के लिए काम करेंगे।)}

चुनौती

गैर-खाली, अक्षरों की निचली स्ट्रिंग az को देखते हुए, "जॉनी बी। गोयोड" के कोरस को सभी उदाहरणों के साथ Goया goइनपुट स्ट्रिंग के साथ बदल दिया गया, उसी तरह से कैपिटल किया गया।

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

उदाहरण के लिए , यदि इनपुट है codeतो आउटपुट बिल्कुल होना चाहिए
Code, code
Code Johnny code, code
Code Johnny code, code
Code Johnny code, code
Code Johnny code, code
Johnny B. Codeode
वैकल्पिक रूप से एक newline द्वारा पीछा किया।

ध्यान दें कि सभी शब्दों का पूंजीकरण मूल कोरस से मेल खाता है, और (लय की कमी के बावजूद) में Goऔर Goodeसाथ ही व्यक्ति Goऔर की जगह है go।

बाइट्स में सबसे छोटा कोड जीतता है।

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

"input"
output

"go"
Go, go
Go Johnny go, go
Go Johnny go, go
Go Johnny go, go
Go Johnny go, go
Johnny B. Goode

"code"
Code, code
Code Johnny code, code
Code Johnny code, code
Code Johnny code, code
Code Johnny code, code
Johnny B. Codeode

"a"
A, a
A Johnny a, a
A Johnny a, a
A Johnny a, a
A Johnny a, a
Johnny B. Aode

"johnny"
Johnny, johnny
Johnny Johnny johnny, johnny
Johnny Johnny johnny, johnny
Johnny Johnny johnny, johnny
Johnny Johnny johnny, johnny
Johnny B. Johnnyode

"fantastic"
Fantastic, fantastic
Fantastic Johnny fantastic, fantastic
Fantastic Johnny fantastic, fantastic
Fantastic Johnny fantastic, fantastic
Fantastic Johnny fantastic, fantastic
Johnny B. Fantasticode

code-golf string

— केल्विन के शौक
स्रोत

46

: परीक्षण मामलों के लिए चूके हुए अवसर an, c,cath

— नील

54

कोई कृपया एक गो संस्करण करें।

— jl6

2

प्रोग्राम को मल्टी-वर्ड स्ट्रिंग्स को कैसे संभालना चाहिए?

— कॉमरेड स्पार्कलपनी

6

चलो बस एक या दो मिनट का मौन पालन करते हैं, और रेस्ट इन पीस टू चक में कामना करते हैं।

— को आउटगोल्फ

1

Google अनुवादक द्वारा स्पैनिश में बोले जाने पर कोड पाठ सबसे अच्छा लगता है: Translate.google.com/#es/en/…

— palsch

86

जाओ, 123 बाइट्स

जाओ जॉनी, जाओ !

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

import."strings"
func(s string)string{t,e:=Title(s),", "+s+"\n";return t+e+Repeat(t+" Johnny "+s+e,4)+"Johnny B. "+t+"ode"}

— Uriel
स्रोत

12

केवल एक चीज गायब है 90बाइट्स।

— यूरिल

14

वीआईएम, 54 49 कीस्ट्रोक्स ( क्रिक्सी लिथोस से 1 कीस्ट्रोके बचाई गई )

yw~hC<Ctrl-R>", <Ctrl-R>0<Enter>Johnny B. <Ctrl-R>"ode<Esc>}O<Ctrl-R>", Johnny <Ctrl-R>0, <Ctrl-R>0<Esc>3.

पहले वर्ण पर कर्सर के साथ एक फ़ाइल पर एक लाइन पर शब्द के साथ शुरू करें, फिर यह पाठ व्याख्या के साथ यह सब बदल देगा

शब्द को एक रजिस्टर में कॉपी करें, फिर पहले अक्षर को कैपिटल में बदलें और इसे एक रजिस्टर में सहेजें।
प्रतिस्थापन और अंतिम लाइनों को भरने के लिए रजिस्टरों का उपयोग करके पहली पंक्ति लिखें
प्रतिस्थापनों को भरने के लिए रजिस्टरों का उपयोग करके दूसरी पंक्ति लिखें
मध्य रेखा को 3 बार दोहराएं

इसे ऑनलाइन आज़माएं! (धन्यवाद DJMcMayhem !)

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

मुझे लगता है कि आप Yइसके बजाय कर सकते हैं yyऔर शायदG इसके बजाय भी कर सकते हैं2j

— क्रिति लिथोस

और आप <CR>इसके बजाय कर सकते हैं<esc>o

— कृति लिथोस

इसके अलावा hDकाम करता हैdiw

— Krikii Lithos

सुझावों के लिए धन्यवाद! मैं वर्तमान संस्करण में आपके अंतिम एक में काम करने में सक्षम था। मैंने एक बार में पहली और आखिरी पंक्ति लिखकर कुछ और बचत की, फिर बीच में भर दी।

— डोमिनिक ए।

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

— DJMcMayhem

11

शुद्ध बैश, 69 76 बाइट्स

M=aaaa;echo -e ${1^}, $1 ${M//a/\\n${1^} Johnny $1, $1}\\nJohnny B. ${1^}ode

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

— आर। कप
स्रोत

2

आपके प्रयास में यह ऑनलाइन है, यह आवश्यक पूंजीकरण नहीं करता है। उदाहरण के लिए यदि आप codeसभी निचले मामलों में भोजन करते हैं, तो आपको आवश्यक पूंजीकरण नहीं मिलता है।

— टॉम कारपेंटर

2

@TomCarpenter फिक्स्ड! :)

— आर। काप

11

05AB1E , 37 बाइट्स

™„, ¹J¹Ð™”ÿºÇ ÿ, ÿ”4.D¹™”ºÇ B. ÿode”»

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

व्याख्या

™„, ¹J                                # concatenate title-cased input with ", " and input
     ¹Ð™                              # push input, input, title-cased input
        ”ÿºÇ ÿ, ÿ”                    # push the string "ÿ Johnny ÿ, ÿ" with "ÿ" replaced 
                                      # by title-cased input, input, input
                  4.D                 # push 3 copies of that string
                     ¹™               # push title-cased input
                       ”ºÇ B. ÿode”   # push the string "Johnny B. ÿode" with "ÿ" replaced 
                                      # by title-case input
                                   »  # join the strings by newlines

— Emigna
स्रोत

6

बैच, 207 बाइट्स

@set s= %1
@for %%l in (A B C D E F G H I J K L M N O P Q R S T U V W X Y Z)do @call set s=%%s: %%l=%%l%%
@set j="%s% Johnny %1, %1"
@for %%l in ("%s%, %1" %j% %j% %j% %j% "Johnny B. %s%ode")do @echo %%~l

— नील
स्रोत

6

जावास्क्रिप्ट, 98

s=>[S=s[0].toUpperCase()+s.slice(1),[,,,].fill(` ${s}
${S} Johnny `+s)]+`, ${s}
Johnny B. ${S}ode`

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

["Go",
 " go\nGo Johnny go", (repeated...)]

और इसे प्रपत्र की स्ट्रिंग तक पहुँचाता है ", go\nJohnny B. Goode":

["Go",
 " go\nGo Johnny go",
 " go\nGo Johnny go",
 " go\nGo Johnny go",
 " go\nGo Johnny go"] + ", go\nJohnny B. Goode"

— apsillers
स्रोत

6

जावास्क्रिप्ट (ईएस 6), 104 101 99 बाइट्स

(i,u=i[0].toUpperCase()+i.slice(1),x=`, ${i}
${u} Johnny `+i)=>u+x+x+x+x+`, ${i}
Johnny B. ${u}ode`

पुराना वर्जन:

(i,u=i[0].toUpperCase()+i.slice(1))=>u+`, ${i}
${u} Johnny ${i}`.repeat(4)+`, ${i}
Johnny B. ${u}ode`

यह काम किस प्रकार करता है:

यह एक अनाम फ़ंक्शन है जो इनपुट को पैरामीटर के रूप में लेता है i
एक चर uको परिभाषित करता है क्योंकि iपहले अक्षर के साथ इनपुट पूंजीकृत है (ध्यान दें कि यह मानता है कि इनपुट गैर-रिक्त है, जो ठीक है)
बस सीधे उन दो चर से वापस आने के लिए स्ट्रिंग का निर्माण करें।
दोहराने के "go, \nGo Johnny go"बजाय स्ट्रिंग को चार बार दोहराने "Go Johnny go, go"से एक बाइट बचती है।

संपादित 1: अर्धविराम बाहर गोल्फ के लिए भूल गया, हाहा !! इसके अलावा बाइट्स को गलत तरीके से पेश किया गया, यह मूल रूप से 102 था, न कि 104। धन्यवाद अप्सिलर्स ।

संपादित करें 2: इसके बजाय .repeat(4), उस स्ट्रिंग को एक चर में रखकर xऔर x+x+x+xदो बाइट्स को सहेजने की अनुमति देता है।

टेस्ट स्निपेट

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

let f = (i,u=i[0].toUpperCase()+i.slice(1),x=`, ${i}
${u} Johnny `+i)=>u+x+x+x+x+`, ${i}
Johnny B. ${u}ode`;

<input id=I type="text" size=70 value="code"><button onclick="console.log(f(I.value))">Run</button>

स्निपेट का विस्तार करें

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

वैसे, मैं यहां नया हूं, मेरा एक सवाल है: क्या मेरे कार्यक्रम में दो नए अंक बाइट्स के रूप में गिने जाते हैं? यदि नहीं, तो यह वास्तव में 102 बाइट्स है, लेकिन मुझे लगता है कि यह शायद मायने रखता है ... सही है?

— पेड्रो ए

हां, वे प्रत्येक एक बाइट का उपयोग करते हैं।

— जोनाथन एलन

मैं केवल 102 बाइट्स यहाँ ( mothereff.in/byte-counter का उपयोग करके ) गिनता हूं , और अंतिम अर्धविराम का उपयोग करने की भी कोई आवश्यकता नहीं है, इसलिए यह वास्तव में 101 बाइट्स है।

— अप्सिलर्स

@apsillers तुम सही हो, मैं गलत समझा! और इससे भी बदतर, हाहा मैं सेमीकोलन से बाहर निकलना भूल गया। धन्यवाद।

— पेड्रो ए

6

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

ÄJé,Ùäwa johnny 5ÄGdwwcWB.W~Aode.Î~

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

वी के लिए सही चुनौती!

स्पष्टीकरण:

ä$                              " Duplicate the input ('go' --> 'gogo', and cursor is on the first 'o')
  a, <esc>                      " Append ', '
                                " Now the buffer holds 'go, go'
          Ù                     " Duplicate this line
           äw                   " Duplicate this word (Buffer: 'gogo, go')
             a Johnny <esc>     " Append ' Johnny ' (Buffer: 'go Johnny go, go')
                           5Ä   " Make 5 copies of this line
G                               " Go to the very last line in the buffer
 dw                             " Delete a word
   w                            " Move forward one word (past 'Johnny')
    cW                          " Change this WORD (including the comma), to
      B.<esc>                   "   'B.'
             W                  " Move forward a WORD
              ~                 " Toggle the case of the character under the cursor
               Aode.<esc>       " Apppend 'ode.'
                         ÎvU    " Capitalize the first letter of each line

— DJMcMayhem
स्रोत

5

कृपया स्पष्टीकरण दें?

— ckjbgames

@ckjbgames हो गया!

— DJMcMayhem

5

पायथ - 52 बाइट्स

j", "_ArBQ3V4s[H" Johnny "G", "G;%"Johnny B. %sode"H

टेस्ट सूट ।

— Maltysen
स्रोत

5

सी, 156 151 बाइट्स

i,a,b;B(char*s){a=*s++;printf("%c%s, %c%s\n",b=a-32,s,a,s);for(;++i%4;)printf("%c%s Johnny %c%s, %c%s\n",b,s,a,s,a,s);printf("Johnny B. %c%sode",b,s);}

— Steadybox
स्रोत

यह gcc में संकलित नहीं करता है 4.4.7

— खलनायक

@villapx मैं नहीं देखता कि यह क्यों नहीं होगा। यह MinGW पर ठीक संकलन करता है और ऑनलाइन भी काम करता है । शायद कुछ संकलक ध्वज निहित प्रकार या फ़ंक्शन घोषणा को अक्षम कर रहे हैं?

— स्टेडियबॉक्स

यह कुछ चेतावनियाँ उत्पन्न करता है, लेकिन जब आप एक main()ऐसा जोड़ते हैं जो वास्तव में उस फ़ंक्शन को कॉल करता है जो काम करता है ...

— moooeeeep

@mooeeeeeep ठीक है, कि मैं क्या याद कर रहा था - मैं समझ रहा था कि इस चुनौती के लिए एक पूर्ण कार्यक्रम की आवश्यकता है , लेकिन वास्तव में, यह स्पष्ट रूप से ओपी में यह नहीं कहता है।

— खलनायक

5

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

lambda x:("{0}, {1}\n"+4*"{0} Johnny {1}, {1}\n"+"Johnny B. {0}ode").format(x.title(),x)

स्थितिगत तर्कों के साथ एक सरल प्रारूप स्ट्रिंग।

— wizzwizz4
स्रोत

@EricDuminil धन्यवाद। फिक्स्ड।

— wizzwizz4

1

@ EricDuminil मुझे पता था कि यह लाइन के अंत में था, लेकिन संपादक विंडो में लाइन रैप था ...: - /

— wizzwizz4

मैं 88 बाइट्स गिन रहा हूं

— फेलिप नारदी बतिस्ता

1

@ EricDuminil len("\n".__repr__()[1:-2])है 2. __repr__()कार्यक्रम की लंबाई मापने के दौरान मैं भूल गया ।

— wizzwizz4

1

@ EricDuminil केवल तभी यदि आप इसे """अंकों के बजाय अंकों के साथ लपेटते हैं "।

— wizzwizz4

4

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

बाइट गिनती आईएसओ 8859-1 एन्कोडिंग मानती है।

^
$', 
:T01`l`L
:`,
 Johnny$',
:`$
¶$`
(\S+) (\S+ ).+$
$2B. $1ode

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

— मार्टिन एंडर
स्रोत

4

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

5“ Johnny “, “¶”ẋj¹Ḋṙ7ỴŒu1¦€Y“B. ”⁸Œt“ode

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

— डेनिस
स्रोत

4

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

lambda s:("|, #\n"+"| Johnny #, #\n"*4+"Johnny B. |ode").replace("|",s.title()).replace("#",s)

— Trelzevir
स्रोत

4

सी #, 219 211 212 146 122 बाइट्स

अतिरिक्त अनुकूलन के साथ टिप्पणियों से कई सुझावों को लागू किया गया है

a=>{string x=(char)(a[0]^32)+a.Remove(0,1),n=a+"\n",c=", ",r=n+x+" Johnny "+a+c;return x+c+r+r+r+r+n+$"Johnny B. {x}ode";}

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

explantation:

a=>//Input parameter Explanation assumes "go" was passed
{
string x = (char)(a[0] ^ 32) + a.Remove(0, 1)// Input with first letter Uppercase "go"->"Go"
,
n = a + "\n",                               //"go" followed by newline
c = ", "                                    //Hard to believe: Comma followed by space
,
r = n + x + " Johnny " + a + c             //"go" follwed by newline followed by "Go Johnny go, "
;
return x + c + r + r + r + r + n + $"Johnny B. {x}ode"; };//return in the right order                              //Johnny B. Goode

टेस्टकेस के लिए आउटपुट:

Go, go
Go Johnny go, go
Go Johnny go, go
Go Johnny go, go
Go Johnny go, go
Johnny B. Goode

Code, code
Code Johnny code, code
Code Johnny code, code
Code Johnny code, code
Code Johnny code, code
Johnny B. Codeode

A, a
A Johnny a, a
A Johnny a, a
A Johnny a, a
A Johnny a, a
Johnny B. Aode

Johnny, johnny
Johnny Johnny johnny, johnny
Johnny Johnny johnny, johnny
Johnny Johnny johnny, johnny
Johnny Johnny johnny, johnny
Johnny B. Johnnyode

Fantastic, fantastic
Fantastic Johnny fantastic, fantastic
Fantastic Johnny fantastic, fantastic
Fantastic Johnny fantastic, fantastic
Fantastic Johnny fantastic, fantastic
Johnny B. Fantasticode

संपादित करें: किसी फ़ंक्शन का उपयोग करने के सुझाव के लिए वेस्टन के लिए धन्यवाद

— सर बिट्सलॉट
स्रोत

1

आपको एक पूरे कार्यक्रम, एक समारोह या बेहतर अभी तक, लंबोदा, पर्याप्त होगा प्रदान करने की आवश्यकता नहीं है।

— वेस्टन

1

+1 करने के लिए धन्यवाद ^32। कि &~32मैं उपयोग कर रहा था की तुलना में कम है । इसके अलावा, मेरे जावा 7 उत्तर का एक पोर्ट छोटा प्रतीत होता है:

string x(string a){string x=(char)(a[0]^32)+a.Remove(0,1),n=a+"\n",c=", ",r=n+x+" Johnny "+a+c;return x+c+r+r+r+r+n+"Johnny B. "+x+"ode";}}

( 139 बाइट्स ) इसे यहाँ आज़माएँ।

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

1

आशा है कि आप बुरा नहीं मानेंगे, लेकिन मैंने आपसे एक विचार चुराया है। : पी एक बुरे आदमी के रूप में नहीं जाने के लिए, मैं यहाँ एक टिप छोड़ दूँगा: आप अपने तरीके को एक लैम्ब्डा एक्सप्रेशन ( string x(string a)-> (a)=>, -13 बाइट्स) में बदल सकते हैं, मेरे पीछे केवल 1 बाइट;)

— एहमैन

1

@auhmaan आप एक को संकलित कर रहे हैं, तो Func<string, string>आप सिर्फ कर सकते हैं a=>के लिए कोई ज़रूरत नहीं ()।

— द लीथेलकोडर

3

MATLAB / ऑक्टेव , 133 111 बाइट्स

@(a)regexprep(['1, 2' 10 repmat(['1 32, 2' 10],1,4) '3B. 1ode'],{'1','2','3'},{[a(1)-32 a(2:end)],a,'Johnny '})

यह एक शुरुआत है। उम्मीद है कि और कम किया जा सकता है।

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

@(a)                                                    %Anonymous Function
    regexprep(                                          %Regex Replace
        ['1, 2' 10                                      %First line is: Code, code
            repmat(['1 32, 2' 10],1,4)                  %Then four lines of: Code Johnny code, code 
                               '3B. 1ode'],             %Final line: Johnny B. Codeode
         {'1','2','3'},                                 %1,2,3 are our replace strings in the lines above
         {[a(1)-32 a(2:end)],a,'Johnny '}               %We replace with '(I)nput', 'input' and 'Johnny ' respectively.
    )

एक उदाहरण:

@(a)regexprep(['1, 2' 10 repmat(['1 32, 2' 10],1,4) '3B. 1ode'],{'1','2','3'},{[a(1)-32 a(2:end)],a,'Johnny '});
ans('hi')
ans =

Hi, hi
Hi Johnny hi, hi
Hi Johnny hi, hi
Hi Johnny hi, hi
Hi Johnny hi, hi
Johnny B. Hiode

आप कर सकते हैं एक तरह से यह ऑनलाइन कोशिश करो! । कोड ऑक्टेव के साथ काम नहीं करता है क्योंकि सभी ऊपरी मामले पत्र बन जाते हैं ${upper($0)}, जबकि MATLAB में यह वास्तविक ऊपरी केस पत्र में बदल जाता है।

यह देखते हुए कि इनपुट की गारंटी केवल a-z(लोअरकेस वर्णमाला) है, मैं upper()फ़ंक्शन के साथ regex का उपयोग करने के बजाय, स्ट्रिंग में पहले अक्षर को कैपिटल में बदलने के लिए 32 के एक साधारण घटाव का उपयोग करके 22 बाइट्स बचा सकता हूं ।

नतीजतन, कोड अब ऑक्टेव के साथ भी काम करता है, इसलिए अब आप इसे ऑनलाइन आज़मा सकते हैं !

— टॉम बढ़ई
स्रोत

3

रूबी, 89 88 86 79 बाइट्स

मेरा पहला गोल्फ सबमिशन:

->x{"^, *
#{"^ Johnny *, *
"*4}Johnny B. ^ode".gsub(?^,x.capitalize).gsub ?*,x}

उनकी शानदार टिप्पणी के लिए @manatwork को बहुत धन्यवाद: 7 बाइट्स कम!

— एरिक डुमिनील
स्रोत

1

अच्छा लगा। खरीद पैरामीटर के आसपास कोष्ठक की जरूरत नहीं है; आप वर्ण भागने के बजाय शाब्दिक न्यूलाइन वर्णों का उपयोग कर सकते हैं; एकल पत्र स्ट्रिंग शाब्दिक ?अंकन के साथ लिखा जा सकता है ; अंतिम .gsubपैरामीटर के आसपास कोष्ठक की जरूरत नहीं है। pastebin.com/6C6np5Df

— manatwork

@manatwork: वाह, बहुत प्रभावशाली और आप का अच्छा। धन्यवाद!

— एरिक डुमिनील

3

नोवा , 105 बाइट्स

a(String s)=>"#{s.capitalize()+", #s\n"+"#s.capitalize() Johnny #s, #s\n"*4}Johnny B. #s.capitalize()ode"

क्योंकि नोवा ( http://nova-lang.org ) बेहद शुरुआती बीटा (और छोटी गाड़ी) हैं, ऐसे कुछ स्पष्ट बाधाएं हैं जो यहां कम बाइट्स का उपयोग करने से रोक रही हैं।

उदाहरण के लिए, इस तरह के एक स्थानीय चर में पूंजीकृत फ़ंक्शन कॉल (जिसे 3 बार कहा जाता है) को बचाया जा सकता है:

a(String s)=>"#{(let c=s.capitalize())+", #s\n"+"#c Johnny #s, #s\n"*4}Johnny B. #{c}ode"

जो बाइट काउंट को 89 बाइट तक ले जाता । इसका कारण यह नहीं है कि अब C भाषा में तर्क मूल्यांकन आदेश पर दोष दिया जा सकता है, क्योंकि नोवा को C से संकलित किया गया है (तर्क मूल्यांकन आदेश भविष्य के अद्यतन में तय किया जाएगा)

इससे भी अधिक, मैं स्ट्रिंग वर्ग में एक "शीर्षक" संपत्ति पेश कर सकता था (और मैं इस योग्य होने के बाद) कैपिटलाइज़ेशन फ़ंक्शन कॉल से गिनती कम करने के लिए:

a(String s)=>"#{(let c=s.title)+", #s\n"+"#c Johnny #s, #s\n"*4}Johnny B. #{c}ode"

और जो कि 7 बाइट्स को 82 बाइट्स के एक नए कुल में मुक्त करेगा ।

इसके अलावा (और आगे बंद), एक बार लंबो वैरिएबल प्रकार का इंजेक्शन जोड़ा जाता है, तो यह मान्य होगा:

s=>"#{(let c=s.title)+", #s\n"+"#c Johnny #s, #s\n"*4}Johnny B. #{c}ode"

गिनती को 72 बाइट्स तक लाया जा सकता है ।

वैसे, यह मेरा पहला कोड गोल्फ है, इसलिए मैं शायद और भी अधिक अनुकूलन याद कर सकता हूं जो बनाया जा सकता था। और यह एक गैर-गोल्फ केंद्रित , सामान्य उद्देश्य भाषा होने के नाते , मुझे लगता है कि यह बहुत प्रभावशाली है।

पहला 105 बाइट कोड वर्तमान नोवा बीटा v0.3.8 में http://nova-lang.org पर उपलब्ध है

class Test {
    static a(String s)=>"#{s.capitalize()+", #s\n"+"#s.capitalize() Johnny #s, #s\n"*4}Johnny B. #s.capitalize()ode"

    public static main(String[] args) {
        Console.log(a("expl"))
    }
}

आउटपुट:

Expl, expl
Expl Johnny expl, expl
Expl Johnny expl, expl
Expl Johnny expl, expl
Expl Johnny expl, expl
Johnny B. Explode

सामान्य उद्देश्य भाषा नोवा के लिए मेरा बेशर्म विज्ञापन सुनने के लिए धन्यवाद ( http://nova-lang.org पर मिला ... अभी प्राप्त करें) !!

— ब्रैडेन स्टेनिआनाक
स्रोत

3

ब्रेनफक, 352 बाइट्स

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

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

इनपुट प्राप्त करें
बाद के लिए विशेष वर्ण सहेजें।
पहला भाग लिखिए।
बाद के लिए "जॉनी" सहेजें
प्रिंट "गो जॉनी गो, गो" चार बार
अंतिम भाग लिखें

मैं हमेशा ब्रेनफक में चुनौतियों को पसंद करता हूं इसलिए यह मजेदार था। यह शायद अधिक गोल्फ हो सकता है, लेकिन गोल्फिंग ब्रेनफक एक तरह का लंबा है।

— AboveFire
स्रोत

3

PHP, 86 बाइट्स

echo strtr("1, 0\n2222Johnny B. 1ode",[$l=$argn,$u=ucfirst($l),"$u Johnny $l, $l\n"]);

— जार्ग हुल्सरमैन
स्रोत

3

जावा 8, 151 147 146 130 बाइट्स

s->{String x=(char)(s.charAt(0)^32)+s.substring(1),n=s+"\n",r=n+x+" Johnny "+s+", ";return x+", "+r+r+r+r+n+"Johnny B. "+x+"ode";}

स्पष्टीकरण:

इसे यहाँ आज़माएँ।

s->{                               // Method with String as both parameter and return-type
  String x=                        //  Temp String with: 
           (char)(s.charAt(0)^32)  //   The first letter capitalized
    +s.substring(1),               //   + the rest of the String
         n=s+"\n",                 //  Temp String with input + new-line
         c=", ",                   //  Temp String with ", "
         r=n+x+" Johnny "+s+c;     //  Temp String with "input\nInput Johnny input, "
  return x+c+r+r+r+r+n+"Johnny B. "+x+"ode";
                                   //  Return output by putting together the temp Strings
}                                  // End of method

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

2

स्टैक किया गया , 64 बाइट्स

:@n tc@N('%N, %n
'!'%N Johnny %n, %n
'!4*'Johnny B. 'N'ode'!)sum

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

— कोनोर ओ ब्रायन
स्रोत

2

सी # , 159 130 128 बाइट्स

golfed

i=>string.Format("{0},{1}????\n{2} B. {0}ode".Replace("?","\n{0} {2}{1},{1}"),(i[0]+"").ToUpper()+i.Substring(1)," "+i,"Johnny");

Ungolfed

i => string.Format( "{0},{1}????\n{2} B. {0}ode"
    .Replace( "?", "\n{0} {2}{1},{1}" ),

    ( i[ 0 ] + "" ).ToUpper() + i.Substring( 1 ), // {0}
    " " + i,                                      // {1}
    "Johnny" );                                   // {2}

अनपढ़ पठनीय

i => string.Format( @"{0},{1}
    ????
    {2} B. {0}ode"

    // Replaces the '?' for the string format that contains the 
    // repetition of "___ Johnny ___, ___".
    .Replace( "?", "\n{0} {2}{1},{1}" ),

    // {0} - Converts the first letter to upper,
    //       then joins to the rest of the string minus the first letter
    ( i[ 0 ] + "" ).ToUpper() + i.Substring( 1 ),
    // {1} - The input padded with a space, to save some bytes
    " " + i,
    // {2} - The name used as parameter, to save some bytes
    "Johnny" );

पूर्ण कोड

using System;

namespace Namespace {
    class Program {
        static void Main( string[] args ) {
            Func<string, string> func = i =>
                string.Format( "{0},{1}????\n{2} B. {0}ode"
                    .Replace( "?", "\n{0} {2}{1},{1}" ),

                    ( i[ 0 ] + "" ).ToUpper() + i.Substring( 1 ),
                    " " + i,
                    "Johnny" );

            int index = 1;

            // Cycle through the args, skipping the first ( it's the path to the .exe )

            while( index < args.Length ) {
                Console.WriteLine( func( args[index++] ) );
            }

            Console.ReadLine();
        }
    }
}

विज्ञप्ति

v1.2 - - 2 bytes- स्वैप के(i)=> लिए i=>, TheLetalCoder टिप्पणी के लिए धन्यवाद ।
v1.1 - -29 bytes- सर बिट्सलॉट के अंतिम अपडेट के लिए धन्यवाद , जिन्होंने मुझे याद किया कि मैं प्रारूप से पहले स्ट्रिंग को संपादित कर सकता हूं।
v1.0 - 159 bytes- प्रारंभिक समाधान।

टिप्पणियाँ

शीर्षक में कोड और परीक्षण मामलों के साथ एक पृष्ठ का लिंक होता है। बस गो को हिट करें और परिणाम कोड के नीचे प्रिंट किया जाएगा।

— auhmaan
स्रोत

सिर्फ करने के लिए ()तर्क के आसपास के लिए कोई ज़रूरत नहीं Funcहै i=>। आप संभवतः C # 6 से प्रक्षेपित स्ट्रिंग्स का उपयोग भी कर सकते हैं और खो सकते हैं string.Formatहालांकि मैंने यह देखने के लिए कोड को बहुत अधिक नहीं देखा है कि (कैसे तुच्छ होना चाहिए)।

— द लीथेलकोडर

मैं ड्रॉप कर सकता हूं (), लेकिन मुझे संदेह है कि मैं कोड के आकार को बढ़ाए बिना प्रक्षेपित स्ट्रिंग्स का उपयोग कर सकता हूं, रिप्लेसमेंट को ध्वस्त करने के लिए होने वाले प्रतिस्थापन के कारण।

— अनुमन

जैसे मैंने कहा कि मैं आलसी हो रहा था और वास्तव में खुद कुछ भी करने की कोशिश नहीं कर रहा था! सिर्फ देखने का सुझाव था।

— द लीथलकोडर

2

जावास्क्रिप्ट - 72 106 बाइट्स

संपादित करें: उफ़ !! मैंने पूंजीकरण नियमों पर ध्यान नहीं दिया! यह थोड़ी देर बाद होगा

संपादित करें 2: अब नियमों का पालन करना चाहिए!

शायद और अधिक गोल्फ हो सकता है

c=>(`G,g
`+`G Johnnyg,g
`.repeat(4)+`Johnny B.Gode`).replace(/g/g,' '+c.toLowerCase()).replace(/G/g,' '+c)

इसके समान इस्तेमाल किया:

c=>(`G,g
`+`G Johnnyg,g
`.repeat(4)+`Johnny B.Gode`).replace(/g/g,' '+c.toLowerCase()).replace(/G/g,' '+c)
alert(f("Code"));
alert(f("Go"));

— नीला ओकिरिस
स्रोत

2

एक्सेल VBA, _{137 121 112 89 87} 84 बाइट्स

बेनामी VBE तत्काल विंडो फ़ंक्शन जो VBE तत्काल विंडो को प्रिंट करके Variant/Stringसेल [A1]और आउटपुट से प्रकार का इनपुट लेता है

c=[Proper(A1)]:s=vbCr+c+[" Johnny "&A1&", "&A1]:?c", "[A1]s;s;s;s:?"Johnny B. "c"ode

-16 तत्काल विंडो फ़ंक्शन को परिवर्तित करने के लिए बाइट्स

-9 उपयोग करने के लिए बाइट्स [PROPER(A1)]

-23 For ...लूप छोड़ने और ?बयान का दुरुपयोग करने के लिए बाइट्स

-2 बाइट्स के " Johnny "&[A1]&", "&[A1]साथ बदलने के लिए[" Johnny "&A1&", "&A1]

स्ट्रिंग कंक्रीटिंग के लिए उपयोग +करने के &लिए और टर्मिनल स्ट्रिंग को छोड़ने के लिए -3 बाइट्स

उदाहरण प्रकरण

[A1]="an"          ''  <- Setting [A1] (may be done manually)
                   '' (Below) Anonymous VBE function
c=[Proper(A1)]:s=vbCr+c+[" Johnny "&A1&", "&A1]:?c", "[A1]s;s;s;s:?"Johnny B. "c"ode"
 An, an            ''  <- output
 An Johnny an, an
 An Johnny an, an
 An Johnny an, an
 An Johnny an, an
 Johnny B. Anode

— टेलर स्कॉट
स्रोत

1

है Debug.?sको प्रभावी ढंग से Debug.Print? वह कैसे काम करता है?

— ब्रूसवेयने

1

@ ब्रूसवेने, अच्छी केप। वीबीए ऑटोफोर्मेटिंग का समर्थन करता है, जिसका अर्थ है कि चीजें जैसे ?, i=1Toऔर &cअधिक क्रियात्मक लेकिन पढ़ने योग्य शब्दों में पच जाती हैं Print, i = 1 Toऔर & c। समुदाय ने फैसला किया है कि भाषाओं में कोड का संपीड़ित संस्करण प्रतिक्रियाओं के लिए स्वीकार्य है (देखें कोडगल्फ.मेटा.स्टैकएक्सचेंज.com/questions/10258/… )

— टेलर स्कॉट

1

@BruceWayne के रूप में ?, मेरा मानना है कि यह एक्सेल (4.0 और नीचे) के पुराने संस्करण से एक अवशेष है, जहां मैक्रो शीट्स को VBA के माध्यम से VBA में इस्तेमाल किया गया था, जहां इसे प्री के बाद प्रदान किए गए स्ट्रिंग को प्रिंट करने के लिए एक कीवर्ड के रूप में उपयोग किया गया था। संकेतित पाठ फ़ाइल। ?कीवर्ड स्वयं अभी भी कोड गोल्फ के लिए बहुत उपयोगी है Printकीवर्ड VBA के वर्तमान संस्करण में किसी पाठ फ़ाइल में तार लिखने के लिए प्रयोग किया जाता है। ध्यान दें, मैं एक के साथ स्मृति से दूर जा रहा हूँ ताकि नमक के एक दाने के साथ ले लो।

— टेलर स्कॉट

1

जानकार अच्छा लगा! मैंने सिर्फ कोडगॉल्फ उद्देश्यों के लिए नहीं, बल्कि इसलिए पूछा क्योंकि मैं लगातार VBA सीख रहा हूं और यह मेरे लिए सुपर नया था, इसलिए मैं उत्सुक था। हमेशा VBA में साफ सुथरी छोटी-छोटी ट्रिक्स सीखना पसंद करते हैं। चीयर्स!

— ब्रूसवेने

1

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

r:L(eu\+:M',SLN[MS"Johnny ":OL',SLN]4*O"B. "M"ode"

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

स्पष्टीकरण:

r:L(eu\+:M',SLN[MS"Johnny ":OL',SLN]4*O"B. "M"ode" e# Accepts an input token.
r:L                                                e# Gets input token and stores it in L.
   (eu\+:M                                         e# Converts token to uppercase-first and stores it in M.
          ',S                                      e# Appears as ", ".
             L                                     e# Input token.
              N                                    e# Newline.
               [                                   e# Opens array.
                M                                  e# Modified token.
                 S                                 e# Space.
                  "Johnny ":O                      e# Pushes "Johnny " and stores it in O.
                             L                     e# Input token.
                              ',SLN                e# The same {',SLN} as before.
                                   ]4*             e# Closes array and repeats it 4 times.
                                      O            e# "Johnny ".
                                       "B. "       e# "B. ".
                                            M      e# Modified token.
                                             "ode" e# "ode".

— आउटगोल्फर को एरिक करें
स्रोत

1

पायके , 43 बाइट्स

l5j", "Qs3
Qld"Johnny "iQs3:D4i"B. ode"+Tj:

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

निर्माण और पहली पंक्ति को प्रिंट करता है फिर Johnny goकॉमा से पहले सम्मिलित करता है और उस 4 बार डुप्लिकेट करता है। अंत में अंतिम भाग का निर्माण करता है।

— नीला
स्रोत

इनपुट के लिए काम नहीं कर रहा है johnny। tio.run/nexus/…

— डेनिस

मुझे पता नहीं है कि मैंने कैसे स्पॉट नहीं किया, अब तय किया गया

— ब्लू

1

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

from jinja2 import Template
def f(go):
    t = Template("""{{ Go }}, {{ go }}
{{ Go }} Johnny {{ go }}, {{ go }}
{{ Go }} Johnny {{ go }}, {{ go }}
{{ Go }} Johnny {{ go }}, {{ go }}
{{ Go }} Johnny {{ go }}, {{ go }}
Johnny B. {{ Go }}ode""")
    return t.render(Go=go.title(), go=go)

— user7610
स्रोत

ध्यान दें कि यह वास्तव में इस समय जावा के बराबर है, और यह बहुत पठनीय है;)

— user7610

1

साइट पर आपका स्वागत है! आप इस उत्तर को छोटा करने के लिए स्ट्रिंग गुणन का उपयोग कर सकते हैं। इसके अलावा चर को घोषित करना आवश्यक नहीं है tक्योंकि यह केवल एक बार कहा जाता है।

— श्रीओटचिलिज्म ओ’जैविक

धन्यवाद, लेकिन मैं वास्तव में 258 बाइट्स पर लक्ष्य कर रहा था, जावा के बराबर होना

— user7610

2

आप दूसरे स्कोर से मेल खाने की कोशिश क्यों कर रहे हैं? यह कोड गोल्फ है, पठनीयता प्रतियोगिता नहीं।

— पश्चिम की ओर

2

@ user7610 मुझे लगता है कि आप इस बिंदु को याद कर रहे हैं।

— मिराडुलो

1

जावा 6, 258 242 बाइट्स

enum j{;public static void main(String[]a){char[]b=a[0].toCharArray();b[0]^=32;System.out.printf("%1$s, %2$s\n%1$s %3$s%2$s, %2$s\n%1$s %3$s%2$s, %2$s\n%1$s %3$s%2$s, %2$s\n%1$s %3$s%2$s, %2$s\n%3$sB. %1$sode",new String(b),a[0],"Johnny ");}}

इसका सबसे लंबा हिस्सा प्रिंटफ के लिए प्रारूप है। वहाँ इनपुट स्ट्रिंग की तुलना में अलग से के साथ समस्याएं हैं aकरने के लिए z(हाँ मैं जानता हूँ कि मैं और कुछ समर्थन करने की आवश्यकता नहीं है)।

टिप्पणियों के साथ अपुष्ट:

enum j {
    ;

    public static void main(String[] a) {
        char[] b = a[0].toCharArray();              // Copy of the input string
        b[0]^=32;                                   // First character of copy to uppercase
        System.out.printf(
                "%1$s, %2$s\n%1$s %3$s%2$s, %2$s\n%1$s %3$s%2$s, %2$s\n%1$s %3$s%2$s, %2$s\n%1$s %3$s%2$s, %2$s\n%3$sB. %1$sode", // Format string
                new String(b),  // Capitalized string
                a[0],           // Original input string
                "Johnny ");     // "Johnny "
    }
}

संपादित करें: 16 बाइट्स वेस्टन के लिए धन्यवाद

— कुकी
स्रोत

1

आप बहुत सारे बाइट्स को बचाने के लिए एक लैम्ब्डा का उपयोग कर सकते हैं।

— corvus_192

1

"Johnny"हमेशा एक स्थान का अनुसरण किया जाता है।

— वेस्टन

b[0]^=32;(char)कास्ट की आवश्यकता के बिना भी अपरकेस होगा ।

— वेस्टन

1

मैथेमेटिका, 83 बाइट्स

{a=ToTitleCase@#,b=", ",#,{"
",a," Johnny ",#,b,#}~Table~4,"
Johnny B. ",a}<>"ode"&

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

— LegionMammal978
स्रोत

कोड जॉनी कोड, कोड!

चुनौती

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

जाओ, 123 बाइट्स

वीआईएम, 54 49 कीस्ट्रोक्स ( क्रिक्सी लिथोस से 1 कीस्ट्रोके बचाई गई )

शुद्ध बैश, 69 76 बाइट्स

05AB1E , 37 बाइट्स

बैच, 207 बाइट्स

जावास्क्रिप्ट, 98

जावास्क्रिप्ट (ईएस 6), 104 101 99 बाइट्स

टेस्ट स्निपेट

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

पायथ - 52 बाइट्स

सी, 156 151 बाइट्स

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

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

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

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

सी #, 219 211 212 146 122 बाइट्स

MATLAB / ऑक्टेव , 133 111 बाइट्स

रूबी, 89 88 86 79 बाइट्स

नोवा , 105 बाइट्स

ब्रेनफक, 352 बाइट्स

PHP, 86 बाइट्स

जावा 8, 151 147 146 130 बाइट्स

स्टैक किया गया , 64 बाइट्स

सी # , 159 130 128 बाइट्स

जावास्क्रिप्ट - 72 106 बाइट्स

एक्सेल VBA, 137 121 112 89 87 84 बाइट्स

उदाहरण प्रकरण

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

पायके , 43 बाइट्स

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

जावा 6, 258 242 बाइट्स

मैथेमेटिका, 83 बाइट्स

एक्सेल VBA, _{137 121 112 89 87} 84 बाइट्स