Créez un programme qui prend une longueur et une liste d'intervalles et génère une règle de cette longueur avec des graduations plus longues pour chaque intervalle en utilisant les caractères de dessin au trait ┌ ┬ ┐ │ ╵

• La première ligne de la sortie doit commencer par le tick pour 0 avec ┌et se terminer par un tick pour la longueur avec ┐, avec un ┬étant utilisé pour chaque caractère entre les deux. Il y aura un total de length+ 1 caractères de dessin au trait dans cette première ligne.
• Un tick doit être allongé verticalement par incréments d'un demi-caractère en utilisant ╵et en │fonction des intervalles d'entrée.
• Les intervalles sont répertoriés du plus petit au plus grand, par rapport à l'intervalle précédent. Élaborer:
  • Le premier intervalle indique le nombre de ticks de base (la première ligne - un caractère par tick) dans le deuxième plus petit intervalle (le plus petit intervalle étant 1). Par exemple, [3] allongera chaque troisième tick d'un demi-caractère.
  • Le deuxième intervalle et les intervalles suivants sont en termes du plus petit intervalle suivant. Par exemple, [3, 5] allongera chaque 15ème tick de base d'un caractère complet et [3, 5, 2] allongera chaque 30ème tick de base d'un caractère et demi.
  • Un sous-intervalle de 1 est valide et signifie effectivement que les dernières lignes d'intervalle sont allongées par un caractère complet au lieu d'un demi-caractère.
• Les exemples de cas de test devraient aider à clarifier comment cela fonctionne.

Exemples / cas de 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]

┌┐
│
│
│
│
╵

Autres règles / notes

• L'entrée et la sortie peuvent utiliser n'importe quel format pratique
• La règle n'a pas à se terminer sur une tique majeure
• La liste d'intervalles peut être vide
• Le tick zéro est toujours dans tous les intervalles.
• Vous pouvez supposer que la longueur et les intervalles de la règle seront toujours des entiers positifs inférieurs à 120
• L'espace de fin est bien, mais pas l'espace de tête.
• Tout espace fixe simple largeur est autorisé comme caractère d'espacement si, pour une raison quelconque, vous souhaitez utiliser autre chose que des espaces ASCII.

Bon golf!

JavaScript (Node.js) , 123 octets

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

Essayez-le en ligne!

Utilisez cette fonction comme f(20)([5, 2]).

Merci Arnauld, enregistre 4 octets.

Perl 6 , 130 122 102 102 92 octets

-10 octets grâce à nwellnhof!

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

Essayez-le en ligne!

Ah oui, beaucoup plus court que ma méthode précédente. Il s'agit d'un bloc de code anonyme qui renvoie une liste de lignes.

Explication:

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

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

Essayez-le en ligne!

¯2 ¯8 ¯14 octets grâce à ngn !

Python 3 , 173 172 octets

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

Essayez-le en ligne!

05AB1E , 51 octets

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

Pas trop satisfait de la I¯Qiεõ}}solution de contournement pour les listes d'entrées vides .. Et peut certainement être joué à d'autres parties également ..

REMARQUE: utilise des entiers compressés convertis en caractères requis, car l'utilisation directe des caractères requis signifie que je devrai compter le programme entier en UTF-8, en l'augmentant trop pour tous les caractères intégrés de 05AB1E.

Essayez-le en ligne ou vérifiez tous les cas de test .

Explication:

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

Voir cette astuce 05AB1E (section Comment compresser les grands entiers? ) Pour comprendre pourquoi •5·W4•est 94749589et •áΣ=Yô•est 948495169488.

Fusain , 50 octets

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

Essayez-le en ligne! Le lien est vers la version détaillée du code. Les caractères de dessin de boîte ont une représentation de 3 octets en fusain, donc la chaîne ci-dessus ne fait que 40 caractères. Explication:

≔ＥηΠ…η⊕κη

Calculez le produit cumulé des intervalles.

⪫┐┌×┬⊖θ↙

Imprimez la première ligne de graduations. Les caractères gauche et droit sont dans le mauvais sens car le résultat est reflété plus tard.

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

Calculez le nombre d'intervalles qui sont un facteur de chaque coche. Générez une chaîne de │s de la moitié de cette longueur et ajoutez ╵pour les longueurs impaires. Imprimer chaque chaîne vers le bas avec les chaînes suivantes dans les colonnes précédentes, c'est-à-dire l'ordre inverse.

‖

Tout refléter pour obtenir la règle de gauche à droite.

Toile , 42 41 40 octets

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

Essayez-le ici! ( avec une police qui espace la sortie )

Emacs Lisp , 303 octets

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

Utilisez cette fonction comme (f '(30 (5 2))).

Meilleure version lisible:

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

Gelée ,  42  41 octets

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

Un programme complet.
Essayez-le en ligne!

Ou voir une suite de tests
^{Remarque: ce code a été modifié à partir d'un programme complet - ñ(le lien suivant en tant que dyade) a été remplacé par 1ŀ(lien à l'index 1 en tant que dyade) pour lui permettre d'être appelé plusieurs fois par le pied de page .}

Comment?

‘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

Rubis , 126 octets

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

Essayez-le en ligne!

Semble assez bavard avec tout ça each_slice ça, mais fera l'affaire pour l'instant, à moins que je n'arrive pas à trouver une approche de golfeur.

Prend l'entrée comme lpour la longueur et ipour les intervalles, retourne un tableau de chaînes.

R , 175170 octets

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

Essayez-le en ligne!

Prend des intervalles vides comme 0, renvoie une matrice de caractères. Le lien TIO affiche la sortie bien imprimée.

Haskell , 167 164 149 octets

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

Essayez-le en ligne! Approche différente légèrement golfée par 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

Essayez-le en ligne! Il y a encore des redondances qui semblent pouvoir être exploitées, mais jusqu'à présent, elles ont résisté à toutes les autres tentatives de golf.

La solution précédente de 167 octets est la même en dehors de la gestion des sauts de ligne et est probablement légèrement plus lisible:

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

Essayez-le en ligne!

PowerShell , 152 octets

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}

Essayez-le en ligne!

Déroulé:

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 # Interactive Compiler) , 204 octets

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

Essayez-le en ligne!

Sorties, mais se coince dans une boucle infinie.

Nettoyer , 221 201 195 162 octets

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

Essayez-le en ligne!

Renvoie une liste de listes de caractères UTF-8 (sous forme de chaînes, car Clean n'a pas de prise en charge UTF-8 innée).

Fonctionne en générant la première ligne, puis en prenant le produit des préfixes de la liste fournie par groupes de deux, et vérifie quelle marque dessiner selon que le produit divise la position actuelle du caractère.

Non golfé:

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