Uzunluk ve aralık listesi alan ve çizgi çizme karakterlerini kullanarak her aralık için daha uzun keneler içeren bir cetvel çıkaran bir program yapın. ┌ ┬ ┐ │ ╵

• Çıktının ilk satırı 0 ile başlayan tik ile başlamalı ┌ve aradaki her karakter için kullanılan ┐ile uzunluğundaki bir tik ile bitmelidir ┬. lengthBu ilk satırda toplam + 1 çizgi çizme karakteri olacaktır.
• Bir onay işareti , giriş aralıklarını kullanarak ╵ve bu değerleri │temel alarak yarım karakter aralıklarla uzatmalıdır .
• Aralıklar, önceki aralığa göre en küçükten en büyüğe sıralanır. Ayrıntılı olarak:
  • İlk aralık kaç temel kenenin (ilk satır - her bir onay için bir karakter) ikinci en küçük aralıkta olduğunu gösterir (en küçük aralık 1'dir). Örneğin, [3] her üç teneği yarım karakter uzatacaktır.
  • İkinci ve sonraki aralıklar bir sonraki en küçük aralık açısındandır. Örneğin, [3, 5] her 15.
  • 1 alt aralığı geçerli ve etkili bir şekilde son aralık çizgilerinin yarım karakter yerine tam karakterle uzatıldığı anlamına gelir.
• Örnek test durumları bunun nasıl çalıştığını açıklamaya yardımcı olmalıdır.

Örnekler / Test Durumları

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]

┌┐
│
│
│
│
╵

Diğer Kurallar / Notlar

• Giriş ve çıkış uygun herhangi bir formatı kullanabilir
• Cetvel büyük bir kene bitirmek zorunda değildir
• Aralık listesi boş olabilir
• Sıfırıncı onay, her zaman tüm aralıklarda olur.
• Cetvel uzunluğunun ve aralıkların her zaman 120'den küçük pozitif bir tamsayı olacağını varsayabilirsiniz.
• İzleyen boşluk boş, ancak baştaki boşluk boş değil.
• Herhangi bir nedenle ASCII boşlukları dışında bir şey kullanmak istiyorsanız, sabit-tek genişlikli herhangi bir boşluğa boşluk karakteri olarak izin verilir.

Mutlu Golf!

JavaScript (Node.js) , 123 bayt

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

Çevrimiçi deneyin!

Bu işlevi olduğu gibi kullanın f(20)([5, 2]).

Teşekkürler Arnauld, 4 bayt kaydeder.

Perl 6 , 130 122 102 92 bayt

Nwellnhof sayesinde -10 bayt!

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

Çevrimiçi deneyin!

Ah evet, önceki yöntemimden çok daha kısa. Bu, bir satır listesi döndüren adsız bir kod bloğudur.

Açıklama:

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

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

Çevrimiçi deneyin!

2 8 14 sayesinde bayt NGN !

Python 3 , 173 172 bayt

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

Çevrimiçi deneyin!

05AB1E , 51 bayt

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

I¯Qiεõ}}Boş giriş listeleri için uğraşırken pek mutlu değilsin .. Ve kesinlikle diğer bazı yerlerde de golf oynayabilirsin ..

NOT: İstenilen karakterlere dönüştürülen sıkıştırılmış tam sayıları kullanır, çünkü istenen karakterleri doğrudan kullanmak, tüm programı UTF-8'de saymak zorunda kalacağım anlamına gelir, böylece 05AB1E'nin yerleşik karakterleri için de çok fazla artırabilirim.

Çevrimiçi deneyin veya tüm test durumlarını doğrulayın .

Açıklama:

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

Benim bu 05AB1E ucu bakın (bölüm ne kadar büyük tamsayılar sıkıştırmak için? ) Anlamak için •5·W4•ise 94749589ve •áΣ=Yô•olup 948495169488.

Kömür , 50 bayt

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

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı bir versiyonudur. Kutu çizme karakterleri Kömür'de 3 baytlık bir gösterime sahiptir, bu nedenle yukarıdaki dize yalnızca 40 karakter uzunluğundadır. Açıklama:

≔ＥηΠ…η⊕κη

Aralıkların kümülatif ürününü hesaplayın.

⪫┐┌×┬⊖θ↙

İlk satır çizgilerini yazdırın. Sol ve sağ karakterler yanlış yoldur çünkü sonuç daha sonra yansıtılır.

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

Her onay işaretinin faktörü olan aralık sayısını hesaplayın. │Bu uzunluktaki yarısı bir s dizesi oluşturun ve ╵tek uzunluklar için ekleyin . Her dizgiyi, önceki sütunlarda sonraki dizelerle aşağı doğru yazdırın, yani ters sırada.

‖

Cetvelin soldan sağa sıralanması için her şeyi yansıtın.

Tuval , 42 41 40 bayt

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

Burada dene! ( çıktıyı monospac eden bir fontla )

Emacs Lisp , 303 bayt

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

Bu işlevi olduğu gibi kullanın (f '(30 (5 2))).

Daha iyi okunabilir sürüm:

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

Jöle ,  42  41 bayt

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

Tam bir program.
Çevrimiçi deneyin!

Veya bir test takımına bakın
^{Not: bu kod tam bir programdan değiştirildi - ñ(bir dyad olarak sonraki bağlantı), 1ŀaltbilgi ile birden çok kez çağrılmasını sağlamak için (bir dyad olarak 1. dizinde bağlantı ) ile değiştirildi .}

Nasıl?

‘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 bayt

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

Çevrimiçi deneyin!

Bunlarla ilgili oldukça ayrıntılı görünüyor each_slice, ancak golfçü yaklaşımı bulamadığım sürece şimdilik devam edecek.

Girdiyi luzunluk olarak alır ve iaralıklarla dizge dizisini döndürür.

R , 175 170 bayt

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

Çevrimiçi deneyin!

Boş aralıkları alır 0, karakter matrisini döndürür. TIO bağlantısı çıktıyı oldukça basılmış gösterir.

Haskell , 167 164 149 bayt

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

Çevrimiçi deneyin! Biraz farklı bir yaklaşım 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

Çevrimiçi deneyin! Hala sömürülebilecek gibi görünen bazı fazlalıklar var, ancak şimdiye kadar bütün golf denemelerine dayandılar.

Önceki 167 bayt çözüm, newline işlemenin dışında aynıdır ve muhtemelen biraz daha iyi okunabilir:

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

Çevrimiçi deneyin!

PowerShell , 152 bayt

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}

Çevrimiçi deneyin!

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

C # (Visual C # Etkileşimli Derleyici) , 204 bayt

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

Çevrimiçi deneyin!

Çıktılar, ancak sonsuz bir döngüde sıkışıp kalıyorlar.

Temiz , 221 201 195 162 bayt

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

Çevrimiçi deneyin!

UTF-8 karakter listelerinin bir listesini döndürür (Temiz olarak doğuştan UTF-8 desteği bulunmadığından dizeler olarak).

İlk satırı oluşturarak çalışır, daha sonra iki kişilik gruplar halinde verilen listenin öneklerinin ürününü alır ve ürünün mevcut karakter konumunu ayırıp ayırmadığına göre hangi işareti çizeceğini kontrol eder.

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