Zeichnen Sie dieses Rautenmuster

24

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.
code-golf  ascii-art 
— AdmBorkBork
quelle
1
— Luis Mendo

Antworten:

10

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
— dzaima
quelle
wow O_o Leinwand ist zu kurz
— ASCII
6

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 bis7 bedeutetn-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.

— Arnauld
quelle
6

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

x10w+20y10h+109 (von oben nach unten) geht.

w=3h=2

(32,30)(31,30)…(0,30)(32,29)(31,29)(0,29)⋮⋱⋮(32,9)(31,9)…(0,9)

x=0

Für alle anderen Zellen berechnen wir:

  • ein=(x-y)mod10
  • d=(x+y)mod10

Wir zeichnen ein "/"if:

((ymod10)>3 und d=5) oder ((ymod10)<6 und 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:

((ymod10)>3 und ein=8) oder ((ymod10)<6 und ein=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.

— Arnauld
quelle
Das ist wirklich cool.
— AdmBorkBork
— Nur ASCII
@Arnauld Ich wusste, dass dies Ihre Antwort war, indem ich mir nur den Code
— ansah
6

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
— AZTECCO
quelle
1
Ungültig, kein vollständiges Programm oder eine Funktion
— ASCII
1
Aber 10/10 eine sehr schöne Methode
— ASCII
1
Welche Antworten sind nicht vollständige Programme oder Funktionen? (nur nachfragen, möglicherweise verpasst) Beachten Sie, dass einige Sprachen (z. B. Skriptsprachen) für vollständige Programme kein Boilerplate benötigen
— ASCII
1
— ASCII-only
1
159 , aber nicht sicher, ob die Ausgabe einer Funktion gültig ist (wahrscheinlich)
— Nur ASCII
4

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!

— ovs
quelle
1
Durch die Verwendung von reverse.map(map k)<>idover werden (++).reverse=<<map(map k)in beiden Lösungen 3 Byte gespart.
— ბიმო
1
Ach, und in der 2. man map tkann sich t<$>und take$10*x+2spart ein weiteres Byte zu und schließlich können Sie mit cycle"\\ /"!!nüber "\\ /"!!mod n 3- jetzt die zweite ist kürzer :) Online ausprobieren!
— ბიმო
3

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.

— Neil
quelle
3

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.
— mazzy
quelle
2

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!

— Xcali
quelle
1

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.

— Titus
quelle
1

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!

— JohnWells
quelle
1
136 , Diebstahl aus der neuen C ++
— ASCII
1

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.

— Neil A.
quelle
192 Bytes ohne Verwendung der Variablen b und c
— Black Owl Kai
187 Bytes durch Entfernen von zwei +=/ *=Zuweisungen und Umdrehen des gesamten Diamanten, wodurch die letzte Zeichenfolge leichter zu speichern ist
— Black Owl Kai
181
— Nur ASCII
147 , verwendet C ++
— ASCII
127
— Nur ASCII
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.