Elija un conjunto de cuatro bytes sin reemplazo (es decir, sin byte repetido), y no necesariamente en un orden particular, de cualquiera de los siguientes cuatro conjuntos:

1. Los caracteres de cualquier codificación de un solo byte
2. Los caracteres Unicode en el rango 00 – FF
3. Los enteros decimales con signo en el rango −128–127
4. Los enteros decimales sin signo en el rango 0-255

Los cuatro valores que elija (indique cuáles son) serán las entradas válidas. Debe emparejar cada valor con una de las siguientes obras de arte ASCII.

Dada (por cualquier medio) una de sus cuatro entradas válidas, responda (por cualquier medio, incluso una lista de cadenas) con el arte ASCII correspondiente. Se permite espacio en blanco adicional en todos los lados, siempre que la imagen esté allí en un área 2D contigua.

Primer byte:

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

Segundo byte:

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

Tercer byte:

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

Cuarto byte:

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

¿Qué hay de nuevo en este desafío de complejidad ASCII art Kolmogorov?

1. La capacidad de seleccionar entradas válidas presenta un nuevo aspecto para el desafío. Las entradas son claramente demasiado limitadas para codificar el resultado completo, pero pueden llevar suficiente información para merecer atención.

2. Las múltiples salidas posibles comparten mucha estructura, por lo que la reutilización de código o subimágenes es factible tanto dentro de cada imagen como entre imágenes.

3. Existe suficiente duplicación para que incluso los lenguajes que no estén bien orientados a desafíos como este tengan una oportunidad justa de poder usar código inteligente en lugar de solo codificar cadenas de manera extensiva.

JavaScript (ES6), 247 bytes

RegPack'ed. Espera 0 ... 3 como entrada.

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]

Pruébalo en línea!

Carbón , 67 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Toma la entrada como un número 3-0. Explicación:

Ｎθ

Ingrese el número.

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

Si es 3, dibuje la mitad del refuerzo, luego duplíquelo, luego muévase a la punta del cohete.

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

Si no es 0, dibuje la mitad izquierda del tanque de combustible delantero.

↓d/_¶ _\

Pero si es 3, dibuje la mitad izquierda del cono de la nariz.

↓×⁴∨›²θ⁶

Dibuja el lado izquierdo del cohete.

¿‹¹θAA↑¶/_‖Ｍ

Dibuja la base apropiada del cohete y luego espejo para terminar.

Limpio , 292 278 273 271 262 261 bytes

-5 bytes gracias a 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]

Pruébalo en línea!

Una función lambda, que asigna los Intvalores 0..3a las imágenes en el orden indicado en el OP.

Python 2 , 292 290 284 282 281 bytes

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])

Pruébalo en línea!

Toma un número entero de 0 a 3 como entrada y utiliza la indexación de lista (1 o 0) para construir cada salida.

-2 para un par de paréntesis innecesarios.

-6 eliminando una asignación variable que solo se usó una vez.

-2 para otra variable de uso único.

-1 con un consejo de @Rod

Ruby , 234 212 205 bytes

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

Pruébalo en línea!

Toma un entero 0-3. Construye una matriz de las mitades izquierdas de cada fase, indexa, luego rellena y refleja cada fila. Todo el relleno tiene el mismo ancho, por lo que las últimas fases tienen espacios en blanco iniciales. Devuelve una matriz de cadenas.

-2 bytes: declarar ycomo una matriz de inmediato en lugar de necesitar *[y]más tarde.

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

-5 bytes: menos desreferenciación, más adición de matriz.

-1 bytes: h+y*21+[?A*2]-> h+y*21<<?A*2en la fase 1.

-3 bytes: la especificación permite la omisión de *$/unir el resultado.

-4 bytes: ["b","\\_","_/"]-> %w{b \\_ _/}en la fase 3.

-2 bytes: use la %wnotación en la matriz principal también.

-7 bytes: usar en rjustlugar de relleno manual (esto también significa generar el lado izquierdo y reflejarlo, en lugar de comenzar con el lado derecho)

Sin golf:

->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 bytes

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

Pruébalo aquí!

Entradas 0/1/2/3 correspondientes a los bytes 1/2/3/4

Rubí , 209 183 bytes

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

Pruébalo en línea!

Entradas requeridas de la siguiente manera:

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

La idea es tomar el centre core + upper stage + fairingvalor predeterminado y modificarlo para las otras salidas.

Comentado

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

Rojo , 333 bytes

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]]]

Pruébalo en línea!

Toma 1 - 4 como entrada

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 bytes

Hice un experimento con la compressfunción de Rebol , comprimiendo una cadena de las 4 etapas e imprimiendo la parte correspondiente después de la descompresión:

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 bytes

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

Explicación

↕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.

Pruébalo en línea!

C (sonido metálico) , 421 408 bytes

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

Pruébalo en línea!