Lấy một vòng tròn đơn vị tập trung vào nguồn gốc. Trong bất kỳ hai góc phần tư lân cận nào , hãy phản chiếu đường cong của vòng tròn qua các đường nối giữa các x và y của vòng tròn.

Với hình dạng kết quả, bạn có thể xếp mặt phẳng:

^{Tôi đã tạo ra hình ảnh này với hộp cát vật lý 2D tuyệt vời Algodoo !}

Viết chương trình xuất ra một hình ảnh tương tự như hình này trong một số định dạng tệp hình ảnh lossless phổ biến. Bạn có thể lưu hình ảnh dưới dạng một tệp với tên bạn chọn hoặc bạn có thể chỉ cần hiển thị nó. Không có đầu vào nên được thực hiện.

Quy tắc:

• Các toàn bộ hình ảnh phải được lót đá với gạch sửa đổi vòng tròn sử dụng bất kỳ hai màu RGB biệt bằng mắt: một cho gạch chỉ theo chiều dọc, một cho gạch ngang chỉ.

• Bán kính của các ô hình tròn nên có ít nhất 32 pixel. (Bán kính trong hình trên là khoảng 110 pixel.)

• Hình ảnh phải có ít nhất 4 gạch rộng và 4 gạch cao. Điều này, kết hợp với quy tắc trên, có nghĩa là hình ảnh có thể có kích thước tối thiểu 256 × 256 pixel. (Hình trên là 4 ô bằng 4 ô.)

• Các tessname có thể được dịch bởi bất kỳ số lượng. Ví dụ, góc trên cùng bên trái của hình ảnh không cần phải là đỉnh nơi các ô gặp nhau. (Tuy nhiên, phần thứ ba không nên được xoay.)

• Bạn có thể sử dụng các thư viện đồ họa bên ngoài có các lệnh để vẽ vòng tròn và xuất hình ảnh và những thứ tương tự.

• Các đường cong thực sự nên xấp xỉ các vòng tròn, như có thể thực hiện với thuật toán vòng tròn trung điểm , điều mà hầu hết các thư viện đồ họa sẽ làm cho bạn.

• Khử răng cưa xung quanh các cạnh của gạch được cho phép nhưng không bắt buộc.

Đệ trình ngắn nhất tính bằng byte thắng.

gs2, 49 byte

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

Tạo hình ảnh PBM:

Ghi nhớ:

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

Tôi đang sử dụng càng nhiều tham số mặc định cho máy ảnh và nguồn sáng càng tốt, đó là lý do tại sao nó hơi tối. Cho phép ungolf trước

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

Rõ ràng những gì đang xảy ra khi chúng ta tăng độ lệch của trục hình trụ và thay đổi phối cảnh

Gnuplot, 182

Tôi nhận thấy rằng ranh giới giữa các tế bào trông rất hình sin, vì vậy tôi đã tìm một giải pháp phân tích với phương trình lõi rất đơn giản

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

Trong khi nó trông tương tự, các vòng tròn là quá vuông. Với ý tưởng tương tự, tôi thay thế sinbằng một đường cong được làm từ các vòng cung tứ giác nối liền và xoay nó 45 ° bằng cách thay thế xvà ybằng x+yvà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

Ngữ cảnh miễn phí, 99 byte

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

Bạn có thể xem kết quả tại Thư viện ngữ cảnh miễn phí .

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>

Để kiểm tra, lưu dưới dạng tệp html và mở bằng trình duyệt. Hoặc nếu không, chạy đoạn trích

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>

Do nhu cầu phổ biến, đây là hình ảnh đầu ra. Rốt cuộc không thú vị lắm ...

IDL 8.3, 201 193 183 byte

Hình ảnh được xuất ra một cửa sổ đồ họa IDL; Tôi chụp ảnh màn hình, bên dưới.

EDIT: cảm ơn @AlexA. và @ Sp3000 vì đã giúp tôi cạo một số byte

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

Toán học: 86 byte (hoặc 82 byte)

Cảm ơn @alephalpha vô hạn cho một phương pháp dựa trên mảng thông minh:

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

Bên trong mảng là một hàm ẩn danh, sử dụng một mẹo thông minh để thêm các đối số của nó ( +##) và xác định xem tổng có phải là số lẻ hay không. Boolean đó được sử dụng làm điều kiện cho một mẫu thay thế toàn bộ ô 'trắng' bằng ô 'đen' được chuyển đổi. Từ đó, ArrayFlattennối các viên gạch lại với nhau và Imagehiển thị chúng.

Lưu ý việc sử dụng ngắn hơn Threadđể thay thế Transpose. Chúng ta vẫn có thể lưu 4 byte bằng cách sử dụng biểu tượng chuyển vị thay thế.

Trước đó: 97 byte (hoặc 90 byte)

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

Bạn có thể giảm số lượng byte bằng cách thay thế Transpose@#bằng ký hiệu superscript-t (codepoint U + F3C7, phím tắt ESCtrESC). Trong UTF-8 mang lại tổng số 90 byte trong 88 ký tự .

Chúng tôi bắt đầu với DiskMatrix, tạo ra một ma trận nhị phân:

DiskMatrix@32 // Image

Sau đó, chúng tôi dịch chuyển các hàng của ma trận để tạo ô đơn vị cho ốp lát:

RotateLeft[DiskMatrix@32, 32] // Image

Nếu máy bay là bàn cờ, thì đây là những ô vuông 'trắng'. Đối với hình vuông 'đen', chúng ta cần đảo ngược màu sắc và xoay 90 độ. Chúng ta có thể đảo ngược bằng cách trừ từ 1 ( 1 - 1 -> 0và 1 - 0 -> 1) và xoay bằng cách chuyển vị trí:

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

Nếu kích thước của hình ảnh là chẵn (như kích thước tối thiểu là 4), thì một ô ở cạnh phải sẽ giống với kích thước tiếp theo ở cạnh trái. Tuy nhiên, việc thêm một ô để có kích thước lẻ (5) sau đó ghép các hàng sẽ tạo ra một mô hình xen kẽ thông thường.

Điều này cho thấy rằng chúng ta có thể có được hình ảnh đầy đủ bằng cách gói một hàng gạch xen kẽ với Partition. Chúng tôi sử dụng Tableđể lập danh sách các 13cặp gạch đen / trắng và Joinlàm phẳng danh sách các cặp thành danh sách 26 gạch. Sau đó chúng tôi Partitiondanh sách thành 5bởi 5ma trận của gạch ( Partitionvứt bỏ các dấu 26 ^thứ ngói):

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

Cuối cùng ArrayFlattenbiến ma trận của ma trận gạch thành ma trận phẳng và Imagehiển thị kết quả.

Trước đó: 111 byte

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

Java, 550 540 508 504 byte

Đây là một applet java.

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

Mở rộng với nồi hơi:

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: Một chương trình ứng dụng nhỏ có thể được gọi để sử dụng trong khi làm việc trong một ứng dụng khác.

Hình ảnh ví dụ:

Giải trình:

Điều này hoạt động bằng cách sử dụng một phương pháp để in từng ô. Trước khi phương thức được tạo, nó được cung cấp một đối tượng đồ họa sử dụng hệ tọa độ được căn giữa ở góc trên bên trái của mỗi ô:

Để tạo một lát, chúng tôi sử dụng phương pháp sau:

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

Tuy nhiên, mọi ô khác phải được phản chiếu theo chiều ngang để tạo ra hình ảnh chính xác.

Để phản ánh một lát, chúng ta chỉ cần sửa đổi graphicsđối tượng được cung cấp với mã này:

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

Cảm ơn @CoolGuy cho 4 byte.

Toán học 299 256

Wordy nhưng nó là tốt đẹp để tìm ra.

Ngói cơ bản là r (hiển thị bên dưới), là một khu vực được hiển thị bởi RegionPlot. Một phản xạ trái phải của gạch được thực hiện và nối với r. Hai con số lắp ráp gạch sau đó được lặp đi lặp lại để gạch không gian.

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 byte

180 byte. Phiên bản này bao gồm những thay đổi được đề xuất bởi edc65 trong một bình luận. Nó đưa ra 9 cảnh báo về trình biên dịch khi xây dựng trên máy Mac với các tùy chọn mặc định và tiếng kêu:

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 byte, sử dụng một số gợi ý từ ý kiến ​​của Martin. Biên dịch mà không có cảnh báo với tiếng kêu:

#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("");}}

Phiên bản gốc, 237 byte:

#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("");}}

Kết quả (256x256):

Mã gốc với khoảng trắng để dễ đọc hơn:

#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("");
    }
}

Điều này không sử dụng bất kỳ thư viện đồ họa, kết xuất hoàn toàn được chứa trong mã.

Ý tưởng cơ bản là chỉ đơn giản lặp lại trên tất cả 256x256 pixel và xem liệu chúng có ở trong / ngoài cung tròn của hình vuông phụ 32x32 mà chúng nằm trong không. 5 bit dưới cùng của tọa độ pixel tổng thể xác định tọa độ tương đối của pixel bên trong hình vuông phụ. Thử nghiệm bên trong / bên ngoài của (x, y)vòng cung có bán kính rlà tiêu chuẩn:

x * x + y * y < r * r

Hầu hết logic là để đặt tâm của vòng cung vào góc chính xác của hình vuông phụ và xác định màu nào ở bên trong / bên ngoài.

Một số ý kiến ​​về giải pháp:

• Mã này tạo ra hình ảnh ở định dạng PBM ASCII. Tôi đã tải kết quả vào GIMP và thực hiện sao chép & dán vào Paint để tạo tệp thực tế tôi đã đăng ở đây. Vì vậy, định dạng đã được chuyển đổi, nhưng nội dung chính xác như đầu ra ban đầu.
• Nếu bạn nhìn kỹ, bạn có thể nhận thấy rằng chất lượng không tốt. Điều này là do tính toán bên trong / bên ngoài được thực hiện cho góc của pixel, thay vì trung tâm pixel, khiến toàn bộ vật thể bị giảm 1/2 pixel. Tôi không nghĩ rằng sẽ rất khó để làm tốt hơn, nhưng nó sẽ làm cho mã dài hơn một chút. Và vì không có yêu cầu chất lượng cụ thể, tôi tin rằng điều này là đủ.
• Mã được biên dịch bằng tiếng kêu trên máy Mac. Phiên bản mới nhất đưa ra cảnh báo, phiên bản ban đầu thì không.
• Đây là lần đầu tiên tôi từng thử một trong số này, vì vậy tôi có thể đã bỏ lỡ một vài thủ thuật để lưu byte cuối cùng có thể.