编辑

在我的错字之后，似乎在原始帖子中出现了一些混乱，该帖子使用小写字母o定义平面，然后使用大写字母定义。不幸的是，此错误并未在沙箱中被发现。由于很多成员都写了答案，而且错别字是我的错，所以在飞机的定义中允许使用大写或小写的o。我为此添加了一条新规则。

背景

我喜欢ascii艺术动画，因为我倾向于称它们为动画，所以这里是另一个动画。我认为这实施起来并不难，因此有望得到一些简短而有趣的答案。

给所有社区成员

如果您的答案有所改善，请修改为

旧字节数新字节数

这样我们就可以看到您的进度。谢谢！

挑战

这是一个ascii飞机

--O--

这是一条ascii跑道

____|     |____

飞机从跑道上方的5条新线开始。为了防止公制和英制之间发生冲突，并使之成为真正的国际挑战，我不会提及米或英尺。例：

        --O--




____|     |____

飞机必须正好降落在跑道中间，如下所示：

____|--O--|____

输入项

平面的初始水平位置由整数输入定义，该整数输入用于参考左翼的尖端，即介于0到10之间（含0和10）。

输出量

必须显示飞机飞行的每个阶段。以下示例（输入= 10）：

          --O--




____|     |____

         --O--



____|     |____

        --O--


____|     |____

       --O--

____|     |____

      --O--
____|     |____

____|--O--|____

为了简单起见，我们忽略了透视定律。靠近跑道时，跑道保持不变。

规则

• 更新平面的中间可以是大写或小写的o，但是在整个代码中选择的哪个必须一致。如果您的语言不支持上述字符，请随意使用其他ascii字符。
• 平面每帧下降1行。
• 飞机每次下降一行，只能向左或向右移动1个空间。它不必在下降的每一行上移动。只要它在跑道上完成，它就取决于您向右或向左移动。你是飞行员！
• 无需错误处理。您可以假设输入将始终是一个有效的整数，范围从0到10（含0和10）。
• 输出必须仅包含上面显示的字符（如果您的语言不支持它们，请参见编辑的第一条规则），并且必须具有相同的大小，即必须以6行高，15个字符宽开头。如上例所示，高度可以随着进度的增加而减小。
• 程序或函数很好，但必须产生如上所述的输出。
• 前导/尾随空格/换行符对我来说很好。
• 如果需要，请随时清除输出帧之间的屏幕。这不是必需的。
• 像往常一样禁止出现标准漏洞（尽管我不认为有很多漏洞可以帮助应对此类挑战）。
• 这是代码高尔夫，因此最短的答案显然是获胜者，并且可能会获得最多的选票，但是，如果采用某种意外的语言（即使更长）提出了一些真正有趣的解决方案，则不一定会被认为是最佳答案。只要符合要求，就可以随意发布。

可以在线尝试 Python 2中的非引用参考实现！这样您就可以了解不同输入值的外观。

TI-BASIC，61字节

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字节

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

请注意，TI-BASIC不支持_或|。因此，我用大写字母I和-代替。这不会影响字节数。

Python 2，107个字节

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

在线尝试

只需对着陆飞机的最后一行进行硬编码。可以通过重复使用零件或将其集成到环中来打高尔夫球。

Perl，94个字节

93个字节的代码+ -p标志。

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

在线尝试！

JavaScript（ES6），108个字节

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

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

测试一下

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>

用法

只需调用f飞机的索引即可。

f(2)

输出量

  --O--




____|     |____

   --O--



____|     |____

    --O--


____|     |____

     --O--

____|     |____

    --O--
____|     |____

____|--O--|____

Scala中，224个 181字节

编辑：我不知道您可以"string"*n重复n次！Scala继续打动我。缺少if(t>0)而不是if(t==0)新秀错误。感谢您的提示，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)}

原始说明：

我认为尝试递归解决方案会很有趣。我是Scala的新手，所以我确信这远非最佳。

批处理，230字节

@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是要从字符串开头删除的空格数s，因此我从10减去了参数。最后一行是最接近Batch的行x-=sgn(x-5)。

sed，181个字节+ 2个-nr标志

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

不打高尔夫球

# 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

用法： $ echo 2 | sed -nrf flightsim.sed

视网膜，86 83字节

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

在线尝试！

我可能在跑道上及其上方的空白处使用了某种压缩方式，但是我尝试的任何操作都比纯文本更昂贵（在Retina¶中是换行符，因此您可以在显示屏上以纯文本形式查看初始状态第二行）。

Scala，177、163、159137字节

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

根据另一个答案，明显减少了。

Perl 6的，97个 90 81字节

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

与它的外观相反，它输出飞机的*小写版本（--o--），这是更新的任务描述所允许的。

在线尝试！

怎么运行的

按位字符串运算符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.
}

之所以起作用，是因为按位字符串运算符使用两个字符串中给定位置处的字符的代码点值来计算输出字符串中该位置处的新字符。
在这种情况下：

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

对于大写字母-O平面，我们可以使用~^（按位字符串XOR），其平面掩码为\r\ro\r\r（反斜杠+4字节）：

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

平面偏移量的公式h + v*(17 - h/5)简化为：

  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字节

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

在线尝试！

这是参考实现从384下降到160的方法。只是为了好玩并鼓励更好的Python答案而发布。

Befunge-93，136个 130字节

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

在线尝试！

说明

&                          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个字节

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

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

打印飞机的位置，后跟换行符，然后是机场。然后根据相对于5的位置将平面移动1，-1或0。

循环上述5次后，它将在飞机上打印飞机。

8th，177172字节

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

该词f期望0到10之间的整数。

用法

4 f

说明

: 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个字节

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

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

匿名函数。以数字作为输入，并返回一个字符串作为输出。可能会打得更远。

QBIC，93 91 84字节

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

通过替换X $的声明删除一些字节；优化了FOR循环，该循环打印地面上的距离。以下说明是针对旧版本的，但其基本原理相同。

为了测试（和美观），我有一个略有不同的版本，为103字节：

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

这些在功能上是相同的。第二个功能是在画面之间清除屏幕，并且在画面之间暂停0.5秒。

样品输出

请注意，我在框架之间添加了两个换行符。上面最常用的代码不会在框架之间添加空行，较凉的代码可以清除屏幕。

Command line: 10


          --O--




____|     |____


         --O--



____|     |____


        --O--


____|     |____


       --O--

____|     |____


      --O--
____|     |____


____|--O--|____

说明

因为我感觉到这涉及到我非常喜欢QBIC的许多事情，并且可以很好地了解QBIC的某些功能是如何工作的，所以我在解释上有些过分了。请注意，QBIC的核心是Codegolf的QBasic解释器。QBIC代码进入-QBasic代码出现（并随后执行）。

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

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字节

还很长

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

从命令行参数获取输入；与运行-r。

分解

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