Scegli un set di quattro byte senza sostituzione (ovvero nessun byte ripetuto), e non necessariamente in un ordine particolare, da uno dei seguenti quattro set:

1. I caratteri di ogni codifica a byte singolo
2. I caratteri Unicode nell'intervallo 00 – FF
3. Gli interi decimali con segno nell'intervallo −128–127
4. Gli interi decimali senza segno nell'intervallo 0–255

I quattro valori scelti (si prega di indicare quali sono) saranno gli input validi. È necessario associare ciascun valore a una delle illustrazioni ASCII sottostanti.

Dato (con qualsiasi mezzo) uno dei tuoi quattro input validi, rispondi (con qualsiasi mezzo, anche elenco di stringhe) con la corrispondente arte ASCII. È consentito uno spazio bianco extra su tutti i lati, purché l'immagine sia all'interno di un'area 2D contigua.

Primo byte:

     /\
    /  \
   |    |
   |    |
   |    |
   |____|
    \__/
    |  |
    |  |
    |  |
    |  |
 /\ |  | /\
/  \|  |/  \
|  ||  ||  |
|  ||  ||  |
|  ||  ||  |
|  ||  ||  |
|  ||  ||  |
|  ||  ||  |
|  ||  ||  |
|  ||  ||  |
|  ||  ||  |
|  ||  ||  |
|  ||  ||  |
|  ||  ||  |
|  ||  ||  |
|  ||  ||  |
|  ||  ||  |
|  ||  ||  |
|  ||  ||  |
|  ||  ||  |
AAAAAAAAAAAA

Secondo byte:

  /\
 /  \
|    |
|    |
|    |
|____|
 \__/
 |  |
 |  |
 |  |
 |  |
 |  |
 |  |
 |  |
 |  |
 |  |
 |  |
 |  |
 |  |
 |  |
 |  |
 |  |
 |  |
 |  |
 |  |
 |  |
 |  |
 |  |
 |  |
 |  |
 |  |
 AAAA

Terzo byte:

  /\
 /  \
|    |
|    |
|    |
|____|
 \__/
 |  |
 |  |
 |  |
 |__|
  /\

Quarto byte:

 db
_/\_
\__/
|  |
|  |
|  |
|__|
 /\

Cosa c'è di nuovo in questa sfida di complessità Kolmogorov nell'arte ASCII?

1. La possibilità di selezionare input validi presenta un nuovo aspetto della sfida. Gli input sono chiaramente troppo limitati per codificare l'intero risultato, ma possono trasportare informazioni sufficienti per meritare attenzione.

2. Le molteplici uscite possibili condividono molta struttura, quindi è possibile riutilizzare il codice o le immagini secondarie sia all'interno di ciascuna immagine sia tra le immagini.

3. Vi è una duplicazione sufficiente che persino le lingue che non sono ben orientate verso sfide come questa hanno una buona possibilità di essere in grado di utilizzare il codice intelligente piuttosto che solo stringhe con codifica estesa.

JavaScript (ES6), 247 byte

RegPack'ed. Si aspetta 0 ... 3 come input.

n=>[...'BigFu!#?%$Rocket'].reduce((s,c)=>(x=s.split(c)).join(x.pop()),`oF#$!
FRFRFRF|??|$i$t$t$t$t%# t #
!t!BBB
uuceeeeeee%c%|?|
o#, db
_#_
iggg
|?|%#g|o|e%t%t%tkgttgttcu,o#%!
RRR|??|%ieF R|oo|
$
oo%
 ?__#/\\!/o\\uAAAAFo g
ti\\?/Bkkk`).split`,`[n]

Provalo online!

Carbone , 67 byte

ＮθＦ⁼³θ«ＰAA↑↑¹⁸↗²‖ＭＭ⁴±χ»¿θ«↙²↓⁴Ｍ↗__¶\_¶»↓d/_¶ _\↓×⁴∨›²θ⁶¿‹¹θAA↑¶/_‖Ｍ

Provalo online! Il collegamento è alla versione dettagliata del codice. Accetta input come numero 3-0. Spiegazione:

Ｎθ

Inserisci il numero.

Ｆ⁼³θ«ＰAA↑↑¹⁸↗²‖ＭＭ⁴±χ»

Se è 3, pesca metà del booster, quindi rispecchialo, quindi spostati sulla punta del razzo.

¿θ«↙²↓⁴Ｍ↗__¶\_¶»

Se non è 0, disegna la metà sinistra del serbatoio del carburante anteriore.

↓d/_¶ _\

Ma se è 3, disegna la metà sinistra del cono del naso.

↓×⁴∨›²θ⁶

Disegna il lato sinistro del razzo.

¿‹¹θAA↑¶/_‖Ｍ

Disegna la base appropriata del razzo e poi specchia per finire.

Pulito , 292 278 273 271 262 261 byte

-5 byte grazie ad Adám

import StdEnv,Text
e=[k,k,k,"|__|",m]
l=repeatn
o="\\__/"
n="/  \\"
m="/\\"
u="|    |"
s="AAAA"
k="|  |"
?z=[m,n,u,u,u,"|____|",o:z]

\i=[cjustify 12[c\\c<-:q]\\q<-[?[k,k,k,k,m+" "+k+" "+m,n+k+n,k+k+k:l 18(k+k+k)]++[s+s+s],?(l 24k++[s]),?e,["db","_/\\_",o:e]]!!i]

Provalo online!

Una funzione lambda, che associa i Intvalori 0..3alle immagini nell'ordine elencato nell'OP.

Python 2 , 292 290 284 282 281 byte

i,j,d,e,x,y=input()," "," /\\ ","/  \\","|  |","\__/"
f=i<1
l,m,n,p,q,s=3*f*j,j*(i<3),d*f,e*f,x*f,j*(i>0)
print"\n".join(([l+j+d,l+j+e]+[l+"|    |"]*3+[l+"|____|",l+j+y],[" db\n_/\_",y])[i>2]+([l+j+x]*4+[n+s+x+n,p+s+x+p]+[q+s+x+q]*18+[s+"A"*(4,12)[f]],[m+x]*3+[m+"|__|",m+d])[i>1])

Provalo online!

Accetta un numero intero compreso tra 0 e 3 come input e utilizza l'indicizzazione dell'elenco (1 o 0) per creare ogni output.

-2 per una coppia di parentesi non necessarie.

-6 rimuovendo un'assegnazione variabile che è stata utilizzata una sola volta.

-2 per un'altra variabile monouso.

-1 con un suggerimento da @Rod

Rubino , 234 212 205 byte

->n{y=*"| "
h=%w{/ /\ }+["|  "]*3+%w{|__ \\_}+y*3
t=%w{|_ /}
[h+["| ","/\\ | ","/  \\| ",*["|  || "]*18,?A*6],h+y*21<<?A*2,h+t,%w{d _/ \\_}+y*3+t][n].map{|a|a.rjust(6," ")+a.reverse.tr("\\\\/d","/\\\\b")}}

Provalo online!

Prende un numero intero 0-3. Costruisce un array delle metà sinistra di ogni fase, indicizza, quindi esegue il pad e riflette ogni riga. Tutte le imbottiture hanno la stessa larghezza, quindi le ultime fasi hanno spazi bianchi iniziali. Restituisce una matrice di stringhe.

-2 byte: dichiarare subito ycome un array invece di averne bisogno in *[y]seguito.

-5 byte: sostituire x="\\"con t=%w{_| \\}.

-5 byte: meno dereferenziazione, più aggiunta di array.

-1 byte: h+y*21+[?A*2]-> h+y*21<<?A*2nella fase 1.

-3 byte: la specifica consente l'omissione di *$/unire il risultato.

-4 byte: ["b","\\_","_/"]-> %w{b \\_ _/}nella fase 3.

-2 byte: utilizzare anche la %wnotazione nell'array head.

-7 byte: utilizzare al rjustposto dell'imbottitura manuale (ciò significa anche generare il lato sinistro e rispecchiarlo, anziché iniziare con il lato destro)

Ungolfed:

->n{
  y=*"| "                                            # Same as y=[" |"]
  h=%w{/ /\ }+["|  "]*3+%w{|__ \\_}+y*3              # Head for phases 0-2
  t=%w{|_ /}                                         # Tail for phases 2,3
  [
    h+["| ","/\\ | ","/  \\| ",*["|  || "]*18,?A*6], # Phase 0
    h+y*21<<?A*2,                                    # Phase 1
    h+t,                                             # Phase 2
    %w{d _/ \\_}+y*3+t                               # Phase 3
  ][n].map{|a|                                       # Choose phase
    a.rjust(6," ") +                                 # Pad left to width 6
    a.reverse.tr("\\\\/d","/\\\\b")                  # Add mirror (right side)
  }
}

SOGL V0.12 , 90 byte

┐∙2╚;+ƨA+.1>?jj■|_ /√+}R
3<?'».1>⌡9R"    kΓC+SA}‘03ž}.‽'⁴R╬³2±6«ž}.3=?4R╬³"XƧ⁸│\׀2⁴‘4n10žP}╬³

Provalo qui!

Ingressi 0/1/2/3 corrispondenti ai byte 1/2/3/4

Rubino , 209 183 byte

->n{z=[a=' /\\ ',b='/  \\']+['|    |']*3+%w{|____| \__/}+[c='|  |']*24+[?A*n]
n>4&&z[10..-n/6]=n>8?[c,a+c+a,b+c+b]+[c*3]*18:['|__|',a]
n==5&&z[0,6]=%w{db _/\_}
z.map{|i|i.center(12)}}

Provalo online!

Ingressi richiesti come segue:

Centre core + upper stage + fairing: 4
As above + boosters : 12
Upper stage + fairing: 6
Upper stage without fairing 5

L'idea è di prendere il centre core + upper stage + fairingvalore predefinito e modificarlo per gli altri output.

Commentate

->n{
  #z = array of parts for centre core + upper stage + fairing, with n A's at the bottom
  z=[a=' /\\ ',b='/  \\']+['|    |']*3+%w{|____| \__/}+[c='|  |']*24+[?A*n]

  #if n not 4, z from element 10 to the last [10..-1] or last but one [10..-2] =
  n>4&&z[10..-n/6]=
    n>8?[c,a+c+a,b+c+b]+[c*3]*18:   #centre core + boosters#
    ['|__|',a]                      #upper stage engine
  n==5&&z[0,6]=%w{db _/\_}        #if n==5, replace first 6 elements with unfaired payload
  z.map{|i|i.center(12)}          #pad each element of array to 12 characters
}                                 #return array of strings (format allowed by question)

Rosso , 333 byte

f: func[g][t:{    }b:{ /\ }c:{/  \}d:{   |}e:{|}j:{\__/}k:{|  |}a:{AAAA}h:[1[t b]1[t c]3[d t e]1[d{____}e]1[t j]]z:[3[t k]1[t{|__|}]1[t b]]r: func[w][foreach[i v]w[loop i[print rejoin v]]]switch g[1 do[r h r[4[t k]1[b k b]1[c k c]18[k k k]]r[1[a a a]]]2 do[r h r[24[t k]]r[1[t a]]]3 do[r h r z]4 do[r[1[t{ db}]1[t{_/\_}]1[t j]]r z]]]

Provalo online!

Accetta 1 - 4 come input

f: func [ g ] [
    t: {    }
    b: { /\ }
    c: {/  \}
    d: {   |}
    e: {|}
    j: {\__/}
    k: {|  |}
    a: {AAAA} 
    h: [1 [t b] 1 [t c] 3 [d t e] 1 [d {____} e ] 1 [t j]]
    z: [3 [t k] 1 [t {|__|}] 1 [t b]]
    r: func [ w ] [
        foreach [ i v ] w [
            loop i [print rejoin v]]]
    switch g [
        1 do [r h r [4 [t k] 1 [b k b] 1 [c k c] 18 [k k k]] r [1 [a a a]]]
        2 do [r h r [24 [t k]] r [1 [t a]]]
        3 do [r h r z]
        4 do [r [ 1 [t { db}] 1 [t {_/\_}] 1 [t j] ] r z]
    ]
]

Rebol , 258 byte

Ho fatto un esperimento con la compressfunzione di Rebol , comprimendo una stringa di tutte e 4 le fasi e stampandone la parte corrispondente dopo la decompressione:

f: func[n][o:[[1 374][374 196][570 74][644 37]]
b: decompress debase{eJzjUgAB/RguMKWgAGbUgDg1OFnxQABmKcTEx+uDGTVQOZwM/RgwA2QTyBYQG2wbiAHDw5vjiAS4IEEOCwGoWmQKGsaQAIYE4eAhqeMFSCICGZKSxBWvHxPPBVYKDzkoAVamHwMAjkWmoKkCAAA=}
repeat i o/(n)/2[prin b/(i + o/(n)/1)]]

 f 3
  /\
 /  \
|    |
|    |
|    |
|____|
 \__/
 |  |
 |  |
 |  |
 |__|
  /\

Jstx , 124 byte

↕t▌ÇÇÉÇ~éÇÇÇÇÇÇÇÉΘçK↑ε♀▄ü╙Çz⌡"#ße┐é+\òEhZ█╣S♪[ƒuø>!f♪K▌;0♂9☺}ås══½☻eP▌◙&£óZß:&╝af$V≈-wº[√D(♪╘Pφó√ò▲¶>å⌡◘├^∟z◘αßj◙÷»|æ⌠┼øk&£b

Spiegazione

↕t▌ÇÇÉÇ~éÇÇÇÇÇÇÇÉΘçK↑ε♀▄ü╙Çz⌡"#ße┐é+\òEhZ█╣S♪[ƒuø>!f♪K▌;0♂9☺}ås══½☻eP▌◙&£óZß:&╝af$V≈-wº[√D(♪╘Pφó√ò▲¶>å⌡◘├^∟z◘αßj◙÷»|æ⌠┼ # Push literal      /\\n    /  \\n   |    |\n   |    |\n   |    |\n   |____|\n    \__/\n    |  |\n    |  |\n    |  |\n    |  |\n /\ |  | /\\n/  \|  |/  \\n|  ||  ||  |\n|  ||  ||  |\n|  ||  ||  |\n|  ||  ||  |\n|  ||  ||  |\n|  ||  ||  |\n|  ||  ||  |\n|  ||  ||  |\n|  ||  ||  |\n|  ||  ||  |\n|  ||  ||  |\n|  ||  ||  |\n|  ||  ||  |\n|  ||  ||  |\n|  ||  ||  |\n|  ||  ||  |\n|  ||  ||  |\n|  ||  ||  |\nAAAAAAAAAAAA0\n  /\\n /  \\n|    |\n|    |\n|    |\n|____|\n \__/\n |  |\n |  |\n |  |\n |  |\n |  |\n |  |\n |  |\n |  |\n |  |\n |  |\n |  |\n |  |\n |  |\n |  |\n |  |\n |  |\n |  |\n |  |\n |  |\n |  |\n |  |\n |  |\n |  |\n |  |\n AAAA0\n  /\\n /  \\n|    |\n|    |\n|    |\n|____|\n \__/\n |  |\n |  |\n |  |\n |__|\n  /\0\n db\n_/\_\n\__/\n|  |\n|  |\n|  |\n|__|\n /\
ø                                                                                                                       # Push literal 0
k                                                                                                                       # Push a list of strings obtained by splitting the second stack value with the first stack value.
&                                                                                                                       # Swap the top two stack values.
£b                                                                                                                      # Push the value in the list of the second stack value at the index of the first stack value.

Provalo online!

C (clang) , 421 408 byte

r,d,i;f(t){char *s="    ",*e="\n",*l[]={" /\\ ","/  \\","|    |","|____|","\\__/","|  |","AAAA","|__|"," /\\ ","_/\\_","\n"," db","|  ||  ||  |"},*p[]={"VABU3C1DVE8FFF1G","VABU3C1DVE4F1RYAFAKBFBKZ9MM1YGGG","VABU3C1DVE3F1HI","VLJE3F1HI"},*a="",*b,*c=e,*q=p[t];for(r=1;d=*q++;r=(d/48&&57/d)?d-48:r,c=(d/89&&90/d)?e+90-d:c,a=(d/82&&86/d)?s+86-d:a)if(d/65&&77/d)for(b=l[d-65],i=0;i<r;i++)printf("%s%s%s",a,b,c);}

Provalo online!