Il padre fondatore del rock-and-roll Chuck Berry è morto tristemente oggi.

Considera il coro della sua famosa canzone " Johnny B. Goode ":

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

^{(Ci sono altri modi in cui è stato punteggiato ma quanto sopra servirà ai fini della sfida.)}

Sfida

Data una stringa di lettere az vuota e minuscola, genera il ritornello di "Johnny B. Goode" con tutte le istanze Goo gosostituite con la stringa di input, maiuscole nello stesso modo.

Una newline finale può facoltativamente seguire. Nient'altro nel coro dovrebbe cambiare.

Ad esempio , se l'input è codel'output deve essere esattamente

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

facoltativamente seguito da una nuova riga.

Si noti che la capitalizzazione di tutte le parole corrisponde al coro originale, e (nonostante la mancanza di ritmo) la Goin Goodeè sostituito così come le singole parole Goe go.

Vince il codice più breve in byte.

Casi test

"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

Vai, 123 byte

Vai Johnny, vai !

Provalo 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 Tasti (salvato 1 tasto da 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.         

Inizia con la parola su una riga su un file con il cursore sul primo carattere, quindi questo sostituirà tutto con il testo Spiegazione

1. Copia la parola in un registro, quindi modifica la prima lettera da scrivere in maiuscolo e salvala in un registro.
2. Scrivi la prima riga usando i registri per compilare le sostituzioni e le ultime righe
3. Scrivi la seconda riga usando i registri per compilare le sostituzioni
4. Ripeti la linea di mezzo 3 volte

Provalo online! (Grazie DJMcMayhem !)

Pure Bash, 69 76 byte

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

Provalo online!

05AB1E , 37 byte

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

Provalo online!

Spiegazione

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

Lotto, 207 byte

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

Abusa della serializzazione da array a stringa per creare virgole. Costruisce una matrice del modulo:

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

E lo concatena alla stringa del modulo ", 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`

Versione precedente:

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

Come funziona:

• È una funzione anonima che accetta l'input come parametro i

• Definisce una variabile ucome input icon la prima lettera maiuscola (si noti che ciò presuppone che l'input sia non vuoto, il che è OK)

• Costruisci direttamente direttamente la stringa da restituire da queste due variabili.

• Ripetendo la stringa "go, \nGo Johnny go"quattro volte invece di ripetere si "Go Johnny go, go"salva un byte.

Modifica 1: Hai dimenticato di giocare a golf con il punto e virgola, ahah !! Inoltre ha contato male i byte, originariamente era 102, non 104. Grazie apsillers .

Modifica 2: Invece di .repeat(4), inserendo quella stringa in una variabile xe facendo x+x+x+xconsente di salvare due byte.

Test snippet

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 byte

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

Provalo online!

La sfida perfetta per V!

Spiegazione:

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

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

Test Suite .

C, 156 151 byte

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 byte

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

Una stringa di formato semplice, con argomenti posizionali.

Retina , 65 byte

Il conteggio dei byte presuppone la codifica ISO 8859-1.

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

Provalo online!

Gelatina , 41 byte

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

Provalo online!

Python, 94 byte

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

C #, 219 211 212 146 122 byte

Implementati più suggerimenti dai commenti con ottimizzazione aggiuntiva Questo è l'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";}

Provalo online!

espianto:

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

Uscita per testcase:

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

Modifica: grazie a Weston per aver suggerito di usare una funzione

MATLAB / Octave , 133 111 byte

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

È un inizio Si spera che possa essere ulteriormente ridotto.

Fondamentalmente è una funzione anonima che accetta un input di stringa e quindi utilizza regex per creare l'output richiesto.

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

Un esempio:

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

È possibile sorta di Provalo in rete! . Il codice non funziona abbastanza con Octave come diventano tutte le lettere maiuscole ${upper($0)}, mentre in MATLAB questo viene convertito nella lettera maiuscola effettiva.

Dato che l'input è garantito solo a-z(alfabeto minuscolo), posso salvare 22 byte usando una semplice sottrazione di 32 per convertire la prima lettera nella stringa in maiuscolo, piuttosto che usare regex con la upper()funzione.

Di conseguenza, il codice ora funziona anche con Octave, quindi ora puoi provarlo online!

Rubino, 89 88 86 79 byte

La mia prima presentazione di golf:

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

Grazie mille a @manatwork per il suo fantastico commento: 7 byte in meno!

Nova , 105 byte

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

Poiché Nova ( http://nova-lang.org ) è una beta (e un buggy) estremamente precoce, ci sono alcuni ovvi handicap che impediscono di usare ancora meno byte.

Ad esempio, avrebbe potuto salvare la chiamata di funzione in maiuscolo (che viene chiamata 3 volte) in una variabile locale come questa:

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

che avrebbe portato il conteggio dei byte a 89 byte . Il motivo per cui questo non funziona ora può essere incolpato dell'ordine di valutazione degli argomenti nel linguaggio C, perché Nova viene compilata in C. (L'ordine di valutazione degli argomenti verrà risolto in un aggiornamento futuro)

Ancora di più, avrei potuto introdurre una proprietà "title" nella classe String (e lo farò dopo aver fatto questo lol) per ridurre il conteggio dalla chiamata della funzione di capitalizzazione:

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

e ciò libererebbe 7 byte per un nuovo totale di 82 byte .

Inoltre (e più avanti), una volta aggiunta l'inferenza del tipo di variabile lambda, questo sarebbe valido:

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

Il conteggio potrebbe essere ridotto a 72 byte .

A proposito, questo è il mio primo codice golf, quindi probabilmente ho perso ancora più ottimizzazioni che avrebbero potuto essere fatte. E questo essere un centrica non-golf , general purpose lingua, penso che sia abbastanza impressionante.

Il primo codice da 105 byte funziona nell'attuale build Nova Beta v0.3.8 disponibile su 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"))
    }
}

uscite:

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

Grazie per aver ascoltato la mia pubblicità spudorata per il linguaggio generico Nova (disponibile su http://nova-lang.org ... ottenerlo ora !!)

Brainfuck, 352 byte

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

Provalo online!

1. Ottieni l'input.
2. Salva i caratteri speciali per dopo.
3. Scrivi la prima parte.
4. Salva "Johnny" per dopo
5. Stampa "Vai Johnny vai, vai" quattro volte
6. Scrivi l'ultima parte

Mi piacciono sempre le sfide in Brainfuck, quindi è stato divertente. Probabilmente si può giocare a golf di più, ma il golf Brainfuck è piuttosto lungo.

PHP, 86 byte

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

Java 8, 151 147 146 130 byte

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

Spiegazione:

Provalo qui.

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

Stacked , 64 byte

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

Provalo online!

C # , 159 130 128 byte

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}

Leggibile non golfato

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

Codice completo

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

Uscite

• v1.2 - - 2 bytes- Swapped (i)=>per i=>, grazie a TheLetalCoder commento.
• v1.1 - -29 bytes- Grazie all'ultimo aggiornamento di Sir Bitesalot , che si è ricordato di me, ho potuto modificare la stringa prima del formato.
• v1.0 - 159 bytes- Soluzione iniziale.

Appunti

Il titolo ha un collegamento a una pagina con il codice e i casi di test. Basta premere Vai e il risultato verrà stampato sotto il codice.

Javascript - 72 106 byte

Modifica: Oops !! Non ho prestato attenzione alle regole di capitalizzazione! Passerà più tempo

Modifica 2: ora dovrebbero seguire le regole!

Probabilmente potrebbe essere più giocato a golf

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

Usato come:

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 byte

Funzione di finestra immediata VBE anonima che accetta input di tipo Variant/Stringdalla cella [A1]e output stampando la finestra immediata VBE

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

-16 byte per la conversione in funzione finestra immediata

-9 byte per l'utilizzo [PROPER(A1)]

-23 byte per eliminare il For ...loop e abusare ?dell'istruzione

-2 byte per la sostituzione " Johnny "&[A1]&", "&[A1]con[" Johnny "&A1&", "&A1]

-3 byte per l'utilizzo di +over &per la concatenazione di stringhe e la chiusura della stringa di terminale chiusa

Caso di esempio

[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 byte

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

Provalo online!

Spiegazione:

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 byte

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

Provalo online!

Costruisce e stampa la prima riga, quindi inserisce Johnny goprima della virgola e la duplica 4 volte. Costruisce infine l'ultima parte.

Python, 258 byte

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 byte

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

La parte più lunga è il formato per printf. Ci sono problemi con input diversi dalla stringa da aa z(sì, lo so che non ho bisogno di supportare nient'altro).

Ungolfed con commenti:

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: golfato 16 byte grazie a Weston

Mathematica, 83 byte

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

Funzione anonima. Accetta una stringa come input e restituisce una stringa come output. Probabilmente potrebbe essere ulteriormente giocato a golf.