Cho đầu vào của hai số nguyên n và m , xuất ra một thang ASCII có chiều dài n và kích thước m .

Đây là thang ASCII có chiều dài 3 và kích thước 3:

o---o
|   |
|   |
|   |
+---+
|   |
|   |
|   |
+---+
|   |
|   |
|   |
o---o

Đây là thang ASCII có chiều dài 5 và kích thước 1:

o-o
| |
+-+
| |
+-+
| |
+-+
| |
+-+
| |
o-o

Đây là thang ASCII có chiều dài 2 và kích thước 5:

o-----o
|     |
|     |
|     |
|     |
|     |
+-----+
|     |
|     |
|     |
|     |
|     |
o-----o

Để được cụ thể:

• Độ dài ( n ) đại diện cho bao nhiêu hình vuông mà thang được tạo thành.

• Kích thước ( m ) đại diện cho chiều rộng và chiều cao của nội thất của thành phố, nghĩa là không tính hình vuông "viền".

• Mỗi hình vuông được tạo thành từ khu vực bên trong chứa đầy không gian, được bao quanh bởi -s ở trên và dưới, |s ở bên trái và bên phải, và +s ở cả bốn góc.

• Biên giới giữa các hình vuông hợp nhất với nhau, vì vậy hai dòng liên tiếp +--...--+hợp nhất thành một.

• Các góc của toàn bộ thang được thay thế bằng ký tự o.

• Bạn có thể tùy ý xuất ra một dòng mới.

Chiều dài của thang ( n ) sẽ luôn là ≥ 2 và kích thước ( m ) sẽ luôn là ≥ 1.

Đầu vào có thể được lấy dưới dạng một chuỗi được phân tách bằng khoảng trắng / dấu phẩy, một mảng / danh sách / v.v. hoặc hai hàm / dòng lệnh / vv. lập luận. Các đối số có thể được thực hiện theo bất kỳ thứ tự nào là thuận tiện nhất / golfiest.

Vì đây là mã golf , mã ngắn nhất tính bằng byte sẽ thắng.

Mẹo: Các ví dụ trên cũng có thể được sử dụng làm trường hợp thử nghiệm.

Bình thường, 34 byte

.NjjNm*QTvz*2YjC:M++J"+|o"m"- -"QJ

Bộ kiểm tra

Đưa ra các đối số dòng mới được phân tách trên STDIN.

Sử dụng hàm trợ giúp, :xây dựng từng loại chuỗi dọc từ ba ký tự, sau đó sao chép khi cần thiết, hoán vị và tham gia vào dòng mới.

Ruby, 71

->m,n{h=0;(?o+?+*(n-1)+?o).chars{|c|puts [?|+' '*m+?|]*h,c+?-*m+c;h=m}}

vô dụng trong chương trình thử nghiệm

f=->m,n{
  h=0                             #The number of | above the 1st rung is 0
  (?o+?+*(n-1)+?o).chars{|c|      #Make a string of all the rung ends o++...++o and iterate through it
    puts [?|+' '*m+?|]*h,         #draw h vertical segments |  ...  |
      c+?-*m+c                    #and a rung with the correct ends
    h=m                           #The number of | above all rungs except the 1st is m
  }
}


f[gets.to_i,gets.to_i]

CJam, 43 42 byte

Tôi không bị ảnh hưởng bởi điểm số. Nhưng tôi không phải là Dennis, phải không?

q~:Z;'-'o{[\Z*1$N]}:X~['-_'+X\'|XZ*]@*1>1$

Đầu vào là 2 mục cách nhau. Chiều dài đầu tiên

2 3
o---o
|   |
|   |
|   |
+---+
|   |
|   |
|   |
o---o

Giải trình

q~:Z;'-'o{[\Z*1$N]}:X~['-_'+X\'|XZ*]@*1>1$
q~                                         e# read input
  :Z;                                      e# Record the size in Z and discard
     '-'o{[\Z*1$N]}:X~                     e# Create the initial line (and final). also creates a shorcut to do this later
           \                               e# Capture two arguments
            Z*                             e# The separator is repeated size times
              1$                           e# Repeat the first argument
                N                          e# Add newline
                                           e# X is a function to create line in a ladder
                      ['-_'+X\'|XZ*]       e# Design the repeating part
                                    @*     e# Repeat the pattern n times
                                      1>   e# Discard the initial
                                        1$ e# Since the final line is same than the initial, we just write it.
                                           e# Implicit printing

JavaScript (ES6), 89

... lặp lại, lặp lại, lặp lại ...

(n,m,R=x=>x.repeat(m),b=R(`|${R(' ')}|
`),d=`o${c=R('-')}o
`)=>d+R(b+`+${c}+
`,m=n-1)+b+d

Kiểm tra

F=(n,m,R=x=>x.repeat(m),b=R(`|${R(' ')}|
`),d=`o${c=R('-')}o
`)=>d+R(b+`+${c}+
`,m=n-1)+b+d

// Less golfed
U=(n,m)=>
{
  var R=x=>x.repeat(m),
      a=R(' '),
      b=R(`|${a}|\n`);
      c=R('-'),
      d=`o${c}o\n`;
  m=n-1;
  return d+R(b+`+${c}+\n`)+b+d
}

function test() {
  var i=I.value.match(/\d+/g)
  if (i) O.textContent=F(+i[0],+i[1])
  console.log(i,I.value)
}  
 
test()

N,M: <input id=I value="3,5" oninput=test()>
<pre id=O></pre>

C #, 1412 byte

... Nỗ lực CodeGolf đầu tiên của tôi, Không có khả năng giành chiến thắng nhưng nó hoạt động vì vậy chúng tôi đi đây:

using System;

namespace Ascii_Ladders
{
    class Program
    {
        static void Main(string[] args)
        {
            int n = 0;
            int m = 0;

            Console.Write("Please enter Height: ");
            n = int.Parse(Console.ReadLine());
            Console.Write("Please Enter Width: ");
            m = int.Parse(Console.ReadLine());

            Console.Write("o");
            for (int i = 0; i < m; i++)
            {
                Console.Write("-");
            }
            Console.WriteLine("o");

            for (int k = 0; k < n; k++)
            {
                for (int i = 0; i < m; i++)
                {
                    Console.Write("|");
                    for (int j = 0; j < m; j++)
                    {
                        Console.Write(" ");
                    }
                    Console.WriteLine("|");
                }
                if (k != n - 1)
                {
                    Console.Write("+");
                    for (int i = 0; i < m; i++)
                    {
                        Console.Write("-");
                    }
                    Console.WriteLine("+");
                }
            }

            Console.Write("o");
            for (int i = 0; i < m; i++)
            {
                 Console.Write("-");
            }
            Console.WriteLine("o");

            Console.ReadKey();
        }
    }
}

Julia, 87 byte

f(n,m)=(g(x)=(b=x[1:1])x[2:2]^m*b*"\n";(t=g("o-"))join([g("| ")^m for i=1:n],g("+-"))t)

Đây là một hàm chấp nhận hai số nguyên và trả về một chuỗi.

Ung dung:

function f(n::Int, m::Int)
    # Create a function g that takes a string of two characters and
    # constructs a line consisting of the first character, m of the
    # second, and the first again, followed by a newline.
    g(x) = (b = x[1:1]) * x[2:2]^m * b * "\n"

    # Assign t to be the top and bottom lines. Construct an array
    # of length n where each element is a string containing the
    # length-m segment of the interior. Join the array with the
    # ladder rung line. Concatenate all of this and return.
    return (t = g("o-")) * join([g("| ")^m for i = 1:n], g("+-")) * t
end

pb - 147 byte

^t[B]>>[B]vw[T!0]{b[43]<[X]b[43]>w[B=0]{b[45]>}v[X-1]w[B=0]{b[124]^}v[X]t[T-1]}t[111]b[T]<w[X!0]{b[45]<}b[T]w[Y!0]{w[B!0]{^}b[124]^}b[T]^>>[B]vb[T]

Đây là loại thách thức mà theo quyền, pb nên thực sự giỏi. Vẽ các hình ảnh đơn giản với các ký tự là chính xác những gì pb được thiết kế cho. Than ôi, tôi đoán đó chỉ là một ngôn ngữ dài dòng.

Lấy chiều dài đầu vào trước, tiếp theo là kích thước. Lấy đầu vào dưới dạng các giá trị byte, ví dụ:python -c 'print(chr(5) + chr(7))' | ./pbi.py ladder.pb

Hãy nhìn xem, một hình ảnh động vui nhộn!

Với nhận xét:

^t[B]            # Save length to T
>>[B]v           # Go to X=size+1, Y=0

w[T!0]{          # While T is not 0:
    b[43]            # Write a '+'
    <[X]b[43]        # Write a '+' on the left side as well
    >w[B=0]{b[45]>}  # Travel back to the right '+', writing '-' on the way
    v[X-1]           # Go down by X-1 (== size)
    w[B=0]{b[124]^}  # Travel back up to the '+', writing '|' on the way
    v[X]             # Go down by X (== size + 1, location of next '+')
    t[T-1]           # Decerement T
}

t[111]           # Save 'o' to T (it's used 4 times so putting it
                 # in a variable saves bytes)

b[T]             # Write an 'o' (bottom right)

<w[X!0]{         # While not on X=0:
    b[45]<           # Travel left, writing '-' on the way
}

b[T]             # Write an 'o' (bottom left)

w[Y!0]{          # While not on Y=0:
    w[B!0]{^}        # Skip nonempty spaces
    b[124]           # Write a '|'
    ^                # Travel up
}

b[T]             # Write an 'o' (top left, replaces existing '+')

^>>[B]v          # Go back to where the size is saved and go to X=size+1, Y=0

b[T]             # Write an 'o' (top right, replaces existing '+')

Bash tinh khiết, 132 130 128 127 byte

Có, tôi có thể giảm thêm 1 byte thay thế cuối cùng ${p% *}, nhưng tôi thích điều này hơn:

p=printf\ -v;$p a %$1s;$p b %$2s;o="|$a|\n";h=+${a// /-}+\\n v=${a// /$o}
a=${b// /$h$v}${h//+/o};a=${a/+/o};${p% *} "${a/+/o}"

Mẫu vật:

ladders() {
    p=printf\ -v;$p a %$1s;$p b %$2s;o="|$a|\n";h=+${a// /-}+\\n v=${a// /$o}
    a=${b// /$h$v}${h//+/o};a=${a/+/o};${p% *} "${a/+/o}"
}

ladders 3 4
o---o
|   |
|   |
|   |
+---+
|   |
|   |
|   |
+---+
|   |
|   |
|   |
+---+
|   |
|   |
|   |
o---o

ladders 2 1
o--o
|  |
|  |
o--o

Haskell, 100 97 byte

l#s=unlines$t:m++[t]where _:m=[1..l]>>["+"!"-"]++("|"!" "<$u);t="o"!"-";o!i=o++(u>>i)++o;u=[1..s]

Ví dụ sử dụng:

*Main> putStr $ 4 # 3
o---o
|   |
|   |
|   |
+---+
|   |
|   |
|   |
+---+
|   |
|   |
|   |
+---+
|   |
|   |
|   |
o---o

Làm thế nào nó hoạt động:

l#s=unlines$t:m++[t]         -- concat top line, middle part and end line
                             -- with newlines between every line
  where                      -- where
  _:m=                       -- the middle part is all but the first line of
     [1..l]>>                -- l times
         ["+"!"-"]           --    a plus-dashes-plus line
         ++("|"!" "<$u)      --    followed by s times a bar-spaces-bar line

  t="o"!"-"                  -- very first and last line
  o!i=o++(u>>i)++o           -- helper to build a line
  u=[1..s]

Chỉnh sửa: @Christian Irwan tìm thấy 3 byte. Cảm ơn!

brainfuck - 334 byte

,[<+<<<<+>>>>>-]<[[>>]+[<<]>>-]<----[>---<----]--[>[+>>]<<[<<]>++++++]>[+.>>]-[<+>---]<+++++++>>--[<+>++++++]->---[<------->+]++++++++++[<++<]+++++[>[++++++>>]<<[<<]>-]>[-]>.-<<----[>>+++<<----]--[>+<--]>---<<<<++++++++++.,[>[>+>+<<-]>[<+>-]>[<<<<[>>>>>>[.>>]<<[<<]>>-]>>>>>[.>>]<<[<<]>-]<<<<+>-]>>>>[-]----[>---<----]>+.[>]<<<<<[.<<]

Tôi dự kiến ​​điều này sẽ ngắn hơn rất nhiều.

Điều này thiết lập một "chuỗi" trông giống | (...) |và một chuỗi trông giống như +----(...)----+, in từng cái khi cần thiết, với một số vỏ đặc biệt cho os ở trên và dưới.

Yêu cầu trình thông dịch sử dụng các ô 8 bit và cho phép bạn đi bên trái từ ô 0 (có thể vào các ô âm hoặc lặp). Theo kinh nghiệm của tôi, đây là những cài đặt mặc định phổ biến nhất.

Với nhận xét:

,[<+<<<<+>>>>>-]<[[>>]+[<<]>>-] Get m from input; make a copy
                      Turn it into m cells containing 1 with empty cells between

<----[>---<----]      Put 67 at the beginning (again with an empty cell between)

--[>[+>>]<<[<<]>++++++]  Add 43 to every nonempty cell

>[+.>>]               Add 1 to each cell and print it

-[<+>---]<+++++++    Put 92 after the last 45 (no empty cell!)

>>--[<+>++++++]      Put 43 immediately after the 92

->---[<------->+]    Put 234 after 43

++++++++++           And 10 after that

[<++<]             Add two to the 234; 92; the empty spaces; and left of the 111

+++++[>[++++++>>]<<[<<]>-] Add 30 to each 2; the 94; and the 236

>[-]>.-<<----[>>+++<<----] Erase leftmost 32; Print 111; subtract 68 from it

--[>+<--]>---        Put 124 where the 32 was

<<<<++++++++++.,     Print a newline; override the cell with n from input

[                    n times:

  >[>+>+<<-]>[<+>-]    Make a copy of m

  >[                   m times:

    <<<<                 Look for a flag at a specific cell

    [                    If it's there:

      >>>>>>[.>>]          Go to the 43; print it and every second cell after

      <<[<<]>>-            Clear the flag

    ]

    >>>>>[.>>]           Go to the 124; print it and every second cell after

    <<[<<]>              Go back to the copy of m

  -]

  <<<<+>               Plant the flag

-]

>>>>

[-]----[>---<----]>+ Erase the 124; add 68 to 43

.[>]                 Print it; then head to the end

<<<<<[.<<] Go to the last 45; print it; then print every second cell to the left

PowerShell, 77 80

param($l,$s)$a='-'*$s
($c="o$a`o")
(($b=,"|$(' '*$s)|"*$s)+"+$a+")*--$l
$b
$c

Jolf, 36 byte

Hãy thử nó ở đây!

ρpi,a+2J+2J"o-| "j"o(.+)o
o.+o'+$1+

Giải trình

ρpi,a+2J+2J"o-| "j"o(.+)o\no.+o'+$1+
 pi              j                   repeat vertically j times
   ,a+2J+2J"o-| "                    a box with dimensions 2+J
ρ                 "o(.+)p\np.+o'     replace with regex
                                +$1+ with the -...-

Perl, 98 byte

($n,$m)=@ARGV;print$h="o"."-"x$m."o\n",((("|".(" "x$m)."|\n")x$m.$h)x$n)=~s{o(-+)o(?=\n.)}{+$1+}gr

C, 122 byte

f(int m,int n,char*s){int i=0,w=3+m++;for(;i<w*m*n+w;++i)*s++=i%w>m?10:" |-+-o"[!(i/w%m)*2+!(i%w%m)+!(i/w%(m*n))*2];*s=0;}

Hãy thử trực tuyến .

Tcl, 187 byte

lassign $argv n w
set c 0
while { $c < [expr {($w * $n) + ($n + 2)}]} {if {[expr {$c % ($n + 1)}] == 0} {puts "o[string repeat "-" $w ]o"} else {puts "|[string repeat " " $w ]|"}
incr c}

Mã này được tạo để đưa vào một tệp có đầu vào đối số trên dòng lệnh. cung cấp số lượng hộp và chiều rộng theo thứ tự đó.

PHP, 81byte

Yêu cầu 2 đối số, được thông qua khi gọi lệnh PHP trực tiếp. Cái đầu tiên là kích thước và cái thứ hai là số bước.

$R=str_repeat;echo$P="o{$R('-',$W=$argv[1])}o
",$R("|{$R(' ',$W)}|
$P",$argv[2]);

Có thể yêu cầu một số cải tiến.

Python 2, 94 byte

def F(n,m):a,b,c,d='o|+-';r=[a+d*m+a]+([b+' '*m+b]*m+[c+d*m+c])*n;r[-1]=r[0];print'\n'.join(r)

'Ungolfed':

def F(n,m):
 # 'o---o'
 r = ['o'+'-'*m+'o']
 # ('|   |'*m+'+---+') n times
 r += (['|'+' '*m+'|']*m+['+'+'-'*m+'+'])*n
 # replace last +---+ with o---o
 r[-1] = r[0]
 print '\n'.join(r)

Perl 5 , 91 + 1 (-a) = 92 byte

$_='|'.$"x$F[1].'|';push@a,y/| /+-/r,($_)x$F[1]while$F[0]--;$a[0]=y/| /o-/r;say for@a,$a[0]

Hãy thử trực tuyến!

Pip -l , 35 byte

(^YsXbRLaJW'-)XbWR^('|XbRLaJ'+)WR'o

Hãy thử trực tuyến!

Giải trình

(^YsXbRLaJW'-)XbWR^('|XbRLaJ'+)WR'o
                                     a is length, b is size, s is space (implicit)
   sXb                               String containing b spaces
      RLa                            List containing a copies of that string
         JW'-                        Join on "-" and wrap the result in "-" as well
  Y                                  Necessary for operator precedence reasons
 ^                                   Split into a list of characters
(            )Xb                     String-repeat each character in the list b times
                                     This list represents the central columns of the ladder

                    '|Xb             String containing b pipe characters
                        RLa          List containing a copies of that string
                           J'+       Join on "+"
                   (          )WR'o  Wrap in "o"
                  ^                  Split into a list of characters
                                     This list represents the outer columns of the ladder

                WR                   Wrap the left list in the right list, vectorizing

Một số phiên bản khác

Tôi đã thử rất nhiều cách tiếp cận khác nhau để cố bắt Pyth ...

[Y'-XbWR'o;@>(sXbWR'|RLbPE'-XbWR'+RL:a)y]  41
Y^(t**b.1*:t**bX--a.1)" --"@yXbWR"|o+"@y   40
Y'|XbRLaJ'+YyWR'o;Z:sXbRLaJW'-RLbPEyAEy    39
t**:b(" |-o-+"<>2)@_@^t.1M$*Y[ttXa-1].1    39
J*Z:sXbRLaJW'-RLbWR:^('|XbRLaJ'+)WR'o      37
Y^$*Y[t**:btXa-1].1" --"@yXbWR"|o+"@y      37

Tôi đặc biệt thích t**bnhững cái, sử dụng toán học để tạo ra mẫu dọc của thang:

        b           Size; e.g. 3
    t               Preset variable for 10
     **:            Set t to t**b (e.g. 1000)
           a        Length; e.g. 3
            -1      2
         tX         String-repeat (the new value of) t 2 times: 10001000
   [          ]     Put t and the above into a list: [1000; 10001000]
               .1   Append 1 to both of them: [10001; 100010001]
$*(              )  Fold on multiplication: 1000200020001

Sau 1000200020001đó có thể được sử dụng để tạo ra các mẫu o|||+|||+|||ovà - - - -, tạo nên các bậc thang. Thật không may, tôi không thể có được cách tiếp cận này ngắn hơn phương pháp nối / quấn.