Infelizmente, o pai fundador do rock and roll, Chuck Berry, faleceu hoje.

Considere o refrão de sua famosa música " Johnny B. Goode ":

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

^{(Existem outras maneiras de pontuar, mas as opções acima servirão para os propósitos do desafio.)}

Desafio

Dada uma sequência de letras em minúscula az, vazia, emita o coro de "Johnny B. Goode" com todas as instâncias Goou gosubstituídas pela sequência de entrada, maiúsculas da mesma maneira.

Uma nova linha à direita pode seguir opcionalmente. Nada mais no refrão deve mudar.

Por exemplo , se a entrada for codea saída, deve ser exatamente

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

opcionalmente seguido por uma nova linha.

Observe que a capitalização de todas as palavras corresponde ao refrão original e (apesar da falta de ritmo) o Goin Goodeé substituído, bem como as palavras individuais Goe go.

O código mais curto em bytes vence.

Casos de teste

"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

Vá, 123 bytes

Vai Johnny, vai !

Experimente 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 Pressionamentos de tecla (salvou 1 pressionamento de tecla do 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.         

Comece com a palavra em uma linha em um arquivo com o cursor no primeiro caractere, e isso substituirá tudo pelo texto Explicação

1. Copie a palavra em um registro e altere a primeira letra a ser maiúscula e salve-a em um registro.
2. Escreva a primeira linha usando os registradores para preencher as substituições e as últimas linhas
3. Escreva a segunda linha usando os registradores para preencher as substituições
4. Repita a linha do meio 3 vezes

Experimente online! (Obrigado DJMcMayhem !)

Pure Bash, 69 76 bytes

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

Experimente online!

05AB1E , 37 bytes

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

Experimente online!

Explicação

™„, ¹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 a serialização de matriz para string para criar vírgulas. Constrói uma matriz do formulário:

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

E concatena-o com a sequência do formulário ", 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`

Versão anterior:

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

Como funciona:

• É uma função anônima que recebe a entrada como parâmetro i

• Define uma variável ucomo a entrada icom a primeira letra maiúscula (Observe que isso pressupõe que a entrada não seja vazia, o que é OK)

• Apenas construa diretamente a string a ser retornada dessas duas variáveis.

• Repetir a string "go, \nGo Johnny go"quatro vezes em vez de repetir "Go Johnny go, go"economiza um byte.

Edit 1: Esqueceu de jogar fora o ponto e vírgula, haha ​​!! Também desconsiderou os bytes, era originalmente 102, não 104. Obrigado apsillers .

Edit 2: Em vez de .repeat(4), colocar essa string em uma variável xe doing x+x+x+xpermite salvar dois bytes.

Snippet de teste

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

Experimente online!

O desafio perfeito para o V!

Explicação:

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

Pitão - 52 bytes

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

Conjunto de Teste .

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)

Uma string de formato simples, com argumentos posicionais.

Retina , 65 bytes

A contagem de bytes assume a codificação ISO 8859-1.

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

Experimente online!

Geléia , 41 bytes

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

Experimente 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

Implementou várias sugestões de comentários com otimização adicional Este é o 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";}

Experimente online!

Explicação:

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

Saída para casos de teste:

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: Obrigado a weston por sugerir o uso de uma função

MATLAB / Oitava , 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 '})

É um começo. Esperemos que possa ser reduzido ainda mais.

Basicamente, é uma função anônima que recebe uma entrada de sequência e usa regex para criar a saída necessária.

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

Um exemplo:

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

Você pode tipo de Experimente online! . O código não funciona bem com o Octave à medida que todas as letras maiúsculas se tornam ${upper($0)}, enquanto no MATLAB isso é convertido para a letra maiúscula real.

Dado que a entrada é garantida como apenas a-z(alfabeto minúsculo), eu posso salvar 22 bytes usando uma subtração simples de 32 para converter a primeira letra da string em maiúscula, em vez de usar regex com a upper()função

Como resultado, o código agora também funciona com o Octave, para que você possa experimentá-lo online!

Ruby, 89 88 86 79 bytes

Minha primeira submissão de golfe:

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

Muito obrigado a @manatwork por seu comentário impressionante: 7 bytes a menos!

Nova , 105 bytes

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

Como o Nova ( http://nova-lang.org ) é extremamente beta (e com erros), existem algumas desvantagens óbvias existentes aqui, impedindo o uso de menos bytes ainda.

Por exemplo, poderia ter salvo a chamada de função em maiúscula (que é chamada três vezes) em uma variável local como esta:

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

o que levaria a contagem de bytes para 89 bytes . A razão pela qual isso não funciona agora pode ser atribuída à ordem de avaliação de argumentos na linguagem C, porque Nova é compilada em C. (A ordem de avaliação de argumentos será corrigida em uma atualização futura)

Ainda mais, eu poderia ter introduzido uma propriedade "title" na classe String (e depois de fazer isso lol) para reduzir a contagem da chamada da função de capitalização:

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

e isso liberaria 7 bytes para um novo total de 82 bytes .

Além disso (e mais adiante), uma vez adicionada a inferência do tipo de variável lambda, isso seria válido:

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

A contagem pode ser reduzida para 72 bytes .

A propósito, este é o meu primeiro código de golfe, então provavelmente perdi ainda mais otimizações que poderiam ter sido feitas. E sendo esta uma linguagem de uso geral , não centrada no golfe , acho bastante impressionante.

O primeiro código de 105 bytes funciona na versão atual do Nova Beta v0.3.8 disponível em 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"))
    }
}

saídas:

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

Obrigado por ouvir meu anúncio descarado para o idioma de uso geral Nova (encontrado em http://nova-lang.org ... obtenha-o agora !!)

Brainfuck, 352 bytes

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

Experimente online!

1. Obtenha a entrada.
2. Salve caracteres especiais para mais tarde.
3. Escreva a primeira parte.
4. Salve "Johnny" para mais tarde
5. Imprimir "Vai Johnny vai, vai" quatro vezes
6. Escreva a última parte

Eu sempre gosto de desafios no Brainfuck, então foi divertido. Provavelmente pode ser jogado mais, mas o golfe Brainfuck é meio longo.

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

Explicação:

Experimente aqui.

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

Empilhados , 64 bytes

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

Experimente online!

C # , 159 130 128 bytes

Golfe

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 legible

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

Lançamentos

• v1.2 - - 2 bytes- Trocado (i)=>por i=>, graças ao comentário de TheLetalCoder .
• v1.1 - -29 bytes- Graças a Sir Bitesalot, na última atualização, que se lembrava de mim: eu podia editar a string antes do formato.
• v1.0 - 159 bytes- Solução inicial.

Notas

O título possui um link para uma página com o código e os casos de teste. Basta pressionar Go e o resultado será impresso abaixo do código.

Javascript - 72 106 bytes

Edit: Opa !! Não prestei atenção às regras de capitalização! Vai demorar mais tempo

Edit 2: Deve estar seguindo as regras agora!

Provavelmente poderia ser jogado mais

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

Função de janela imediata VBE anônima que recebe entrada do tipo Variant/Stringda célula [A1]e sai imprimindo a janela imediata do VBE

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

-16 bytes para converter em função de janela imediata

-9 bytes para usar [PROPER(A1)]

-23 bytes para descartar o For ...loop e abusar da ?instrução

-2 bytes para substituir " Johnny "&[A1]&", "&[A1]por[" Johnny "&A1&", "&A1]

-3 bytes para usar +over &para concatenação de String e deixar a string do terminal não fechada

Exemplo de Caso

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

Experimente online!

Explicação:

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:

Experimente online!

Constrói e imprime a primeira linha, insere Johnny goantes da vírgula e a duplica 4 vezes. Finalmente constrói a ú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 ");}}

A parte mais longa é o formato para printf. Existem problemas com a entrada diferente de string de apara z(sim, eu sei que não preciso dar suporte a mais nada).

Ungolfed com comentários:

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: Golfed 16 bytes graças a weston

Mathematica, 83 bytes

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

Função anônima. Pega uma string como entrada e retorna uma string como saída. Provavelmente poderia ser jogado ainda mais.