Falcon etapas pesadas

43

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.

Adán
fuente
2
db suena como un Aston Martin! AFAIK es un Tesla Roadster.
Level River St
1
@LevelRiverSt ¡Bowie, no Brown!
Adám
¿Se permiten los espacios en blanco iniciales / finales, particularmente a la izquierda?
Level River St
@LevelRiverSt Gracias. Olvidé escribirlo, aunque lo pensé.
Adám
1
¿Es esto realmente una animación ?
FantaC

Respuestas:

41

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!

Arnauld
fuente
16
BigFu!#?%$Rocket? ¡Pero esto es solo Falcon Heavy!
Adám
16
@ Adám Eso es correcto. Pero BFR.reduce() == FalconHeavy: p
Arnauld
Esto es genial. Por un segundo pensé, ¿qué, hay un javascript incorporado para eso? Entonces volví a mis sentidos ... +1!
rodolphito
Impresionante como siempre.
Weijun Zhou
"FRFRFRF" = "Fu!#?%$RocketFu!#?%$RocketFu!#?%$RocketFu!#"¿Derecha? Me encanta esta respuesta más que nada jajaja.
Magic Octopus Urn
13

Carbón , 67 bytes

NθF⁼³θ«PAA↑↑¹⁸↗²‖MM⁴±χ»¿θ«↙²↓⁴M↗__¶\_¶»↓d/_¶ _\↓×⁴∨›²θ⁶¿‹¹θAA↑¶/_‖M

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:

Nθ

Ingrese el número.

F⁼³θ«PAA↑↑¹⁸↗²‖MM⁴±χ»

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

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

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↑¶/_‖M

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

Neil
fuente
¿Creaste Charcoalsolo para este concurso?
nielsbot
@nielsbot El carbón tiene 7 meses (ver el registro de confirmación).
phyrfox
Estaba bromeando. Pero supongo que plantea la pregunta: ¿es golf si creas un lenguaje para resolver el problema? ¿Dónde está el límite?
nielsbot
1
@nielsbot Creo que eso cuenta como una de las lagunas estándar .
Neil
7

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.

Οurous
fuente
1
287
Adám
@ Adám ¡Gracias! Yo era capaz de aplicar eso, sino que sólo lo vi después de haber acortado aún más - todavía ahorra bytes aunque :)
Οurous
¿Por qué hay dos fragmentos?
Erik the Outgolfer
@EriktheOutgolfer el segundo es el lambda. El primero es el código del que depende. No los pongo en el mismo fragmento porque no puedo multilínea una tarea en el fragmento.
Οurous
5

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

ElPedro
fuente
1
Las variables n, py también qson innecesarias (-2 bytes cada una). " db"y "_/\_"se unirá "\n"más tarde, puede convertir ambos en " db\n_/\_"para guardar otro byte. Puede (probablemente) mover +y, de cada elemento, fuera de la lista (y eliminar también la constante) algo como(...)[i>2]+["\__/"]
Rod
@ Rod Gracias por el consejo \ n. Me perdí esa. Sin embargo, no estoy seguro acerca de n, p y q. Se usan dos veces cada uno, uno a cada lado del cohete principal para definir si los impulsores son necesarios o no. De manera similar, en un caso, necesita una nueva línea antes y, en el otro, algunos otros caracteres. Probablemente podría beneficiarse de una reescritura completa para ser honesto. Siéntase libre de tomar cualquier idea y usarla para publicar su propia respuesta.
ElPedro
5

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)
  }
}
benj2240
fuente
2

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

dzaima
fuente
2

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)
Level River St
fuente
¡La primera respuesta para hacer un uso no trivial de la entrada! Muy agradable.
benj2240
1

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
  /\
 /  \
|    |
|    |
|    |
|____|
 \__/
 |  |
 |  |
 |  |
 |__|
  /\
Galen Ivanov
fuente
1

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!

Quantum64
fuente
0

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!

GPS
fuente
383 bytes
ceilingcat