선 그리기 문자를 사용하여 길이와 간격 목록을 가져와 각 간격에 대해 더 긴 눈금으로 해당 길이의 눈금자를 출력하는 프로그램을 만듭니다. ┌ ┬ ┐ │ ╵

• 출력의 첫 번째 행은 0으로 시작한다 눈금 ┌과 눈금 길이와 단부 ┐와 ┬사이의 모든 문자에 대해 사용된다. length이 첫 번째 행 에는 총 + 1 개의 선 그리기 문자가 있습니다.
• 틱이 사용 반 문자 씩 수직으로 연장되어야 ╵하고 │, 입력 간격에 근거.
• 간격은 이전 간격과 비교하여 최소에서 최대로 나열됩니다. 정교하게 :
  • 첫 번째 간격은 두 번째로 작은 간격 (가장 작은 간격은 1)에있는 기본 눈금 (첫 번째 행-한 문자 당 한 문자)의 수를 나타냅니다. 예를 들어, [3]은 3 번째 틱마다 반자 씩 길어집니다.
  • 두 번째 및 후속 간격은 다음으로 가장 작은 간격으로 표시됩니다. 예를 들어 [3, 5]는 15 번째 틱마다 문자 전체를 길게하고 [3, 5, 2]는 30 번째 틱마다 문자와 반자를 길게합니다.
  • 1의 하위 간격은 유효하며 효과적으로 마지막 간격 행이 반자 대신 전체 문자로 길어짐을 의미합니다.
• 예제 테스트 사례는 이것이 어떻게 작동하는지 명확히하는 데 도움이됩니다.

예제 / 테스트 사례

삼, []:

┌┬┬┐

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]

┌┐
│
│
│
│
╵

다른 규칙 / 참고

• 입력 및 출력은 편리한 형식을 사용할 수 있습니다
• 통치자는 큰 진드기로 끝날 필요가 없습니다
• 간격 목록이 비어있을 수 있습니다
• 0 번째 틱은 항상 모든 간격 내에 있습니다.
• 눈금자 길이와 간격이 항상 120보다 작은 양의 정수라고 가정 할 수 있습니다.
• 후행 공백은 괜찮지 만 선행 공백은 그렇지 않습니다.
• 어떤 이유로 든 ASCII 공백 이외의 다른 것을 사용하려는 경우 고정 된 단일 너비 공백은 간격 문자로 허용됩니다.

행복한 골프!

자바 스크립트 (Node.js) , 123 바이트

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

온라인으로 사용해보십시오!

이 기능을로 사용하십시오 f(20)([5, 2]).

감사 Arnauld, 4 바이트를 저장합니다.

Perl 6 , 130122102 92 바이트

nwellnhof 덕분에 -10 바이트!

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

온라인으로 사용해보십시오!

아 예, 이전 방법보다 훨씬 짧습니다. 행 목록을 리턴하는 익명 코드 블록입니다.

설명:

{                                                   }   # 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

Dyalog APL, 66 64 58 52 바이트

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

온라인으로 사용해보십시오!

ngn 덕분에 ¯2 ¯8 ¯14 바이트 !

파이썬 3 , 173 172 바이트

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

온라인으로 사용해보십시오!

05AB1E , 51 바이트

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

너무 행복하지 않은 I¯Qiεõ}}빈 입력 목록에 대한 해결 방법으로 . 그리고 다른 부분에서도 확실히 골프를 칠 수 있습니다.

참고 : 필요한 문자로 변환 된 압축 정수를 사용하십시오. 필수 문자를 직접 사용한다는 것은 전체 프로그램을 UTF-8로 계산해야하므로 모든 05AB1E의 내장 문자에 대해서도 너무 많이 증가시켜야한다는 것을 의미합니다.

온라인으로 시도 하거나 모든 테스트 사례를 확인하십시오 .

설명:

Ý             # 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)

내이 05AB1E 팁을 참조하십시오 (섹션 얼마나 큰 정수를 압축하는 방법을? ) 이유를 이해하는 •5·W4•것입니다 94749589하고 •áΣ=Yô•있다 948495169488.

숯 , 50 바이트

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

온라인으로 사용해보십시오! 링크는 자세한 버전의 코드입니다. Box-drawing 문자는 Charcoal에서 3 바이트로 표시되므로 위 문자열의 길이는 40 자입니다. 설명:

≔ＥηΠ…η⊕κη

구간의 누적 곱을 계산하십시오.

⪫┐┌×┬⊖θ↙

눈금의 첫 번째 행을 인쇄하십시오. 결과가 나중에 반영되므로 왼쪽 및 오른쪽 문자가 잘못 돌아갑니다.

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

각 눈금 표시의 요인 인 간격 수를 계산하십시오. │길이가 절반 인 s 문자열을 생성하고 ╵홀수 길이를 더합니다. 이전 열의 연속 된 문자열, 즉 역순으로 각 문자열을 아래쪽으로 인쇄하십시오.

‖

왼쪽에서 오른쪽으로 눈금자를 얻기 위해 모든 것을 반영하십시오.

캔버스 , 42 41 40 바이트

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

여기 사용해보십시오! ( 출력을 고정하는 글꼴로 )

이맥스 리스프 , 303 바이트

(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)))))))

이 기능을로 사용하십시오 (f '(30 (5 2))).

더 읽기 쉬운 버전 :

(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)))))))

젤리 ,  42  41 바이트

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

전체 프로그램.
온라인으로 사용해보십시오!

또는 테스트 슈트를 참조하십시오.
^{참고 :이 코드는 전체 프로그램에서 변경되었습니다- ñ(다음 번 링크로 연결되는 링크)가 1ŀ바닥 글에서 여러 번 호출 될 수 있도록 (색인으로 색인 1 링크 )으로 대체되었습니다. .}

방법?

‘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

루비 , 126 바이트

->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)]}*''}}

온라인으로 사용해보십시오!

오히려 모든 것을 장황하게 보입니다. each_slice골퍼 접근 방식을 찾지 못하면 것들로 보이지만 지금은 그렇게 할 것입니다.

l길이와 i간격 으로 입력을 받고 문자열 배열을 반환합니다.

R , 175 170 바이트

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

온라인으로 사용해보십시오!

빈 간격을로 사용 0하고 문자 행렬을 반환합니다. TIO 링크는 출력이 예쁘게 표시됩니다.

하스켈 , 167 (164) 149 바이트

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

온라인으로 사용해보십시오! 약간에 의해 다른 접근 방식을 golfed Ο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

온라인으로 사용해보십시오! 여전히 악용 될 수있는 중복성이 있지만 아직까지는 모든 추가 골프 시도를 견뎌냈습니다.

이전의 167 바이트 솔루션은 줄 바꾸기 처리와 동일하며 약간 더 읽기 쉽습니다.

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=[]

온라인으로 사용해보십시오!

PowerShell , 152 바이트

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}

온라인으로 사용해보십시오!

풀림 :

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 # (Visual C # 대화식 컴파일러) 204 바이트

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?"╵":"|");}}

온라인으로 사용해보십시오!

출력하지만 무한 루프에 빠집니다.

면도 , 221 201 195 162 바이트

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

온라인으로 사용해보십시오!

Clean은 기본 UTF-8을 지원하지 않으므로 UTF-8 문자 목록 목록을 문자열로 리턴합니다.

첫 번째 줄을 생성 한 다음 두 그룹으로 제공된 목록의 접두사 곱을 가져 와서 제품이 현재 문자 위치를 나누는 지 여부에 따라 표시 할 마크를 확인합니다.

언 골프 드 :

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