Ваша задача - создать программу или функцию, которая принимает в качестве входных данных натуральное число ( n) от 1 до 25 (включительно) и печатает изометрическое представление слайда и лестницы сn количеством ступеней.

Характеристики лестницы и горки

Лестница всегда ориентирована слева, а горка справа. Мы видим его со стороны лестницы, поэтому часть слайда скрыта на верхних трех уровнях. Ступеньки представлены четырьмя черточками ( ----) и сторонами лестницы и скользят косыми чертами ( /и \). Ниже приведена схема, представляющая шаблоны пространств, необходимых для слайда с пятью ступенями.

Slide              Blank space count
    /----/\        1234/----/\ 
   /----/  \       123/----/12\ 
  /----/    \      12/----/1234\ 
 /----/ \    \     1/----/1\1234\ 
/----/   \    \    /----/123\1234\

Примеры

>>1
/----/\

>>3
  /----/\ 
 /----/  \ 
/----/    \ 

>>4
   /----/\ 
  /----/  \ 
 /----/    \ 
/----/ \    \ 

>>10
         /----/\ 
        /----/  \ 
       /----/    \ 
      /----/ \    \ 
     /----/   \    \ 
    /----/     \    \ 
   /----/       \    \ 
  /----/         \    \ 
 /----/           \    \ 
/----/             \    \ 

Это код-гольф, поэтому выигрывает ответ с наименьшим количеством байтов.

Примечание: конечный пробел допустим в выводе, если он не превышает длину строки.

Сетчатка , 81 72 52 байта

Количество байтов предполагает кодировку ISO 8859-1.

.+
$* /\    \
^.

+` /(.+)$
$&¶$%`/  $1
/.{5}
/----/

Попробуйте онлайн!

объяснение

Программа состоит из четырех этапов, каждый из которых является заменой регулярных выражений (с парой специфичных для Retina функций). Я буду использовать вход 5в качестве примера для объяснения.

Этап 1

.+
$* /\    \

Это превращает ввод nв nпробелы, за /\ \которыми следует вершина лестницы / слайда:

     /\    \

Сейчас мы просто покажем слайд полностью и представим лестницу только левой рукой /.

Этап 2

^.

К сожалению, nпробелы на один больше, чем нам нужно, поэтому мы снова удаляем первый символ. Теперь у нас есть:

    /\    \

Этап 3

+` /(.+)$
$&¶$%`/  $1

Время расширить полную структуру. Знающий где находится верх, достаточно, чтобы построить все это, потому что мы можем просто растянуть его по одной линии за раз, раздвинув лестницу и ползунок на две части.

+Говорит Retina повторить этот этап в цикле , пока на выходе не перестает изменяться (в данном случае, так как регулярное выражение останавливает согласование). Что касается самого регулярного выражения, мы просто сопоставим/ последнюю строку и все после нее, а также сопоставляем один пробел перед ним, что означает, что это больше не может совпадать, когда /достигнет первого столбца.

Вот что мы заменим на это:

 $&    The match itself. We don't want to remove the line we already have.
 ¶     A linefeed, because we want to append a new line.
 $%`   This is a very recent addition to Retina: it's like the normal $` but
      is bounded by linefeeds. That means this inserts everything in front
      of the match which is on the same line. In particular this one space
      less than the indentation of the matched line, hence we are shifting
      the / one column left.
 /     A literal /, representing the left edge of the ladder.
>  <   Two spaces, so that we can shift the slide one column right.
 $1    Capturing group 1 which contains the slide and its separation from
      the ladder.

Таким образом, на каждой итерации это добавляет одну строку к строке, пока мы не получим следующее:

    /\    \
   /  \    \
  /    \    \
 /      \    \
/        \    \

4 этап

/.{5}
/----/

Все, что осталось, это правильно выбрать лестницу. Это действительно просто, мы просто сопоставляем /и следующие 5 символов и вставляем правильное представление релейной логики, тем самым переопределяя слайд или пробелы, которые уже есть:

    /----/\
   /----/  \
  /----/    \
 /----/ \    \
/----/   \    \

V , 38, 37, 36, 34, 33, 32, 31, 30 29 байтов

Àé r\2é/4é-òhYpX$2P^ò3GEòjlr\

Попробуйте онлайн!

Я могу догнать Осаби. Один байт короче, чем у Осаби.\o/Связано с 2sable!Один байт короче!

Из других новостей, это определенно самый длинный зачеркнутый заголовок, который я когда-либо делал.

Объяснение:

Àé              "Insert 'arg1' spaces
   r\           "Turn the last one into a '\'
     2é/        "Insert 2 '/'
        4é-     "Insert 4 '-'

ò        ò      "Recursivly:
 h              "  Move one to the left
  Yp            "  Duplicate this line
    X           "  Delete one space from the left
     $2P        "  Paste two spaces at the end of this line
        ^       "  Move back to the beginning of this line.

Это будет выполняться до тех пор, пока не произойдет ошибка, которая благодаря команде «переместить влево» («h») будет превышать «arg1».

Теперь нам просто нужно добавить внутреннюю ногу

3GE             "Move to the second slash of line 3
   ò    ò       "Recursively: (The second 'ò' is implicit)
    jl          "  Move down and to the right
      r\        "  And replace the character under the cursor with a '\'

Неконкурентная версия (28 байт)

Pyth, 39 35 байт

VQ++*dt-QN"/----/">+*+ddN"\    \\"5

Объяснение:

VQ                                  # Interate over 0 -> Q-1 (Q is the input)
  +                                 # Concatenate the 2 halfs of the slide
   +                                # Concatenate the whitespace block and the ladder
    *d                              # Multiply d (whitespace) by this number \/
      t-QN                          # Calculate the amount of spaces before : input - step of the iterarion -1
          "/----/"                  # Ladder
                  >               5 # Remove the first 5 chars  from the string generated in the following lines 
                   +                # Concatenate the whitespace block and the slide
                    *+ddN           # Multiply "+dd" (2 whitespace) by the step of the iterarion to generate the space between the ladder and the slide
                         "\    \\"  # Slide

Тест здесь

2sable , 40 36 32 30 байт

Хм, V приближается очень близко ...

F¹N-<ð×…/--«ðð«N×…\  ««5F¦}¶

Использует кодировку CP-1252 . Попробуйте версию, совместимую с 05AB1E! ,

PowerShell v2 +, 99 90 82 байта

param($n)1..$n|%{" "*($n-$_)+"/----/"+-join(" "*($_+$i++)+"\    \")[6..(6+$_+$i)]}

Принимает ввод $n, запускает цикл с 1по $nс |%{...}. На каждой итерации мы создаем строку. Начнем с соответствующего количества пробелов " "*($n-$_)и лестницы "/----/".

К этому мы добавляем еще одну строку, которая была разрезана [...]и -joinотредактирована вместе. Вторая строка - это слайд, и мы предполагаем, что весь слайд всегда виден. Это количество пробелов до начала слайда " "*($_+$i++), за которым следует сам слайд "\ \". Это разделено на диапазон, рассчитанный как часть «пространства плюс слайд», который частично скрыт лестницей.

Примеры

PS C:\Tools\Scripts\golfing> .\draw-a-ladder-and-slide.ps1 7
      /----/\
     /----/  \
    /----/    \
   /----/ \    \
  /----/   \    \
 /----/     \    \
/----/       \    \

PS C:\Tools\Scripts\golfing> .\draw-a-ladder-and-slide.ps1 15
              /----/\
             /----/  \
            /----/    \
           /----/ \    \
          /----/   \    \
         /----/     \    \
        /----/       \    \
       /----/         \    \
      /----/           \    \
     /----/             \    \
    /----/               \    \
   /----/                 \    \
  /----/                   \    \
 /----/                     \    \
/----/                       \    \

Python 2 - 79 76 75 байт

x=input()
for i in range(x):print(x-i)*' '+'/----/'+(i*'  '+'\\    \\')[5:]

Спасибо Hubert Grzeskowiak за «дисквалификацию» меня, так как печать моей программы фактически сэкономила 3 ​​байта! Спасибо также Eʀɪᴋ ᴛʜᴇ Gᴏʟғᴇʀ за сохранение еще 1 байта!

Vim, 71 нажатие клавиш

Это такой глупый способ сделать это, но это немного забавно. Входные данные представлены в виде текстового файла с одной строкой, содержащей целое число. Это, вероятно, вполне пригодно для игры в гольф, но пока подойдет ( edit: переключенный стиль управляющих символов по запросу ):

A@qyyPgg<c-v><c-v>GkI <c-v><esc>G$i  <c-v><esc><esc>
Tq"qDI/----/\^[lD@"ddh<c-v>god:%s/     \\/\\    \\<cr>

<c-v>, <esc>И <cr>все отдельные нажатия клавиш; Ctrl + V, escape и возврат каретки (ввод) соответственно. Для простой для усвоения версии с правильными литералами вот файл, ladder.keysхотя выполните xxd:

00000000: 4140 7179 7950 6767 1616 476b 4920 161b  A@qyyPgg..GkI ..
00000010: 4724 6920 2016 1b1b 5471 2271 4449 2f2d  G$i  ...Tq"qDI/-
00000020: 2d2d 2d2f 5c1b 6c44 4022 6464 6816 676f  ---/\.lD@"ddh.go
00000030: 643a 2573 2f20 2020 2020 5c5c 2f5c 5c20  d:%s/     \\/\\
00000040: 2020 205c 5c0d 0d0a                         \\...

Чтобы попробовать это (предполагая, что nix с соответствующими инструментами), возьмите вышесказанное, запустите его xxd -rи поместите в файл ladder.keys. Создайте файл ladder.txtс целым числом. Затем сделайте:

vim -s ladder.keys -u NONE ladder.txt

Баш, 61

for((;i<$1;)){ printf "%$[$1+i]s\    \^M%$[$1-++i]s/----/\n";}

где ^Mбуквальный возврат каретки

$ ./ladder 1
/----/\
$ ./ladder 4
   /----/\
  /----/  \
 /----/    \
/----/ \    \
$ ./ladder 10
         /----/\
        /----/  \
       /----/    \
      /----/ \    \
     /----/   \    \
    /----/     \    \
   /----/       \    \
  /----/         \    \
 /----/           \    \
/----/             \    \

JavaScript (ES6), 79 байт

f=
n=>" ".repeat(n).replace(/./g,"$'/$`$`\\    \\\n").replace(/\/...../g,"/----/")
;

<input type=number min=0 oninput=o.textContent=f(this.value)><pre id=o>

Работает, взяв строку nпробелов, затем выполняя некоторую экзотическую замену, чтобы получить слайд с подставкой, а затем заменяет подставку лестницей.

Рубин, 61 байт

->n{n.times{|i|puts"%*s\\    \\\r%*s----/"% [n+i,"",n-i,?/]}}

Ungolfed

->(num_rows) {
  num_rows.times {|row_idx|
    puts "%*s\\    \\\r%*s----/" % [ num_rows + row_idx, "", num_rows - row_idx, "/" ]
  }
}

Я мог бы сохранить два байта, используя '%*s\ \^M%*s----/'(где ^Mбуквенный возврат каретки) для строки формата, но затем Ruby выводит предупреждение "warning: encountered \r in middle of line, treated as a mere space ". ¯ \ _ (ツ) _ / ¯

Предыдущее решение (64 байта)

->n{n.times{|i|puts" "*(n+i)+"\\    \\\r"+" "*(n-i-1)+"/----/"}}

Пакет, 194 байта

@echo off
for /l %%i in (1,1,%1)do call:l %1 %%i
exit/b
:l
set s=\    \
for /l %%j in (1,1,%2)do call set s=  %%s%%
set s=/----/%s:~7%
for /l %%j in (%2,1,%1)do call set s= %%s%%
echo%s%

Оказалось, что это достаточно просто: сделать отступ в слайде, убрать первые 7 символов, сделать отступ в лестнице, удалить пробел. Этот последний бит включает в себя небольшую хитрость, хотя!

Java, 116 байт

c->{for(int i=0;i<c;i++)System.out.format("%"+(5+c-i)+"s%"+(i<3?i*2+1:2*(i-2))+"s%5s\n","/----/","\\",i<3?"":"\\");};

К сожалению, вы не можете [легко] дублировать строки в Java, поэтому я в итоге злоупотребил функцией форматирования.

Скала, 95 байт

def l(n:Int)=for(i<- 0 to n-1){println(" "*(n-i-1)+"/----/"+("  "*i+"\\    \\").substring(5))}

Haskell, 81 байт

a n=[1..n]>>" "
f n=[1..n]>>=(\i->a(n-i)++"/----/"++drop 7(a(2*i)++"\\    \\\n"))

eacal , неконкурентный, 386 байт

init .
define @ curry push .
define ~ curry exec .--func
alias $ strap
alias ' string
set n set m cast number arg number 0
set s empty string
label l
@ get n
set n ~ dec
@ space
@ get n
$ ~ repeat
$ ' /----/
@ space
@ get m
@ get n
@ ~ sub
@ ~ dec
@ number 2
@ ~ mul
$ ~ repeat
$ ' \
$ newline
@ get n
@ number 0
if ~ more
goto l
@ $
@ regex gm '   ( {4})(?=.$)
@ '  \$1
print ~ replace

Я официально сделал самый многословный язык возможным.Я сделал комментарий в шутку и с сарказмом. Пожалуйста, успокойся. Инструкция по запуску в репозитории github приведена в шапке.

Ungolfed

init .
set n set m cast number arg number 0
set s empty string
label loop
    push . get n
    set n exec .--func dec
    push . space
    push . get n
    strap exec .--func repeat
    strap string /----/
    push . space
    push . get m
    push . get n
    push . exec .--func sub
    push . exec .--func dec
    push . number 2
    push . exec .--func mul
    strap exec .--func repeat
    strap string \
    strap newline
    push . get n
    push . number 0
    if exec .--func more
        goto loop

push . strap
push . regex gm string   ( {4})(?=.$)
push . string  \$1
print exec .--func replace