Das folgende Muster bildet die Grundlage für diese Herausforderung.

     /\
     \/
     /\
    /  \
   /    \
/\/      \/\
\/\      /\/
   \    /
    \  /
     \/
     /\
     \/

Bei gegebener Eingabebreite und Eingabehöhe wird jeweils >=1das obige ASCII-Kunstmuster so oft wiederholt ausgegeben, wobei die kleinen Rauten verbunden (und überlappt) werden.

Hier ist zum Beispiel eine Eingabe mit width = 2und height = 1:

     /\        /\
     \/        \/
     /\        /\
    /  \      /  \
   /    \    /    \
/\/      \/\/      \/\
\/\      /\/\      /\/
   \    /    \    /
    \  /      \  /
     \/        \/
     /\        /\
     \/        \/

Hier ist eine Eingabe width = 3und height = 2:

     /\        /\        /\
     \/        \/        \/
     /\        /\        /\
    /  \      /  \      /  \
   /    \    /    \    /    \
/\/      \/\/      \/\/      \/\
\/\      /\/\      /\/\      /\/
   \    /    \    /    \    /
    \  /      \  /      \  /
     \/        \/        \/
     /\        /\        /\
     \/        \/        \/
     /\        /\        /\
    /  \      /  \      /  \
   /    \    /    \    /    \
/\/      \/\/      \/\/      \/\
\/\      /\/\      /\/\      /\/
   \    /    \    /    \    /
    \  /      \  /      \  /
     \/        \/        \/
     /\        /\        /\
     \/        \/        \/

Regeln und I / O

• Die Ein- und Ausgabe kann auf jede bequeme Weise erfolgen .
• Sie können es an STDOUT drucken oder als Funktionsergebnis zurückgeben.
• Es ist entweder ein vollständiges Programm oder eine Funktion zulässig.
• Beliebige Leerzeichen sind zulässig, sofern die Zeichen richtig ausgerichtet sind.
• Standardlücken sind verboten.
• Dies ist Codegolf, daher gelten alle üblichen Golfregeln, und der kürzeste Code (in Byte) gewinnt.

Canvas , 26 25 24 21 18 Byte

４／╬/╬⁰ｒ：⤢ｎ↷⁸｛Ａ×├ｍ↷

Probieren Sie es hier aus!

-3 Bytes durch Beheben der ｍnicht wiederholten Zeichenfläche

Erläuterung:

4/╬                 quad-palindromize a 4-long diagonal - big inner diamond
   /╬               quad-palindromize "/" - small diamond
     ⁰r             join the two vertically, centered
       :⤢n          overlap with transpose
           ↷        and rotate the thing clockwise
            ⁸{      for each input
              A×      times 10
                ├     plus 2
                 m    mold the canvas to that width
                  ↷   and rotate clockwise, setting up for the next iteration

JavaScript (ES8), 167 161 159 Bytes

^{NB: Dies kodiert das Muster. Siehe meine andere Antwort für einen kürzeren mathematischen Ansatz.}

Übernimmt die Eingabe als (width)(height).

w=>h=>(g=h=>h?g(--h)+`
`+([4106,4016,31305,21504,17010]['0102344320'[h%=10]]+'').replace(/./g,c=>'\\/'[c^h>5]||''.padEnd(c-1)).repeat(w+1).slice(8):'')(h*10+2)

Probieren Sie es online!

Wie?

Wir kodieren die obere Hälfte des Musters mit Ziffern:

• $0$ bedeutet\
• $1$ bedeutet/
• $n=2$ bis$7$ bedeutet$n-1$ Leerzeichen

Das gibt:

0  ···/\·····  -->  [3 spaces] [/] [\] [5 spaces]             -->  4106
1  ···\/·····  -->  [3 spaces] [\] [/] [5 spaces]             -->  4016
0  ···/\·····  -->  [3 spaces] [/] [\] [5 spaces]             -->  4106
2  ··/··\····  -->  [2 spaces] [/] [2 spaces] [\] [4 spaces]  -->  31305
3  ·/····\···  -->  [1 space] [/] [4 spaces] [\] [3 spaces]   -->  21504
4  /······\/\  -->  [/] [6 spaces] [\] [/] [\]                -->  17010

Für die untere Hälfte verwenden wir die Zeilen $4,3,2,0$ mit /und \invertiert.

JavaScript (ES6), 139 Byte

Dies ist ein ganz anderer Ansatz als meine ursprüngliche Antwort, daher poste ich dies separat.

Übernimmt die Eingabe als (width)(height).

w=>h=>(g=x=>y>8?` /\\
`[a=(x+y*9)%10,d=(x+y)%10,x?(y%10>3&&2*(a==8)|d==5)|(y%10<6&&2*(a==6)|d==7):3]+g(x--?x:--y&&w):'')(w=w*10+2,y=-~h*10)

Probieren Sie es online!

Wie?

Ausgehend von der Breite $w$ und der Höhe $h$ zeichnen wir die Ausgabe zeichenweise über ein Gitter, das wie folgt lautet:

• $10w+3$ Zeichen breit
• $10h+2$ Zeichen hoch

$x$$10w+2$$0$$y$$10h+10$$9$ (von oben nach unten) geht.

$w=3$$h=2$

$$\begin{matrix}(32,30)&(31,30)&\dots&(0,30)\\ (32,29)&(31,29)&&(0,29)\\ \vdots&&\ddots&\vdots\\ (32,9)&(31,9)&\dots&(0,9)\end{matrix}$$

$x=0$

Für alle anderen Zellen berechnen wir:

• $a=(x-y)\bmod 10$
• $d=(x+y)\bmod 10$

Wir zeichnen ein "/"if:

$$((y\bmod 10)>3\text{ and }d=5)\text{ or }((y\bmod 10)<6\text{ and }d=7)$$

 y  | y % 10 | output (w = 3, h = 1)
----+--------+----------------------------------
 20 |    0   | ...../........./........./......
 19 |    9   | ....../........./........./.....
 18 |    8   | ...../........./........./......
 17 |    7   | ..../........./........./.......
 16 |    6   | .../........./........./........
 15 |    5   | /./......././......././......./.
 14 |    4   | ./......././......././......././
 13 |    3   | ......../........./........./...
 12 |    2   | ......./........./........./....
 11 |    1   | ....../........./........./.....
 10 |    0   | ...../........./........./......
  9 |    9   | ....../........./........./.....

Wir zeichnen ein "\"if:

$$((y\bmod 10)>3\text{ and }a=8)\text{ or }((y\bmod 10)<6\text{ and }a=6)$$

 y  | y % 10 | output (w = 3, h = 1)
----+--------+----------------------------------
 20 |    0   | ......\.........\.........\.....
 19 |    9   | .....\.........\.........\......
 18 |    8   | ......\.........\.........\.....
 17 |    7   | .......\.........\.........\....
 16 |    6   | ........\.........\.........\...
 15 |    5   | .\.......\.\.......\.\.......\.\
 14 |    4   | \.\.......\.\.......\.\.......\.
 13 |    3   | ...\.........\.........\........
 12 |    2   | ....\.........\.........\.......
 11 |    1   | .....\.........\.........\......
 10 |    0   | ......\.........\.........\.....
  9 |    9   | .....\.........\.........\......

Oder wir zeichnen ein Leerzeichen, wenn keine dieser Bedingungen erfüllt ist.

C ++ (gcc) , 137 Bytes

#include<cstdio>
auto p(int x,int y){int n=10,t=x=++x*n;for(++y*=n;y>8;)t>7?putchar(t<9?y--,n:t%n-y%n+4&7?t%n+y%n-5&7?32:47:92),t--:t=x;}

Probieren Sie es online!

Erläuterung

_______________________________
   098765432109876.... 
   9    \/    .     factor =y%10 - x10
   8    /\    .     if factor = -4 || 4. Print --> '\'  47
   7   /  \   . 
   6  /    \  .     factor =x%10+y%10;  
   5\/      \/*-.   if factor = 5 || 13 --> /  92
   4/\      /\   `.
   3  \    /       `->  * is 9,5 => \
   2   \  /      
   1    \/   
   0    /\       
   9

Haskell , 179 Bytes

k '\\'='/'
k '/'='\\'
k x=x
f x=take(10*x+2)
w#h=map(f w.cycle).f h.drop 9.cycle$(++).reverse=<<map(map k)$["\\/\\      /","   \\    / ","    \\  /  ","     \\/   ","     /\\   "]

Probieren Sie es online!

---

Haskell , 181 Bytes

k '\\'='/'
k '/'='\\'
k x=x
f x=take(10*x+2)
w#h=map(f w.cycle).f h.drop 9.cycle$(++).reverse=<<map(map k)$map t[49200,36058,31630,30010,29038]
t 0=""
t n="\\ /"!!mod n 3:t(div n 3)

Probieren Sie es online!

Holzkohle , 24 22 20 Bytes

\/↘²‖Ｍ↘LＦ⊖ＮＣχ⁰Ｆ⊖ＮＣ⁰χ

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Erläuterung:

´\/↘²

Zeichnen Sie ein Achtel des ursprünglichen Musters.

‖Ｍ↘L

Dupliziere es dreimal, um das ursprüngliche Muster zu vervollständigen.

Ｆ⊖ＮＣχ⁰

Kopieren Sie die erforderliche Anzahl horizontal.

Ｆ⊖ＮＣ⁰χ

Kopieren Sie die erforderliche Anzahl vertikal.

Powershell, 146 Bytes

param($w,$h)0..9*$h+0,1|%{$y=$_
-join(0..9*$w+0,1|%{('3  /\33  \/33  /\33 /  \3  /3 \ /\/33\\/\33/3\3 /3  \  /33 \/3'-replace3,'   ')[$y*10+$_]})}

Erläuterung

Das Muster ist 10x10 Zeichen Array:

     /\   
     \/   
     /\   
    /  \  
   /    \ 
/\/      \
\/\      /
   \    / 
    \  /  
     \/   

Das Drehbuch:

• wiederholt das Muster;
• fügt Spalten [0,1] an das Ende jeder Zeile an;
• Fügt Zeilen [0,1] an das Ende der Ausgabe an.

Zwei Dinge fürs Golfen:

1. Das Muster-Array, das einer Zeichenfolge mit einer Länge von 100 Byte zugeordnet ist.
2. Die Saite reduziert sich einfach replace.

Perl 5 -p , 148 Bytes

$_='3A3'x$_.$/.'3B3
3A3
2/2\\2
1/4\\1
A6A
B6B
1\\4/1
2\\2/2
3B3
3A3
'=~s/^.*$/$&x$_/mger x<>.'3B3'x$_;s|A+|/\\|g;s|B+|\\/|g;s/\d/$"x$&/ge;s|^ |  |gm

Probieren Sie es online!

PHP, 159 Bytes

Muster aus mazzy genommen; übersetzt nach 1-2-3, konvertiert nach base26 -> vom Programm dekodiert

while($y<$argv[2]*10+2)echo str_pad("",$argv[1]*10+2,strtr(base_convert([jng1,jnnb,jng1,jofn,k333,"1h4p5",23814,k94d,k02h,jnnb][$y++%10],26,4),312,"\ /")),"
";

benötigt PHP 5.5 oder neuer. Laufen Sie mit -nroder versuchen Sie es online .

Berechnung kann kürzer sein (wie es für Arnauld war). Ich kann das untersuchen.

Kotlin , 196.135 Bytes

61 Byte gespart dank dem Vorschlag von ASCII-only, den C ++ - Algorithmus von AZTECCO zu verwenden.

{h,w->var r=""
for(l in 9..h*10+10){for(c in 9..w*10+10){r+=when{(l%10+c%10)%8==5->'/'
(l%10-c%10+8)%8==4->'\\'
else->' '}}
r+='\n'}
r}

Probieren Sie es online!

Python 3 , 194 192 187 127 Bytes

@ Nur-ASCII-Lösung:

lambda w,h,n=10:"\n".join("".join([" /","\\"][(j%n-i%n)%8==4][(j%n+i%n)%8==5]for i in range(-1,w*n+1))for j in range(-1,h*n+1))

Probieren Sie es online!

---

Ursprüngliche Lösung

n="\n"
def f(w,h):a=[r"     /\   "*w,r"     \/   "*w,r"    \  /  "*w,r"   \    / "*w,r"\/\      /"*w+r"\/"];return a[0]+n+n.join(([i.translate({47:92,92:47})for i in a]+a[::-1])*h)+n+a[1]

Probieren Sie es online!

-2 Bytes dank @Black Owl Kai, der zeigt, dass auf die Tops und Bottoms vom generierten Array aus zugegriffen werden kann, anstatt in separaten Variablen.

-5 weitere Bytes dank @Black Owl Kai, der die Diamanten kreativer speichert

Erzeugt diesen Teil jedes Diamanten:

     /\
     \/
    \  /
   \    /
\/\      /\/

Ein /\am Ende jeder Zeile hinzugefügt, um es zu vervollständigen. Dann werden /s und \s vertauscht, um die Oberseite jedes Diamanten zu bilden, und die Reihenfolge der Linien wird umgekehrt, um die untere Hälfte zu bilden. Schließlich wird es in der obersten Reihe von hinzugefügt/\ s und in der untersten Reihe von \/s hinzugefügt, um das Bild zu vervollständigen.