EDYTOWAĆ

Wygląda na to, że nastąpiło pewne zamieszanie po mojej literówce w oryginalnym poście, w którym za pomocą małej litery o zdefiniowano płaszczyznę, a następnie wielką literą później. Niestety ten błąd nie został wykryty w piaskownicy. Ponieważ wielu członków napisało odpowiedzi na oba te pytania, a ponieważ literówka była moją winą, w definicji płaszczyzny pozwolę na pisanie wielkimi lub małymi literami. Dodałem do tego nową regułę.

tło

Lubię animacje sztuki ascii, jak je nazywam, więc oto kolejna. Nie sądzę, że jest to zbyt trudne do wdrożenia, więc mam nadzieję, że otrzymam krótkie i interesujące odpowiedzi.

Do wszystkich członków społeczności

Jeśli poprawisz swoją odpowiedź, zmień liczbę bajtów jako

stara liczba bajtów nowa liczba bajtów

abyśmy mogli zobaczyć Twoje postępy. Dzięki!

Wyzwanie

Oto samolot ascii

--O--

Oto pas startowy ascii

____|     |____

Samolot startuje z 5 nowych linii powyżej pasa startowego. Aby zapobiec konfliktom między systemami metrycznymi i imperialnymi i uczynić z tego prawdziwie międzynarodowe wyzwanie, nie wspomnę o metrach ani stopach. Przykład:

        --O--




____|     |____

Samolot musi wylądować dokładnie na środku pasa startowego, jak pokazano poniżej:

____|--O--|____

Wkład

Początkowe poziome położenie płaszczyzny jest określone liczbą całkowitą, która służy do odniesienia do końca lewego skrzydła, tzn. Zawiera się między 0 a 10 włącznie.

Wydajność

Każdy etap lotu samolotów musi być pokazany. Przykład poniżej (wkład = 10):

          --O--




____|     |____

         --O--



____|     |____

        --O--


____|     |____

       --O--

____|     |____

      --O--
____|     |____

____|--O--|____

Dla uproszczenia ignorujemy prawa perspektywy. Pas startowy pozostaje taki sam, jak się zbliżasz.

Zasady

• Aktualizacja Środek płaszczyzny może być wielkimi lub małymi literami o, ale cokolwiek zostanie wybrane, musi być spójne w całym kodzie. Jeśli twój język nie obsługuje powyższych znaków, możesz użyć alternatywnych znaków tylko ascii.
• Płaszczyzna schodzi o 1 linię na ramkę.
• Samolot może przesunąć tylko 1 pole w lewo lub w prawo za każdym razem, gdy schodzi o jedną linię. Nie musi poruszać się po każdej linii zniżania. Tak długo, jak kończy się na pasie startowym, zależy od ciebie, kiedy porusza się w prawo lub w lewo. Jesteś pilotem!
• Obsługa błędów nie jest wymagana. Możesz założyć, że wejście zawsze będzie prawidłową liczbą całkowitą od 0-10 włącznie.
• Dane wyjściowe muszą składać się wyłącznie ze znaków pokazanych powyżej (jeśli Twój język ich nie obsługuje, patrz: edytowana pierwsza reguła) i muszą być tego samego rozmiaru, tzn. Muszą zaczynać się o 6 linii od 15 znaków. Wysokość może się zmniejszać wraz z postępem, jak w powyższym przykładzie.
• Program lub funkcja działa poprawnie, ale musi dawać wynik, jak pokazano powyżej.
• Wiodące / końcowe spacje / nowe linie są dla mnie w porządku.
• Jeśli chcesz, możesz wyczyścić ekran między ramkami wyjściowymi. To nie jest wymóg.
• Standardowe luki zabronione jak zwykle (choć nie sądzę, aby było wiele takich problemów).
• To jest golf golfowy, więc najkrótsza odpowiedź jest oczywiście zwycięzcą i prawdopodobnie otrzyma najwięcej głosów, ale niekoniecznie zostanie zaakceptowana jako najlepsza odpowiedź, jeśli pojawi się jakieś naprawdę interesujące rozwiązanie w jakimś nieoczekiwanym języku, nawet jeśli jest ono dłuższe. Publikuj wszystko, co spełnia zasady, o ile działa.

Implementacja referencji bez golfisty w Pythonie 2 dostępna na stronie Wypróbuj online! dzięki czemu można zobaczyć, jak to wygląda dla różnych wartości wejściowych.

TI-BASIC, 61 bajtów

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 bajty

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

Zauważ, że TI-BASIC nie obsługuje _ ani | i dlatego zastąpiłem wielką I i. Nie powinno to wpływać na liczbę bajtów.

Python 2, 107 bajtów

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

Wypróbuj online

Po prostu zakoduj na ostatniej linii samolot lądujący. Można go prawdopodobnie zagrać w golfa poprzez ponowne użycie części z przeszłości lub włączenie do pętli.

Perl, 94 bajty

93 bajty kodu + -pflaga.

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

Wypróbuj online!

JavaScript (ES6), 108 bajtów

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

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

Sprawdź to

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>

Stosowanie

Wystarczy zadzwonić fz indeksem samolotu.

f(2)

Wydajność

  --O--




____|     |____

   --O--



____|     |____

    --O--


____|     |____

     --O--

____|     |____

    --O--
____|     |____

____|--O--|____

Scala, 224 181 bajtów

EDYCJA : Nie miałem pojęcia, że ​​możesz to "string"*npowtórzyć n razy! Scala nadal oszałamia mój umysł. Tęsknota za if(t>0)zamiast if(t==0)była błędem debiutanta. Dzięki za wskazówki, 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)}

Oryginalne uwagi:

Uznałem, że wypróbowanie rekurencyjnego rozwiązania byłoby fajne. Jestem stosunkowo nowy w Scali, więc jestem pewien, że nie jest to optymalne.

Partia, 230 bajtów

@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

xto liczba spacji do usunięcia od początku łańcucha s, więc odejmuję parametr od 10. Ostatni wiersz to najbliższa partia x-=sgn(x-5).

sed, 181 bajtów + 2 dla -nrflag

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

Bez golfa

# 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

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

Retina , 86 83 bajtów

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

Wypróbuj online!

Prawdopodobnie jest jakiś rodzaj kompresji, którego mógłbym użyć na pasie startowym i pustej przestrzeni nad nim, ale wszystko, co próbowałem, okazało się droższe niż zwykły tekst (w Retina ¶ jest nowym wierszem, więc możesz zobaczyć stan początkowy w postaci zwykłego tekstu na druga linia).

Scala , 177, 163, 159 137 bajtów

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

Na podstawie innej odpowiedzi , ze znacznymi obniżkami.

Perl 6 , 97 90 81 bajtów

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

W przeciwieństwie do tego, jak to wygląda, wypisuje * wersję samolotu ( --o--) o małych literach , na co pozwala zaktualizowany opis zadania.

Wypróbuj online!

Jak to działa

Bitowe ciągi znaków 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.
}

Działa, ponieważ operatorzy łańcuchów bitowych używają wartości znaków kodowych znaków w danej pozycji w dwóch ciągach, aby obliczyć nowy znak w tej pozycji w ciągu wyjściowym.
W tym przypadku:

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

W przypadku wielkiej litery O, moglibyśmy użyć ~^(ciąg bitowy XOR), z płaską maską \r\ro\r\r(+4 bajty dla odwrotnych ukośników):

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

Wzór na przesunięcie płaszczyzny h + v*(17 - h/5)został uproszczony z:

  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 bajtów

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

Wypróbuj online!

Oto implementacja referencyjna, która spadła do 160 z 384. Myślę, że nadal jest to droga. Właśnie wysłano dla zabawy i aby zachęcić do lepszej odpowiedzi w języku Python.

Befunge-93, 136 130 bajtów

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

Wypróbuj online!

Wyjaśnienie

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

Rubinowy, 94 bajty

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

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

Drukuje pozycję samolotu, następnie nowe linie, a następnie lotnisko. Następnie przesuwa płaszczyznę o 1, -1 lub 0, w zależności od położenia względem 5.

Po zapętleniu powyższego 5 razy drukuje samolot na lotnisku.

8th , 177 172 bajtów

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

Słowo f oczekuje liczby całkowitej od 0 do 10.

Stosowanie

4 f

Wyjaśnienie

: 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 bajtów

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

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

Funkcja anonimowa. Pobiera liczbę jako dane wejściowe i zwraca ciąg znaków jako dane wyjściowe. Prawdopodobnie można by dalej grać w golfa.

QBIC , 93 91 84 bajtów

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

Usunięto niektóre bajty, zastępując deklarację X $; zoptymalizowana pętla FOR, która drukuje odległość nad ziemią. Wyjaśnienie poniżej dotyczy starej wersji, ale w zasadzie działa tak samo.

Do testowania (i estetyki) miałem nieco inną wersję, o wielkości 103 bajtów:

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

Są funkcjonalnie identyczne. Drugi polega na tym, że ekran jest usuwany między ramkami i zatrzymuje się na 0,5 sekundy między ramkami.

Próbka wyjściowa

Zauważ, że dodałem dwie nowe linie między ramkami. Najbardziej golfowy kod powyżej nie dodaje pustych linii między ramkami, chłodniejszy usuwa ekran.

Command line: 10


          --O--




____|     |____


         --O--



____|     |____


        --O--


____|     |____


       --O--

____|     |____


      --O--
____|     |____


____|--O--|____

Wyjaśnienie

Ponieważ czuję, że dotyczy to wielu rzeczy, które naprawdę lubię w QBIC i daje dobry wgląd w to, jak niektóre z jego funkcji działają pod maską, nieco przesadziłem z wyjaśnieniem. Zauważ, że QBIC jest w istocie interpretatorem QBasic dla Codegolfa. Kod QBIC wchodzi - kod QBasic wychodzi (i jest następnie wykonywany).

:{      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 bajtów

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 bajtów

wciąż okropnie długo

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

pobiera dane wejściowe z argumentu wiersza poleceń; biegać z -r.

awaria

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