Ojciec założyciel rock and rolla Chuck Berry niestety dzisiaj zmarł.

Zastanów się nad refrenem jego słynnej piosenki „ Johnny B. Goode ”:

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

^{(Istnieją inne sposoby interpunkcji, ale powyższe będą służyć do celów wyzwania).}

Wyzwanie

Biorąc pod uwagę niepuste, małe litery alfabetu, wypisz refren „Johnny B. Goode” ze wszystkimi wystąpieniami Golub gozastąpiony przez ciąg wejściowy, pisany wielkimi literami w ten sam sposób.

Końcowy znak nowej linii może opcjonalnie nastąpić. Nic innego w refrenie nie powinno się zmienić.

Na przykład , jeśli wejście jest codewyjściem, musi być dokładnie

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

opcjonalnie następuje nowa linia.

Zauważ, że wielkie litery wszystkich słów pasują do oryginalnego refrenu i (pomimo braku rytmu) Goin Goodejest zamieniany, a także pojedyncze słowa Goi go.

Najkrótszy kod w bajtach wygrywa.

Przypadki testowe

"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

Idź, 123 bajty

Idź Johnny, idź !

Wypróbuj 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 Klawisze (zapisane 1 naciśnięcie klawisza z Kritixi Lithos )

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.         

Zacznij od słowa w wierszu pliku z kursorem na pierwszym znaku, a to zastąpi wszystko tekstem Objaśnienie

1. Skopiuj słowo do rejestru, a następnie zmień pierwszą literę na wielką i zapisz ją w rejestrze.
2. Napisz pierwszą linię za pomocą rejestrów, aby wypełnić zamienniki i ostatnie linie
3. Napisz drugą linię za pomocą rejestrów, aby wypełnić zamienniki
4. Powtórz środkową linię 3 razy

Wypróbuj online! (Dzięki DJMcMayhem !)

Pure Bash, 69 76 bajtów

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

Wypróbuj online!

05AB1E , 37 bajtów

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

Wypróbuj online!

Wyjaśnienie

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

Partia, 207 bajtów

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

Nadużywa szeregowania tablic do ciągów, aby tworzyć przecinki. Tworzy tablicę formularza:

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

I łączy to z ciągiem formularza ", 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 bajtów

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

Poprzednia wersja:

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

Jak to działa:

• Jest to anonimowa funkcja, która przyjmuje dane wejściowe jako parametr i

• Definiuje zmienną ujako wejście iz pierwszą literą wielkimi literami (zauważ, że zakłada to, że dane wejściowe nie są puste, co jest OK)

• Wystarczy bezpośrednio skonstruować ciąg, który zostanie zwrócony z tych dwóch zmiennych.

• Powtarzanie ciągu "go, \nGo Johnny go"cztery razy zamiast powtarzania "Go Johnny go, go"zapisuje jeden bajt.

Edycja 1: Zapomniałem zagrać w średnik, haha ​​!! Również błędnie policzyłem bajty, początkowo było to 102, a nie 104. Dzięki apsillers .

Edycja 2: Zamiast tego .repeat(4), umieszczając ten ciąg w zmiennej xi wykonywanie x+x+x+xpozwala na zapisanie dwóch bajtów.

Testowy fragment kodu

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 bajtów

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

Wypróbuj online!

Idealne wyzwanie dla V!

Wyjaśnienie:

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

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

Pakiet testowy .

C, 156 151 bajtów

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 bajtów

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

Łańcuch o prostym formacie z argumentami pozycyjnymi.

Siatkówka , 65 bajtów

Liczba bajtów zakłada kodowanie ISO 8859-1.

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

Wypróbuj online!

Galaretka , 41 bajtów

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

Wypróbuj online!

Python, 94 bajty

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

C #, 219 211 212 146 122 bajtów

Wdrożono wiele sugestii z komentarzy z dodatkową optymalizacją Oto Endresult:

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

Wypróbuj online!

Wyjaśnienie:

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

Dane wyjściowe dla przypadków testowych:

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

Edycja: Podziękowania dla weston za sugestię użycia funkcji

MATLAB / Octave , 133 111 bajtów

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

To poczatek. Mam nadzieję, że można go jeszcze bardziej zmniejszyć.

Zasadniczo jest to anonimowa funkcja, która pobiera ciąg znaków, a następnie używa wyrażenia regularnego do utworzenia wymaganego wyniku.

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

Przykład:

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

Można rodzaj Spróbuj online! . Kod nie do końca działa z Octave, ponieważ stają się wszystkie wielkie litery ${upper($0)}, podczas gdy w MATLAB jest to konwertowane na rzeczywistą wielką literę.

Biorąc pod uwagę, że dane wejściowe są gwarantowane jako a-z(małe litery), mogę zapisać 22 bajty, używając prostego odejmowania 32, aby przekonwertować pierwszą literę w ciągu na dużą, zamiast używania wyrażenia regularnego z upper()funkcją.

W rezultacie kod działa teraz również z Octave, więc możesz teraz wypróbować online!

Rubinowy, 89 88 86 79 bajtów

Moje pierwsze zgłoszenie do gry w golfa:

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

Bardzo dziękuję @manatwork za jego niesamowity komentarz: 7 bajtów mniej!

Nova , 105 bajtów

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

Ponieważ Nova ( http://nova-lang.org ) jest bardzo wczesną wersją beta (i zawiera błędy), istnieją pewne oczywiste utrudnienia, które uniemożliwiają wykorzystanie jeszcze mniej bajtów.

Na przykład, mógłbym zapisać wielką funkcję (która jest wywoływana 3 razy) w zmiennej lokalnej, takiej jak ta:

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

co spowodowałoby odliczenie bajtu do 89 bajtów . Powód, dla którego to teraz nie działa, można winić za kolejność oceny argumentów w języku C, ponieważ Nova jest kompilowana do C. (Kolejność oceny argumentów zostanie ustalona w przyszłej aktualizacji)

Co więcej, mógłbym wprowadzić właściwość „title” w klasie String (i zrobię to po tym lol), aby zmniejszyć liczbę wywoływanych funkcji wywołania wielką literą:

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

i to uwolniłoby 7 bajtów do nowej łącznie 82 bajtów .

Ponadto (i jeszcze dalej), po dodaniu wnioskowania o typie zmiennej lambda, byłoby to prawidłowe:

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

Liczba ta może zostać zmniejszona do 72 bajtów .

Nawiasem mówiąc, jest to mój pierwszy golfowy kod, więc prawdopodobnie przegapiłem jeszcze więcej optymalizacji, które można było wprowadzić. I to bycie centric non-golf , ogólnego przeznaczenia, język, myślę, że to całkiem imponujące.

Pierwszy 105-bajtowy kod działa w bieżącej wersji Nova Beta v0.3.8 dostępnej na stronie 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"))
    }
}

wyjścia:

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

Dziękuję za wysłuchanie mojej bezwstydnej reklamy języka ogólnego Nova (znajdującego się na stronie http://nova-lang.org ... pobierz teraz !!)

Brainfuck, 352 bajtów

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

Wypróbuj online!

1. Uzyskaj dane wejściowe.
2. Zapisz znaki specjalne na później.
3. Napisz pierwszą część.
4. Zapisz „Johnny” na później
5. Drukuj „Idź Johnny idź, idź” cztery razy
6. Napisz ostatnią część

Zawsze lubię wyzwania w Brainfuck, więc było fajnie. Prawdopodobnie można grać bardziej w golfa, ale gra w golfa Brainfuck jest dość długa.

PHP, 86 bajtów

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

Java 8, 151 147 146 130 bajtów

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

Wyjaśnienie:

Wypróbuj tutaj.

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

Skumulowane , 64 bajty

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

Wypróbuj online!

C # , 159 130 128 bajtów

Grał w golfa

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

Nie golfił

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}

Nieczytelny czytelny

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

Pełny kod

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

Prasowe

• v1.2 - - 2 bytes- Zamieniono (i)=>na i=>, dzięki komentarzowi TheLetalCoder .
• v1.1 - -29 bytes- Dzięki ostatniej aktualizacji Sir Bitesalot , który mnie zapamiętał, mogłem edytować ciąg przed formatowaniem.
• v1.0 - 159 bytes- Wstępne rozwiązanie.

Notatki

Tytuł zawiera link do strony z kodem i przypadkami testowymi. Wystarczy nacisnąć Go, a wynik zostanie wydrukowany poniżej kodu.

JavaScript - 72 106 bajtów

Edycja: Ups !! Nie zwracałem uwagi na zasady kapitalizacji! Po pewnym czasie będzie dłużej

Edycja 2: Powinieneś teraz przestrzegać zasad!

Prawdopodobnie można by grać w golfa więcej

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

Użyty jako:

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 bajtów

Anonimowa funkcja bezpośredniego okna VBE, która pobiera dane wejściowe typu Variant/Stringz komórki [A1]i danych wyjściowych poprzez wydrukowanie bezpośredniego okna VBE

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

-16 Bajtów do konwersji do funkcji okna natychmiastowego

-9 Bajtów do użycia [PROPER(A1)]

-23 Bajty za zrzucanie For ...pętli i nadużywanie ?instrukcji

-2 bajtów do wymiany " Johnny "&[A1]&", "&[A1]z[" Johnny "&A1&", "&A1]

-3 Bajty za użycie +w &celu konkatenacji ciągu znaków i pozostawienie łańcucha końcowego niezamkniętego

Przykładowa sprawa

[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 bajtów

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

Wypróbuj online!

Wyjaśnienie:

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 bajty

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

Wypróbuj online!

Konstruuje i drukuje pierwszą linię, a następnie wstawia Johnny goprzed przecinkiem i powiela to 4 razy. Wreszcie konstruuje ostatnią część.

Python, 258 bajtów

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 bajtów

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

Najdłuższą częścią jest format printf. Występują problemy z danymi wejściowymi innymi niż ciąg od ado z(tak, wiem, że nie muszę obsługiwać niczego innego).

Niegolfowany z komentarzami:

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

EDYCJA: Gra w golfa 16 bajtów dzięki Weston

Mathematica, 83 bajty

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

Funkcja anonimowa. Pobiera ciąg jako dane wejściowe i zwraca ciąg jako dane wyjściowe. Prawdopodobnie można by dalej grać w golfa.