El padre fundador del rock and roll, Chuck Berry, falleció hoy tristemente.

Considere el coro de su famosa canción " Johnny B. Goode ":

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

^{(Hay otras formas en que se ha puntuado, pero lo anterior servirá para los propósitos del desafío).}

Desafío

Dada una cadena de letras z minúscula no vacía, genera el coro de "Johnny B. Goode" con todas las instancias Goo goreemplazadas por la cadena de entrada, en mayúscula de la misma manera.

Una nueva línea final puede seguir opcionalmente. Nada más en el coro debería cambiar.

Por ejemplo , si la entrada es codela salida debe ser exactamente

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

opcionalmente seguido por una nueva línea.

Tenga en cuenta que la mayúscula de todas las palabras coincide con el coro original, y (a pesar de la falta de ritmo) se reemplaza el Goin Goode, así como las palabras individuales Goy go.

El código más corto en bytes gana.

Casos de prueba

"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

Go, 123 bytes

¡Ve, Johnny, ve !

Pruébalo en línea!

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 pulsaciones de teclas (guardado 1 pulsación de tecla de 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.         

Comience con la palabra en una línea en un archivo con el cursor en el primer carácter, luego esto lo reemplazará todo con el texto Explicación

1. Copie la palabra en un registro, luego cambie la primera letra a mayúscula y guárdela en un registro.
2. Escriba la primera línea usando los registros para completar los reemplazos y las últimas líneas
3. Escriba la segunda línea usando los registros para completar los reemplazos
4. Repite la línea media 3 veces

Pruébalo en línea! (¡Gracias DJMcMayhem !)

Pure Bash, 69 76 bytes

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

Pruébalo en línea!

05AB1E , 37 bytes

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

Pruébalo en línea!

Explicación

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

Lote, 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`

Abusa de la serialización de matriz a cadena para crear comas. Construye una matriz de la forma:

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

Y lo concatena a la cadena del formulario ", 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 bytes

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

Versión previa:

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

Cómo funciona:

• Es una función anónima que toma la entrada como parámetro i

• Define una variable ucomo entrada icon la primera letra en mayúscula (tenga en cuenta que esto supone que la entrada no está vacía, lo cual está bien)

• Simplemente construya directamente la cadena que se devolverá a partir de esas dos variables.

• Repetir la cadena "go, \nGo Johnny go"cuatro veces en lugar de repetir "Go Johnny go, go"ahorra un byte.

Edición 1: Olvidé jugar al punto y coma, jaja !! También contó mal los bytes, originalmente era 102, no 104. Gracias a los apsillers .

Edición 2: en lugar de .repeat(4)poner esa cadena en una variable xy hacer, x+x+x+xpermite guardar dos bytes.

Fragmento de prueba

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.Î~

Pruébalo en línea!

¡El desafío perfecto para V!

Explicación:

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

Una cadena de formato simple, con argumentos posicionales.

Retina , 65 bytes

El recuento de bytes asume la codificación ISO 8859-1.

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

Pruébalo en línea!

Jalea , 41 bytes

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

Pruébalo en línea!

Python, 94 bytes

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

C #, 219 211 212 146 122 Bytes

Se implementaron múltiples sugerencias de comentarios con optimización adicional. Este es el resultado final:

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

Pruébalo en línea!

Explantación

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

Salida para casos de prueba:

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

Editar: Gracias a Weston por sugerir el uso de una función.

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 un comienzo. Con suerte se puede reducir aún más.

Básicamente es una función anónima que toma una entrada de cadena y luego usa expresiones regulares para crear la salida requerida.

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

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

Puede especie de Pruébelo en línea! . El código no funciona con Octave ya que todas las letras mayúsculas se vuelven${upper($0)} , mientras que en MATLAB se convierte en la letra mayúscula real.

Dado que la entrada solo se garantiza a-z(alfabeto en minúsculas), puedo ahorrar 22 bytes usando una simple resta de 32 para convertir la primera letra de la cadena en mayúscula, en lugar de usar expresiones regulares conupper() función.

Como resultado, el código ahora también funciona con Octave, por lo que ahora puede probarlo en línea.

Ruby, 89 88 86 79 bytes

Mi primera presentación de golf:

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

Muchas gracias a @manatwork por su increíble comentario: ¡7 bytes menos!

Estrella nueva , 105 bytes

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

Porque Nova ( http://nova-lang.org ) es extremadamente beta (y con errores), existen algunas desventajas obvias que impiden que use aún menos bytes.

Por ejemplo, podría haber guardado la llamada a la función en mayúscula (que se llama 3 veces) en una variable local como esta:

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

que habría tomado el byte cuenta atrás para bytes 89 bytes . La razón por la que esto no funciona ahora puede atribuirse al orden de evaluación de argumentos en el lenguaje C, porque Nova se compila en C. (El orden de evaluación de argumentos se solucionará en una actualización futura)

Aún más, podría haber introducido una propiedad "title" en la clase String (y lo haré después de hacer esto lol) para reducir el recuento de la llamada a la función de capitalización:

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

y eso liberaría 7 bytes a un nuevo total de 82 bytes .

Además (y más allá), una vez que se agrega la inferencia de tipo variable lambda, esto sería válido:

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

El recuento podría reducirse a 72 bytes .

Por cierto, este es mi primer código de golf, por lo que probablemente me haya perdido aún más optimizaciones que podrían haberse hecho. Y siendo este un campo no centrado en el golf , de uso general del lenguaje, creo que es bastante impresionante.

El primer código de 105 bytes funciona en la versión actual de Nova Beta v0.3.8 disponible en 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"))
    }
}

salidas:

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

Gracias por escuchar mi anuncio descarado para el lenguaje de propósito general Nova (que se encuentra en http://nova-lang.org ... ¡¡ consíguelo ahora !!)

Brainfuck, 352 bytes

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

Pruébalo en línea!

1. Obtenga la entrada.
2. Guarde caracteres especiales para más tarde.
3. Escribe la primera parte.
4. Guardar "Johnny" para más tarde
5. Imprime "Ve, Johnny ve, ve" cuatro veces
6. Escribe la última parte

Siempre me gustan los desafíos en Brainfuck, así que fue divertido. Probablemente se pueda jugar más al golf, pero el golf Brainfuck es bastante largo.

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

Explicación:

Pruébalo aquí.

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

Apilado , 64 bytes

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

Pruébalo en línea!

C # , 159 130 128 bytes

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

Sin golf

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}

Legible sin golf

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

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

Lanzamientos

• v1.2 - - 2 bytes- Intercambiado (i)=>por i=>, gracias al comentario de TheLetalCoder .
• v1.1 - -29 bytes- Gracias a la última actualización de Sir Bitesalot , quien me recordó que podía editar la cadena antes del formato.
• v1.0 - 159 bytes- Solución inicial.

Notas

El título tiene un enlace a una página con el código y los casos de prueba. Simplemente presione Ir y el resultado se imprimirá debajo del código.

Javascript - 72 106 bytes

Editar: ¡Uy! ¡No presté atención a las reglas de capitalización! Será más largo después de un tiempo

Edición 2: ¡Debería seguir las reglas ahora!

Probablemente podría jugar más golf

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

Usado como:

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

Función de ventana inmediata anónima de VBE que toma la entrada de tipo Variant/Stringde la celda [A1]y las salidas imprimiendo la ventana inmediata de VBE

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

-16 bytes para convertir a la función de ventana Inmediato

-9 bytes para usar [PROPER(A1)]

-23 bytes para abandonar el For ...ciclo y abusar de la ?declaración

-2 Bytes para reemplazar " Johnny "&[A1]&", "&[A1]con[" Johnny "&A1&", "&A1]

-3 bytes para usar + más &para la concatenación de cadenas y dejar la cadena de terminal sin cerrar

Caso de ejemplo

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

Pruébalo en línea!

Explicación:

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:

Pruébalo en línea!

Construye e imprime la primera línea, luego la inserta Johnny goantes de la coma y la duplica 4 veces. Finalmente construye la última parte.

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

La parte más larga es el formato para printf. Hay problemas con la entrada diferente de string de aa z(sí, sé que no necesito admitir nada más).

Ungolfed con comentarios:

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

EDITAR: Golfed 16 bytes gracias a Weston

Mathematica, 83 bytes

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

Función anónima. Toma una cadena como entrada y devuelve una cadena como salida. Probablemente podría jugar más golf.