DÜZENLE

İlk yazımdaki yazımın ardından düzlemi tanımlamak için küçük harf o ve daha sonra büyük harf kullanmak için bir karışıklık olduğu anlaşılıyor. Ne yazık ki bu hata Sandbox'ta tespit edilemedi. Birçok üye her ikisine de cevap yazdığından ve yazım hatası benim hatam olduğu için uçağın tanımında büyük veya küçük harflere izin vereceğim. Bunun için yeni bir kural ekledim.

Arka fon

Ben , bir başka sanat eseri olarak adlandırmaya çalıştığım gibi, sanat sanat animasyonlarını severim . Bunun uygulanmasının çok zor olduğunu sanmıyorum, umarım kısa ve ilginç cevaplar alırsınız.

Tüm diğer topluluk üyelerine

Cevabınızı geliştirirseniz, lütfen bayt sayınızı şu şekilde değiştirin:

eski bayt sayısı yeni bayt sayısı

böylece ilerlemenizi görebiliriz. Teşekkürler!

Meydan okuma

İşte bir ascii uçağı

--O--

İşte bir ascii pist

____|     |____

Uçak pistin üzerindeki 5 yeni çizgide başlar. Metrik ve emperyal sistemler arasındaki herhangi bir çatışmayı önlemek ve bunu gerçek anlamda uluslararası bir meydan okuma yapmak için metre veya ayaktan bahsetmiyorum. Örnek:

        --O--




____|     |____

Uçak, aşağıda gösterildiği gibi tam olarak pistin ortasına inmelidir:

____|--O--|____

Giriş

Düzlemin ilk yatay pozisyonu, sol kanadın ucuna referans vermek için kullanılan bir tamsayı girişi ile tanımlanır, yani 0 ila 10 arasındadır.

Çıktı

Uçakların uçuşunun her aşaması gösterilmelidir. Aşağıdaki örnek (giriş = 10):

          --O--




____|     |____

         --O--



____|     |____

        --O--


____|     |____

       --O--

____|     |____

      --O--
____|     |____

____|--O--|____

Her şeyi basit tutmak için, perspektif yasalarını görmezden geliyoruz. Pist, yaklaştığınız boyutta kalıyor.

kurallar

• Güncelleme Düzlemin ortası büyük veya küçük harf o olabilir, ancak hangisi seçilirse kod boyunca tutarlı olmalıdır. Diliniz yukarıdaki karakterleri desteklemiyorsa, alternatif ASCII sadece karakterleri kullanmaktan çekinmeyin.
• Düzlem, kare başına 1 satır iner.
• Uçak, bir çizgiye her indiğinde sadece 1 boşluk sola veya sağa hareket ettirebilir. Her iniş çizgisinde hareket etmek zorunda değildir. Pistte bitince, sağa veya sola hareket ettiğinde size kalmıştır. Sen pilotsun!
• Hata işlemeye gerek yok. Girişin her zaman 0-10 dahil olmak üzere geçerli bir tam sayı olacağını varsayabilirsiniz.
• Çıktı yalnızca yukarıda gösterilen karakterlerden oluşmalı (eğer diliniz onları desteklemiyorsa, ilk yönetilen kuralı görünüz) ve aynı boyutta olmalıdır; Yükseklik yukarıdaki örnekteki gibi ilerledikçe azalabilir.
• Program veya işlev iyi ancak yukarıda gösterildiği gibi bir çıktı üretmek zorunda.
• Lider / sondaki boşluk / yeni satırlar bana göre iyi durumda.
• İsterseniz çıkış çerçeveleri arasındaki ekranı temizlemek için çekinmeyin. Bu bir gereklilik değil .
• Her zamanki gibi yasaklanmış standart boşluklar (bu tür zorluklara yardımcı olacak birçok insan olduğunu düşünmeme rağmen).
• Bu kod golf, bu yüzden en kısa cevap kesinlikle kazanır ve muhtemelen en fazla oyu alır, ancak gerçekten ilginç bir çözüm beklenmedik bir dilde, daha uzun olsa bile ortaya çıkarsa, en iyi cevap olarak kabul edilmeyebilir. İşe yaradığı sürece kurallara uyan herhangi bir şey göndermekten çekinmeyin.

Python 2'deki Ungolfed referans uygulaması Online olarak deneyin! Böylece farklı giriş değerlerinin nasıl göründüğünü görebilirsiniz.

TI-BASIC, 61 bayt

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 bayt

: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’in _ veya | ve bu yüzden ben büyük harf I ve - ile değiştirdim. Bu, bayt sayısını etkilememelidir.

Python 2, 107 bayt

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

Çevrimiçi deneyin

İniş uçağı için son satırı basitçe kodlar. Öncekinden parçaları tekrar kullanarak veya döngüye entegre ederek muhtemelen golf oynayabilir.

Perl, 94 bayt

93 bayt kodu + -pbayrak.

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

Çevrimiçi deneyin!

JavaScript (ES6), 108 bayt

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

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

Dene

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>

kullanım

Sadece fuçağın indeksi ile arayın .

f(2)

Çıktı

  --O--




____|     |____

   --O--



____|     |____

    --O--


____|     |____

     --O--

____|     |____

    --O--
____|     |____

____|--O--|____

Scala, 224 181 bayt

EDIT : "string"*nN kere tekrarlamak için yapabileceği hakkında hiçbir fikrim yoktu ! Scala aklımı patlatmaya devam ediyor. if(t>0)Bunun yerine eksik if(t==0)bir çaylak hatasıydı. Tavsiyeler için teşekkürler, 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)}

Orijinal açıklamalar:

Özyinelemeli bir çözüm denemek eğlenceli olacağını düşündüm. Scala'da nispeten yeniyim, bu yüzden bunun optimal olmaktan çok uzak olduğundan eminim.

Toplu, 230 bayt

@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

xdize başlangıcından kaldırılacak boşluk sayısıdır s, bu nedenle parametreyi 10'dan çıkarırım. Son satır, Batch'in sahip olması gereken en yakın satırdır x-=sgn(x-5).

-nrbayraklar için sed, 181 bayt + 2

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

Kullanımı: $ echo 2 | sed -nrf flightsim.sed

Retina , 86 83 bayt

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

Çevrimiçi deneyin!

Muhtemelen pistte ve üzerinde boş olan alanda kullanabileceğim bir tür sıkıştırma vardır, ancak denediğim herhangi bir şey düz metinden daha pahalıydı (Retina in'da yeni bir satırdır, bu nedenle başlangıç ​​durumunu düz metin olarak düz metin olarak görebilirsiniz. ikinci çizgi).

Scala , 177, 163, 159 137 bayt

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

Dayanarak başka bir yanıt önemli azalmalar ile.

Perl 6 , 97 90 81 bayt

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

Göründüğünün aksine --o--, güncellenmiş görev tanımlamasının izin verdiği şekilde uçağın ( ) küçük harfli versiyonunu çıkarır.

Çevrimiçi deneyin!

Nasıl çalışır

Bitsel dize operatörleri 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.
}

Bitsel dize işleçleri, belirli bir konumdaki karakterlerin kod noktası değerlerini, iki dizgede, dizgede o konumda yeni bir karakter hesaplamak için kullandıkları için çalışır.
Bu durumda:

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

Büyük harfli bir Odüzlem için, ~^( düz bitli XOR dizesi), bir \r\ro\r\rters maske (ters eğik çizgiler için +4 bayt) ile kullanabilirdik:

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

Uçağın kayması için formül h + v*(17 - h/5), basitleştirildi:

  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 2,160 bayt

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

Çevrimiçi deneyin!

Referans uygulaması 384'ten 160'a düşürüldü. Yine de gitmenin bir yolu olduğunu düşünüyorum. Sadece eğlence için gönderildi ve daha iyi bir Python cevabını teşvik etmek için gönderildi.

Befunge-93, 136 130 bayt

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

Çevrimiçi deneyin!

açıklama

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

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

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

Uçağın konumunu, ardından yeni satırları ve sonra havaalanını yazdırır. Sonra düzlemi 5'e göre konumuna bağlı olarak 1, -1 veya 0 hareket ettirir.

Yukarıdaki 5 kez döngüden sonra, havaalanındaki uçağı yazdırır.

8 , 177 172 bayt

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

Kelime f, 0 ile 10 arasında bir tam sayı bekliyor.

kullanım

4 f

açıklama

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

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

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

Anonim işlev Girdi olarak bir sayı alır ve çıktı olarak bir dize döndürür. Muhtemelen daha da golf oynayabilirdi.

QBIC , 93 91 84 bayt

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

X $ bildirgesini değiştirerek bazı baytları attı; mesafeyi yerden basan FOR döngüsünü optimize etti. Aşağıdaki açıklama eski sürüm içindir, ancak temelde aynı şekilde çalışır.

Test için (ve estetik) 103 baytta biraz farklı bir sürüme sahiptim:

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

Bunlar fonksiyonel olarak aynıdır. İkincisi, ekranın çerçeveler arasında temizlendiğini ve çerçeveler arasında 0,5 saniye durduğunu ekledi.

Örnek çıktı

Kareler arasına iki yeni satır eklediğimi unutmayın. Yukarıdaki en çok kodlanan kod, çerçeveler arasına boş satırlar eklemez, soğuk olan ise ekranı temizler.

Command line: 10


          --O--




____|     |____


         --O--



____|     |____


        --O--


____|     |____


       --O--

____|     |____


      --O--
____|     |____


____|--O--|____

açıklama

Bunun QBIC hakkında gerçekten sevdiğim pek çok şeye dokunduğunu ve bazı işlevlerinin kaputun altında nasıl çalıştığı hakkında iyi bir fikir verdiğimi düşündüğüm için, açıklama üzerine biraz girdim. QBIC'in özünde, Codegolf için bir QBasic tercümanı olduğunu unutmayın. QBIC kodu girilir - QBasic kodu çıkar (ve daha sonra yürütülür).

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

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 bayt

hala çok uzun

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

komut satırı argümanından girdi alır; ile koş -r.

Yıkmak

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