Tạo một chương trình lấy độ dài và danh sách các khoảng và đưa ra thước đo có độ dài đó với các đánh dấu dài hơn cho mỗi khoảng bằng cách sử dụng các ký tự vẽ đường thẳng ┌ ┬ ┐ │ ╵

• Hàng đầu tiên của đầu ra phải bắt đầu bằng đánh dấu 0 ┌và kết thúc bằng một đánh dấu cho độ dài với ┐, với một ┬ký tự được sử dụng cho mọi ký tự ở giữa. Sẽ có tổng cộng length+ 1 ký tự vẽ trong hàng đầu tiên này.
• Một đánh dấu nên được kéo dài theo chiều dọc bằng cách tăng nửa ký tự bằng cách sử dụng ╵và │dựa trên các khoảng đầu vào.
• Các khoảng được liệt kê từ nhỏ nhất đến lớn nhất, liên quan đến khoảng trước đó. Để giải thích:
  • Khoảng đầu tiên cho biết có bao nhiêu đánh dấu cơ sở (hàng đầu tiên - một ký tự cho mỗi đánh dấu) trong khoảng nhỏ nhất thứ hai (khoảng nhỏ nhất là 1). Ví dụ: [3] sẽ kéo dài mỗi đánh dấu thứ ba thêm một nửa ký tự.
  • Các khoảng thứ hai và tiếp theo là về khoảng thời gian nhỏ nhất tiếp theo. Ví dụ [3, 5] sẽ kéo dài mỗi lần đánh dấu cơ sở thứ 15 bởi một nhân vật đầy đủ và [3, 5, 2] sẽ kéo dài mỗi lần đánh dấu cơ sở thứ 30 bởi một nhân vật và một nửa.
  • Một khoảng phụ 1 là hợp lệ và có hiệu quả có nghĩa là các dòng khoảng cuối được kéo dài bởi một ký tự đầy đủ thay vì một nửa ký tự.
• Các trường hợp thử nghiệm ví dụ sẽ giúp làm rõ cách thức này hoạt động.

Ví dụ / Trường hợp kiểm tra

3, []:

┌┬┬┐

9, [3]:

┌┬┬┬┬┬┬┬┬┐
╵  ╵  ╵  ╵

30, [5, 2]:

┌┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┐
│    ╵    │    ╵    │    ╵    │

32, [4, 2, 2, 2]:

┌┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┐
│   ╵   │   ╵   │   ╵   │   ╵   │
│               ╵               │

48, [5, 3, 2]

┌┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┐
│    ╵    ╵    │    ╵    ╵    │    ╵    ╵    │
╵                             ╵

24, [7, 3]

┌┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┐
│      ╵      ╵      │

17, [3, 2, 1]

┌┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┬┐
│  ╵  │  ╵  │  ╵
╵     ╵     ╵

1, [23, 19, 13, 11, 7, 5, 3, 2, 1]

┌┐
│
│
│
│
╵

Các quy tắc / ghi chú khác

• Đầu vào và đầu ra có thể sử dụng bất kỳ định dạng thuận tiện
• Người cai trị không phải kết thúc với một đánh dấu lớn
• Danh sách khoảng có thể trống
• Các dấu zeroth luôn luôn trong tất cả các khoảng thời gian.
• Bạn có thể giả sử chiều dài thước và khoảng sẽ luôn là một số nguyên dương nhỏ hơn 120
• Khoảng trắng Trailing là tốt, nhưng khoảng trắng hàng đầu thì không.
• Bất kỳ không gian rộng đơn cố định nào đều được phép làm ký tự khoảng cách nếu bạn, vì một số lý do, muốn sử dụng một cái gì đó không phải là không gian ASCII.

Chúc bạn chơi golf vui vẻ!

JavaScript (Node.js) , 123 byte

l=>g=([p,q,...t],h='┌'.padEnd(l,'┬')+`┐
`)=>p?h+g(t,h.replace(/\S/g,c=>'╵│ '[c>'╴'||++i%p?2:i/p%q<1|0],i=-1)):h

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

Sử dụng chức năng này như f(20)([5, 2]).

Cảm ơn Arnauld, tiết kiệm 4 byte.

Perl 6 , 130 122 102 92 byte

-10 byte nhờ nwellnhof!

{'┌'~'┬'x$^a-1~'┐',|map {[~] <<' '╵ │>>[:1[$_ X%%@_]for 0..$a]},batch [\*] @^b: 2}

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

À đúng rồi, ngắn hơn nhiều so với phương pháp trước đây của tôi. Đây là một khối mã ẩn danh trả về một danh sách các dòng.

Giải trình:

{                                                   }   # Anonymous code block
 '┌'~'┬'x$^a-1~'┐',     # Return the first line
 |[\*] @^b          # Get the cumulative product of the input list
              .batch(2) # And split it into pairs
  .map:{                                      }  # Map each pair to
                                    for 0..$a    # For each interval
                        :1[$_ X%%@_]    # Whether it is divisible by none of the pair, one of the pair, or both
            <<' '╵ │>>[                     ]      # Map to a list of characters
        [~]        # And join

Thuốc nhuộm APL, 66 64 58 52 byte

{'┌┐'@0⍵@0⍉('┬│',⎕UCS 9589)/⍤1⍨1,⍉0 2⊤⊥¨⍨0=(⍵+1)⍴⍳⍺}

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

¯2 8 14 byte nhờ ngn !

Python 3 , 173 172 byte

def f(w,n):
 print('┌'+'┬'*~-w+'┐');R=r=range(w+1)
 for i,j in zip(*[iter(n+[0])]*2):a=r[::i];r=j*[0]and a[::j];print(''.join(' ╵│'[(v in a)+(v in r)]for v in R))

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

05AB1E , 51 byte

ÝεyIηPÖO2‰•5·W4•2äç×SI¯Qiεõ}}•áΣ=Yô•3äçy¹QyĀ+èš}ζJ»

Không quá hài lòng với I¯Qiεõ}}công việc xung quanh cho các danh sách đầu vào trống rỗng .. Và chắc chắn có thể được đánh gôn ở một số phần khác nữa ..

LƯU Ý: Sử dụng các số nguyên nén được chuyển đổi thành các ký tự được yêu cầu, bởi vì sử dụng trực tiếp các ký tự được yêu cầu có nghĩa là tôi sẽ phải đếm toàn bộ chương trình trong UTF-8, tăng quá nhiều cho tất cả các ký tự dựng sẵn của 05AB1E.

Hãy thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình:

Ý             # Create a list in the range [0, first (implicit) input-integer]
 ε            # Map each value `y` to:
   Iη         #  Get the prefixes of the second input-list
     P        #  Get the product of each prefix
  y   Ö       #  Check for each if its evenly dividing the value `y`
       O      #  Take the sum of that
        2‰    #  And then the divmod 2
  •5·W4•      #  Push compressed integer 94749589
        2ä    #  Split into two equal-sized parts: [9474,9589]
          ç   #  Convert each to a character: ["│","╵"]
           ×  #  Repeat each based on the divmod 2 result
            S #  And convert it to a flattened list of characters
  I¯Qi   }    #  If the second input-list was empty:
      εõ}     #   Map each list to an empty string
              #   (for some reason `€õ` doesn't work here..)
  •áΣ=Yô•     #  Push compressed integer 948495169488
         3ä   #  Split into three equal-sized parts: [9484,9516,9488]
           ç  #  Convert each to a character: ["┌","┬","┐"]
  y¹Q         #  Check if the value `y` is equal to the first input-integer
              #  (1 if truthy; 0 if falsey)
     yĀ       #  Check if the value `y` is NOT 0 (1 if truthy; 0 if falsey)
       +      #  Add both checks together
        è     #  Use it to index into the list ["┌","┬","┐"]
         š    #  And prepend the result in front of the other characters
 }ζ           # After the map: zip/transpose; swapping rows and columns (with space filler)
   J          # Join every inner list together to a single string
    »         # Join the lines with newline delimiter (and output implicitly)

Xem 05AB1E mẹo này của tôi (phần Làm thế nào để nén các số nguyên lớn? ) Để hiểu tại sao •5·W4•là 94749589và •áΣ=Yô•là 948495169488.

Than , 50 byte

≔ＥηΠ…η⊕κη⪫┐┌×┬⊖θ↙↓ＥＥ⊕θΣＥη¬﹪ιλ⁺×│⊘ι×╵﹪ι²‖

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Các ký tự vẽ hình hộp có biểu diễn 3 byte trong Char than, do đó chuỗi trên chỉ dài 40 ký tự. Giải trình:

≔ＥηΠ…η⊕κη

Tính tích lũy tích của các khoảng.

⪫┐┌×┬⊖θ↙

In hàng đầu tiên của dấu tick. Các ký tự bên trái và bên phải là sai cách xung quanh vì kết quả được phản ánh sau đó.

↓ＥＥ⊕θΣＥη¬﹪ιλ⁺×│⊘ι×╵﹪ι²

Tính số lượng các khoảng là một yếu tố của mỗi dấu tick. Tạo một chuỗi │s có độ dài bằng một nửa và thêm ╵độ dài lẻ. In từng chuỗi xuống dưới với các chuỗi tiếp theo trong các cột trước đó, tức là thứ tự ngược lại.

‖

Phản ánh tất cả mọi thứ để có được thước kẻ theo thứ tự từ trái sang phải.

Canvas , 42 41 40 byte

┐”┬”┌”Ｏ⁸╷×ｏｏ╵（０）⁷｛＊Ｊ╵；∔｝ｍ｛２ｎ“╵”×；“│”××］⤢

Hãy thử nó ở đây! ( với một phông chữ không gian đầu ra )

Emacs Lisp , 303 byte

(defun f(a)(princ'┌)(dotimes(i(1-(car a)))(princ'┬))(princ'┐)(let((m 1))(while(cadr a)(let((q(caadr a))(w (cadadr a)))(princ"\n")(dotimes(i(1+(car a)))(cond((if w(= 0(mod i(* m q w))))(princ'│))((= 0(mod i (* m q)))(princ'╵))(t(princ" "))))(setq m(* m q(if w w 1)))(setcdr a`(,(cddadr a)))))))

Sử dụng chức năng này như (f '(30 (5 2))).

Phiên bản dễ đọc hơn:

(defun f (a)
  (princ '┌)
  (dotimes (i (1- (car a)))
    (princ '┬))
  (princ '┐)
  (let ((m 1))
    (while (cadr a)
      (let ((q (caadr a)) (w (cadadr a)))
    (princ "\n")
    (dotimes (i (1+ (car a)))
      (cond ((if w (= 0 (mod i (* m q w))))
        (princ '│))
       ((= 0 (mod i (* m q)))
        (princ '╵))
       (t
        (princ " "))))
    (setq m (* m q (if w w 1)))
    (setcdr a `(,(cddadr a)))))))

Thạch ,  42  41 byte

‘Rm×\}Ṭ€+2/
⁽!ṣ;“½¥÷I‘ÄỌṙ-;⁶
Ḷ¬;.Ḥ~W;ñị¢Y

Một chương trình đầy đủ.
Hãy thử trực tuyến!

Hoặc xem bộ kiểm tra
^{Lưu ý: mã này đã được thay đổi từ một chương trình đầy đủ - ñ(liên kết tiếp theo dưới dạng dyad) đã được thay thế bằng 1ŀ(liên kết tại chỉ mục 1 dưới dạng dyad) để cho phép nó được gọi nhiều lần bởi chân trang .}

Làm sao?

‘Rm×\}Ṭ€+2/ - Link 1, lower interval tick types: length; intervals  e.g. 7; [3,2]
‘           - increment length                                           8
 R          - range                                                      [1,2,3,4,5,6,7,8]
     }      - use right argument for this monad as if it were a dyad:
   ×\       -   cumulative reduce by multiplication                      [3,6]
  m         - modulo slice (vectorises)                                  [[1,4,7],[1,7]]
      Ṭ€    - untruth €ach                               [[1,0,0,1,0,0,1],[1,0,0,0,0,0,1]]
        +2/ - pairwise reduce with addition                              [[2,0,0,1,0,0,2]]
            -   -- yielding a list of types for each row of characters below the first
            -      where 0 is a space, 1 is a short tick-mark and 2 is a long tick-mark

⁽!ṣ;“½¥÷I‘ÄỌṙ-;⁶ - Link 2, make character set: no arguments
⁽!ṣ              - literal 9474
    “½¥÷I‘       - list of code-page indices   = [10,4,28,73]
   ;             - concatenate              [9474,10,4,28,73]
          Ä      - cumulative addition      [9474,9484,9488,9516,9589]
           Ọ     - to characters            "│┌┐┬╵"
            ṙ-   - rotate left by -1        "╵│┌┐┬"
               ⁶ - literal space character  ' '
              ;  - concatenate              "╵│┌┐┬ "

Ḷ¬;.Ḥ~W;ñị¢Y - Main link: length, L; intervals, I
Ḷ            - lowered range         [ 0, 1, 2, ..., L-1]
 ¬           - logical Not           [ 1, 0, 0, ..., 0]
   .         - literal 0.5
  ;          - concatenate           [ 1, 0, 0, ..., 0, 0.5]
    Ḥ        - double                [ 2, 0, 0, ..., 0, 1]
     ~       - bitwise NOT           [-3,-1,-1, ...,-1,-2]
      W      - wrap that in a list  [[-3,-1,-1, ...,-1,-2]]
        ñ    - call next Link (1) as a dyad (f(L, I))
       ;     - (left) concatenated with (right)
          ¢  - call last Link (2) as a nilad (f())
         ị   - (left) index into (right)  (1-indexed and modular)
           Y - join with newline characters
             - implicit print

Ruby , 126 byte

->l,i{y=1;[?┌+?┬*~-l+?┐]+i.each_slice(2).map{|j,k|x=y*j;y=k&&x*k;(0..l).map{|z|'│╵ '[(z%x<=>0)+(k ?z%y<=>0:1)]}*''}}

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

Trông khá dài dòng với tất cả những each_slicethứ đó, nhưng sẽ làm ngay bây giờ, trừ khi tôi tìm cách tiếp cận người chơi gôn.

Lấy đầu vào theo lchiều dài và itrong các khoảng, trả về một chuỗi các chuỗi.

R , 175 170 byte

function(l,i,`&`=rep)rbind(c('┌','┬'&l-1,'┐'),if(i)sapply(rowSums(!outer(0:l,cumprod(i),`%%`)),function(j,x=j%/%2,y=j%%2)c('│'&x,'╵'&y,' '&(1+sum(1|i))/2-x-y)))

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

Có các khoảng trống như 0, trả về một ma trận các ký tự. Liên kết TIO hiển thị đầu ra được in đẹp.

Haskell , 167 164 149 byte

n%l=unlines$("┌"++([2..n]>>"┬")++"┐"):[do p<-[0..n];let(j#a)b|1>p`rem`product(take j l)=a|1>0=b in(i-1)#(i#"│"$"╵")$" "|i<-[1,3..length l]]

Hãy thử trực tuyến! Cách chơi golf hơi khác nhau của Οurous .

n%l|let c=take(n+1).cycle;m&(x:y:r)=c('│':init([1..y]>>(m*x)!" "++"╵"))++'\n':(m*x*y)&r;m&[x]=c$'╵':(m*x)!" ";m&e=[]='┌':n!"┬"++"┐\n"++1&l
n!s=[2..n]>>s

Hãy thử trực tuyến! Vẫn còn một số dư thừa trông giống như chúng có thể được khai thác, nhưng cho đến nay chúng đã chịu được mọi nỗ lực chơi gôn hơn nữa.

Giải pháp 167 byte trước đó giống với cách xử lý dòng mới và có thể dễ đọc hơn một chút:

n%l=unlines$('┌':n!"┬"++"┐"):(take(n+1)<$>1&l)
n!s=[2..n]>>s
m&(x:y:r)=cycle('│':init([1..y]>>(m*x)!" "++"╵")):(m*x*y)&r
m&[x]=[cycle$'╵':(m*x)!" "]
m&e=[]

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

PowerShell , 152 byte

param($t,$i)"┌$('┬'*--$t)┐"
$i|%{$s=++$s*$_-1;$p=".(.{$s}|.*$)"
if($r){$r-replace$p,'│$1';rv r}else{$r=' '*($t+2)-replace$p,'╵$1'}}
if($r){$r}

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

Chưa được kiểm soát:

param($ticks,$intervals)
"┌$('┬'*--$ticks)┐"                         # implicit output
$intervals|%{
    $step=++$step*$_-1
    $pattern=".(.{$step}|.*$)"
    if($row){
        $row-replace$pattern,'│$1'          # implicit output
        Remove-Variable row
    }else{
        $row=' '*($ticks+2)-replace$pattern,'╵$1'
    }
}
if($row){$row}                              # implicit output

C # (Trình biên dịch tương tác Visual C #) , 204 byte

a=>b=>{Write("┌"+"┐\n".PadLeft(++a,'┬'));for(int i=1;;i++,WriteLine())for(int j=0;j<a;){var m=b.Select((c,d)=>b.Take(d+1).Aggregate((e,f)=>e*f)).Count(c=>j++%c<1);Write(m<1|i>m?" ":m<2?"╵":"|");}}

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

Đầu ra, nhưng bị mắc kẹt trong một vòng lặp vô hạn.

Sạch sẽ , 221 201 195 162 byte

import StdEnv
$n l=[["┌":repeatn(n-1)"┬"]++["┐"]:[[if(?(i-1))if(?i&&l%(i,i)>[])"│""╵"" "\\p<-[0..n],let?j=1>p rem(prod(l%(0,j)))
]\\i<-[1,3..length l]]]

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

Trả về danh sách các danh sách các ký tự UTF-8 (dưới dạng chuỗi, vì Clean không có hỗ trợ UTF-8 bẩm sinh).

Hoạt động bằng cách tạo dòng đầu tiên, sau đó lấy sản phẩm tiền tố của danh sách được cung cấp trong nhóm hai và kiểm tra dấu nào sẽ vẽ dựa trên việc sản phẩm có phân chia vị trí ký tự hiện tại hay không.

Ung dung:

$ n l
    = [
        ["┌": repeatn (n - 1) "┬"] ++ ["┐"]:
        [
            [
                if(? (i - 1))
                    if(? i && l%(i, i) > [])
                        "│"
                        "╵"
                    " "
                \\ p <- [0..n]
                , let
                    ? j = 1 > p rem (prod (l%(0, j)))
            ]
            \\ i <- [1, 3.. length l]
        ]
    ]