Père fondateur du rock and roll Chuck Berry malheureusement décédé aujourd'hui.

Pensez au refrain de sa célèbre chanson " Johnny B. Goode ":

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

^{(Il a été ponctué d’ autres manières, mais ce qui précède servira aux fins du défi.)}

Défi

Avec une chaîne de lettres z non vide et minuscule, indiquez le refrain de "Johnny B. Goode" avec toutes les instances de Goougo remplacé par la chaîne d'entrée, avec une majuscule de la même manière.

Un retour à la ligne peut éventuellement suivre. Rien d'autre dans le choeur ne devrait changer.

Par exemple , si l’entrée est codela sortie doit être exactement

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

éventuellement suivi d'une nouvelle ligne.

Notez que la mise en majuscule de tous les mots correspond au refrain d'origine, et (malgré le manque de rythme), le Godans Goodeest remplacé ainsi que les mots individuels Goet go.

Le code le plus court en octets gagne.

Cas de 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

Go, 123 octets

Allez Johnny, allez !

Essayez-le en ligne!

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 séquences de touches (1 sauvegarde enregistrée 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.         

Commencez avec le mot sur une ligne d'un fichier avec le curseur sur le premier caractère, puis tout sera remplacé par le texte Explication

1. Copiez le mot dans un registre, puis modifiez la première lettre à mettre en majuscule et enregistrez-la dans un registre.
2. Écrivez la première ligne en utilisant les registres pour remplir les remplacements et les dernières lignes
3. Écrivez la deuxième ligne en utilisant les registres pour remplir les remplacements
4. Répétez la ligne médiane 3 fois

Essayez-le en ligne! (Merci, DJMcMayhem !)

Pure Bash, 69 à 76 octets

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

Essayez-le en ligne!

05AB1E , 37 octets

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

Essayez-le en ligne!

Explication

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

Lot, 207 octets

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

Abuse de la sérialisation de chaîne en chaîne pour créer des virgules. Construit un tableau de la forme:

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

Et le concatène à la chaîne de la forme ", 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 octets

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

La version précédente:

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

Comment ça fonctionne:

• C'est une fonction anonyme qui prend l'entrée comme paramètre i

• Définit une variable ucomme entrée iavec la première lettre en majuscule (notez que cela suppose que l'entrée est non vide, ce qui est OK)

• Il suffit de construire directement la chaîne à renvoyer à partir de ces deux variables.

• Répéter la chaîne "go, \nGo Johnny go"quatre fois au lieu de répéter "Go Johnny go, go"enregistre un octet.

Edit 1: Oublié de jouer au point-virgule, haha ​​!! Également mal compté les octets, il était à l'origine 102, pas 104. Merci apsillers .

Edit 2: Au lieu de .repeat(4), mettre cette chaîne dans une variable xet le faire x+x+x+xpermet de sauvegarder deux octets.

Extrait de test

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 octets

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

Essayez-le en ligne!

Le défi parfait pour V!

Explication:

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

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

Suite de test .

C, 156 151 octets

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 octets

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

Une chaîne de format simple, avec des arguments de position.

Retina , 65 octets

Le nombre d'octets suppose un codage ISO 8859-1.

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

Essayez-le en ligne!

Gelée , 41 octets

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

Essayez-le en ligne!

Python, 94 octets

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

C #, 219 211 212 146 122 octets

Implémentation de multiples suggestions à partir de commentaires avec optimisation supplémentaire. Voici le résultat 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";}

Essayez-le en ligne!

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

Sortie pour les cas de test:

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: Merci à Weston d’avoir suggéré l’utilisation d’une fonction

MATLAB / Octave , 133 111 octets

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

C'est un début. Espérons pouvoir être réduit davantage.

En gros, il s’agit d’une fonction anonyme qui prend une entrée de chaîne puis utilise regex pour créer la sortie requise.

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

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

Vous pouvez en quelque sorte l' essayer en ligne! . Le code ne fonctionne pas tout à fait avec Octave car toutes les lettres majuscules deviennent ${upper($0)}, alors que dans MATLAB, il est converti en lettre majuscule réelle.

Étant donné que la saisie est garantie a-z(alphabet minuscule), je peux économiser 22 octets en utilisant une simple soustraction de 32 pour convertir la première lettre de la chaîne en majuscule, plutôt qu'en utilisant regex avec la upper()fonction.

En conséquence, le code fonctionne également avec Octave, vous pouvez donc l' essayer en ligne!

Ruby, 89 88 86 79 octets

Ma première soumission de golf:

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

Merci beaucoup à @manatwork pour son commentaire génial: 7 octets de moins!

Nova , 105 octets

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

Comme Nova ( http://nova-lang.org ) est une version bêta (et un buggy) extrêmement précoce, il existe des handicaps évidents qui l'empêchent d'utiliser encore moins d'octets.

Par exemple, vous auriez pu enregistrer un appel de fonction en majuscule (appelé 3 fois) dans une variable locale comme celle-ci:

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

qui aurait pris le compte d'octets à 89 octets . La raison pour laquelle cela ne fonctionne pas maintenant peut être imputée à l'ordre d'évaluation des arguments en langage C, car Nova est compilé en C. (L'ordre d'évaluation des arguments sera corrigé dans une prochaine mise à jour)

Encore plus, j'aurais pu introduire une propriété "title" dans la classe String (et je ferai cela après lol) pour réduire le nombre de l'appel de fonction de capitalisation:

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

et cela libérerait 7 octets pour un nouveau total de 82 octets .

De plus (et plus loin), une fois que l'inférence de type de variable lambda est ajoutée, ceci serait valide:

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

Le nombre pourrait être réduit à 72 octets .

En passant, il s’agit de mon premier code de golf, j’ai probablement manqué encore plus d’optimisations qui auraient pu être faites. Et comme il s'agit d'un langage généraliste , non centré sur le golf , je pense que c'est assez impressionnant.

Le premier code de 105 octets fonctionne dans la version actuelle de Nova Beta v0.3.8 disponible sur 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"))
    }
}

les sorties:

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

Merci d'avoir écouté ma publicité sans vergogne pour le langage généraliste Nova (disponible sur http://nova-lang.org ... obtenez-le maintenant !!)

Brainfuck, 352 octets

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

Essayez-le en ligne!

1. Obtenez l'entrée.
2. Enregistrez les caractères spéciaux pour plus tard.
3. Écrivez la première partie.
4. Enregistrez "Johnny" pour plus tard
5. Imprimer "Allez Johnny allez, allez" quatre fois
6. Écrire la dernière partie

J'aime toujours les défis dans Brainfuck, donc c'était amusant. On peut probablement jouer plus au golf, mais jouer au Brainfuck est plutôt long.

PHP, 86 octets

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

Java 8, 151 147 146 130 octets

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

Explication:

Essayez ici.

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

Empilés , 64 octets

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

Essayez-le en ligne!

C # , 159 130 128 octets

Golfé

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 lisible

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

Code complet

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

Communiqués

• v1.2 - - 2 bytes- Permuté (i)=>pour i=>, grâce au commentaire de TheLetalCoder .
• v1.1 - -29 bytes- Merci à Sir Bitesalot de la dernière mise à jour, qui m'a rappelé que je pouvais éditer la chaîne avant le formatage.
• v1.0 - 159 bytes- Solution initiale.

Remarques

Le titre contient un lien vers une page avec le code et les cas de test. Appuyez simplement sur Go et le résultat sera imprimé sous le code.

Javascript - 72 106 octets

Edit: Oups !! Je n'ai pas fait attention aux règles de capitalisation! Ça va être plus long après un moment

Edit 2: Devrait suivre les règles maintenant!

Pourrait probablement être joué au golf plus

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

Utilisé comme:

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 octets

Fonction de fenêtre immédiate VBE anonyme qui prend en entrée le type Variant/Stringde la cellule [A1]et la sort en imprimant la fenêtre immédiate VBE

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

-16 octets pour la conversion en fonction de fenêtre immédiate

-9 octets pour utiliser [PROPER(A1)]

-23 octets pour laisser tomber la For ...boucle et abuser de la? déclaration

-2 octets à remplacer " Johnny "&[A1]&", "&[A1]par[" Johnny "&A1&", "&A1]

-3 octets pour utiliser +plus& de concaténation String et en laissant la séquence terminale non fermée

Exemple de cas

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

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

Essayez-le en ligne!

Explication:

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 octets

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

Essayez-le en ligne!

Construit et imprime la première ligne puis insère Johnny goavant la virgule et duplique 4 fois. Enfin construit la dernière partie.

Python, 258 octets

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 octets

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 partie la plus longue est le format pour printf. Il y a des problèmes avec l'entrée différente de string from ato z(oui, je sais que je n'ai pas besoin de supporter quoi que ce soit d'autre).

Ungolfed avec des commentaires:

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: Golfé 16 octets grâce à weston

Mathematica, 83 octets

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

Fonction anonyme. Prend une chaîne en entrée et retourne une chaîne en sortie. Pourrait probablement être joué au golf plus loin.