MODIFICARE

Sembra che ci sia stata una certa confusione dopo il mio errore di battitura nel post originale che utilizzava una o minuscola per definire il piano e poi una maiuscola in seguito. Sfortunatamente questo bug non è stato raccolto nella Sandbox. Poiché molti membri hanno scritto delle risposte con entrambi e poiché l'errore è stato colpa mia, nella definizione dell'aereo consentirò o maiuscole o minuscole. Ho aggiunto una nuova regola per questo.

sfondo

Mi piacciono le animazioni di arte ascii come tendo a chiamarle, quindi eccone un'altra. Non penso che sia troppo difficile da implementare, quindi spero di ottenere risposte brevi e interessanti.

A tutti i membri della comunità

Se si migliora la risposta, modificare il numero di byte come

conteggio byte vecchi conteggio byte nuovi

così possiamo vedere i tuoi progressi. Grazie!

Sfida

Ecco un aereo ascii

--O--

Ecco una pista ascii

____|     |____

L'aereo parte da 5 nuove linee sopra la pista. Per prevenire eventuali scontri tra i sistemi metrici e imperiali e renderlo una vera sfida internazionale, non menzionerò metri o piedi. Esempio:

        --O--




____|     |____

L'aereo deve atterrare esattamente al centro della pista come mostrato di seguito:

____|--O--|____

Ingresso

La posizione orizzontale iniziale del piano è definita da un input intero che viene utilizzato per fare riferimento alla punta dell'ala sinistra, ovvero tra 0 e 10 inclusi.

Produzione

Ogni fase del volo degli aerei deve essere mostrata. Esempio di seguito (input = 10):

          --O--




____|     |____

         --O--



____|     |____

        --O--


____|     |____

       --O--

____|     |____

      --O--
____|     |____

____|--O--|____

Per semplificare le cose, ignoriamo le leggi della prospettiva. La pista rimane delle stesse dimensioni man mano che ti avvicini.

Regole

• Aggiorna La parte centrale del piano può essere maiuscola o minuscola o, qualunque sia la scelta, deve essere coerente in tutto il codice. Se la tua lingua non supporta i caratteri qui sopra, sentiti libero di usare solo caratteri ascii alternativi.
• Il piano scende di 1 linea per fotogramma.
• Il piano può spostare solo 1 spazio a sinistra o a destra ogni volta che scende di una linea. Non deve spostarsi su ciascuna linea di discesa. Finché finisce sulla passerella, dipende da te quando si sposta a destra o a sinistra. Sei il pilota!
• Non è richiesta la gestione degli errori. Si può presumere che l'input sarà sempre un numero intero valido compreso tra 0 e 10 inclusi.
• L'output deve essere composto solo dai caratteri mostrati sopra (se la tua lingua non li supporta, vedi la prima regola modificata) e deve avere le stesse dimensioni, cioè deve iniziare con 6 righe di altezza per 15 caratteri di larghezza. L'altezza può diminuire man mano che procede come nell'esempio sopra.
• Il programma o la funzione vanno bene, ma devono produrre un output come mostrato sopra.
• Gli spazi iniziali / finali / le nuove righe vanno bene per me.
• Se lo desideri, sentiti libero di cancellare lo schermo tra i frame di output. Questo non è un requisito.
• Le scappatoie standard sono proibite come al solito (anche se non credo che ce ne siano molte che potrebbero aiutare in questo tipo di sfida).
• Questo è il golf del codice, quindi la risposta più breve è ovviamente il vincitore e probabilmente otterrà il maggior numero di voti, ma potrebbe non essere necessariamente accettata come la migliore risposta se una soluzione davvero interessante arriva in un linguaggio inaspettato, anche se è più lunga. Sentiti libero di pubblicare tutto ciò che soddisfa le regole fintanto che funziona.

Implementazione di riferimento non golfata in Python 2 disponibile su Provalo online! così puoi vedere come cerca diversi valori di input.

TI-BASIC, 61 byte

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 byte

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

Si noti che TI-BASIC non supporta _ o | e quindi ho sostituito con una I maiuscola e -. Ciò non dovrebbe influire sul conteggio dei byte.

Python 2, 107 byte

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

Provalo online

Codifica semplicemente l'ultima riga per il piano di atterraggio. Probabilmente si può giocare a golf riutilizzando le parti precedenti o essere integrato nel circuito.

Perl, 94 byte

93 byte di codice + -pflag.

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

Provalo online!

JavaScript (ES6), 108 byte

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

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

Provalo

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

Basta chiamare fcon l'indice dell'aereo.

f(2)

Produzione

  --O--




____|     |____

   --O--



____|     |____

    --O--


____|     |____

     --O--

____|     |____

    --O--
____|     |____

____|--O--|____

Scala, 224 181 byte

EDIT : Non avevo idea che potresti fare "string"*nper ripeterlo n volte! Scala continua a stupirmi. Manca if(t>0)invece di if(t==0)un errore da principiante. Grazie per i suggerimenti, 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)}

Osservazioni originali:

Ho pensato che una soluzione ricorsiva sarebbe stata divertente da provare. Sono relativamente nuovo in Scala, quindi sono certo che questo è tutt'altro che ottimale.

Lotto, 230 byte

@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

xè il numero di spazi da rimuovere dall'inizio della stringa s, quindi sottraggo il parametro da 10. L'ultima riga è il batch più vicino che deve x-=sgn(x-5).

sed, 181 byte + 2 per le -nrbandiere

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

Ungolfed

# 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 byte

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

Provalo online!

Probabilmente esiste una sorta di compressione che avrei potuto usare sulla passerella e lo spazio vuoto su di essa, ma tutto ciò che ho provato è risultato più costoso del semplice testo (in Retina ¶ è una nuova riga, quindi puoi vedere lo stato iniziale in chiaro sul seconda linea).

Scala , 177, 163, 159 137 byte

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

Basato su un'altra risposta , con riduzioni significative.

Perl 6 , 97 90 81 byte

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

Contrariamente a come appare, produce la versione * minuscola del piano ( --o--), come consentito dalla descrizione dell'attività aggiornata.

Provalo online!

Come funziona

Operatori di stringa 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.
}

Funziona perché gli operatori di stringa bit a bit usano i valori del punto di codice dei caratteri in una data posizione in due stringhe, per calcolare un nuovo carattere in quella posizione nella stringa di output.
In questo caso:

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

Per un Opiano maiuscolo , avremmo potuto usare ~^(stringa XOR bit a bit), con una maschera piana di \r\ro\r\r(+4 byte per le barre rovesciate):

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

La formula per l'offset del piano h + v*(17 - h/5), è stata semplificata da:

  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 byte

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

Provalo online!

Ecco l'implementazione di riferimento ridotta a 160 da 384. Penso che sia ancora una strada da percorrere. Appena pubblicato per divertimento e per incoraggiare una migliore risposta di Python.

Befunge-93, 136 130 byte

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

Provalo online!

Spiegazione

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

Rubino, 94 byte

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

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

Stampa la posizione dell'aereo seguita da newline e quindi dall'aeroporto. Quindi sposta il piano di 1, -1 o 0, a seconda della sua posizione rispetto a 5.

Dopo aver ripetuto le 5 volte precedenti, stampa l'aereo in aeroporto.

8 ° , 177 172 byte

: 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 parola fprevede un numero intero compreso tra 0 e 10.

uso

4 f

Spiegazione

: 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 byte

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

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

Funzione anonima. Accetta un numero come input e restituisce una stringa come output. Probabilmente potrebbe essere ulteriormente giocato a golf.

QBIC , 93 91 84 byte

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

Eliminati alcuni byte sostituendo la dichiarazione di X $; ottimizzato il ciclo FOR che stampa la distanza dal suolo. La spiegazione di seguito è relativa alla versione precedente, ma sostanzialmente funziona allo stesso modo.

Per i test (e l'estetica) ho avuto una versione leggermente diversa, a 103 byte:

:{_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

Questi sono funzionalmente identici. Il secondo ha l'aggiunta che lo schermo viene cancellato tra i frame e che si ferma per 0,5 secondi tra i frame.

Uscita campione

Nota che ho aggiunto due nuove righe tra i frame. Il codice più golfato sopra non aggiunge linee vuote tra i frame, quello più freddo cancella lo schermo.

Command line: 10


          --O--




____|     |____


         --O--



____|     |____


        --O--


____|     |____


       --O--

____|     |____


      --O--
____|     |____


____|--O--|____

Spiegazione

Dal momento che sento che questo tocca molte cose che mi piacciono molto di QBIC e che danno una buona idea di come alcune delle sue funzioni funzionano sotto il cofano, sono andato un po 'fuori bordo sulla spiegazione. Si noti che QBIC è, in sostanza, un interprete QBasic per Codegolf. Il codice QBIC entra: il codice QBasic esce (e viene successivamente eseguito).

:{      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 byte

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 byte

ancora terribilmente lungo

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

accetta input dall'argomento della riga di comando; corri con -r.

abbattersi

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