Erstellen Sie ein Programm, das eine Länge und eine Liste von Intervallen annimmt und ein Lineal dieser Länge mit längeren Häkchen für jedes Intervall unter Verwendung der Strichzeichnungszeichen ausgibt ┌ ┬ ┐ │ ╵

• Die erste Zeile der Ausgabe sollte mit dem Häkchen für 0 mit beginnen ┌und mit einem Häkchen für die Länge mit enden ┐, ┬wobei für jedes Zeichen dazwischen ein verwendet wird. lengthIn dieser ersten Zeile befinden sich insgesamt + 1 Strichzeichnungszeichen.
• Ein Häkchen sollte mit ╵und │auf der Grundlage der Eingabeintervalle vertikal in Schritten von jeweils einem halben Zeichen verlängert werden.
• Intervalle werden vom kleinsten bis zum größten im Verhältnis zum Intervall davor aufgelistet. Ausarbeiten:
  • Das erste Intervall gibt an, wie viele Basis-Ticks (die erste Zeile - ein Zeichen pro Tick) sich im zweitkleinsten Intervall befinden (das kleinste Intervall ist 1). Zum Beispiel verlängert [3] jeden dritten Tick um ein halbes Zeichen.
  • Das zweite und die nachfolgenden Intervalle beziehen sich auf das nächstkleinere Intervall. Zum Beispiel verlängert [3, 5] jeden 15. Basistick um ein ganzes Zeichen und [3, 5, 2] jeden 30. Basistick um eineinhalb Zeichen.
  • Ein Unterintervall von 1 ist gültig und bedeutet effektiv, dass die letzten Intervallzeilen durch ein volles Zeichen anstelle eines halben Zeichens verlängert werden.
• Die Beispiel-Testfälle sollen verdeutlichen, wie dies funktioniert.

Beispiele / Testfälle

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]

┌┐
│
│
│
│
╵

Sonstige Regeln / Hinweise

• Die Ein- und Ausgabe kann in jedem beliebigen Format erfolgen
• Das Lineal muss nicht mit einem großen Häkchen enden
• Die Intervallliste ist möglicherweise leer
• Das nullte Häkchen liegt immer in allen Intervallen.
• Sie können davon ausgehen, dass die Länge des Lineals und die Intervalle immer positive ganze Zahlen sind, die kleiner als 120 sind
• Nachgestellte Leerzeichen sind in Ordnung, führende Leerzeichen jedoch nicht.
• Ein beliebiges Leerzeichen mit fester Einfachbreite ist als Abstandszeichen zulässig, wenn Sie aus irgendeinem Grund etwas anderes als ASCII-Leerzeichen verwenden möchten.

Viel Spaß beim Golfen!

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

Probieren Sie es online!

Verwenden Sie diese Funktion als f(20)([5, 2]).

Danke Arnauld, spart 4 Bytes.

Perl 6 , 130 122 102 92 Bytes

-10 bytes dank nwellnhof!

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

Probieren Sie es online!

Ach ja, viel kürzer als meine bisherige Methode. Dies ist ein anonymer Codeblock, der eine Liste von Zeilen zurückgibt.

Erläuterung:

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

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

Probieren Sie es online!

2 8 14 Bytes dank ngn !

Python 3 , 173 172 Bytes

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

Probieren Sie es online!

05AB1E , 51 Bytes

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

Nicht allzu gerne I¯Qiεõ}}als Umgehungslösung für leere Eingabelisten. Und kann definitiv auch an einigen anderen Stellen gespielt werden.

ANMERKUNG: Verwendet komprimierte Ganzzahlen, die in die erforderlichen Zeichen konvertiert wurden, da bei der direkten Verwendung der erforderlichen Zeichen das gesamte Programm in UTF-8 gezählt werden muss, wodurch es auch für alle in 05AB1E integrierten Zeichen um zu viel erhöht wird.

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Erläuterung:

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

Sehen Sie diese 05AB1E Spitze Mine (Abschnitt Wie große natürliche Zahlen zu komprimieren? ) Zu verstehen , warum •5·W4•ist 94749589und •áΣ=Yô•ist 948495169488.

Holzkohle , 50 Bytes

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Box-Drawing-Zeichen haben eine 3-Byte-Darstellung in Charcoal, daher ist die obige Zeichenfolge nur 40 Zeichen lang. Erläuterung:

≔ＥηΠ…η⊕κη

Berechnen Sie das kumulative Produkt der Intervalle.

⪫┐┌×┬⊖θ↙

Drucken Sie die erste Zeile der Häkchen. Das linke und das rechte Zeichen sind falsch herum, da das Ergebnis später wiedergegeben wird.

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

Berechnen Sie die Anzahl der Intervalle, die ein Faktor für jedes Häkchen sind. Erzeugen Sie eine Folge von │s mit der halben Länge und addieren Sie sie ╵für ungerade Längen. Drucken Sie jede Zeichenfolge mit den nachfolgenden Zeichenfolgen in den vorherigen Spalten nach unten, dh in umgekehrter Reihenfolge.

‖

Reflektiere alles, um das Lineal in der Reihenfolge von links nach rechts zu erhalten.

Canvas , 42 41 40 Bytes

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

Probieren Sie es hier aus! ( mit einer Schriftart, die die Ausgabe monospaces )

Emacs Lisp , 303 Bytes

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

Verwenden Sie diese Funktion als (f '(30 (5 2))).

Besser lesbare Version:

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

Jelly ,  42  41 Bytes

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

Ein volles Programm.
Probieren Sie es online!

Oder sehen Sie sich eine Testsuite an.
^{Hinweis: Dieser Code wurde von einem vollständigen Programm geändert - ñ(nächster Link als Dyade) wurde durch 1ŀ(Link bei Index 1 als Dyade) ersetzt, damit er mehrmals von der Fußzeile aufgerufen werden kann .}

Wie?

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

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

Probieren Sie es online!

Sieht mit all dem each_sliceZeug ziemlich wortreich aus , wird aber vorerst reichen, es sei denn, ich finde einen golferischeren Ansatz.

Nimmt Eingaben in Bezug lauf Länge und iIntervalle vor und gibt ein Array von Zeichenfolgen zurück.

R , 175 170 Bytes

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

Probieren Sie es online!

Nimmt leere Intervalle als 0, gibt eine Zeichenmatrix zurück. TIO-Link zeigt die Ausgabe hübsch gedruckt an.

Haskell , 167 164 149 Bytes

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

Probieren Sie es online! Etwas andere Herangehensweise von Golf Ο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

Probieren Sie es online! Es gibt immer noch einige Redundanzen, die so aussehen, als könnten sie ausgenutzt werden, aber bisher haben sie alle weiteren Golfversuche überstanden.

Die vorherige 167-Byte-Lösung ist abgesehen vom Newline-Handling dieselbe und wahrscheinlich etwas besser lesbar:

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

Probieren Sie es 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}

Probieren Sie es online!

Abgerollt:

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

Probieren Sie es online!

Ausgänge, bleibt aber in einer Endlosschleife stecken.

Sauber , 221 201 195 162 Bytes

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

Probieren Sie es online!

Gibt eine Liste von Listen mit UTF-8-Zeichen zurück (als Zeichenfolgen, da Clean keine angeborene UTF-8-Unterstützung bietet).

Generiert zunächst die erste Zeile, nimmt dann das Produkt der Präfixe der Liste in Zweiergruppen und prüft, welche Markierung zu zeichnen ist, basierend darauf, ob das Produkt die aktuelle Zeichenposition teilt.

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