Nehmen Sie einen Einheitskreis, der auf dem Ursprung zentriert ist. Spiegeln Sie in zwei benachbarten Quadranten die Kurve des Kreises über die Linien, die die x- und y-Achsen des Kreises verbinden.

Mit der resultierenden Form können Sie die Ebene kacheln:

^{Ich habe dieses Bild mit der fantastischen 2D-Physik-Sandbox Algodoo gemacht !}

Schreiben Sie ein Programm, das ein ähnliches Bild in einem gängigen verlustfreien Bilddateiformat ausgibt. Sie können das Bild als Datei mit dem Namen Ihrer Wahl speichern oder es einfach anzeigen. Es sollten keine Eingaben gemacht werden.

Regeln:

• Das gesamte Bild muss mit den Kacheln mit modifizierten Kreisen unter Verwendung von zwei visuell unterschiedlichen RGB-Farben tesselliert werden: eine für die vertikal zeigenden Kacheln, eine für die horizontal zeigenden Kacheln.

• Der Radius der Kreiskacheln sollte mindestens 32 Pixel betragen. (Der Radius im obigen Bild beträgt ca. 110 Pixel.)

• Das Bild sollte mindestens 4 Kacheln breit und 4 Kacheln hoch sein. In Kombination mit der obigen Regel bedeutet dies, dass Bilder eine Mindestgröße von 256 × 256 Pixel haben können. (Das Bild oben zeigt 4 x 4 Kacheln.)

• Die Tessellation kann beliebig umgerechnet werden. Beispielsweise muss die linke obere Ecke des Bildes nicht der Scheitelpunkt sein, an dem sich Kacheln treffen. (Die Tessellation sollte jedoch nicht gedreht werden.)

• Sie können externe Grafikbibliotheken verwenden, die Befehle zum Zeichnen von Kreisen und zum Ausgeben von Bildern und dergleichen enthalten.

• Die Kurven sollten sich wirklich Kreisen annähern, wie dies mit dem Mittelpunktkreis-Algorithmus möglich ist , den die meisten Grafikbibliotheken für Sie tun werden.

• Anti-Aliasing an den Kanten der Kacheln ist zulässig, aber nicht erforderlich.

Die kürzeste Übermittlung in Bytes gewinnt.

gs2, 49 bytes

50 31 05 0d 1f 2a 48 0a 1e 2e 40 83 2c e8 64 2d
1e 73 ed 1e 33 40 20 30 9a a2 22 e8 e9 40 20 30
9a 30 40 20 30 ee 40 20 30 12 32 e9 12 32 55 e8
2b

Erzeugt ein PBM-Image:

Mnemonik:

# Print header
"P1" space 256 double
2dup new-line

# Make 1/4 circle
64 range dup cartesian-product
square m1 sum sqrt 64 >= m6
64 /

# Make tile
dup reverse + transpose
@2 not m1 m2
dup reverse + transpose
+

# Make quarter of image
dup reverse + z1
dup reverse +

# Loop
2 * m2
2 *

# Format
show-words m1
unlines

POV-Ray, 199 163

Old version
camera{location -9*z}light_source{-9*z}#declare L=union{#for(X,-9,9,2)#for(Y,-9,9,2)cylinder{X*x+x+Y*y,<.001*pow(-1,(X+Y)/2),0,.1>+X*x+x+Y*y,1}#end#end}object{L pigment{color x}}object{L rotate z*90}

Same output, but golfed down further by using default light/camera, so I dont even need to specify them
#declare L=union{#for(X,-9,9,2)#for(Y,-9,9,2)cylinder{<X+1,Y,9>,<.001*pow(-1,(X+Y)/2),0,.1>+<X+1,Y,9>,1}#end#end}object{L pigment{color rgb x}rotate z*90}object{L}

Ich verwende so viele Standardparameter für Kamera und Lichtquelle wie möglich, deshalb ist es ein wenig dunkel. Lässt es zuerst ungolf

camera{location 9*z look_at 0}
light_source{9*z color 1} 
#declare L=union{
    #for(X,-9,9,2)
        #for(Y,-9,9,2)
            cylinder{<1+X,Y,0>,                                 //central axis, start
                     <1+X,Y,0> + <.001*pow(-1,(X+Y)/2), 0, .1>, //central axis, end
                      1}                                        //radius
        #end         
    #end
}                         
object{L pigment{color x}} // x is the <1,0,0> vector, here interpreted as RGB
object{L rotate<0,0,90>}

Es ist offensichtlich, was passiert, wenn wir den Versatz der Zylinderachse erhöhen und die Perspektive ändern

Gnuplot, 182

Mir ist aufgefallen, dass die Grenzen zwischen den Zellen sehr sinusförmig sind, und so habe ich mich für eine analytische Lösung mit einer sehr einfachen Kerngleichung entschieden

set view map
set isosamples 900
f(x,y)=.3*sin(x*3.14)+y
splot(ceil(f(x,y))+ceil(f(y,x)))%2?1:NaN   #can only modulo integers

Während es ähnlich aussieht, sind die Kreise viel zu quadratisch. Mit der gleichen Idee ersetze ich sindurch eine Kurve aus verketteten Viertelkreisbögen und drehe sie durch Ersetzen von xund ydurch x+yund um 45 °x-y

set view map
set samples 800
set isosamples 800
d=.5**.5
c(x,k)=(-1)**k*sqrt(1-(x-d*(1+2*k))**2)-(-1)**k*d  # k-th circle arc
# s(x)=c(x,floor(x/d/2))                           # circlified sinus
# f(x,y)=d*s(x/d)+y
f(x,y)=d*c(x/d,floor(x))+y                         # combined commented functions
splot(ceil(f(x+y,x-y))+ceil(f(x-y,x+y)))%2?1:NaN

Kontextfrei, 99 Bytes

startshape d CF::Tile=[s 4]CF::Symmetry=CF::pmg,0,1,0path d{ARCTO(-1,1,1)ARCTO(1,1,-1)ARCTO(0,0,1)}

Sie können das Ergebnis in der kontextfreien Galerie sehen .

HTML + JavaScript, 277

<canvas id=C></canvas><script>r=50,C.width=C.height=9*r,T=C.getContext('2d');
for(f=1,P=Math.PI,i=0;i<45;f=-f,i+=i&7?1:2)x=2*r*(i%8-2),y=2*r*(i>>3),T.moveTo(x,y+f*r),
T.arc(x+r,y+f*r,r,P,-f*P/2,f<0),T.arc(x,y,r,0,P,f>0),T.arc(x-r,y+f*r,r,-f*P/2,0,f<0);
T.fill()</script>

Zum Testen als HTML-Datei speichern und mit einem Browser öffnen. Oder führen Sie das Snippet aus

r=50,C.width=C.height=9*r,T=C.getContext('2d')
for(f=1,P=Math.PI,i=0;i<45;f=-f,i+=i&7?1:2)
  x=2*r*(i%8-2),y=2*r*(i>>3),
  T.moveTo(x,y+f*r),
  T.arc(x+r,y+f*r,r,P,-f*P/2,f<0),
  T.arc(x,y,r,0,P,f>0),
  T.arc(x-r,y+f*r,r,-f*P/2,0,f<0)
T.fill()

<canvas id=C></canvas>

Aufgrund der großen Nachfrage sehen Sie hier das Ausgabebild. Immerhin nicht so aufregend ...

IDL 8.3, 201 193 183 Bytes

Das Bild wird in ein IDL-Grafikfenster ausgegeben. Ich habe unten einen Screenshot gemacht.

EDIT: danke an @AlexA. und @ Sp3000 für die Hilfe beim Rasieren einiger Bytes

p=!pi/99*[0:99]
q=p[49:0:-1]
o=p[99:50:-1]
window,xs=(ys=400)
for i=0,24 do cgpolygon,i mod 5*100+50*[cos(p),cos(q)-1,cos(o)+1],i/5*100+(-1)^i*50*[sin(p),sin(q)-1,sin(o)-1],/d,/fi
end

Mathematica: 86 Bytes (oder 82 Bytes)

Vielen Dank an @alephalpha für eine clevere Array-basierte Methode:

Image@ArrayFlatten@Array[DiskMatrix@32~RotateLeft~32/.a_/;OddQ@+##:>1-Thread@a&,{5,5}]

In dem Array befindet sich eine anonyme Funktion, die mit einem cleveren Trick die Argumente ( +##) hinzufügt und feststellt, ob die Summe ungerade ist. Dieser Boolesche Wert wird als Bedingung für ein Muster verwendet, das die gesamte "weiße" Kachel durch die transformierte "schwarze" Kachel ersetzt. Von dort aus werden ArrayFlattendie Kacheln zusammengefügt und Imageangezeigt.

Beachten Sie die Verwendung der kürzeren Threadzu ersetzen Transpose. Wir können weiterhin 4 Bytes sparen, indem wir stattdessen das Transponierungssymbol verwenden.

Zurück: 97 Bytes (oder 90 Bytes)

Image@ArrayFlatten@Partition[
 Join@@Table[{#,1-Transpose@#}&@RotateLeft[DiskMatrix@32,32],{13}],5]

Sie können die Anzahl der Bytes verringern, indem Sie sie Transpose@#durch das hochgestellte t-Symbol ersetzen (Codepunkt U + F3C7, Tastenkürzel ESCtrESC). In UTF-8 ergibt das 90 Bytes in 88 Zeichen .

Wir beginnen mit DiskMatrix, die eine binäre Matrix erzeugt:

DiskMatrix@32 // Image

Wir verschieben dann die Zeilen der Matrix kreisförmig, um die Einheitszelle für die Kachelung zu erzeugen:

RotateLeft[DiskMatrix@32, 32] // Image

Wenn das Flugzeug ein Schachbrett ist, sind dies die "weißen" Quadrate. Für die "schwarzen" Quadrate müssen wir die Farben umkehren und um 90 Grad drehen. Wir können invertieren, indem wir von 1 ( 1 - 1 -> 0und 1 - 0 -> 1) subtrahieren , und rotieren, indem wir die Transponierte nehmen:

Image /@ {#, 1 - Transpose@#} &@RotateLeft[DiskMatrix@32, 32]

Wenn die Abmessungen des Bildes gerade sind (wie die Mindestgröße 4), entspricht eine Kachel am rechten Rand der nächsten am linken Rand. Wenn Sie jedoch eine Kachel hinzufügen, um eine ungerade Größe (5) zu erhalten, und dann die Zeilen verketten, wird ein regelmäßiges Wechselmuster erzeugt.

Dies legt nahe, dass wir das vollständige Bild erhalten können, indem wir eine einzelne Reihe abwechselnder Kacheln mit umwickeln Partition. Wir verwenden Table, um eine Liste von 13Schwarz / Weiß-Kachelpaaren Joinzu erstellen und die Liste der Paare auf eine Liste von 26 Kacheln zu reduzieren. Dann haben wir Partitiondie Liste in eine 5von 5Matrix von Kacheln ( Partitionverwirft die 26 Hinter ^th Kachel):

Map[Image] /@ 
  Partition[
   Join @@ Table[{#, 1 - #\[Transpose]} &@
      RotateLeft[DiskMatrix@32, 32], {13}], 5] // MatrixForm

Schließlich ArrayFlattenstellt sich die Matrix der Fliese Matrizen in eine flache Matrix und Imagezeigt das Ergebnis an .

Zurück: 111 Bytes

Image[ArrayFlatten[{{#, #}, {#, #}}] &[
  Join[#, Reverse@#, 2] &[
   Join[1 - Transpose@#, #] &@RotateLeft[DiskMatrix[32], 32]]]]

Java, 550 540 508 504 Bytes

Dies ist ein Java-Applet.

import java.awt.*;public class T extends java.applet.Applet{int a=98,b=49,x,y;public void paint(Graphics g){for(x=0;x<5;x++)for(y=0;y<5;y++)a(g.create(x*a,y*a,a,a),x%2^y%2);}void a(Graphics g,int c){if(c>0){g.translate(a,0);((Graphics2D)g).scale(-1,1);}g.setColor(Color.red);g.fillRect(0,0,b,b);g.fillRect(b,b,b,b);g.setColor(Color.blue);g.fillRect(b,0,b,b);g.fillRect(0,b,b,b);g.fillArc(0,-b,a,a,180,90);g.fillArc(0,b,a,a,0,90);g.setColor(Color.red);g.fillArc(-b,0,a,a,0,-90);g.fillArc(b,0,a,a,90,90);}}

Erweitert mit Boilerplate:

import java.awt.*;
public class T extends java.applet.Applet{
    int a = 98, b = 49, x, y; //Make these larger for better quality pictures. a = b * 2
    public void paint(Graphics g) {
        for (x=0; x < 5; x++)      //Make these larger for more tiles.
            for (y=0; y < 5; y++)  //
                a(g.create(x * a, y * a, a, a), x % 2 ^ y % 2);
    }

    void a(Graphics g, int c) {
        if (c > 0) {
            g.translate(a, 0);
            ((Graphics2D) g).scale(-1, 1);
        }
        g.setColor(Color.red);            //Change colors for nicer looking colors.
        g.fillRect(0, 0, b, b);
        g.fillRect(b, b, b, b);
        g.setColor(Color.blue);
        g.fillRect(b, 0, b, b);
        g.fillRect(0, b, b, b);
        g.fillArc(0, -b, a, a, 180, 90);
        g.fillArc(0, b, a, a, 0, 90);
        g.setColor(Color.red);
        g.fillArc(-b, 0, a, a, 0, -90);
        g.fillArc(b, 0, a, a, 90, 90);
    }
}

Applet: Ein kleines Anwendungsprogramm, das für die Arbeit in einer anderen Anwendung aufgerufen werden kann.

Beispielbild:

Erläuterung:

Dies funktioniert mithilfe einer Methode zum Drucken der einzelnen Kacheln. Bevor die Methode erstellt wird, erhält sie ein Grafikobjekt, das ein Koordinatensystem verwendet, das in der oberen linken Ecke jeder Kachel zentriert ist:

Um eine Kachel zu erstellen, verwenden wir die folgende Methode:

void a(Graphics g, int c) {
    g.setColor(Color.red);
    g.fillRect(0, 0, b, b);
    g.fillRect(b, b, b, b);
    g.setColor(Color.blue);
    g.fillRect(b, 0, b, b);
    g.fillRect(0, b, b, b);
    g.fillArc(0, -b, a, a, 180, 90);
    g.fillArc(0, b, a, a, 0, 90);
    g.setColor(Color.red);
    g.fillArc(-b, 0, a, a, 270, 90);
    g.fillArc(b, 0, a, a, 90, 90);
}

Jede andere Kachel muss jedoch horizontal reflektiert werden, um das richtige Bild zu erhalten.

Um eine Kachel wiederzugeben, ändern wir einfach das bereitgestellte graphicsObjekt mit dem folgenden Code:

g.translate(a, 0);
((Graphics2D) g).scale(-1, 1);

Danke @CoolGuy für 4 Bytes.

Mathematica 299 256

Wordy, aber es war schön herauszufinden.

Die Grundkachel ist r (siehe unten), eine Region, die von RegionPlot angezeigt wird. Ein Links-Rechts-Spiegelbild der Kachel wird erstellt und mit r verbunden. Die zusammengesetzte Figur aus zwei Kacheln wird dann wiederholt, um den Raum zu kacheln.

a_~f~b_ := (x + a)^2 + (y + b)^2 <= 1;
a = ImageAssemble;
r = RegionPlot[(0~f~0 && y <= 0 && ! f[-1, 1]) \[Or] (0~f~2 && 
      y >= -2 && ! f[1, 1]), {x, -1, 1}, {y, -2, 0}, Frame -> False,
    BoundaryStyle -> None];
s = ImageCrop@Rasterize@r;
t = s~ImageReflect~Right;
i = a@{s, t};
j = a@{t, s};
a@{k = {i, i, i, i}, m = {j, j, j, j}, k, m, k, m}

C 237 209 180 Bytes

180 Bytes. Diese Version enthält Änderungen, die von edc65 in einem Kommentar vorgeschlagen wurden. Es gibt 9 Compiler-Warnungen, wenn auf einem Mac mit Klirr- und Standardoptionen gebaut wird:

a,b,c,d,x,y;main(){for(puts("P1 256 256");b=a+32&64,a<256;++a){for(c=0;d=c+32&64,x=(a&64)-d?31-a&31:a&31,y=(c&64)-b?c&31:31-c&31,c++<256;)putchar(48+(x*x+y*y<962^b==d));puts("");}}

209 Bytes, unter Verwendung einiger Vorschläge aus Kommentaren von Martin. Kompiliert ohne Warnung mit clang:

#include <stdio.h>
int a,b,c,d,x,y;int main(){puts("P1 256 256");for(;b=a+32&64,a<256;++a){for(c=0;d=c+32&64,x=(a&64)-d?31-a&31:a&31,y=(c&64)-b?c&31:31-c&31,c<256;++c)putchar(48+(x*x+y*y<962^b==d));puts("");}}

Originalversion, 237 Bytes:

#include <stdio.h>
int main(){puts("P1 256 256");for(int a=0;a<256;++a){int b=a+32&64;for(int c=0;c<256;++c){int d=c+32&64;int x=(a&64)-d?31-a&31:a&31;int y=(c&64)-b?c&31:31-c&31;putchar(48+(x*x+y*y<962^b==d));}puts("");}}

Ergebnis (256 x 256):

Originalcode mit Leerzeichen zur besseren Lesbarkeit:

#include <stdio.h>
int main()
{
    puts("P1 256 256");
    for (int a = 0; a < 256; ++a)
    {
        int b = a + 32 & 64;
        for (int c = 0; c < 256; ++c)
        {
            int d = c + 32 & 64;
            int x = (a & 64) - d ? 31 - a & 31 : a & 31;
            int y = (c & 64) - b ? c & 31 : 31 - c & 31;
            putchar(48 + (x * x + y * y < 962 ^ b == d));
        }
        puts("");
    }
}

Hierbei wird keine Grafikbibliothek verwendet, das Rendering ist vollständig im Code enthalten.

Die Grundidee besteht darin, einfach alle 256 x 256 Pixel zu durchlaufen und zu prüfen, ob sie sich innerhalb / außerhalb des Kreisbogens des 32 x 32-Teilquadrats befinden, in dem sie sich befinden. Die unteren 5 Bits der gesamten Pixelkoordinaten definieren die relativen Koordinaten des Pixels innerhalb das Unterquadrat. Der Innen- / Außentest (x, y), innerhalb des Bogens mit Radius zu sein, rist dann der Standard:

x * x + y * y < r * r

Die meiste Logik besteht darin, den Mittelpunkt des Bogens in der richtigen Ecke des Unterquadrats zu platzieren und zu bestimmen, welche Farbe innen / außen ist.

Einige Kommentare zur Lösung:

• Der Code generiert das Bild im PBM-ASCII-Format. Ich habe das Ergebnis in GIMP geladen und in Paint kopiert und eingefügt, um die tatsächliche Datei zu generieren, die ich hier gepostet habe. Das Format wurde also konvertiert, aber der Inhalt entspricht genau der ursprünglichen Ausgabe.
• Wenn Sie genau hinschauen, werden Sie feststellen, dass die Qualität nicht besonders gut ist. Dies liegt daran, dass die Innen- / Außenberechnung für die Ecke des Pixels und nicht für die Pixelmitte durchgeführt wird, wodurch das Ganze um 1/2 Pixel versetzt wird. Ich denke nicht, dass es sehr schwierig wäre, es besser zu machen, aber es würde den Code etwas länger machen. Und da es keine spezifischen Qualitätsanforderungen gab, halte ich dies für ausreichend.
• Code wurde mit clang auf einem Mac kompiliert. Neueste Version gibt Warnungen, erste Version nicht.
• Dies ist das erste Mal, dass ich einen dieser Versuche unternommen habe. Vermutlich habe ich ein paar Tricks verpasst, um das letzte mögliche Byte zu speichern.