Isso não é ciência de foguetes

59

Escreva um programa ou função que utilize uma string de linha única. Você pode assumir que ele contém apenas ASCII imprimível . Imprima ou retorne uma sequência de um foguete de arte ASCII, como

  |
 /_\
 |E|
 |a|
 |r|
 |t|
 |h|
 |_|
/___\
 VvV

com a sequência de entrada escrita de cima para baixo na fuselagem. Nesse caso, a entrada foi Earth. A altura do foguete (incluindo chamas) é sempre o comprimento da corda mais cinco.

Cada linha na saída pode ter até dois espaços à direita e pode haver uma nova linha à direita opcional. O código mais curto em bytes vence.

Mais exemplos:

[empty string]

  |
 /_\
 |_|
/___\
 VvV

a

  |
 /_\
 |a|
 |_|
/___\
 VvV

|0

  |
 /_\
 |||
 |0|
 |_|
/___\
 VvV

\/\

  |
 /_\
 |\|
 |/|
 |\|
 |_|
/___\
 VvV

 _ _ [note trailing space]

  |
 /_\
 | |
 |_|
 | |
 |_|
 | |
 |_|
/___\
 VvV

    [4 spaces]

  |
 /_\
 | |
 | |
 | |
 | |
 |_|
/___\
 VvV

SPACEY

  |
 /_\
 |S|
 |P|
 |A|
 |C|
 |E|
 |Y|
 |_|
/___\
 VvV

Entre os melhores

Passatempos de Calvin
fonte
11
Relacionado . Pode haver outros que sejam próximos o suficiente para que isso seja considerado um engano.
Peter Taylor
2
@ Sefa Spaces sim. Não para outro espaço em branco. Como o wiki vinculado indica.
Passatempos de Calvin
6
Ah, eu vi o título e esperava algo sobre cirurgia cerebral. :(
17
E se o fundo apontar para o céu, você não irá para o espaço hoje.
AstroDan
4
"Funcionou no Kerbal Space Program ..."
Magic Octopus Urn

Respostas:

55

Excel VBA, 142 179 175 160 155 bytes

Instrução:

Defina a planilha do Excel em que a célula A1 é entrada e a coluna C como saída. Defina o alinhamento do texto na coluna C para centralizar . Escreva e execute o seguinte código na janela imediata:

[C1]="|":[C2]="/_\":T=[A1]&"_":For i=1To Len(T):Cells(i+2,3)="|"&Mid(T,i,1)&"|":Next:Cells(i+2,3)="/__\":Cells(i+3,3)="VvV":[C:C].HorizontalAlignment=-4108

Ungolfed o código:

Sub R()
    [C1] = "|"
    [C2] = "/_\"
    T = [A1]&"_"

    For i = 1 To Len(T)
        Cells(i + 2, 3) = "|" & Mid(T, i, 1) & "|"
    Next

    Cells(i + 2, 3) = "/__\"
    Cells(i + 3, 3) = "VvV"
    [C:C].HorizontalAlignment = -4108   'Set the text alignment in column C to center
End Sub

Resultado:

insira a descrição da imagem aqui

Nota: A fonte e a cor são apenas uma opção pessoal.


15 bytes salvos devido à sugestão de edc65. Obrigado.

5 bytes salvos devido à sugestão de TaylorScott. Obrigado.

Anastasiya-Romanova 秀
fonte
Salve 15 bytes adicionando "_"a T. Assim[C1]="|":[C2]="/_\":T=[A1]&" ":For i=1To Len(T):Cells(i+2,3)="|"&Mid(T,i,1)&"|":Next:Cells(i+2,3)="/__\":Cells(i+4,3)="VvV":Columns(3).HorizontalAlignment=-4108
edc65 29/08
(ok há um erro no meu código e que seja tarde demais para editá-lo Mas você começa a idéia.)
edc65
@ edc65 Não entendi a idéia. Seu código é exatamente o mesmo que o meu, então o que devo editar para economizar 15 bytes?
Anastasiya-Romanova秀
11
154 Bytes:[C:C].HorizontalAlignment=-4108:[C1]="|":[C2]="/_\":T=[A1]&"_":For i=1To Len(T):Cells(i+2,3)="|"&Mid(T,i,1)&"|":Next:Cells(i+2,3)="/__\":Cells(i+3,3)="VvV
Taylor Scott
11
Ou você pode obtê-lo para baixo para 151 bytes, mantendo o aspecto centrando[C:C].HorizontalAlignment=3:[C1]="|":[C2]="/_\":T=[A1]&"_":For i=1To Len(T):Cells(i+2,3)="|"&Mid(T,i,1)&"|":Next:Cells(i+2,3)="/___\":Cells(i+3,3)="VvV
Taylor Scott
30

Perl 6, 75 bytes

"  |\n /_\\".say;" |$_|".say for slurp.chomp.comb;" |_|\n/___\\\n VvV".say;
bb94
fonte
101
slurp.chomp.comb... Perl é estranho.
Mego
14
SLURP !!! CHOMP !!! PENTE!! Aí vem o monstro Perl!
Stommestack 29/08/16
Observe que, usando uma função e concatanação, você pode cortar bastante: {[~] " |\n /_\\\n",|(" |$_|\n"for $_.comb)," |_|\n/___\\\n VvV"}65 bytes
user0721090601
Mas você pode ir ainda mais baixo pegando emprestado dos JS: tio.run/…
user0721090601
22

JavaScript (ES6), 54

Direto

x=>`  |
 /_\\
 |${[...x+'_'].join`|
 |`}|
/___\\
 VvV`

Teste

f=x=>`  |
 /_\\
 |${[...x+'_'].join`|
 |`}|
/___\\
 VvV`

function update() {
  O.textContent=f(I.value)
}

update()
<input id=I value='hello' oninput='update()'><pre id=O></pre>

edc65
fonte
16

Na verdade, 40 bytes

"/___\
 VvV",'_o"|
 |"j'|o" |"+"  |
 /_\

Sim, essas novas linhas devem estar lá.

Experimente online!

Explicação:

As novas linhas são representadas por \npara facilitar a formatação

"/___\\n VvV",'_o"|\n |"j'|o" |"+"  |\n /_\
"/___\\n VvV"                                create the bottom of the rocket
             ,'_o                            get input, append a "_" (for the last section before the jets)
                 "|\n |"j                    insert "|\n |" between every pair of characters
                         '|o                 append "|"
                            " |"+            prepend " |"
                                 "  |\n /_\  create the nose cone
Mego
fonte
12
Seu programa parece deprimente semelhante a um foguete explodido.
precisa saber é o seguinte
15

C, 83 , 82 bytes

F(char*c){for(puts("  |\n /_\\");*c;printf(" |%c|\n",*c++));puts(" |_|\n/___\\\n VvV");}

Teste principal:

int main() {
  F("");
  F("a");
  F("|0");
  F("\\/\\");
  F(" _ _ ");
  F("    ");
  F("SPACEY");
}
Stefano Sanfilippo
fonte
7
Eu desenvolvi minha própria solução C, e ela acabou sendo exatamente sua, personagem por personagem. +1 de mim.
Cody
No telefone e com preguiça de SSH, isso não foi testado, mas deve funcionar. Salva 2 bytes (se contei corretamente):F(char*c){for(puts(" |\n /_\\");*c;printf(" |%c|\n",*c++),puts(" |_|\n/___\\\n VvV");}
algmyr
O @algmyr salva um byte, na verdade, porque o último putsdeve ser executado apenas uma vez, não depois de cada printf. Mas sim, 1 byte salvo, yay!
Stefano Sanfilippo
Direito. Culpo isso no golfe quando deveria estar dormindo.
precisa saber é
Isso não é 88 bytes?
Gastropner
10

Python 2, 93 66 62 61 bytes

Um FGITW. Provavelmente pode ser muito jogado. Sugestões são bem-vindas.

Edit: 27 bytes graças ao Mego. 4 bytes graças ao TheBikingViking. 1 byte graças a user3030010.

Experimente Online!

lambda x:r"""  |
 /_\
 |%s|
/___\
 VvV"""%"|\n |".join(x+"_")
Sherlock9
fonte
9

PHP, 73 72 69 62 bytes

  |
 /_\
 |<?=join('|
 |',str_split($argv[1]._))?>|
/___\
 VvV

Leva a string a ser impressa na fuselagem como o primeiro argumento da linha de comando quando o script é chamado.

Melhorias:

  1. Salve um byte substituindo \ n por uma nova linha LF real no primeiro argumento de join.
  2. Economizou mais três bytes anexando a base do foguete com um único sublinhado à entrada
  3. Agradecimentos a Ismael Miguel : Economize mais 7 bytes aproveitando o fato de o PHP ser o "pré-processador de hipertexto" para que você possa produzir o texto que quiser e iniciar o código em algum lugar no meio.

Experimente online!

Isso foi divertido! :-)

Chamadas de exemplo:

php rocket.php ""
php rocket.php EARTH
php rocket.php "This is a very long rocket"
YetiCGN
fonte
62 bytes: sandbox.onlinephpfunctions.com/code/…
Ismael Miguel
Bom golfe! Eu esqueci totalmente dessa possibilidade. Obrigado!
YetiCGN
De nada. Além disso, salvei 2 bytes na primeira linha. Você tinha 2 espaços extras à direita. Era algo que eu não esperava encontrar, devo dizer.
Ismael Miguel
11
Eu sei, isso foi muito idiota, mas também muito difícil de detectar. Eu só notei uma vez que criei 64 bytes na sua versão aprimorada e precisei descobrir o porquê.
precisa saber é o seguinte
8

brainfuck , 179 bytes

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

Experimente online!

Freira Furada
fonte
@ user00001 Esta frase é usada por todos os muçulmanos em todo o mundo, não apenas pelos terroristas. Você realmente acha que os terroristas representam todos os muçulmanos?
Freira vazada
8

Ruby, 57 55 bytes

-2 bytes por @ValueInk
-5 bytes assumindo que não há nova linha na entrada, conforme sugerido por @manatwork. Uma entrada sem linha de nova pode ser fornecida, por exemplo echo -n, com , como echo -n hey | ruby rocket.rb.

puts'  |
 /_\
 |'+gets.chars*'|
 |'+'|
 |_|
/___\
 VvV'
Versão antiga, assume nova linha na entrada:

Ruby, 62 60 bytes

puts'  |
 /_\
 |'+gets.chop.chars*'|
 |'+'|
 |_|
/___\
 VvV'
daniero
fonte
De acordo com o comentário do proprietário da pergunta, a entrada não conterá caracteres de nova linha, para que você possa removê-la .chop.
manatwork
@manatwork puro, graças :)
daniero
Se você usar seqüências de aspas simples, poderá substituir as duas \\ por \ . (Em cadeias entre aspas simples, caracteres não são escapou, exceto para \'.
Valor Ink
7

Haskell, 58 bytes

f s="  |\n /_\\\n |"++((:"|\n |")=<<s)++"_|\n/___\\\n VvV"
xnor
fonte
7

Retina , 44 37 bytes

7 bytes graças a Martin Ender.

$
_
.
¶ |$0|
$
¶/___\¶ VvV
^
  |¶ /_\

Experimente online!

Freira Furada
fonte
deixa uma lacuna em uma linha na parte inferior :( para "Space, the frontier
border
@xQbert Funciona para mim, você pode anexar um link TIO?
Freira vazada
estranho, funciona bem para mim agora ... ah meu erro teve uma nova linha no final.
XQbert
A retina é o único idioma que sei que adicionar uma nova linha à direita pode alterar completamente o programa.
caird coinheringaahing
6

Geléia , 37 36 bytes

;”_⁾ |;ЀŒB;“/___\“ VvV”“  |“ /_\”;Y

A mesma pontuação da entrada existente, mas usa um novo recurso divertido - ŒB, a versão vetorizada ŒḄ, conhecida como rejeição. Bouncing está sendo executado através de uma lista ao seu fim e depois voltar x[:-1]+x[::-1]por exemplo: bounce("codegolf") == "codegolflogedoc".

-1 byte graças a Dennis (use a versão vetorizada do salto)

Quão?

;”_⁾ |;ЀŒB;“/___\“ VvV”“  |“ /_\”;Y - argument: a string, S
                        “  |“ /_\”   - the top of the rocket ["  |", " /_\"] 
;”_                                  - concatenate to make S=S+"_"
   ⁾ |;                              - concatenate to make c=" |"+c
       Ѐ                            - map over right argument i.e. for c in S
         ŒB                          - bounce! With vectorisation c[:-1]+c[::-1]
                                       e.g. " |B" -> " |B| "
           ;                         - concatenate with
            “/___\“ VvV”             - the bottom of the rocket ["/___\", " VvV"]
                                  ;  - concatenate the top with everything else
                                   Y - join with line feeds

Teste no TryItOnline

Jonathan Allan
fonte
2
ŒBé a abreviação de ŒḄ€.
Dennis
6

Pyke , 40 37 35 bytes

(Atualizado para funcionar com a versão mais recente)

\_+2" ||
"m:"/___\
 VvV"+R"  |
 /_\

Experimente aqui!

Azul
fonte
5

V , 41, 39 bytes

ys$_òlé
òÎá|I |
Hr/$r\YO  |GpX2á_o VvV

Experimente online!

Observe que, por algum motivo, o intérprete on-line estava produzindo resultados inesperados, então enviei uma versão de depuração para o intérprete on-line que é muito mais lento. Ele deve produzir os resultados corretos agora.

Como este programa contém caracteres não imprimíveis, aqui está um hexdump:

0000000: 7973 245f f26c e90a f2ce e17c 4920 7c0a  ys$_.l.....|I |.
0000010: 4872 2f24 725c 594f 2020 7c1b 4770 5832  Hr/$r\YO  |.GpX2
0000020: e15f 6f20 5676 56                        ._o VvV
DJMcMayhem
fonte
Bom, mas não lida com os espaços em "Space, a fronteira final".
precisa saber é
5

R, 163 bytes

v=c();l="\n";for(i in 1:nchar(a<-scan(,"")))v=c(v,paste0(" |",strsplit(a,"")[[1]][i],"|",l,collapse=""));cat("  |",l," /_\\",l,v," |_|",l,"/___\\",l," VvV",sep="")

Ungolfed:

v=c()     #Empty vector
l="\n"    #Line break

for(i in 1:nchar(a<-scan(,"")))                  #For the number of character of the input
    v=c(v, paste0(" |",strsplit(a,"")[[1]][i],"|","\n",collapse=""))
    #This part cut the input into its letters, paste each letter between `|`'s, 
    #and a line break

cat("  |",l," /_\\",l,v," |_|",l,"/___\\",l," VvV",sep="") #Puts everything in the STDOUT,
                                                           #with spaces where needed

Eu realmente não gosto do fato de ter colocado alguns espaços na última linha, mas ei!

Frédéric
fonte
5

PowerShell v2 +, 59 55 51 bytes

"  |
 /_\"
$args|% t*y|%{" |$_|"}
" |_|
/___\
 VvV"

Experimente online!

Abusa o padrão Write-Outputno final da execução para fixar uma nova linha entre cada elemento, pois essas são apenas cadeias literais no pipeline. O único bit "complicado" é um loop através de cada elemento da entrada $argscomo um conjunto de caracteres para obter o corpo do foguete.

Usa novas linhas literais, conforme indicado pelo ConnorLSW, para salvar alguns bytes.
-4 bytes a mais graças ao Veskah.

AdmBorkBork
fonte
você pode colocar novas linhas reais na cadeia para salvar 3, o shell e ise executar bem sem o\r
colsw
4

PowerShell, 70 bytes

"  |`n /_\`n$(([char[]]$a|%{" |$_|"})-join("`n"))`n |_|`n/___\`n VvV 

Defina $ a para inserir.

Se precisar receber outra entrada que não seja uma variável, pode ser canalizado:

"Hello World"|%{"  |`n /_\`n$(([char[]]$_|%{" |$_|"})-join("`n"))`n |_|`n/___\`n VvV "}

Exemplo:

  |
 /_\
 |H|
 |e|
 |l|
 |l|
 |o|
 | |
 |W|
 |o|
 |r|
 |l|
 |d|
 |_|
/___\
 VvV 
Chirishman
fonte
4

Mathematica, 50 bytes

"  |
 /_\\
 |"<>(#<>"|
 |"&/@#)<>"_|
/___\\
 VvV"&

Função anônima. Pega uma lista de caracteres como entrada e retorna uma string como saída.

LegionMammal978
fonte
4

PHP, 108 100 88 bytes

-8 bytes graças ao gato de negócios

-12 bytes graças ao YetiCGN

echo'  | 
 /_\\
';foreach(str_split($argv[1])as$c){echo" |$c|
";}echo' |_|
/___\\
 VvV';

bem direto

Ideone

Sefa
fonte
11
Você pode salvar muitos bytes usando em foreach(str_split($a)as$c)vez do outro loop for. Além disso, você pode colocar $ c diretamente na string se usar aspas duplas:echo" |$c| ....";
Business Cat
@BusinessCat Verdadeiros, graças as aspas duplas não estava funcionando com o estilo variedade pensou devido aos suportes não sendo interpretado
Sefa
E a expressão regular? function f($a){echo' |.␤ /_\\␤',preg_replace('/./',' |$0|␤',$a),' |_|␤/___\\␤ VvV';}
manatwork
11
Por que colocar uma função em torno disso? Substituir $acom $argv[1]a funcionar a partir de linha de comando faz com que seja muito mais curto.
YetiCGN
@manatwork Provavelmente é uma alternativa válida, mas como eu não a entendo e não está no mesmo espírito que o meu, deixarei que você a publique.
Sefa
4

C #, 106 97 80 74 bytes

s=>$@"  |
 /_\
 |{string.Join("|\n |",s.ToCharArray())}|
 |_|
/___\
 VvV";

Eu não tenho o C # 6 para tentar o acima, mas acredito que funcionará

Guardado 7 bytes graças a Kevin Cruijssen

Obrigado ao manatwork por me indicar a direção certa para economizar 17 bytes

Economizou 6 bytes graças ao leite

TheLethalCoder
fonte
+1. Btw, espaços em branco à direita são opcionais, assim você pode alterá-lo para: using System.Linq;s=>$(" |\n /_\\\n{string.Join("",s.Select(c=>" |"+c+"|\n"))} |_|\n/___\\\n VvV");( 100 bytes )
Kevin Cruijssen
11
@KevinCruijssen eu estava apenas no processo de atualizar isso depois de seus comentários à minha resposta anterior :) Obrigado pela ajuda
TheLethalCoder
Você pode salvar alguns caracteres usando uma única string literal dentro Select: " |"+c+"|\n"c+"|\n |"junto com o movimento `|` de depois {}antes dele.
manatwork
@manatwork eu não consigo chegar a esse trabalho
TheLethalCoder
11
A nova linha tem 1 byte em comparação com \nos 2 bytes. Então você economizará mais 5 bytes substituindo-os por novas linhas. Sim, se você estiver usando o Visual Studio, por padrão, novas linhas terão 2 bytes, mas você poderá abrir o arquivo de origem em um editor hexadecimal (o Visual Studio possui um) e excluir os caracteres de retorno de carro. A saída ainda será a mesma.
milk
4

C,  131  , 121 bytes

#define P printf
main(){char s[99],*p=s;gets(s);P("  |\n /_\\\n");while(*p)P(" |%c|\n",*p++);P(" |_|\n/___\\\n VvV\n");}
RosLuP
fonte
Você pode remover três caracteres movendo p=s- se para a inicialização e usando o pinterior scanf:main(){char s[99],*p=s;scanf("%s",p);P(" |\n /_\\\n");while(*p)P(" |%c|\n",*p++);P(" |_|\n/___\\\n VvV\n");}
Quentin
ok .... não sei por que "scanf ("% s ", & s)" em vez de "scanf ("% s ", s)" imprime no final o resultado correto ... no final, porque o scanf não obtém espaços prefiro o perigo gets () ...
RosLuP
2
Por favor, não vandalize suas postagens. Obrigado!
NobodyNada
3

Geléia, 38 37 bytes

;”_“|“|¶”jЀ“  |¶“/_\¶”;K;“/___\¶ VvV

Experimente online!

A mesma idéia da minha resposta Pyth, mas isso provavelmente pode ser jogado.

PurkkaKoodari
fonte
3

05AB1E , 50 47 43 37 bytes

I'_J"  |
 /_\"svy" |ÿ|"}"/___\
 VvV"»

Experimente online!

Economizou 9 bytes graças a Adnan.

Emigna
fonte
Cordas também pode aceitar novas linhas em 05AB1E: p, como este .
26416 Adnan
@ Adnan Nice, obrigado! Alguma idéia de como melhor contornar a entrada vazia?
Emigna
Eu estava pensando em uma abordagem IðJno início do programa, que também inclui a base da fuselagem.
Adnan
@Adnan Ótima idéia. Eu tentei isso com «mais cedo, sem muita sorte. Isso é muito melhor ainda.
Emigna
Remover Ue substituir Xpor stambém salva um byte :).
Adnan
3

Kotlin, 68 bytes

{"""  |
 /_\${it.replace(Regex("."),"\n |\$0|")}
 |_|
/___\
 VvV"""}

Bem direto. Usa seqüência de caracteres multilinha e uma substituição de regex. Este é um lambda com o (String)->Stringtipo. Teste:

fun main(args: Array<String>) {
    val function : (String)->String = {"""  |
 /_\${it.replace(Regex("."),"\n |\$0|")}
 |_|
/___\
 VvV"""}
    println(function(" _ _ "))
}
JustACluelessNewbie
fonte
3

Gema, 50 caracteres

\A=  |\n\ /_\\\n
?=\ |?|\n
\Z=\ |_|\n/___\\\n\ VvV

Exemplo de execução:

bash-4.3$ echo -n gema | gema '\A=  |\n\ /_\\\n;?=\ |?|\n;\Z=\ |_|\n/___\\\n\ VvV'
  |
 /_\
 |g|
 |e|
 |m|
 |a|
 |_|
/___\
 VvV
homem a trabalhar
fonte
3
Você está perdendo o `| _ |` antes da base do foguete Eu acho
TheLethalCoder
Ai. Senhorita idiota. Obrigado @TheLethalCoder.
manatwork
11
+1 por me apresentar um novo idioma (para mim) (não golfe).
Jordan
3

BASH 84 70

Guardado 14 graças a manatwork

(cat&&echo _)|sed 's~.~ |&|\n~g;1s~^~  |\n /_\\\n~;$s~$~/___\\\n VvV~'

Mais da metade dos bytes são para adicionar o nariz e o mecanismo.

Riley
fonte
Por que o grep? (cat&&echo _)|sed 's~.~ |&|\n~g;1s~^~ |\n /_\\\n~;$s~$~/___\\\n VvV~'. Na verdade, não vejo razão para usar cate echotambém. Seria mais curto transformado em sedsolução pura .
manatwork
Com pura sed, você não obter qualquer saída se você não tem entrada
Riley
Doh. Você está certo. Desculpe, esqueci essa parte do requisito.
manatwork
@ manatwork Também esqueci na minha primeira tentativa.
Riley
Para referência futura, evite usar as tags <pre> <code>. Use 4 espaços que precedem o código no futuro, pois isso escapa automaticamente a formatação do Markdown. Eu mantive a formatação atual devido ao rasurado, mas você pode deixar isso no histórico de edições também para os curiosos.
precisa saber é o seguinte
3

GolfScript, 61 51 bytes

Meu primeiro código de golfe, espero que seja bom o suficiente.

"  |
 /_\\
"\1/.,{" |"\(\"|
"\}\*" |_|
/___\\
 VvV"

Explicação

"  |\n /_\\\n"   # Push the rocket's head
\                # Swap the head with the user's string
1/               # The string is converted into an array
.,               # Push array length
{" |"\           # Push the rocket's body and swap
(\               # Array's first element cut out
"|\n"\           # Push rocket's body and swap
}\*              # Repeat for array length times
" |_|\n/___\\\n VvV" # Push rocket's bottom

Experimente online!

FedeWar
fonte
3

Vim, 41 39 bytes

Aqui o <End>é literalmente a tecla "End".

i <End>_:s/./ |&|\r/g
/___\
 VvVggxo /_\

Não imprimíveis, portanto:

i <End>_^O:s/./ |&|\r/g
/___\
 VvV^[ggxo /_\^[
nmjcman101
fonte
3

GNU sed , 54 49 48 bytes

Esta foi a minha primeira resposta a um desafio neste site. A solução é simples, principalmente de impressão, por isso passei algum tempo certificando-me de que não pode mais jogar golfe.

s:.:\n |&|:g
s::  |& /_\\&:
a\ |_|\n/___\\\n VvV

Experimente online!

Avanço rápido meio ano depois, reescrevi o script, usei um truque para uma boa medida e reduzi em 1 byte a menos. Agora isso é progresso!

Explicação: o espaço do padrão em cada etapa é mencionado para maior clareza, dado o exemplo de entrada "GO"

s:.:\n |&|:g
   # turn each input char into a section of the rocket (\n |G|\n |O|)
s::  |& /_\\&:
   # 's::' is a trick; the search part is actually the one from the previous 's'
   #command, i.e. a char. Only the first char, '\n', the modifier 'g' is not
   #inherited. The replace part is the head of the rocket. (  |\n /_\\n |G|\n |O|)
a\ |_|\n/___\\\n VvV
   # append the tail of the rocket, plus implicit printing at the end

  |
 /_\
 |G|
 |O|
 |_|
/___\
 VvV
seshoumara
fonte
3

Lua, 83 , 92 bytes

function f(x)return' |\n /_\\\n'..x:gsub('(.)',' |%1|\n')..' |_|\n/___\\\n VvV'end

print('  |\n /_\\\n'..(arg[1] and arg[1]:gsub('(.)',' |%1|\n') or '')..' |_|\n/___\\\n VvV')
Nolan
fonte
Se eu não adicionar nenhuma entrada à sua resposta. Não funciona.
Nolan