मनमाना अंतराल शासक

Question

एक प्रोग्राम बनाएं जो अंतराल की लंबाई और सूची लेता है और उस लंबाई के एक शासक को आउटपुट करता है जो लाइन वर्णों का उपयोग करके प्रत्येक अंतराल के लिए लंबे समय तक टिक करता है। ┌ ┬ ┐ │ ╵

• आउटपुट की पहली पंक्ति 0 के साथ टिक के साथ शुरू होनी चाहिए ┌और बीच में हर चरित्र के लिए इस्तेमाल होने के ┐साथ लंबाई के लिए एक टिक के साथ समाप्त होनी चाहिए ┬। lengthइस पहली पंक्ति में कुल + 1 लाइन ड्राइंग वर्ण होंगे।
• एक टिक का उपयोग कर आधा चरित्र वृद्धि के साथ खड़ी लम्बे किया जाना चाहिए ╵और │इनपुट अंतराल पर आधारित है।
• अंतराल को सबसे छोटे से सबसे बड़े तक सूचीबद्ध किया जाता है, इससे पहले अंतराल के सापेक्ष। समझाने के लिए:
  • पहला अंतराल बताता है कि दूसरे सबसे छोटे अंतराल (सबसे छोटा अंतराल 1 है) में कितने बेस टिक (पहली पंक्ति - एक टिक प्रति एक वर्ण) हैं। उदाहरण के लिए, [3] हर तीसरे टिक को एक आधे वर्ण से लंबा करेगा।
  • दूसरे और बाद के अंतराल अगले सबसे छोटे अंतराल के संदर्भ में हैं। उदाहरण के लिए [3, 5] एक पूर्ण वर्ण द्वारा हर 15 वें आधार टिक को लंबा करेगा और [3, 5, 2] प्रत्येक 30 वें आधार को एक वर्ण और एक आधे से लंबा करेगा।
  • 1 का एक उप-अंतराल वैध है और प्रभावी रूप से इसका मतलब है कि अंतिम अंतराल लाइनों को एक आधे चरित्र के बजाय एक पूर्ण चरित्र से लंबा किया जाता है।
• उदाहरण परीक्षण मामलों को यह स्पष्ट करने में मदद करनी चाहिए कि यह कैसे काम करता है।

उदाहरण / परीक्षण मामले

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]

┌┐
│
│
│
│
╵

अन्य नियम / नोट्स

• इनपुट और आउटपुट किसी भी सुविधाजनक प्रारूप का उपयोग कर सकते हैं
• शासक को एक प्रमुख टिक पर समाप्त नहीं होना है
• अंतराल सूची खाली हो सकती है
• ज़ीरोथ टिक हमेशा सभी अंतरालों के भीतर होता है।
• आप मान सकते हैं कि शासक की लंबाई और अंतराल हमेशा 120 से कम एक सकारात्मक पूर्णांक होंगे
• ट्रेलिंग व्हाट्सएप ठीक है, लेकिन प्रमुख व्हाट्सएप नहीं है।
• किसी निश्चित-एकल-विस्तृत स्थान को रिक्ति वर्ण के रूप में अनुमति दी जाती है यदि आप किसी कारण से, ASCII रिक्त स्थान के अलावा किसी अन्य चीज़ का उपयोग करना चाहते हैं।

हैप्पी गोल्फिंग!

Comments

आउटपुट के लिए, क्या मैं पहली पंक्ति प्रिंट कर सकता हूं, फिर कॉलम की सूची लौटा सकता हूं?

— अज्ञान का अवतार

@EododimentofIgnorance, मैं कह रहा हूँ कि नहीं करने के लिए। आउटपुट सुसंगत होना चाहिए।

— बीफस्टर

क्या हम एकल-बाइट एन्कोडिंग से बॉक्स-ड्रॉइंग वर्ण ले सकते हैं (बशर्ते कि कोई आवश्यक हो) मौजूद हो?

— Οurous

" कोई भी सुविधाजनक प्रारूप " - क्या हम रिवर्स ऑर्डर में अंतराल सूची को स्वीकार कर सकते हैं?

— NGN

@ngn: मैं नहीं देख क्यों नहीं। अगर वह किसी तरह से आपकी मदद करता है, तो उसके लिए जाएं।

— बीफस्टर

Answer 1

जावास्क्रिप्ट (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 बाइट्स बचाता है।

Answer 2

पर्ल 6 , 130 122 102 92 बाइट्स

-10 बाइट्स nwellnhof के लिए धन्यवाद!

{'┌'~'┬'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

Answer 3

डायलॉग एपीएल, 66 64 58 52 बाइट्स

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

इसे ऑनलाइन आज़माएं!

2 8 14 करने के लिए धन्यवाद बाइट्स NGN !

Comments

∊'┌'(1↓⍵⍴'┬')'┐'->'┌┬┐'/⍨2⍵2-1

— ngn

@ धन्यवाद धन्यवाद! ये गोल्फ के प्रकार हैं जो बहुत समझ में आते हैं, लेकिन मैं कभी भी इसके बारे में अनुमान लगाने या जानने के लिए नहीं जानता

— dzaima

अंत में, मैं सही हिस्से को थोड़ा छोटा करने में कामयाब रहा ... +⌿0=(×\⍺)∘.|⍳1+⍵-> ⊥¨⍨0=(⍵+1)⍴⍳⌽⍺। स्वीकार करने ⍺उलटे क्रम में कर दिया गया है स्पष्ट रूप से अनुमति दी , अब तो तुम भी निकाल सकते हैं⌽

— NGN

('┌┬┐'/⍨2⍵2-1)->'┌┬┐'[2,⍨×⍳⍵]

— नगन

या इससे भी बेहतर: ('┌┬┐'/⍨2⍵2-1)⍪⍉->'┌┐'@0⍵@0⍉'┬',

— ngn

Answer 4

पायथन 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))

इसे ऑनलाइन आज़माएं!

Answer 5

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।

Comments

×Sहो सकता हैи

— मैजिक ऑक्टोपस Urn

@MagicOctopusUrn मैंने पहली बार ऐसा सोचा था, लेकिन यह दुर्भाग्य से नहीं है (बस इसे अन्य परीक्षण मामलों में से एक गैर-खाली सूची के साथ आज़माएं)। sиSकाम करता है, लेकिन दुर्भाग्य से यह कम के बजाय एक बाइट है। ऐसा इसलिए है क्योंकि पूर्णांक पहले स्टैक पर हैं, और इसके बाद के तार। इसके साथ ×यह कोई फर्क नहीं पड़ता कि यह है int,stringया string,int, लेकिन इसके साथ की иउम्मीद है string,int।

— केविन क्रूज़सेन

ओह, मैं देख रहा हूँ, आदमी यह एक भ्रमित था हह। उस पर अच्छा काम, ईमानदार होने के लिए मैंने 10 मिनट बिताए बस यह पता लगाने की कोशिश कर रहा था कि क्या चल रहा था, इस बारे में याद किया и! यह भविष्य में जानना अच्छा होगा, मैंने इसे आपके अन्य उत्तरों में से एक से पहले इस्तेमाल नहीं किया था।

— मैजिक ऑक्टोपस Urn

Answer 6

चारकोल , 50 बाइट्स

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

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। बॉक्स-ड्राइंग पात्रों में चारकोल में एक 3 बाइट प्रतिनिधित्व है, इसलिए उपरोक्त स्ट्रिंग केवल 40 वर्ण लंबा है। स्पष्टीकरण:

≔ＥηΠ…η⊕κη

अंतराल के संचयी उत्पाद की गणना करें।

⪫┐┌×┬⊖θ↙

टिक चिह्नों की पहली पंक्ति प्रिंट करें। बाएं और दाएं वर्ण गलत तरीके से घूमते हैं क्योंकि परिणाम बाद में परिलक्षित होता है।

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

अंतराल की संख्या की गणना करें जो प्रत्येक टिक मार्क का एक कारक है। │उस लंबाई के आधे हिस्से की एक स्ट्रिंग उत्पन्न करें और ╵विषम लंबाई जोड़ें । प्रत्येक तार को पिछले स्तंभों में बाद के तारों के साथ नीचे की ओर प्रिंट करें, अर्थात रिवर्स ऑर्डर।

‖

शासक को बाएं से दाएं क्रम में लाने के लिए सब कुछ प्रतिबिंबित करें।

Answer 7

कैनवस , 42 41 40 बाइट्स

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

यहाँ कोशिश करो! ( एक फ़ॉन्ट के साथ जो आउटपुट को मोनोस्पेस करता है )

Answer 8

एमएसीएस लिस्प , 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)))))))

Answer 9

जेली ,  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

Answer 10

रूबी , 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अंतराल के लिए इनपुट लेता है , स्ट्रिंग्स की एक सरणी देता है।

Answer 11

आर , 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 लिंक आउटपुट को बहुत प्रिंट करता है।

Answer 12

हास्केल , 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]]

इसे ऑनलाइन आज़माएं! थोड़ा अलग दृष्टिकोण byurous द्वारा ।

---

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

इसे ऑनलाइन आज़माएं!

Comments

158 बाइट्स पर अलग-अलग दृष्टिकोण ( इसे ऑनलाइन आज़माएं! ), शायद तब से थोड़ा अधिक छोटा हो सकता हूं क्योंकि मैं हास्केल को अच्छी तरह से नहीं बोलता हूं।

— Οurous

@ Οurous धन्यवाद!

— लकोनी

Answer 13

पॉवरशेल , 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}

इसे ऑनलाइन आज़माएं!

unrolled:

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

Comments

हम्म ... सही उत्पादन के साथ विफल रहता है

— Veskah

तुम सही हो। 1) मैंने एक नियम नहीं देखा जो अंत में नई रेखा को पीछे छोड़ देता है। 2) और मुझे यह पसंद नहीं है कि कोड कभी-कभी अंत में एक नई लाइन जोड़ता है, और कभी-कभी ऐसा नहीं होता है। :)

— माज़ी

Answer 14

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 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?"╵":"|");}}

इसे ऑनलाइन आज़माएं!

आउटपुट, लेकिन एक अनंत लूप में फंस जाता है।

Answer 15

स्वच्छ , 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]]]

इसे ऑनलाइन आज़माएं!

UTF-8 वर्णों की सूचियों की सूची लौटाता है (जैसे तार, क्योंकि क्लीन का कोई जन्मजात UTF-8 समर्थन नहीं है)।

पहली पंक्ति उत्पन्न करके काम करता है, फिर दो के समूहों में प्रदान की गई सूची के उपसर्गों का उत्पाद ले रहा है, और यह जांचता है कि कौन सा उत्पाद मौजूदा चरित्र स्थिति को विभाजित करता है या नहीं।

Ungolfed:

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