Crea un programma che richiede una lunghezza e un elenco di intervalli e genera un righello di quella lunghezza con segni di spunta più lunghi per ogni intervallo usando i caratteri del disegno a tratteggio ┌ ┬ ┐ │ ╵

• La prima riga dell'output dovrebbe iniziare con il segno di spunta per 0 con ┌e terminare con un segno di spunta per la lunghezza con ┐, con un ┬essere utilizzato per ogni carattere in mezzo. Ci saranno un totale di length+ 1 caratteri di disegno al tratto in questa prima riga.
• Un segno di spunta deve essere allungato verticalmente con incrementi di mezzo carattere utilizzando ╵e in │base agli intervalli di input.
• Gli intervalli sono elencati dal più piccolo al più grande, rispetto all'intervallo precedente. Elaborare:
  • Il primo intervallo indica quanti tick di base (la prima riga - un carattere per tick) sono nel secondo intervallo più piccolo (l'intervallo più piccolo è 1). Ad esempio, [3] allungherà ogni terzo segno di spunta di un mezzo carattere.
  • Il secondo e gli intervalli successivi sono in termini del successivo intervallo più piccolo. Ad esempio [3, 5] allungherà ogni 15 tick di base di un carattere completo e [3, 5, 2] allungherà ogni 30 tick di base di un carattere e mezzo.
  • Un sottointervallo pari a 1 è valido ed efficacemente significa che le ultime righe dell'intervallo sono allungate di un carattere completo anziché di un mezzo carattere.
• I casi di test di esempio dovrebbero aiutare a chiarire come funziona.

Esempi / casi di test

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]

┌┐
│
│
│
│
╵

Altre regole / note

• Input e output possono utilizzare qualsiasi formato conveniente
• Il sovrano non deve finire con un segno di spunta maggiore
• L'elenco degli intervalli potrebbe essere vuoto
• Il segno di spunta zeroth è sempre a tutti gli intervalli.
• Puoi assumere la lunghezza del righello e gli intervalli saranno sempre numeri interi positivi inferiori a 120
• Lo spazio bianco finale va bene, ma lo spazio bianco principale non lo è.
• È consentito qualsiasi spazio a larghezza fissa singola come carattere di spaziatura se, per qualche motivo, si desidera utilizzare qualcosa di diverso dagli spazi ASCII.

Buon golf!

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

Provalo online!

Utilizzare questa funzione come f(20)([5, 2]).

Grazie Arnauld, salva 4 byte.

Perl 6 , 130 122 102 92 byte

-10 byte grazie a nwellnhof!

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

Provalo online!

Ah sì, molto più breve del mio metodo precedente. Questo è un blocco di codice anonimo che restituisce un elenco di righe.

Spiegazione:

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

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

Provalo online!

¯2 ¯8 ¯14 byte grazie a 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))

Provalo online!

05AB1E , 51 byte

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

Non troppo contento di I¯Qiεõ}}come soluzione alternativa per liste di input vuote .. E può sicuramente essere giocato anche in altre parti ..

NOTA: utilizza numeri interi compressi convertiti nei caratteri richiesti, poiché l'utilizzo diretto dei caratteri richiesti significa che dovrò contare l'intero programma in UTF-8, aumentandolo di troppo anche per tutti i caratteri incorporati di 05AB1E.

Provalo online o verifica tutti i casi di test .

Spiegazione:

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

Vedi questo mio suggerimento 05AB1E (sezione Come comprimere numeri interi di grandi dimensioni? ) Per capire perché •5·W4•è 94749589ed •áΣ=Yô•è 948495169488.

Carbone , 50 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. I caratteri di disegno a scatola hanno una rappresentazione a 3 byte in carboncino, quindi la stringa sopra è lunga solo 40 caratteri. Spiegazione:

≔ＥηΠ…η⊕κη

Calcola il prodotto cumulativo degli intervalli.

⪫┐┌×┬⊖θ↙

Stampa la prima riga dei segni di spunta. I caratteri sinistro e destro sono invertiti perché il risultato si riflette più tardi.

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

Calcola il numero di intervalli che sono un fattore di ciascun segno di spunta. Genera una stringa di │s della metà di quella lunghezza e aggiungi ╵per lunghezze dispari. Stampa ogni stringa verso il basso con le stringhe successive nelle colonne precedenti, ovvero l'ordine inverso.

‖

Rifletti tutto per ottenere il righello nell'ordine da sinistra a destra.

Tela , 42 41 40 byte

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

Provalo qui! ( con un carattere che monospace l'output )

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

Utilizzare questa funzione come (f '(30 (5 2))).

Versione leggibile meglio:

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

Gelatina ,  42  41 byte

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

Un programma completo.
Provalo online!

Oppure vedi una suite di test
^{Nota: questo codice è stato modificato da un programma completo - ñ(il collegamento successivo come diade) è stato sostituito con 1ŀ(collegamento all'indice 1 come diade) per consentire che venga chiamato più volte dal piè di pagina .}

Come?

‘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

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

Provalo online!

Sembra piuttosto dettagliato con tutta quella each_sliceroba, ma lo farà per ora, a meno che non riesca a trovare un approccio più golfista.

Accetta input lper lunghezza e iintervalli, restituisce una matrice di stringhe.

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

Provalo online!

Accetta intervalli vuoti come 0, restituisce una matrice di caratteri. Il collegamento TIO visualizza l'output piuttosto stampato.

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

Provalo online! Approccio diverso leggermente golfato da ousurous .

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

Provalo online! Ci sono ancora alcuni licenziamenti che sembrano poter essere sfruttati, ma finora hanno resistito a tutti gli ulteriori tentativi di golf.

La precedente soluzione da 167 byte è la stessa a parte la gestione di newline ed è probabilmente leggermente meglio leggibile:

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

Provalo online!

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}

Provalo online!

srotolato:

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 # (compilatore interattivo 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?"╵":"|");}}

Provalo online!

Emette, ma rimane bloccato in un ciclo infinito.

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

Provalo online!

Restituisce un elenco di elenchi di caratteri UTF-8 (come stringhe, poiché Clean non ha supporto innato UTF-8).

Funziona generando la prima riga, quindi prendendo il prodotto dei prefissi dell'elenco forniti in gruppi di due e verifica i segni da tracciare in base al fatto che il prodotto divida la posizione attuale del carattere.

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