Chandler bé nhỏ buồn. Vẽ cho anh ta một đám mây để cổ vũ anh ta.
Lưu ý: Vẽ một đám mây sẽ không thực sự làm anh ấy vui lên.

Một vòng tròn có thể được định nghĩa là 3 tuple (x,y,r)trong đó xvị trí x của vòng tròn trên mặt phẳng Cartesian, ylà vị trí y của vòng tròn trên mặt phẳng Cartesian và rlà bán kính của vòng tròn. xvà ycó thể âm tính. rluôn luôn tích cực. Đầu vào là danh sách các vòng tròn ở dạng không gian được phân tách 3-tuples. Ví dụ:

3,1,1 3,2,1.5 1,2,0.7 0.9,1.2,1.2 1,0,0.8

Có 3,1,1nghĩa là "Một vòng tròn có điểm trung tâm tại 3,1với bán kính 1. Có 3,2,1.5nghĩa là" Một vòng tròn có điểm chính giữa 3,2với bán kính 1,5.

Nếu chúng ta vẽ tất cả các vòng tròn đầu vào này trên một biểu đồ, nó sẽ trông như thế này (tôi chỉ bao gồm các đường lưới và nhãn cho rõ ràng; chúng không bắt buộc):

Chú ý cách tất cả các vòng tròn được gắn kết . Đó là, tất cả chúng được xếp chồng lên nhau sao cho nó tạo thành một nhóm lớn mà không có bất kỳ nhóm vòng tròn nhỏ nào tách biệt với phần còn lại. Các đầu vào được đảm bảo để được gắn kết.

Giả sử bây giờ chúng ta vẽ một đường đi quanh "đường viền" được tạo bởi các vòng tròn này, mà không có bất kỳ đường nào khác. Nó sẽ giống như vẽ đường viền của hình bóng được hình thành bởi tất cả các vòng tròn. Đám mây kết quả sẽ trông giống như thế này:

Vì vậy, đám mây này đã được hình thành bằng cách chỉ vẽ các vòng cung của các vòng tròn trong đầu vào tạo thành một đường viền, dẫn đến một hình dạng duy nhất. Nói cách khác, đám mây được hình thành bằng cách chỉ vẽ các cung không nằm trong vòng tròn khác. Chương trình của bạn sẽ nhận đầu vào ở dạng được giải thích ở trên và xuất ra một hình ảnh hiển thị đám mây kết quả. Hình dạng tổng thể của đám mây phải chính xác, nhưng tỷ lệ, màu sắc, độ dày của đường và cách nó nhìn vào các đỉnh là tùy thuộc vào bạn. Lưu ý rằng đám mây phải được nhìn thấy, vì vậy bạn không thể kéo một cái gì đó như "Chương trình này vẽ một đám mây trắng trên nền trắng", "Chương trình này vẽ một đám mây ở quy mô cực nhỏ", "Chương trình này vẽ một đám mây bằng 0 độ dày đường kẻ ", v.v. Cũng lưu ý rằng màu của đường viền phải khác với màu của màu tô hoặc nền.

Một vi dụ khac. Đầu vào:

1,4,2 5,2,1 3,1,1 3.5,2,1.2 3,3,0.7 1,2,0.7

Đầu ra:

Nếu có một "lỗ" trên đám mây, bạn cũng nên vẽ lỗ đó. Đầu vào:

0,5,4 3,4,4 4,3,4 5,0,4 4,-3,4 3,-4,4 0,-5,4 -3,-4,4 -4,-3,4 -5,0,4 -4,3,4 -3,4,4 

Đầu ra:

Đây là một quy tắc quan trọng: chương trình của bạn phải chỉ vẽ các đường tạo thành đường viền. Điều này có nghĩa là bạn KHÔNG THỂ chỉ vẽ các vòng tròn đầy đủ, sau đó vẽ các vòng tròn nhỏ hơn một chút bằng cách tô màu trắng - bởi vì phương pháp đó vẫn vẽ các đường không tạo thành một đường viền, sau đó nó chỉ che chúng lại. Mục đích của quy tắc là ngăn chặn việc "vẽ các vòng tròn, sau đó vẽ lại các vòng tròn bằng cách điền vào màu trắng" hoặc bất cứ điều gì tương tự như vậy. Câu trả lời dự kiến ​​sẽ thực sự tính toán nơi để vẽ những thứ trước khi vẽ nó.

Đây là mã golf, vì vậy số lượng nhân vật ngắn nhất sẽ thắng.

Toán học 177 126 121 119

Giải theo khu vực đĩa: cách tiếp cận của nhà toán học

Logic là để

• Tạo Vùng 1 (R1), các vòng tròn (không có nội thất của chúng);
• Tạo Vùng 2 (R2), các đĩa (không có viền vòng tròn).
• Tạo Vùng 3 (R3 = R1 - R2).
-

Đây chính xác là cách tiếp cận được thực hiện dưới đây. Nó tạo ra 3 con số trên.

input = "3,1,1 3,2,1.5 1,2,0.7 0.9,1.2,1.2 1,0,0.8";
circles = ((x - #)^2 + (y - #2)^2 == #3^2) & @@@ 
     ToExpression[#~StringSplit~","] &@(StringSplit@input);
R1 = ImplicitRegion[Or @@ circles, {x, y}];
r1 = RegionPlot[R1, PlotLabel -> "R1: circles containing borders", 
   AspectRatio -> 1, PlotRange -> {{-1, 5}, {-1, 5}}];

innerDisks = ((x - #)^2 + (y - #2)^2 < #3^2) & @@@ 
     ToExpression[#~StringSplit~","] &@(StringSplit@input);
R2 = ImplicitRegion[Or @@ innerDisks, {x, y}];
r2 = RegionPlot[R2, PlotLabel -> "R2: disks within circle borders", 
   AspectRatio -> 1, PlotRange -> {{-1, 5}, {-1, 5}}];
R3 = RegionDifference[R1, R2]
r3 = RegionPlot[R3, PlotLabel -> "R3 = R1-R2", AspectRatio -> 1, 
   PlotRange -> {{-1, 5}, {-1, 5}}];
GraphicsGrid[{{r1, r2, r3}}, ImageSize -> 600]

Vùng ẩn ý số 1 là sự kết hợp của các vòng tròn. Vùng ẩn số 2 là sự kết hợp của các đĩa nằm trong vòng tròn. Sự khác biệt của họ là biên giới.

VùngDifference [
ImplicitRegion [(- 3 + x) ^ 2 + (-1 + y) ^ 2 == 1 || (-3 + x) ^ 2 + (-2 + y) ^ 2 == 2,25 || (-1 + x) ^ 2 + (-2 + y) ^ 2 == 0,49 || (-0,9 + x) ^ 2 + (-1,2 + y) ^ 2 == 1,44 | | (-1 + x) ^ 2 + y ^ 2 == 0,64, {x, y}],
ImplicitRegion [(- 3 + x) ^ 2 + (-1 + y) ^ 2 <1 || (-3 + x) ^ 2 + (-2 + y) ^ 2 <2.25 || (-1 + x) ^ 2 + (-2 + y) ^ 2 <0,49 || (-0,9 + x) ^ 2 + (-1.2 + y) ^ 2 <1.44 || (-1 + x) ^ 2 + y ^ 2 <0,64, {x, y}]]

Giải quyết theo khu vực đĩa: phương pháp của kỹ sư (119 ký tự)

Sau đây có sự kết hợp của các vùng đĩa, phân biệt vùng đó và tìm ranh giới của nó. Các điểm trong sơ đồ phân định các khoảng của lưới Delaunay. Chúng tôi hiển thị vùng rời rạc bên dưới để làm nổi bật đối tượng cung cấp ranh giới quan tâm (đường viền của đám mây).

s = StringSplit;RegionBoundary@DiscretizeRegion[RegionUnion[Disk[{#, #2}, #3] &@@@
ToExpression[#~s~","] &@(s@InputString[])]]

"3,1,1 3,2,1,5 1,2,0,7 0,9,1,2,1,2 1,0,0,8"

Ranh giới khu vực được rời rạc.

Giải quyết bằng cách phát hiện các cạnh: Cách tiếp cận của nhiếp ảnh gia - 121 ký tự

Nó vẽ các đĩa màu đen, rasterize hình ảnh, phát hiện các cạnh và đảo ngược màu đen và trắng.

s=StringSplit;ColorNegate@EdgeDetect@Rasterize@Graphics[Disk[{#,#2},#3]&@@@
((ToExpression/@s[#,","])&/@s[InputString[]])]

T-SQL 235 234 229 212 171 73 byte

Điều này sử dụng chức năng không gian trong SQL Server 2012+. Khi nó được chạy trong SSMS (SQL Server Management Studio) sẽ tạo ra một khung kết quả không gian. Đầu vào là từ biến @i. Tôi có thể giảm thêm nếu đầu vào có thể được lấy từ một bảng.

Vì đầu vào bảng bây giờ được cho phép.

SELECT Geometry::UnionAggregate(Geometry::Point(X,Y,0).STBuffer(R))FROM A

Tôi đã để lại giải pháp trước đây bên dưới.

DECLARE @ VARCHAR(999)='WITH a AS(SELECT *FROM(VALUES('+REPLACE(@i,' ','),(')+'))A(X,Y,R))SELECT Geometry::UnionAggregate(Geometry::Point(X,Y,0).STBuffer(R))FROM a'EXEC(@)

Chỉnh sửa : Xóa khoảng trống đi lạc, thặng dư vào và subquery

171: Tạo bảng thay thế bằng CTE và @s bằng @.

Phân tích SQL động

DECLARE @i VARCHAR(100) = '1,4,2 5,2,1 3,1,1 3.5,2,1.2 3,3,0.7 1,2,0.7' -- Input
DECLARE @ VARCHAR(999) = '
WITH a AS(                                       --CTE to produce rows of x,y,r 
    SELECT *FROM(VALUES('+
        REPLACE(@i,' ','),(')                    --Format @i to a value set
        +'))A(X,Y,R)
)
SELECT Geometry::UnionAggregate(                 --Aggregate Buffered Points
    Geometry::Point(X,Y,0).STBuffer(R)           --Create point and buffer
    )               
FROM a                                           --from the table variable
'
EXEC(@)                                          --Execute Dynamic sql

Toán học, 175 158 149 byte

s=StringSplit;l=ToExpression[#~s~","]&@s@InputString[];RegionPlot[Or@@(Norm@{x-#,y-#2}<#3&@@@l),{x,m=Min@(k={{##}-#3,{##}+#3}&@@@l),M=Max@k},{y,m,M}]

Tôi nhớ từ cuộc thảo luận trong hộp cát rằng cách tiếp cận này được cho là hợp lệ, nhưng tôi không hoàn toàn chắc chắn nó phù hợp với cách diễn đạt mới của các quy tắc, vì vậy @Lilac, hãy cho tôi biết nếu bạn nghĩ rằng điều này vi phạm quy tắc.

Về cơ bản, tôi đang tạo một điều kiện logic đúng cho tất cả các điểm bên trong đám mây và sai cho tất cả các điểm bên ngoài nó. Tôi đang cho ăn RegionPlotmà sau đó biểu hiện khu vực của tất cả các điểm có biểu thức Truecũng như một phác thảo xung quanh nó.

Ung dung:

s = StringSplit;
l = ToExpression[#~s~","] &@s@InputString[];
RegionPlot[
 Or @@ (Norm@{x - #, y - #2} < #3 & @@@ l), 
 {x, m = Min@(k = {{##} - #3, {##} + #3} & @@@ l), M = Max@k},
 {y, m, M}
]

Python 3.3 ( 183 177 164 160 byte)

B=list(map(eval,input().split()))
print("".join(" ## "[sum(any(r*r>(x-d%80/4+10)**2+(y+d//80/4-10)**2for
x,y,r in B)for d in[i,i+1,i+80])]for i in range(6400)))

Nó đòi hỏi một giao diện điều khiển rộng 80 ký tự, mà tôi biết là mặc định trong Windows. Nó hoạt động tốt nhất nếu bảng điều khiển của bạn có một phông chữ vuông. Dưới đây là một số trích đoạn từ một số đầu vào thử nghiệm.

Nguyên:

           ########
          ##       #
         ##         #
     #####          #
    ##   #          #
   ##               #
  ##                #
 ##                 #
 #                  #
 #                 ##
  #               ##
  #       ##      #
   #      # #    ##
   #      #  #####
   #      #
    #    ##
     #  ##
      ###

Khác:

    ########
  ###       ##
 ##           #
 #            #
##             #
#              #
#              #
#              #
#              #
#               ##
#                 #
 #                 ##
 #                   ######
  #                        #
   ##      ###             #
     #    ## #             #
     #    #  #             #
      #  ## ##             #
       ###  #             ##
            #       #######
            #      ##
            #      #
             #    ##
              #####

Hố:

                              ############
                            ###           ##
                          ###               ##
                         ##                   #
                  ########                     #######
                ###                                   ##
              ###                                       ##
             ##                                           #
            ##                                             #
           ##                                               #
          ##                                                 #
         ##                                                   #
        ##                                                     #
       ##                                                       #
      ##                                                         #
      #                                                          #
     ##                                                           #
     #                                                            #
    ##                                                             #
    #                                                              #
    #                                                              #
    #                                                              #
    #                                                              #
    #                                                              #
    #                                                              #
   ##                                                               #
  ##                                                                 #
  #                                                                  #
 ##                                                                   #
 #                                                                    #
##                                                                     #
#                                 ####                                 #
#                                ##   #                                #
#                               ##     #                               #
#                              ##       #                              #
#                              #        #                              #
#                              #        #                              #
#                               #      ##                              #
#                                #    ##                               #
#                                 #  ##                                #
#                                  ###                                 #
 #                                                                    ##
 #                                                                    #
  #                                                                  ##
  #                                                                  #
   #                                                                ##
    #                                                              ##
    #                                                              #
    #                                                              #
    #                                                              #
    #                                                              #
    #                                                              #
    #                                                              #
     #                                                            ##
     #                                                            #
      #                                                          ##
      #                                                          #
       #                                                        ##
        #                                                      ##
         #                                                    ##
          #                                                  ##
           #                                                ##
            #                                              ##
             #                                            ##
              #                                          ##
               ##                                      ###
                 ##                                  ###
                   #######                    ########
                          #                  ##
                           ##              ###
                             ##          ###
                               ###########

Con trăn - 253 249 215 199

Đây là một quảng cáo cho thư viện tạo hình tuyệt vời , với các thao tác hình học đã thực hiện việc viết giải pháp một cách đơn giản bằng cách vẽ (các) phác thảo của sự kết hợp các vòng tròn chồng chéo (= điểm đệm):

from pylab import*
from shapely.geometry import*
c=Point()
for s in raw_input().split():
 x,y,r=eval(s)
 c=c.union(Point(x,y).buffer(r))
plot(*c.exterior.xy)
for i in c.interiors:
 plot(*i.xy)
show()

Đầu ra:

Chỉnh sửa:

• 249: Được thay thế sys.argv[1:]bởi raw_input().split(), lưu mộtimport sys
• 215: Loại bỏ sự k={'color':'k'}sang trọng, thay thế savefigbằngshow
• 199: Thay thế map(float,s.split(','))bởieval(s)

Con trăn - 535

import math as m
import matplotlib.pyplot as l
c = "3,1,1 3,2,1.5 1,2,0.7 0.9,1.2,1.2 1,0,0.8"
a = [[float(y) for y in x.split(",")] for x in c.split(" ")]
for a2 in a:
    for x in xrange(0,200):
        q=x*m.pi/100.0
        p=(a2[0]+m.sin(q)*a2[2], a2[1]+m.cos(q)*a2[2])
        cc = []
        for z in a:            
            if z != a2:               
                if ((z[0] - p[0]) ** 2 + (z[1] - p[1]) ** 2 ) < (z[2] ** 2) :
                    cc.append(z)
        if not cc: 
            l.scatter(p[0],p[1])
l.show()

Con trăn - 296 249 231 223 212

from pylab import*
a=map(eval,raw_input().split())
for x,y,r in a:
 for i in range(200):
  q=i*pi/100;p=x+r*sin(q);t=y+r*cos(q);[z for z in a if z!=(x,y,r)and(z[0]-p)**2+(z[1]-t)**2<z[2]**2]or scatter(p,t)
show()

Tín dụng được chuyển đến @ richard-green (đã được cấp phép) cho giải pháp ban đầu, tôi vừa mới đưa nó xuống một chút.

JavaScript (E6) + HTML 322

Câu đố

Mỗi vòng tròn được chia thành khoảng 100 vòng cung nhỏ và mỗi cung được vẽ nếu điểm giữa của nó không nằm trong bất kỳ vòng tròn nào khác.

<canvas id='c'/>
<script>
t=c.getContext("2d"),z=99,c.width=c.height=400,
l=prompt().split(' ').map(c=>c.split(',').map(v=>40*v)),
l.map(c=>{
  for(i=z;--i+z;)
    s=4/z,r=c[2],x=c[0]+r*Math.cos(a=i*s),y=c[1]+r*Math.sin(a),
    t.beginPath(),
    l.some(q=>c!=q&(d=x-q[0],e=y-q[1],d*d+e*e<q[2]*q[2]))||t.arc(z+c[0],z+c[1],r,a-s,a+s),
    t.stroke()
})
</script>

Python 274 byte

Thao tác này sẽ nhập dữ liệu từ stdin và kiểm tra từng điểm trên màn hình, vẽ từng pixel một. Không chính xác hiệu quả nhưng nó tuân theo tất cả các quy tắc.

c=[eval(s)for s in raw_input().split()]
import pygame
S=pygame.display.set_mode((500,500))
S.fill([255]*3)
for p in((x,y)for x in range(500)for y in range(500)if 0<min((((x-250)/25.-a)**2+((y-250)/25.-b)**2)**.5-r for(a,b,r)in c)<.1):S.set_at(p,[0]*3)
pygame.display.update()

Lưu ý rằng màn hình pygame sẽ chấm dứt ngay khi bản vẽ hoàn thành, tôi không chắc mình có nên đưa nó vào như một phần câu trả lời của mình không nhưng để xem nó, bạn có thể ném raw_inputvào cuối hoặc thêm một vòng lặp nếu bạn muốn ngăn hệ điều hành phàn nàn về việc nó không phản hồi và như vậy:

alive = True
while alive:
    pygame.display.update()
    for e in pygame.event.get():
        if e.type == pygame.QUIT:
            alive = False

Hình ảnh ví dụ:

1,4,2 5,2,1 3,1,1 3.5,2,1.2 3,3,0.7, 1,2,0.7

0,5,4 3,4,4 4,3,4 5,0,4 4,-3,4 3,-4,4 0,-5,4 -3,-4,4 -4,-3,4 -5,0,4 -4,3,4 -3,4,4

Perl - 430

@e=map{[map{int($_*32)}split',']}(split' ',<>);for$g(@e){for(0..3){($a[$_]>($q=$$g[$_&1]+(($_>>1)*2-1)*$$g[2]))^($_>>1)&&($a[$_]=$q)}}for(2,3){$a[$_]-=$a[$_-2]-1}for(@e){($x,$y,$r)=@$_;$x-=$a[0];$y-=$a[1];for$k($x-$r..$x+$r){for$l($y-$r..$y+$r){$i=(int(sqrt(($x-$k)**2+($y-$l)**2)+0.5)<=>$r)-1;$f[$l][$k]=($j=$f[$l][$k])<-1||$i<-1?-2:$i||$j;}}}print"P1
$a[2] $a[3]
".join("
",map{join' ',map{$_+1?0:1}@$_,('0')x($a[2]-@$_)}@f)."
"

Viết một tập tin pbm vào thiết bị xuất chuẩn.

Hình ảnh thử nghiệm (được chuyển đổi thành png):