Wyzwanie Schody

20

Twoim zadaniem jest odtworzenie tego dzieła sztuki:

                        _____
                       |
                       |
                       |
                       |
                  _____| 
                 |
                 |
                 |
                 |
            _____|
           |
           |
           |
           |
      _____|
     |
     |
     |
     |
_____|

Odpowiedź musi go odtworzyć i wydrukować. Wszystkie języki dozwolone, nie wymaga bezpośredniego drukowania dzieł sztuki, ofc, wymagany jest pewien poziom manipulacji. Odpowiedź z najmniej bajtami wygrywa.

Zamknięte w czwartek o 6:30 lub mniej więcej UTC.

Oryginalna rzecz została mi pokazana przez mojego przyjaciela, który zrobił to z Javą, odmówił pokazania mi kodu źródłowego, a teraz oszołomię go błyskotliwością innych języków. :RE

Nie możesz użyć żadnej alternatywnej postaci (ułatwia to?).


Obecna tablica wyników

  1. Pyth - 28 bajtów - isaacg
  2. CJam - 30 bajtów - Runer112
  3. CJam - 32 bajty - Martin Büttner

Najwyższe głosy: C - 73 bajty - Paul R.


isaacg przejmuje koronę za zaliczenie wyzwania schodowego z Pyth. Uważaj na więcej takich wyzwań w PPCG!

do tego kawa
źródło
1
Witamy w Programowaniu łamigłówek i wymianie stosów kodów golfowych! Wszystkie wyzwania tutaj wymagają obiektywnego kryterium zwycięstwa, aby bezdyskusyjnie zdecydować, które rozwiązanie powinno wygrać. To wygląda na pytanie o kod-golfa , tzn. Wygrywa najkrótszy kod, ale pozwolę ci go edytować w sobie, na wypadek, gdybyś chciał zrobić coś innego. Dzięki!
Klamka
1
Ach, przepraszam, tęskniłem za tym. W takim razie edytowałem odpowiedni tag do twojego pytania.
Klamka
13
Czy musimy wydrukować to 1 dziwne końcowe miejsce w 6. linii?
Optymalizator
4
Mówiąc bardziej ogólnie, czy końcowe miejsce jest dozwolone? Czy mogę to wstawić do prostokąta o szerokości pierwszej linii?
Martin Ender
8
Czy możemy mieć końcowy znak nowej linii?
TheNumberOne

Odpowiedzi:

4

Pyth, 29 28

V21++**6/-20N5d*5?d%N5\_<\|N

Wypróbuj tutaj.

Całkiem proste rozwiązanie z trikiem „dodaj pięć spacji lub pięć znaków podkreślenia” z rozwiązania @ xnor, ale z pętlą od 0 do 20, a nie od 20 do 0.

isaacg
źródło
1
Nazywam cię, Sir Isaacgu za zaliczenie Wyzwania na schody.
therewillbecoffee
... a teraz możesz wejść na schody
Anthony Pham
22

C, 86 80 76 75 73 bajtów

c;main(i){for(i=21;i--;c='|')printf("%*s%c\n",i/5*6+5,i%5?"":"_____",c);}
Paul R.
źródło
5
Zawsze musi być ten facet, który opublikuje rozwiązanie C. Głosuj za ciebie.
therewillbecoffee
1
Można go jeszcze skrócić, zmieniając pętlę nafor(i=25;i--;)
Felix Bytow
1
@FelixBytow Powinno być i=26. Poza tym ' 'można go zmienić na 32na dodatkową postać. Moje rozwiązanie ma 2 znaki dłużej po tych optymalizacjach :(
Allbeert
2
Wygląda na to, że masz dodatkowy krok. w wymaganym wyjściu jest 21 wierszy, a nie 26. main(i){for(i=21;i--;)printf("%*s%c\n",i/5*6+5,i%5?"":"_____",i<20?'|':0);}Jeszcze więcej optymalizacji: 1. Uprość formułę dla długości 2. Jak mówi @Allbeert, możesz użyć kodu ascii, ' 'ale po co zatrzymywać się na ASCII 32, gdy ASCII 0 zrobi. Również działa mi dobrze z ""zamiast" "
Level River St
1
Co powiesz na to, aby zaoszczędzić dwa bajty podczas '|'drukowania? c;main(i){for(i=21;i--;c='|')printf("%*s%c\n",i/5*6+5,i%5?"":"_____",c);}
Runer112
11

Java, 198 158 156 146 bajtów

Prawdopodobnie można to znacznie skrócić. Jak zwykle sugestie są mile widziane.

void a(){String a="",b="_____",c=b;for(int i=-1;i<20;b=i%5<1?b.replace(c,"     "):i%5>3?b+" "+c:b)a=b+(++i>19?"":"|")+"\n"+a;System.out.print(a);}

Wcięte (trochę):

void a(){
    String a="",b="_____",c=b;
    for(int i=-1;i<20;b=i%5<1?b.replace(c,"     "):i%5>3?b+" "+c:b)
        a=b+(++i>19?"":"|")+"\n"+a;
    System.out.print(a);
}

Dzięki Martin Büttner, Rainbolt i Geobits.

Numer jeden
źródło
1
Szczerze mówiąc, odkąd zrobiłeś to z Javą, jestem pod wrażeniem.
therewillbecoffee
9

Brainfuck (1065 bajtów)

To nie jest ładne, nie jest krótkie ... ale zoptymalizuję później!

++++[->++++++++<]>........................
[->+++<]>-.....>++++++++++.[->+++<]>++....
...................-[->++++<]>.>++++++++++
.[->+++<]>++.......................-[->+++
+<]>.>++++++++++.[->+++<]>++..............
.........-[->++++<]>.>++++++++++.[->+++<]>
++.......................-[->++++<]>.>++++
++++++.[->+++<]>++..................[->+++
<]>-.....[->++++<]>.>++++++++++.[->+++<]>+
+.................-[->++++<]>.>++++++++++.
[->+++<]>++.................-[->++++<]>.>+
+++++++++.[->+++<]>++.................-[->
++++<]>.>++++++++++.[->+++<]>++...........
......-[->++++<]>.>++++++++++.[->+++<]>++.
...........[->+++<]>-.....[->++++<]>.>++++
++++++.[->+++<]>++...........-[->++++<]>.>
++++++++++.[->+++<]>++...........-[->++++<
]>.>++++++++++.[->+++<]>++...........-[->+
+++<]>.>++++++++++.[->+++<]>++...........-
[->++++<]>.>++++++++++.[->+++<]>++......[-
>+++<]>-.....[->++++<]>.>++++++++++.[->+++
<]>++.....-[->++++<]>.>++++++++++.[->+++<]
>++.....-[->++++<]>.>++++++++++.[->+++<]>+
+.....-[->++++<]>.>++++++++++.[->+++<]>++.
....-[->++++<]>.>++++++++++.[--->++<]>+++.
....[->++++<]>.
Joshpbarron
źródło
brainfuck nigdy nie jest ładny :) głosujcie pozytywnie tylko za to, że działa
Purefan
Nie zgadzam się: codegolf.stackexchange.com/questions/13152/…
Joshpbarron
ideone.com/ICtrhv Przekroczono limit czasu Mam na myśli, co ....
therewillbecoffee
Bizzare ... spróbuj tutaj: esoteric.sange.fi/brainfuck/impl/interp/i.html
Joshpbarron
8

CJam, 36 30 bajtów

Wypróbuj online.

L{{S5*\+}/S'|5*+]'_5*+}5*1>zN*

Moje początkowe 36-bajtowe rozwiązanie wygenerowało wynik w orientacji wyjściowej. Mimo moich prób wyciśnięcia większej ilości bajtów z algorytmu, nie mogłem. Potem zobaczyłem genialną strategię Martina, polegającą na generowaniu kolumn zamiast wierszy i transponowaniu wyniku. Zdałem sobie sprawę, że to prawdopodobnie lepsze podejście, więc postanowiłem stworzyć rozwiązanie oparte na transpozycji.

Moje podejście do wdrażania tej strategii jest jednak dość zróżnicowane. Zamiast generować pełne kolumny, używam iteracyjnego rozwiązania, które wcina wszelkie już wygenerowane „kroki” i dodaje nowy krok przy każdej iteracji. Tak więc pierwsza iteracja głównej pętli generuje to:

 |||||
_
_
_
_
_

Druga iteracja głównej pętli wcina istniejący krok i dodaje nowy po nim:

      |||||
     _
     _
     _
     _
     _
 |||||
_
_
_
_
_

A pełne pięć iteracji głównej pętli generuje to:

                     |||||
                    _
                    _
                    _
                    _
                    _
                |||||
               _
               _
               _
               _
               _
           |||||
          _
          _
          _
          _
          _
      |||||
     _
     _
     _
     _
     _
 |||||
_
_
_
_
_

Po tym wszystkim, co trzeba zrobić, to wyeliminować pierwszą linię, która w przeciwnym razie stałaby się niechcianym pionem dla dolnego stopnia i transponowała.

Runer112
źródło
7

Python 2, 80 77 74 bajtów

n=24;exec"print' '*n+'_'*5+'|'*(n<24)+('\\n'+~-n*' '+'|')*4*(n>0);n-=6;"*5

Pozbyłem się podwójnego execi zmieściłeś wszystko w jednym print!

Sp3000
źródło
6

Klip, 46

{:24S:5'_m[z{*4,:+5*6zS"|
":*6zS:5'_"|
"`}vR4`

Wyjaśnienie

{               .- Put everything in a list -.
 :24S           .- 24 spaces                -.
 :5'_           .- 5 underscores            -.
 m[z            .- Map...                   -.
    {           .- A list                   -.
     *4         .- 4 of the following       -.
       ,        .- Append                   -.
        :+5*6zS .- 5 + 6 * the iteration of spaces  -.
        "|      .- A pipe and newline       -.
"
     :*6zS      .- 6 * the iteration of spaces      -.
     :5'_       .- 5 underscores            -.
     "|         .- A pipe and newline       -.
"
    `           .- End list (per iteration  -.
   }vR4         .- The mapping is onto {3,2,1,0}    -.
Ypnypn
źródło
1
Klip nie ma nawet strony w Wikipedii. Chodzi mi o to, co ....
pory kawa
4
@therewillbecoffee Wiele języków na tej stronie nie ma strony w Wikipedii. To jest zabawa;)
Ypnypn
@Ypnypn Czy to zaprojektowałeś? Wygląda naprawdę interesująco! Chociaż byłbym zainteresowany prawdziwym quine. ;) (Ten na stronie przykładów jest nieco podstępny.)
Martin Ender
6

CJam, 36 32 bajtów

{5*S*'_+a5*~_W<S+5'|*+}5/;]W%zN*

Sprawdź to tutaj.

Próbowałem także użyć jawnej formuły, ale jest ona dłuższa w CJam ... może pomaga komuś innemu:

21,29,ff{_2$5/)6*(=@@6/5*=_++" |_|"=}W%N*

Wyjaśnienie

Odkryłem, że schody można zbudować o wiele łatwiej, jeśli a) transponujesz siatkę i b) odwrócisz linie:

_
_
_
_
_
 |||||
     _
     _
     _
     _
     _
      |||||
          _
          _
          _
          _
          _
           |||||
               _
               _
               _
               _
               _
                |||||
                    _
                    _
                    _
                    _
                    _

Najpierw buduję to, potem odwracam, a następnie transponuję.

{                     }5/        "For i in [0 .. 4].";
 5*S*'_+                         "Get a string of 5*i spaces and append _.";
        a5*~                     "Get five such lines.";
            _W<S+                "Duplicate the last, remove the _, add a space.";
                 5'|*+           "Add 5 copies of |.";
                         ;       "The above creates a row too many, so discard the last one.";
                          ]W%zN* "Wrap everything in an array, reverse, transpose, riffle
                                  with newlines.";
Martin Ender
źródło
Dobra, ktoś zrobił to z 30 bajtami.
therewillbecoffee
6

Python 2, 59

n=21
exec"n-=1;print n/5*6*' '+' _'[n%5<1]*5+'|'*(n<20);"*n

W 21 linie są indeksowane nw [20,19,...,1,0]. Najpierw wypisuje 6 spacji dla każdego „kroku”, który osiągamy (minus 1), obliczonego jako n/5*6. Następnie drukuje pięć spacji, ale zamiast nich są to podkreślenia dla wielokrotności pięciu. Na koniec drukuje linię pionową, z wyjątkiem górnej linii n=20.

xnor
źródło
Ładne i proste. Lubię to!
Sp3000,
6

JavaScript, 115 107 96 94 89 87 83 bajtów

To zbyt długo, aby wygrać, ale po raz pierwszy wymyśliłem odpowiedź na PCG.SE i jestem dumny, że stworzyłem coś do wysłania.

Z kilkoma przydatnymi radami składniowymi znacznie skróciłem kod - nawet poniżej progu paska przewijania!

for(s='',y=22;--y;s+='\n')for(x=0;++x<29;)s+=6*~(~-y/5)-~x?4+5*~(x/6)+y?' ':'_':'|'
vvye
źródło
Dobra odpowiedź, kilka rzeczy, które możesz zrobić, aby ją skrócić, to wyjąć alert. Jeśli uruchomisz go w konsoli, będzie działał bez niego. Również średnik w ostatnim nawiasie klamrowym nie jest konieczny. Możesz zapisać 1 bajt, używając (y/5-.2)zamiast((y-1)/5)
qw3n
@ qw3n dzięki za sugestie; Nie byłem pewien, czy reguły wymagały ostrzeżenia.
vvye,
Możesz także przesunąć s+='\n'za y--i pozbyć się nawiasów klamrowych, aby wyglądało to tak for(s='',y=21;y>0;y--,s+='\n').
Zainicjowałem
1
Pomyślałem, że to mój ostatni, ale powinno to być dla mnie, for(s='',y=22;--y;s+='\n')for(x=0;++x<29;)s+=6*~~(y/5-.2)+5-x?5*~~(x/6)+1-y?' ':'_':'|'jeśli odwrócisz swoje trójkowe wyrażenie, które możesz przetestować, dla number - xktórego jest 0, jeśli oba warunki są równe, oszczędzając ci jeszcze 2 bajty.
qw3n
1
Gry tyldy: ~ n == -n-1, - ~ n == n + 1, ~ -n == n-1, for(s='',y=22;--y;s+='\n')for(x=0;++x<29;)s+=6*~(~-y/5)-~x?4+5*~(x/6)+y?' ':'_':'|'to 83
edc65
6

ECMAScript 6, 142 138 129 91 bajtów

Specjalne podziękowania dla @ edc65 za naprawę tego.

a=o='',[for(x of!0+o)(o=(a+'     |\n').repeat(4)+a+'_____|\n'+o,a+='      ')],a+'_____\n'+o

Logika oryginalnej wersji sprawdź komentarz @ edc65, jak się zmieniła.

((f,l,p)=>                  //variables
f(24)+l+p[1]+               //add the non pattern line
[0,1,2,3].map(b=>f(18-6*b)) //add the right number of spaces in front of the 4 steps
.map((a,b)=>f(4,a+f(5)+p)   //the four repeating lines of the step 
+a+l)                       //the landing line
.join(p)+p)                 //put it all together
((n,s=' ')=>s.repeat(n)     //create an variable array of some character
,'_____','|\n')             //string literals
qw3n
źródło
1
Możesz bezpiecznie usunąć newkonstruktor przed Arrayzapisaniem kilku bajtów.
NinjaBearMonkey
@ hsl dziękuję z jakiegoś powodu, który uznałem za newkonieczny.
qw3n
1
Array (n) .join (s) is so ES5! próbowałeśrepeat
edc65
[1,2,3,4].map((a,b)i używając tylko b => [0,1,2,3].map(b(-4)
edc65
Używam Firefoksa i działa całkiem nieźle!
therewillbecoffee
5

MATLAB, 68 bajtów

Mam silne przeczucie, że MATLAB powinien być w stanie radzić sobie lepiej, ale nie mogę wymyślić żadnego sposobu.

p(1:5,6)='|';p(1,1:5)=95;w=blkdiag(p,p,p,p);w(21,25:29)=95;flipud(w)

Tworzy schody do góry nogami i przewraca je. Mój taumometr zepsuł się z powodu wszystkich magicznych stałych wokół.

'|'jest celowo pozostawiony w stanie, w jakim się znajduje (zamiast ascii codepoint) w celu zainicjowania pi wjako tablica char.

Sanchises
źródło
1
'|' = 124tak czy inaczej, więc nie kosztuje to żadnych dodatkowych znaków.
Peter Cordes,
5

Ruby, 48

25.times{|i|puts" "*(4-i/6)*5+(i%6==0??_*5:?|)}

Stare podejście, 68

4.times{|i|(?_*5+"
|"*5).each_line{|l|puts" "*(4-i)*5+l}}
puts"_"*5
psycotica0
źródło
Witamy w PPCG! Kilka rubinowych wskazówek golfowych: 1. jest tam trochę niepotrzebnych białych znaków. 2. Łańcuchy pojedynczych znaków, takie jak, '_'można zapisać jako ?_. 3. Nowe linie mogą być osadzone bezpośrednio w ciągach znaków (możesz to zrobić "<linebreakhere>|"). 4. Nawiasy wokół tego nie są konieczne. Finał putsmożna zastąpić $><<(co pozwala pozbyć się miejsca, nawet po użyciu ?_). Tak trzymaj! :)
Martin Ender
Tak, właśnie pozbyłem się białych znaków. Dzięki! Nie wiedziałem o ciągach pojedynczych znaków.
psycotica0
Prawdopodobnie możesz również zastąpić (1..4).mapprzez, 4.timesa następnie użyć 4-izamiast 5-i.
Martin Ender
Ooh, dobra rozmowa. Gotowy.
psycotica0
4

Julia, 83 bajty

for n=24:-6:0 print(" "^n*"_"^5*"|"^(n<24)*"\n"*(" "^(n>0?n-1:0)*"|\n"^(n>0))^4)end

W Julii konkatenację łańcuchów wykonuje się za pomocą *operatora, a powtarzanie łańcuchów wykonuje się za pomocą ^.

Alex A.
źródło
4

> <> , 108 104 100 bajtów

cc+::?v~'_____'o\/' 'o  \
?:o'|'\' 'o1-30.o\v!?:-1<}:{oav!?:<4;!
-20.12^?(+cc:ooo/ \~1-'!|'o1. \~ao6

Proste rozwiązanie> <>, wykorzystujące tę samą strategię, co moja odpowiedź w języku Python . Główną różnicą jest to, że> <> nie ma mnożenia łańcuchów (ani nawet łańcuchów), więc wszystko to odbywa się za pomocą pętli.

Wyjaśnienie

cc+                  Push 24 (call this "n")

[outer loop]
[loop 1, print n spaces]

:                    Copy n (call this "i")
:?                   If i is not zero...
' 'o1-30.                Print space, decrement i and go to start of loop 1

~'_____'ooooo        Pop i and print five underscores
:cc+(?               If n < 24...
'|'o                     Print a pipe
21.                  Otherwise skip pipe printing

[loop 2: print vertical parts of stairs]

?!;                  If n is zero, halt
4                    Push 4 (call this "j")
?!                   If j is zero...
~ao6-20.                 Pop j, print a newline, minus 6 from n and go to start of outer loop
ao                   Print a newline
}:{                  Copy n (call this "k")

[loop 3: print n-1 spaces]

1-                   Decrement k
:?!                  If k is zero...
    ~1-'!|'o1.           Pop k, decrement j, print a pipe and go to start of loop 2
' 'o                 Otherwise print a space and go to start of loop 3
Sp3000
źródło
Czuję, że zawsze będę głosować za odpowiedzią> <>.
krs013,
3

Groovy, 98 71 bajtów

// old: (25..5).each{i->println((1..(i-(i-1)%5)).collect{' '}.join()+(i%5?'|':('_____'+(i==25?'':'|'))))}

(25..5).each{i->println(' '*(i-(i-1)%5)+(i%5?'|':'_'*5+(i%25?'|':'')))}

(25..5).each { i ->
    println(
        ' '*(i - (i - 1) % 5) + (
            i % 5 ? 
            '|' : 
            '_'*5 + (i % 25 ? '|' : '')
        )
    )
}    

Jestem całkiem pewien, że można to jakoś zmniejszyć :) skrócone o @Score_Under

Kamil Mikołajczyk
źródło
1
Mam kilka bajtów do golenia: Wymień zbierać / join z mnożyć: ' '*(i-(i-1)%5), wsporniki Usuń z całego ('_____'+(i==25?'':'|')), wymienić '_____'się '_'*5, a jeśli odwrócić ostatni warunkowy można użyć% jako niekonwencjonalny operatora nierówność: (i%25?'|':''). To powinno doprowadzić cię do 71.
Score_Under
@Score_Under nice, dzięki, nie wiedziałem o mnożeniu ciągów: D
Kamil Mikolajczyk
2

Perl, 50

#!perl -l
print$"x6x(-$_/5),($_%5?$":_)x5,"|"x$|++for-20..0

Spróbuj mnie .

nutki
źródło
2

T-SQL, 276 bajtów

declare @x int declare @y int declare @w varchar(30) declare @l char(5) set @l='_____' set @x=23 while @x > 4 begin set @w=replicate(' ',@x) set @y=0 if @x=23 print @w+' '+@l else print @w+' '+@l+'|' while @y < 4 begin set @y=1+@y print @w+'|' end set @x=@x-6 end print @l+'|'
Jr Nipok
źródło
2

Visual FoxPro 9.0, 261 bajtów

n = liczba kroków

w sumie 175 znaków, ale musiał poprawnie wyświetlać dane wyjściowe do pliku, więc minus 43 znaki dla operacji na plikach = 132 znaki.

n=10
c=CHR(13)
f="st.t"
ERAS (f)    
FOR i=n TO 1 STEP -1
    p=(i-1)*6
    =STRTO(PADL("_____",p+5)+IIF(i<n,"|","")+c+IIF(i>1,REPLI(PADL("|"+c,p+1),4),""),f,.t.)
    ?PADL("_____",p+5)+IIF(i<n,"|","")+c+IIF(i>1,REPLI(PADL("|"+c,p+1),4),"")
ENDFOR
MODI COMM (f)

Uwaga dla odpowiadającego: Liczba bajtów dotyczy absolutnie działającego kodu źródłowego, a licznik bajtów mówi, że jest to 261 bajtów, więc tak jest.

danr44z
źródło
2

Bash (+ tac z coreutils): 110 bajtów

Można to wkleić bezpośrednio do terminala.

(n =; set {1..4}; dla i do echa "$ {n} _____ |"; n + = ''; dla i do echa "$ n |"; gotowe; n + = \; gotowe; echo " $ {n} _____ ") | tac
Score_Under
źródło
Bez |tactego nie całkiem działa. I uruchomiłem to na Git Bash, więc powinienem się zabić.
therewillbecoffee
1

kod maszynowy x86, 48 bajtów

B1 05 B4 0E 80 E9 01 B0 5F B5 05 80 ED 01 CD 10 80 FD 00 75 F6 B5 05 80 ED 01 B0 0A CD 10 B0 08 CD 10 B0 7C CD 10 80 FD 00 75 EC 80 F9 00 75 D4

Odpowiednik kodu zestawu:

mov cl, 5
mov ah, 0Eh
main:
    sub cl, 1

print_step:
    mov al, '_'
    mov ch, 5

.loop:
    sub ch, 1

    int 10h

    cmp ch, 0
    jne .loop

print_stoop:
    mov ch, 5

.loop:
    sub ch, 1

    mov al, 0Ah;    ascii newline
    int 10h

    mov al, 8;      ascii backspace
    int 10h

    mov al, '|'
    int 10h

    cmp ch, 0
    jne .loop

cmp cl, 0
jne main

Wynik:

_____
    |
    |
    |
    |
    |_____
         |
         |
         |
         |
         |_____
              |
              |
              |
              |
              |_____
                   |
                   |
                   |
                   |
                   |_____
                        |
                        |
                        |
                        |
                        |

Przepraszam, że wynik jest inny; Mam nadzieję, że jest to do przyjęcia.

Zostało to uruchomione w DOSBOX

SirPython
źródło