EDITAR

Parece que ha habido cierta confusión después de mi error tipográfico en la publicación original que usaba una o minúscula para definir el plano y luego una mayúscula. Lamentablemente, este error no se detectó en el Sandbox. Dado que muchos miembros han escrito respuestas con ambos y dado que el error tipográfico fue mi culpa, permitiré o mayúsculas o minúsculas en la definición del plano. He agregado una nueva regla para esto.

Fondo

Me gustan las animaciones de arte ascii, ya que tiendo a llamarlas, así que aquí hay otra. No creo que esto sea demasiado difícil de implementar, por lo que espero obtener algunas respuestas cortas e interesantes.

A todos los miembros de la comunidad.

Si mejora su respuesta, modifique su recuento de bytes como

recuento de bytes antiguos recuento de bytes nuevos

para que podamos ver tu progreso. ¡Gracias!

Reto

Aquí hay un avión ascii

--O--

Aquí hay una pista ascii

____|     |____

El avión comienza en 5 líneas nuevas sobre la pista. Para evitar enfrentamientos entre los sistemas métrico e imperial y hacer de este un verdadero desafío internacional, no mencionaré metros ni pies. Ejemplo:

        --O--




____|     |____

El avión debe aterrizar exactamente en el medio de la pista como se muestra a continuación:

____|--O--|____

Entrada

La posición horizontal inicial del plano está definida por una entrada entera que se usa para hacer referencia a la punta del ala izquierda, es decir, está entre 0 y 10 inclusive.

Salida

Se debe mostrar cada etapa del vuelo del avión. Ejemplo a continuación (input = 10):

          --O--




____|     |____

         --O--



____|     |____

        --O--


____|     |____

       --O--

____|     |____

      --O--
____|     |____

____|--O--|____

Para mantener las cosas simples, estamos ignorando las leyes de la perspectiva. La pista permanece del mismo tamaño a medida que te acercas.

Reglas

• Actualización El centro del plano puede ser mayúscula o minúscula, pero el que se elija debe ser coherente en todo el código. Si su idioma no es compatible con los caracteres anteriores, siéntase libre de usar caracteres alternativos solo ascii.
• El avión desciende 1 línea por cuadro.
• El avión solo puede moverse 1 espacio hacia la izquierda o hacia la derecha cada vez que desciende una línea. No tiene que moverse en cada línea de descenso. Mientras termine en la pista, depende de usted cuando se mueve hacia la derecha o hacia la izquierda. Eres el piloto!
• No se requiere manejo de errores. Puede suponer que la entrada siempre será un número entero válido de 0-10 inclusive.
• La salida debe constar solo de los caracteres que se muestran arriba (si su idioma no los admite, consulte la primera regla editada) y debe tener el mismo tamaño, es decir, debe comenzar con 6 líneas de alto por 15 caracteres de ancho. La altura puede disminuir a medida que avanza como en el ejemplo anterior.
• El programa o la función está bien, pero debe producir una salida como se muestra arriba.
• Los espacios iniciales / finales / nuevas líneas están bien para mí.
• Si lo desea, puede borrar la pantalla entre fotogramas de salida. Esto no es un requisito.
• Las lagunas estándar están prohibidas como de costumbre (aunque no creo que haya muchas que ayuden con este tipo de desafío).
• Este es el código de golf, por lo que la respuesta más corta es obviamente la ganadora y probablemente obtendrá la mayoría de los votos, pero no necesariamente se aceptará como la mejor respuesta si surge una solución realmente interesante en un lenguaje inesperado, incluso si es más larga. Siéntase libre de publicar cualquier cosa que cumpla con las reglas siempre que funcione.

Implementación de referencia sin golf en Python 2 disponible en ¡ Pruébelo en línea! para que pueda ver cómo se ven los diferentes valores de entrada.

TI-BASIC, 61 bytes

Input A
A
For(B,1,5
ClrHome
Output(5,1,"----/     /----
Output(B,Ans,"--O--
Ans+6-median({5,7,Ans
End

TI-BASIC, 62 bytes

:Input A
:A
:For(N,3,8
:ClrHome
:Output(8,1,"----I     I----
:Output(N,Ans,"--O--
:Ans+(Ans<6)-(Ans>6
:End

Tenga en cuenta que TI-BASIC no admite _ o | y por lo tanto lo reemplacé con una I mayúscula y Esto no debería afectar el recuento de bytes.

Python 2, 107 bytes

n=input();h=5
while h:print' '*n+'--O--'+'\n'*h+'____|     |____\n';n-=cmp(n,5);h-=1
print'____|--O--|____'

Pruébalo en línea

Simplemente codifica la última línea para el avión de aterrizaje. Es probable que se pueda jugar al golf reutilizando piezas de antes o integrándolo en el circuito.

Perl, 94 bytes

93 bytes de código + -pbandera.

$\="____|     |____
";$p="--O--";for$i(-5..-1){print$"x$_.$p.$/x-$i;$_+=5<=>$_}$\=~s/ +/$p/}{

Pruébalo en línea!

JavaScript (ES6), 108 bytes

f=(a,b=5)=>b?" ".repeat(a)+`--O--${`
`.repeat(b)}____|     |____

`+f(a<5?a+1:a-1,b-1):"____|--O--|____"

Pruébalo

f=
(a,b=5)=>b?" ".repeat(a)+`--O--${`
`.repeat(b)}____|     |____

`+f(a<5?a+1:a-1,b-1):"____|--O--|____"

<input type=number min=0 max=10 oninput=o.textContent=f(+this.value)><pre id=o>

Uso

Simplemente llame fcon el índice del avión.

f(2)

Salida

  --O--




____|     |____

   --O--



____|     |____

    --O--


____|     |____

     --O--

____|     |____

    --O--
____|     |____

____|--O--|____

Scala, 224 bytes

EDITAR : ¡No tenía idea de que podría hacer "string"*npara repetirlo n veces! Scala sigue impresionándome. Perder el en if(t>0)lugar de if(t==0)fue un error de novato. Gracias por los consejos, Suma !

def?(x:Int,t:Int=5):Unit={var(p,o)=("--o--","")
o=s"____|${if(t>0)" "*5 else p}|____\n"
for(i<-0 to t)o=if(i!=0&&i==t)" "*x+p+o else "\n"+o
println(o)
if(t>0)?(x-(x-4).signum,t-1)}

Observaciones originales:

Pensé que una solución recursiva sería divertida de probar. Soy relativamente nuevo en Scala, así que estoy seguro de que esto está lejos de ser óptimo.

Lote, 230 bytes.

@echo off
set/ax=10-%1
set s=          --O--
for /l %%i in (0,1,4)do call:l %%i
echo ____^|--O--^|____
exit/b
:l
call echo %%s:~%x%%%
for /l %%j in (%1,1,3)do echo(
echo ____^|     ^|____
echo(
set/a"x-=x-5>>3,x+=5-x>>3

xes el número de espacios para eliminar desde el comienzo de la cadena s, por lo que resta el parámetro de 10. La última línea es la más cercana que tiene Batch x-=sgn(x-5).

sed, 181 bytes + 2 para -nrbanderas

s/10/X/
:A
s/^/ /;y/0123456789X/-0123456789/;/[0-9]/bA;s/ -/P\n\n\n\n\n____|P|____/
:B
h;s/P([\n|])/--O--\1/;s/P/     /;s/^ *_/_/;p;/^_/q;x;s/\n//
/^ {5}$/bB;/ {6}/s/  //;s/^/ /;bB

Sin golf

# Add leading spaces
s/10/X/
:A
    s/^/ /
    y/0123456789X/-0123456789/
/[0-9]/bA

s/ -/P\n\n\n\n\n____|P|____/

:B
    # Place plane in appropriate spot
    h
    s/P([\n|])/--O--\1/
    s/P/     /
    s/^ *_/_/
    p
    /^_/q
    x

    # Movement
    s/\n//
    /^ {5}$/bB
    # move left one extra, since we'll move right next line
    / {6}/s/  // 
    s/^/ /
bB

Uso: $ echo 2 | sed -nrf flightsim.sed

Retina , 86 83 bytes

.+
$* --O--¶¶¶¶¶¶____|     |____
{*`$
¶
2D`¶
 ( {5})
$1
}`^ {0,4}-
 $&
 +
--O--
G`_

Pruébalo en línea!

Probablemente haya algún tipo de compresión que podría haber usado en la pista y el espacio vacío sobre ella, pero todo lo que probé resultó más costoso que el texto sin formato (en Retina ¶ es una nueva línea, por lo que puede ver el estado inicial en texto sin formato en el segunda linea).

Scala , 177, 163, 159137 bytes

def p(x:Int,t:Int=5,a:String="\n"):String=a+(if(t>0)
" "*x+"--O--"+"\n"*t+"____|     |____\n"+p(x-(x-4).signum,t-1)else"____|--O--|____")

Basado en otra respuesta , con reducciones significativas.

Perl 6 , 97 90 81 bytes

{say "{"{" "x 15}\n"x 5}____|     |____"~|("\0"x$^h+$_*(17-$h/5)~"--O--") for ^6}

Al contrario de lo que parece, genera la versión * en minúsculas del plano ( --o--), según lo permitido por la descripción de la tarea actualizada.

Pruébalo en línea!

Cómo funciona

Operadores de cadenas bit a bit FTW!

{                                                  # Lambda accepting horizontal index $h.
    say                                            # Print the following:
        "{ "{ " " x 15 }\n" x 5 }____|     |____"  # The 15x6 background string,
        ~|                                         # bitwise-OR'd against:
        (
            "\0"                                   # The NULL-byte,
            x $^h + $_*(17 - $h/5)                 # repeated by the plane's offset,
            ~ "--O--"                              # followed by an OR mask for the plane.
        )
    for ^6                                         # Do this for all $_ from 0 to 5.
}

Funciona porque los operadores de cadena bit a bit usan los valores de punto de código de los caracteres en una posición dada en dos cadenas, para calcular un nuevo carácter en esa posición en la cadena de salida.
En este caso:

space  OR  O   =  o
space  OR  -   =  -
any    OR  \0  =  any

Para un Oplano en mayúscula , podríamos haber usado ~^(string XOR bitwise), con una máscara de plano de \r\ro\r\r(+4 bytes para barras invertidas):

space  XOR   o  =  O
space  XOR  \r  =  -
any    XOR  \0  =  any

La fórmula para el desplazamiento del avión h + v*(17 - h/5), se simplificó de:

  v*16         # rows to the vertical current position
+ h            # columns to the horizontal starting position
+ (5 - h)*v/5  # linearly interpolated delta between horizontal start and goal

Python 2 , 160 bytes

i,s,p,l,r,c,x=input(),' ','--O--','____|','|____',0,4
while x>=0:print'\n'.join([s*i+p]+[s*15]*x+[l+s*5+r])+'\n';c+=1;x-=1;i=((i,i-1)[i>5],i+1)[i<5]
print l+p+r

Pruébalo en línea!

Aquí está la implementación de referencia que se redujo a 160 desde 384. Creo que todavía queda mucho camino por recorrer. Recién publicado por diversión y para alentar una mejor respuesta de Python.

Befunge-93, 136 130 bytes

&5>00p10p55+v
:::00g>:1-\v>:"____|     |_"
>:1-\v^\+55_$"--O--"10g
^\*84_$>:#,_10g::5v>:#,_@
<_v#!:-1g00+`\5\-`<^"____|--O--|____"

Pruébalo en línea!

Explicación

&                          Read the plane position.
 5                         Initialise the plane height.
  >                        Begin the main loop.

   00p                     Save the current height.
      10p                  Save the current position.
         55+:              Push two linefeed characters.

         "____|     |_"    Push most of the characters for the airport string.
:::                        Duplicate the last character three times to finish it off.

   00g>:1-\v               Retrieve the current height, and then push
      ^\+55_$                that many copies of the linefeed character.

             "--O--"       Push the characters for the plane.

>:1-\v              10g    Retrieve the current position, and then push
^\*84_$                      that many copies of the space character.

       >:#,_               Output everything on the stack in reverse.

            10g::          Retrieve the current position and make two copies to work with.
                 5v        If it's greater than 5
                -`<          then subtract 1.
           +`\5\           If it's less than 5 then add 1.

        g00                Retrieve the current height.
      -1                   Subtract 1.
 _v#!:                     If it's not zero, repeat the main loop.

^"____|--O--|____"         Otherwise push the characters for the landed plane.
>:#,_@                     Output the string and exit.

Ruby, 94 bytes

->a{5.times{|i|puts" "*a+"--O--#{?\n*(5-i)}____|     |____

";a+=5<=>a};puts"____|--O--|____"}

Imprime la posición del avión seguido de nuevas líneas y luego el aeropuerto. Luego mueve el plano en 1, -1 o 0, dependiendo de su posición con respecto a 5.

Después de recorrer las 5 veces anteriores, imprime el avión en el aeropuerto.

8º , 177 172 bytes

: f 5 >r 5 repeat over " " swap s:* . "--O--" . ' cr r> times "____|     |____\n\n" . over 5 n:cmp rot swap n:- swap n:1- dup >r while "____|--O--|____\n" . 2drop r> drop ; 

La palabra fespera un número entero entre 0 y 10.

Uso

4 f

Explicación

: f \ n --
  5 >r     \ Push vertical distance from airport to r-stack
  5 repeat 
    \ Print plane
    over " " swap s:* . "--O--" . 
    \ Print airport 
    ' cr r> times "____|     |____\n\n" . 
    \ Now on the stack we have:
    \ distanceFromLeftSide distanceFromAirport
    over      \ Put distance from left side on TOS 
    5 n:cmp   \ Compare left distance and 5. Return
              \ -1 if a<b, 0 if a=b and 1 if a>b
    rot       \ Put distance from left side on TOS   
    swap n:-  \ Compute new distance from left side 
    swap n:1- \ Decrement distance from airport
    dup >r    \ Push new airport-distance on the r-stack  
  while 
  "____|--O--|____\n" .  \ Print final step
  2drop r> drop          \ Empty s-stack and r-stack
;

Mathematica, 111 bytes

If[#<1,"____|--O--|____"," "~Table~#2<>"--O--"<>"
"~Table~#<>"____|     |____

"<>#0[#-1,#2+#2~Order~5]]&[5,#]&

Función anónima. Toma un número como entrada y devuelve una cadena como salida. Probablemente podría jugar más golf.

QBIC , 93 91 84 bytes

:{X=space$(a)+@--O--`┘a=a-sgn(a-5)~t>-1|?X[t|?]t=t-1?@____|`+@     `+_fB|\_xB+A+_fB

Se eliminaron algunos bytes al reemplazar la declaración de X $; optimizado el bucle FOR que imprime la distancia sobre el suelo. La explicación a continuación es para la versión anterior, pero básicamente funciona igual.

Para las pruebas (y la estética) tenía una versión ligeramente diferente, de 103 bytes:

:{_z.5|_CX=Y[a|X=X+@ `]X=X+@--O--`
a=a-sgn(a-5)
~u>0|?X';`[u|?]u=u-1?@____|`+@     `+_fC|\_xC+_tB+_fC

Estos son funcionalmente idénticos. El segundo tiene la adición de que la pantalla se borra entre fotogramas y que se detiene durante 0,5 segundos entre fotogramas.

Salida de muestra

Tenga en cuenta que he agregado dos nuevas líneas entre cuadros. El código más golfizado anterior no agrega líneas vacías entre cuadros, el más claro borra la pantalla.

Command line: 10


          --O--




____|     |____


         --O--



____|     |____


        --O--


____|     |____


       --O--

____|     |____


      --O--
____|     |____


____|--O--|____

Explicación

Como siento que esto toca muchas cosas que realmente me gustan de QBIC, y da una buena idea de cómo funcionan algunas de sus funciones bajo el capó, me he excedido un poco en la explicación. Tenga en cuenta que QBIC es, en esencia, un intérprete QBasic para Codegolf. El código QBIC entra: sale el código QBasic (y posteriormente se ejecuta).

:{      get the starting offset (called 'a') from the command line, and start a DO-loop

----  cool code only  ----
_z.5|_C At the start of a DO-loop, pause for half a second and clear the screen
---- resume golf-mode ----

---- #1 - The tip of the left wing is anywhere between 0 and 10 positions to the right.
----       Create the plane with the spacing in X$
X=Y          Clear X$
[a|          For each point in the current offset
X=X+@ `]     Add a space to X$
    - Every capital letter in QBIC references that letter+$, a variable of type String
    - @ and ` start and end a string literal, in this case a literal space.
    - ] ends one language construct (an IF, DO or FOR). Here, it's NEXT
X=X+@--O--`  Create the actual plane
    - @ and `once again create a string literal. Every literal that is created in this
      way is assigned its own capital letter. This is our second literal, so the body of
      our plane is stored in B$ (A$ contains the space, remember?)

---- #2 Adjust the offset for the next iteration      
a=a-sgn(a-5) The clever bit: We have an offset X in the range 0 - 10, and 5 attempts to 
             get this to be == 5. X - 5 is either positive (X = 6 - 10), negative 
             (X = 0 - 4) or 0 (X=5). sgn() returns the sign of that subtraction 
             as a 1, -1 or 0 resp. We then sub the sign from 'a', moving it closer to 5.

---- #3 Draw the plane, the empty airspace and the landing strip             
~u>0|     Are we there yet?
    - ~ is the IF statement in QBIC
    - It processes everything until the | as one true/false expression
    - All the lower-case letters are (or better, could be) references to numeric 
      variables. Since QBasic does not need to post-fix those, they double as 'natural' 
      language: ignored by QBIC and  passed as literal code to the QBasic beneath.
    - The lower-case letters q-z are kinda special: at the start of QBIC, these 
      are set to 1 - 10. We haven't modified 'u' yet, so in the first DO-loop, u=5

?X';`     If we're still air-borne, print X$ (our plane, incl. spacers)
    - ? denotes PRINT, as it does in QBasic.
    - ' is a code literal in QBIC: everything until the ` is not parsed, but 
      passed on to QBasic.
    - In this case, we want a literal ; to appear after PRINT X$. This suppresses 
      QBasic's normal line-break after PRINT. This needs to be a code literal 
      because it is the command to read a String var from the command Line in QBIC.
[u|?]     FOR EACH meter above the ground, print a newline
u=u-1     Descent 1 meter
?@____|`  Print the LHS of the landing strip
+@     `  plus 5 spaces
+_fC|     plus the LHS reversed.
\         ELSE - touchdown!
_x        Terminate the program (effectively escape the infinite DO-loop)
    - the _x command has an interesting property: ULX, or Upper/Lowercase Extensibility. 
      Writing this command with an uppercase _X does something similar, yet different. 
      The _x command terminates, and prints everything found between _x and | before 
      quitting. Uppercase _X does not look for |, but only prints something if it is 
      followed by a character in the ranges a-z and A-Z - it prints the contents of 
      that variable.
C+B+_fC   But before we quit, print C$ (the LHS of the landing strip) and the plane, 
          and the LHS flipped.

---- #4 QBIC has left the building
- Did I say _x looks for a | ? Well, that gets added implicitly by QBIC at the end of 
  the program, or when one ( ']' ) or all ( '}' ) opened language constructs are closed.
- Also, all still opened language constructs are automatically closed at EOF.
- Had we stored anything in Z$, that would also be printed at this time.

SmileBASIC, 109 105 bytes

G$="_"*4INPUT X
FOR I=0TO 4?" "*X;"--O--";CHR$(10)*(4-I)?G$;"|     |";G$X=X-SGN(X-5)?NEXT?G$;"|--O--|";G$

PHP 7, 139 bytes

todavía muy largo

for($x=$argv[1],$d=6;$d--;$x+=5<=>$x)for($i=$p=-1;$i++<$d;print"$s
")for($s=$i<$d?" ":"____|     |____
";!$i&++$p<5;)$s[$x+$p]="--O--"[$p];

toma datos del argumento de la línea de comando; correr con -r.

Descompostura

for($x=$argv[1],                        // take input
    $y=6;$y--;                          // loop height from 5 to 0
    $x+=5<=>$x)                             // post increment/decrement horizontal position
    for($i=$p=-1;$i++<$y;                   // loop $i from 0 to height
        print"$s\n")                            // 3. print
        for($s=$i<$y?" ":"____|     |____\n";   // 1. template=empty or runway+newline
            !$i&++$p<5;)$s[$x+$p]="--O--"[$p];  // 2. if $i=0, paint plane