Rock-and-Roll-Gründungsvater Chuck Berry ist heute leider verstorben.

Betrachten Sie den Refrain seines berühmten Liedes " Johnny B. Goode ":

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

^{(Es gibt andere Möglichkeiten , wie dies unterbrochen wurde, aber die oben genannten dienen den Zwecken der Herausforderung.)}

Herausforderung

Geben Sie bei einer nicht leeren Kleinbuchstabenfolge az den Refrain von "Johnny B. Goode" mit allen Instanzen der Eingabezeichenfolge aus Gooder goersetzen Sie sie durch die Eingabezeichenfolge, die auf die gleiche Weise in Großbuchstaben geschrieben wurde .

Optional kann ein abschließender Zeilenumbruch folgen. Sonst sollte sich im Refrain nichts ändern.

Wenn zum Beispiel die Eingabe ist, codemuss die Ausgabe genau sein

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

optional gefolgt von einem Zeilenumbruch.

Beachten Sie, dass die Groß- und Kleinschreibung aller Wörter mit dem ursprünglichen Refrain übereinstimmt und (trotz fehlendem Rhythmus) das GoIn Goodesowie die einzelnen Wörter Gound ersetzt werden go.

Der kürzeste Code in Bytes gewinnt.

Testfälle

"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

Los, 123 Bytes

Geh Johnny, geh !

Probieren Sie es online!

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"}

VIM, 54 49 Tastenanschläge (1 Tastenanschlag von Kritixi Lithos gespeichert )

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.         

Beginnen Sie mit dem Wort in einer Zeile einer Datei, wobei sich der Cursor am ersten Zeichen befindet, und ersetzen Sie dann alles durch den Text Erläuterung

1. Kopieren Sie das Wort in ein Register, ändern Sie den ersten Buchstaben, der groß geschrieben werden soll, und speichern Sie ihn in einem Register.
2. Schreiben Sie die erste Zeile mit den Registern, um die Ersetzungen und die letzten Zeilen auszufüllen
3. Schreiben Sie die zweite Zeile mit den Registern, um die Ersetzungen auszufüllen
4. Wiederholen Sie die Mittellinie 3 Mal

Probieren Sie es online! (Danke DJMcMayhem !)

Pure Bash, 69 76 Bytes

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

Probieren Sie es online!

05AB1E , 37 Bytes

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

Probieren Sie es online!

Erläuterung

™„, ¹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

Batch, 207 Bytes

@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

JavaScript, 98

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

Verwendet die Array-zu-String-Serialisierung zum Erstellen von Kommas. Erstellt ein Array des Formulars:

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

Und verkettet es mit der Zeichenfolge des Formulars ", 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"

JavaScript (ES6), 104 101 99 Byte

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

Vorherige Version:

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

Wie es funktioniert:

• Es ist eine anonyme Funktion, die die Eingabe als Parameter verwendet i

• Definiert eine Variable uals Eingabe, ibei der der erste Buchstabe groß geschrieben wird. (Es wird davon ausgegangen, dass die Eingabe nicht leer ist. Dies ist in Ordnung.)

• Erstellen Sie einfach direkt die Zeichenfolge, die aus diesen beiden Variablen zurückgegeben werden soll.

• Durch "go, \nGo Johnny go"viermaliges Wiederholen der Zeichenfolge wird "Go Johnny go, go"ein Byte gespeichert.

Edit 1: Ich habe vergessen, das Semikolon auszuspielen, haha ​​!! Auch die Bytes falsch gezählt, war es ursprünglich 102, nicht 104. Dank apsillers .

Edit 2: Anstatt .repeat(4)diesen String in eine Variable zu setzen xund dabei x+x+x+xzwei Bytes zu speichern.

Testschnipsel

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>

V , 41 , 38 Bytes

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

Probieren Sie es online!

Die perfekte Herausforderung für V!

Erläuterung:

ä$                              " 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

Pyth - 52 Bytes

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

Test Suite .

C, 156 151 Bytes

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

Python 3, 88 Bytes

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

Eine einfache Formatzeichenfolge mit Positionsargumenten.

Netzhaut , 65 Bytes

Die Anzahl der Bytes setzt die Kodierung nach ISO 8859-1 voraus.

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

Probieren Sie es online!

Jelly , 41 Bytes

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

Probieren Sie es online!

Python, 94 Bytes

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

C #, 219 211 212 146 122 Bytes

Mehrere Vorschläge aus Kommentaren mit zusätzlicher Optimierung implementiert. Dies ist das Endresultat:

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";}

Probieren Sie es online!

Erklärung:

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

Ausgabe für Testfälle:

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

Edit: Danke an weston für den Vorschlag, eine Funktion zu verwenden

MATLAB / Octave , 133 111 Bytes

@(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 '})

Es ist ein Anfang. Kann hoffentlich weiter reduziert werden.

Grundsätzlich handelt es sich um eine anonyme Funktion, die eine Zeichenfolge eingibt und dann mithilfe von Regex die erforderliche Ausgabe erstellt.

@(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.
    )

Ein Beispiel:

@(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

Sie können eine Art Online ausprobieren! . Der Code funktioniert mit Octave nicht ganz so, wie alle Großbuchstaben werden ${upper($0)}, während dies in MATLAB in den tatsächlichen Großbuchstaben konvertiert wird.

Da die Eingabe garantiert nur a-z(Kleinbuchstaben) ist, kann ich 22 Bytes einsparen, indem ich den ersten Buchstaben in der Zeichenfolge durch einfache Subtraktion von 32 in Großbuchstaben umwandle, anstatt Regex mit der upper()Funktion zu verwenden.

Infolgedessen funktioniert der Code jetzt auch mit Octave, sodass Sie ihn jetzt online testen können!

Ruby, 89 88 86 79 Bytes

Meine erste Golfeinreichung:

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

Vielen Dank an @manatwork für seinen tollen Kommentar: 7 Bytes weniger!

Nova , 105 Bytes

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

Da es sich bei Nova ( http://nova-lang.org ) um eine extrem frühe Beta (und Buggy) handelt, gibt es einige offensichtliche Nachteile, die verhindern, dass noch weniger Bytes benötigt werden.

Könnte zum Beispiel einen kapitalisierten Funktionsaufruf (der dreimal aufgerufen wird) in einer lokalen Variablen wie dieser gespeichert haben:

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

Das hätte die Anzahl der Bytes auf 89 Bytes verringert . Der Grund, warum dies jetzt nicht funktioniert, kann auf die Argumentbewertungsreihenfolge in der Sprache C zurückgeführt werden, da Nova zu C kompiliert wird. (Die Argumentbewertungsreihenfolge wird in einem zukünftigen Update behoben.)

Außerdem hätte ich eine "title" -Eigenschaft in die String-Klasse einfügen können (und das werde ich auch tun), um die Anzahl der Aufrufe der Großschreibung zu verringern:

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

und das würde 7 Bytes auf insgesamt 82 Bytes freisetzen .

Darüber hinaus (und weiter weg) wäre dies gültig, sobald die Inferenz des Lambda-Variablentyps hinzugefügt wird:

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

Die Anzahl konnte auf 72 Bytes gesenkt werden .

Übrigens ist dies mein erster Code-Golf, daher habe ich wahrscheinlich noch mehr Optimierungen verpasst, die hätte vorgenommen werden können. Und das eine ist nicht Golf centric , für allgemeine Zwecke Sprache, ich denke , es ist ziemlich beeindruckend.

Der erste 105-Byte-Code funktioniert in der aktuellen Version von Nova Beta v0.3.8, die unter http://nova-lang.org verfügbar ist

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"))
    }
}

Ausgänge:

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

Vielen Dank, dass Sie sich meine schamlose Werbung für die Allzwecksprache Nova angehört haben (zu finden unter http://nova-lang.org ... jetzt kaufen !!)

Brainfuck, 352 Bytes

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

Probieren Sie es online!

1. Holen Sie sich die Eingabe.
2. Sonderzeichen für später speichern.
3. Schreiben Sie den ersten Teil.
4. Speichern Sie "Johnny" für später
5. Drucken Sie "Go Johnny go, go" viermal
6. Schreiben Sie den letzten Teil

Ich mag Herausforderungen in Brainfuck immer, also hat es Spaß gemacht. Es kann wahrscheinlich mehr Golf gespielt werden, aber Brainfuck ist ein bisschen lang.

PHP, 86 Bytes

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

Java 8, 151 147 146 130 Bytes

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";}

Erläuterung:

Probieren Sie es hier aus.

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

Gestapelt , 64 Bytes

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

Probieren Sie es online!

C # , 159 130 128 Bytes

Golf gespielt

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}

Ungolfed lesbar

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" );

Vollständiger Code

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

Releases

• v1.2 - - 2 bytes- Swapped (i)=>für i=>dank TheLetalCoder Kommentar.
• v1.1 - -29 bytes- Dank des letzten Updates von Sir Bitesalot , der sich an mich erinnerte, konnte ich die Zeichenfolge vor dem Formatieren bearbeiten.
• v1.0 - 159 bytes- Anfangslösung.

Anmerkungen

Der Titel enthält einen Link zu einer Seite mit dem Code und den Testfällen. Drücken Sie einfach Go und das Ergebnis wird unter dem Code gedruckt.

Javascript - 72 106 Bytes

Edit: Ups !! Ich habe die Großschreibung nicht beachtet! Nach einer Weile wird es länger dauern

Edit 2: Sollte jetzt den Regeln folgen!

Könnte wahrscheinlich mehr Golf gespielt werden

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

Benutzt als:

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"));

Excel VBA, _{137 121 112 89 87} 84 Bytes

Anonyme VBE-Direktfensterfunktion, die die Eingabe des Typs Variant/Stringaus der Zelle übernimmt [A1]und durch Drucken des VBE-Direktfensters ausgibt

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

-16 Bytes für die Konvertierung in die Direktfensterfunktion

-9 Bytes für die Verwendung [PROPER(A1)]

-23 Bytes für das Löschen einer For ...Schleife und den Missbrauch der ?Anweisung

-2 Bytes zum Ersetzen " Johnny "&[A1]&", "&[A1]durch[" Johnny "&A1&", "&A1]

-3 Bytes, um +over &für die String-Verkettung zu verwenden und den Terminal-String nicht zu schließen

Beispielfall

[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

CJam , 50 Bytes

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

Probieren Sie es online!

Erläuterung:

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".

Pyke , 43 Bytes

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

Probieren Sie es online!

Konstruiert und druckt die erste Zeile, fügt sie dann Johnny govor dem Komma ein und dupliziert sie viermal. Konstruiert schließlich den letzten Teil.

Python, 258 Bytes

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)

Java 6, 258 242 Bytes

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

Der längste Teil davon ist das Format für printf. Es gibt Probleme mit Eingaben, die sich von Zeichenfolgen von abis unterscheiden z(ja, ich weiß, dass ich nichts anderes unterstützen muss).

Ungolfed mit Kommentaren:

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 "
    }
}

EDIT: 16 Bytes dank Weston Golf

Mathematica, 83 Bytes

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

Anonyme Funktion. Nimmt einen String als Eingabe und gibt einen String als Ausgabe zurück. Könnte wahrscheinlich weiter golfen werden.