BEARBEITEN

Es scheint, dass es nach meinem Tippfehler im ursprünglichen Beitrag einige Verwirrung gab, bei dem ein Kleinbuchstabe o zum Definieren der Ebene und später ein Großbuchstabe o verwendet wurden. Leider wurde dieser Fehler nicht in der Sandbox gefunden. Da viele Mitglieder mit beiden Antworten geschrieben haben und der Tippfehler mein Fehler war, werde ich in der Definition der Ebene entweder Groß- oder Kleinbuchstaben o zulassen. Ich habe dafür eine neue Regel hinzugefügt.

Hintergrund

Ich mag ASCII-Kunstanimationen, wie ich sie nenne, und hier ist eine andere. Ich denke nicht, dass es zu schwierig ist, dies umzusetzen, deshalb werden wir hoffentlich einige kurze und interessante Antworten erhalten.

An alle anderen Community-Mitglieder

Wenn Sie Ihre Antwort verbessern, ändern Sie bitte Ihre Byteanzahl als

alte Byteanzahl neue Byteanzahl

So können wir Ihren Fortschritt sehen. Vielen Dank!

Herausforderung

Hier ist ein ASCII-Flugzeug

--O--

Hier ist eine ASCII-Landebahn

____|     |____

Das Flugzeug startet an 5 Zeilen oberhalb der Landebahn. Um Zusammenstöße zwischen metrischen und imperialen Systemen zu vermeiden und dies zu einer wahrhaft internationalen Herausforderung zu machen, erwähne ich weder Meter noch Fuß. Beispiel:

        --O--




____|     |____

Das Flugzeug muss genau in der Mitte der Landebahn landen, wie unten gezeigt:

____|--O--|____

Eingang

Die anfängliche horizontale Position der Ebene wird durch eine Ganzzahleingabe definiert, die verwendet wird, um die Spitze des linken Flügels zu referenzieren, dh sie liegt zwischen 0 und einschließlich 10.

Ausgabe

Jede Stufe des Flugzeugfluges muss gezeigt werden. Beispiel unten (Eingabe = 10):

          --O--




____|     |____

         --O--



____|     |____

        --O--


____|     |____

       --O--

____|     |____

      --O--
____|     |____

____|--O--|____

Um die Dinge einfach zu halten, ignorieren wir die Gesetze der Perspektive. Die Landebahn bleibt gleich groß, wenn Sie näher kommen.

Regeln

• Aktualisieren Die Mitte der Ebene kann entweder in Groß- oder Kleinbuchstaben angegeben werden. Wenn Ihre Sprache die oben genannten Zeichen nicht unterstützt, können Sie auch alternative ASCII-Zeichen verwenden.
• Die Ebene senkt sich um 1 Linie pro Frame.
• Die Ebene kann sich jedes Mal, wenn sie um eine Linie absteigt, nur 1 Feld nach links oder rechts bewegen. Es muss sich nicht auf jeder Abstiegslinie bewegen. Solange es auf der Landebahn endet, liegt es an Ihnen, ob Sie sich nach rechts oder links bewegen. Du bist der Pilot!
• Keine Fehlerbehandlung erforderlich. Sie können davon ausgehen, dass die Eingabe immer eine gültige Ganzzahl von 0 bis einschließlich 10 ist.
• Die Ausgabe darf nur aus den oben gezeigten Zeichen bestehen (falls Ihre Sprache diese nicht unterstützt, siehe bearbeitete erste Regel) und muss dieselbe Größe haben, dh 6 Zeilen hoch und 15 Zeichen breit beginnen. Die Höhe kann sich im Verlauf verringern, wie im obigen Beispiel.
• Programm oder Funktion ist in Ordnung, muss aber eine Ausgabe wie oben gezeigt erzeugen.
• Führende / nachfolgende Leerzeichen / Zeilenumbrüche sind von mir in Ordnung.
• Wenn Sie möchten, können Sie den Bildschirm zwischen den Ausgabebildern löschen. Dies ist keine Voraussetzung.
• Standard-Schlupflöcher sind wie üblich verboten (obwohl ich nicht glaube, dass es viele gibt, die bei dieser Art von Herausforderung helfen würden).
• Dies ist Codegolf, so dass die kürzeste Antwort offensichtlich der Gewinner ist und wahrscheinlich die meisten Stimmen erhalten wird, aber möglicherweise nicht als die beste Antwort akzeptiert wird, wenn eine wirklich interessante Lösung in einer unerwarteten Sprache vorliegt, auch wenn sie länger ist. Fühlen Sie sich frei, alles zu posten, was den Regeln entspricht, solange es funktioniert.

Ungolfed-Referenzimplementierung in Python 2 verfügbar unter Try it online! So können Sie sehen, wie es für verschiedene Eingabewerte aussieht.

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

Beachten Sie, dass TI-BASIC _ oder | nicht unterstützt und deshalb habe ich durch ein Kapital I und - ersetzt. Dies sollte die Byteanzahl nicht beeinflussen.

Python 2, 107 Bytes

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

Probieren Sie es online aus

Codieren Sie einfach die letzte Zeile für das Landungsflugzeug fest. Es kann wahrscheinlich Golf gespielt werden, indem Teile von früher wiederverwendet oder in die Schleife integriert werden.

Perl, 94 Bytes

93 Byte Code + -pFlag.

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

Probieren Sie es 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--|____"

Probier es aus

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>

Verwendung

Rufen Sie einfach fmit dem Index des Flugzeugs an.

f(2)

Ausgabe

  --O--




____|     |____

   --O--



____|     |____

    --O--


____|     |____

     --O--

____|     |____

    --O--
____|     |____

____|--O--|____

Scala, 224 181 Bytes

EDIT : Ich hatte keine Ahnung, dass du "string"*nes n-mal wiederholen könntest ! Scala bläst mich immer noch um. Fehlt die if(t>0)statt if(t==0)war ein Anfängerfehler. Danke für die Tipps, 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)}

Ursprüngliche Bemerkungen:

Ich dachte, es würde Spaß machen, eine rekursive Lösung zu finden. Ich bin relativ neu in Scala, daher bin ich mir sicher, dass dies alles andere als optimal ist.

Batch, 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

xGibt die Anzahl der Leerzeichen an, die vom Anfang der Zeichenfolge entfernt werden ssollen. Daher subtrahiere ich den Parameter von 10. Die letzte Zeile ist die nächste Zeile, die der Stapel enthalten muss x-=sgn(x-5).

sed, 181 Bytes + 2 für -nrFlags

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

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

Retina , 86 83 Bytes

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

Probieren Sie es online!

Es gibt wahrscheinlich eine Art Komprimierung, die ich auf der Landebahn und im leeren Raum darüber hätte verwenden können, aber alles, was ich versucht habe, ist teurer als Klartext (in Retina ist ¶ eine neue Zeile, sodass Sie den Anfangszustand im Klartext auf der sehen können zweite Reihe).

Scala , 177, 163, 159, 137 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--|____")

Gestützt auf eine andere Antwort mit erheblichen Einsparungen.

Perl 6 , 97 90 81 Bytes

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

Anders als es aussieht, gibt es die * Kleinbuchstabenversion des Flugzeugs ( --o--) aus, wie in der aktualisierten Aufgabenbeschreibung angegeben.

Probieren Sie es online!

Wie es funktioniert

Bitweise Stringoperatoren 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.
}

Dies funktioniert, weil bitweise Zeichenfolgenoperatoren die Codepunktwerte der Zeichen an einer bestimmten Position in zwei Zeichenfolgen verwenden, um ein neues Zeichen an dieser Position in der Ausgabezeichenfolge zu berechnen.
In diesem Fall:

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

Für eine Großbuchstabenebene hätten Owir ~^(string bitwise XOR) mit einer Ebenenmaske von \r\ro\r\r(+4 Bytes für Backslashes) verwenden können:

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

Die Formel für den Versatz der Ebene h + v*(17 - h/5)wurde vereinfacht aus:

  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

Probieren Sie es online!

Hier ist die Referenzimplementierung, die von 384 auf 160 heruntergespielt wurde. Ich denke, es ist noch ein weiter Weg. Gerade zum Spaß gepostet und um eine bessere Python-Antwort zu ermutigen.

Befunge-93, 136 130 Bytes

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

Probieren Sie es online!

Erläuterung

&                          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--|____"}

Gibt die Position des Flugzeugs gefolgt von Zeilenumbrüchen und dem Flughafen aus. Dann verschiebt es die Ebene um 1, -1 oder 0, abhängig von ihrer Position relativ zu 5.

Nachdem die obigen 5-mal wiederholt wurden, wird das Flugzeug im Flughafen ausgedruckt.

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 ; 

Das Wort ferwartet eine ganze Zahl zwischen 0 und 10.

Verwendung

4 f

Erläuterung

: 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,#]&

Anonyme Funktion. Nimmt eine Zahl als Eingabe und gibt eine Zeichenfolge als Ausgabe zurück. Könnte wahrscheinlich weiter golfen werden.

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

Einige Bytes wurden gelöscht, indem die Deklaration von X $ ersetzt wurde. optimierte die FOR-Schleife, die den Abstand über Grund druckt. Die nachfolgende Erklärung bezieht sich auf die alte Version, funktioniert jedoch im Prinzip genauso.

Zum Testen (und zur Ästhetik) hatte ich eine etwas andere Version mit 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

Diese sind funktional identisch. Der zweite hat den Zusatz, dass der Bildschirm zwischen den Bildern gelöscht wird und zwischen den Bildern für 0,5 Sekunden angehalten wird.

Beispielausgabe

Beachten Sie, dass ich zwischen Frames zwei Zeilenumbrüche eingefügt habe. Der meistgespielte Code oben fügt keine leeren Zeilen zwischen Frames ein, der coolere löscht den Bildschirm.

Command line: 10


          --O--




____|     |____


         --O--



____|     |____


        --O--


____|     |____


       --O--

____|     |____


      --O--
____|     |____


____|--O--|____

Erläuterung

Da ich das Gefühl habe, dass dies viele Dinge berührt, die ich an QBIC wirklich mag, und einen guten Einblick in die Funktionsweise einiger Funktionen unter der Haube gibt, habe ich die Erklärung ein wenig übertrieben. Beachten Sie, dass QBIC im Kern ein QBasic-Interpreter für Codegolf ist. QBIC-Code wird eingegeben - QBasic-Code wird ausgegeben (und anschließend ausgeführt).

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

immer noch furchtbar lang

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

Nimmt Eingaben vom Kommandozeilenargument entgegen; renn mit -r.

Nervenzusammenbruch

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