Chandler kecil sedih. Gambarkan dia awan untuk menghiburnya.
Catatan: Menggambar awan tidak akan benar-benar menghiburnya.

Lingkaran dapat didefinisikan sebagai 3-tupel di (x,y,r)mana xposisi x lingkaran pada bidang Cartesius, yadalah posisi y lingkaran pada bidang Cartesius, dan rmerupakan jari-jari lingkaran. xdan ymungkin negatif. rselalu positif. Input adalah daftar lingkaran dalam bentuk 3-tupel yang dipisahkan ruang. Misalnya:

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

The 3,1,1berarti "Sebuah lingkaran dengan titik pusat di 3,1dengan 1 jari-jari. 3,2,1.5Berarti" Sebuah lingkaran dengan titik pusat di 3,2dengan radius 1,5.

Jika kita menggambar semua lingkaran input pada grafik, sepertinya ini (saya sudah memasukkan garis kotak dan label untuk kejelasan saja; mereka tidak diperlukan):

Perhatikan bagaimana semua lingkaran itu kohesif . Yaitu, mereka semua tumpang tindih bersama sehingga membentuk satu kelompok besar tanpa kelompok lingkaran kecil yang terpisah dari yang lainnya. Masukan dijamin kohesif.

Misalkan sekarang kita menggambar garis yang bergerak di sekitar "perbatasan" yang dibentuk oleh lingkaran-lingkaran ini, tanpa garis lainnya. Itu akan seperti menggambar batas siluet yang dibentuk oleh semua lingkaran. Cloud yang dihasilkan akan terlihat seperti ini:

Jadi awan ini telah dibentuk dengan menggambar hanya busur lingkaran di input yang membentuk perbatasan, sehingga menghasilkan bentuk tunggal. Dengan kata lain, awan dibentuk dengan hanya menggambar busur yang tidak berada dalam lingkaran lain. Program Anda akan menerima input dalam bentuk yang dijelaskan di atas, dan menampilkan gambar yang menampilkan cloud yang dihasilkan. Bentuk keseluruhan awan harus benar, tetapi skala, warna, ketebalan garis, dan bagaimana tampilannya pada titik terserah Anda. Perhatikan bahwa cloud harus terlihat, sehingga Anda tidak dapat menarik sesuatu seperti "Program ini menggambar awan putih pada latar belakang putih", "Program ini menggambar cloud pada skala yang sangat kecil", "Program ini menggambar cloud dengan 0 ketebalan garis ", dll. Juga perhatikan bahwa warna batas harus berbeda dari warna isi atau latar belakang.

Contoh lain. Memasukkan:

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

Keluaran:

Jika ada "lubang" di awan, Anda harus menggambar lubang itu juga. Memasukkan:

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 

Keluaran:

Berikut ini aturan penting: program Anda harus hanya menggambar garis yang membentuk perbatasan. Ini berarti bahwa Anda TIDAK BISA menggambar lingkaran sepenuhnya, dan kemudian menggambar lingkaran sedikit lebih kecil dengan isian putih - karena metode itu masih menarik garis yang tidak membentuk perbatasan, itu hanya akan menutupi mereka setelah itu. Tujuan aturan ini adalah untuk mencegah implementasi "gambar lingkaran, lalu gambar lingkaran lagi dengan isian putih", atau yang serupa dengan itu. Jawabannya diharapkan benar-benar menghitung tempat menggambar sebelum menggambarnya.

Ini adalah kode golf, sehingga jumlah karakter terpendek menang.

Mathematica 177 126 121 119

Memecahkan dengan Wilayah Disk: pendekatan ahli matematika

Logikanya adalah untuk

• Buat Wilayah 1 (R1), lingkaran (tanpa interiornya);
• Buat Wilayah 2 (R2), disk (tanpa batas lingkaran).
• Buat Wilayah 3 (R3 = R1-R2).
-

Inilah tepatnya pendekatan yang diambil di bawah ini. Ini menghasilkan 3 angka di atas.

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]

Wilayah implisit # 1 adalah penyatuan lingkaran. Wilayah implisit # 2 adalah penyatuan disk yang terletak di dalam lingkaran. Perbedaan mereka adalah perbatasan.

Perbedaan Wilayah [
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}]]

Memecahkan berdasarkan Wilayah Disk: pendekatan insinyur (119 karakter)

Yang berikut ini mengambil penyatuan wilayah disk, mendiskritisasi wilayah itu, dan menemukan batasnya. Titik-titik dalam diagram membatasi interval mesh Delaunay. Kami menampilkan wilayah diskrit di bawah ini untuk menyorot objek yang memberikan batas minat (garis besar awan).

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"

Batas wilayah didiskritisasi.

Mengatasi dengan Mendeteksi Tepi: Pendekatan Fotografer - 121 karakter

Ini menarik disk menjadi hitam, rasterisasi gambar, mendeteksi tepi, dan membalikkan hitam dan putih.

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

T-SQL 235 234 229 212 171 73 bytes

Ini memanfaatkan fungsionalitas spasial di SQL Server 2012+. Ketika dijalankan di SSMS (SQL Server Management Studio) menghasilkan panel hasil spasial. Masukan dari variabel @i. Saya bisa menguranginya lebih jauh jika input bisa diambil dari tabel.

Karena input tabel sekarang diizinkan.

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

Saya telah meninggalkan solusi sebelumnya di bawah ini.

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(@)

Sunting : Hapus ruang liar, surplus menjadi dan subquery

171: Pembuatan tabel diganti dengan CTE dan @s dengan @.

Hancurkan SQL Dinamis

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

Mathematica, 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}]

Saya ingat dari diskusi di kotak pasir bahwa pendekatan ini seharusnya valid, tapi saya tidak sepenuhnya yakin bagaimana hal itu bisa terjadi dengan kata-kata baru dari aturan, jadi @Lilac, beri tahu saya jika menurut Anda ini melanggar aturan.

Pada dasarnya, saya membuat kondisi logis yang benar untuk semua titik di dalam cloud dan salah untuk semua titik di luarnya. Saya memberi makan itu RegionPlotyang kemudian merender wilayah semua titik di mana ekspresi Trueserta garis besar di sekitarnya.

Tidak Disatukan:

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

Ini membutuhkan konsol lebar 80 karakter, yang saya tahu adalah default di Windows. Ini bekerja paling baik jika konsol Anda memiliki font persegi. Berikut adalah beberapa kutipan dari beberapa input tes.

Asli:

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

Lain:

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

Lubang:

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

Python - 253 249 215 199

Ini adalah iklan untuk perpustakaan indah yang mengagumkan , yang operasi geometrinya membuat penulisan solusi dengan langsung dengan menggambar garis besar dari gabungan lingkaran yang tumpang tindih (= titik buffer):

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

Keluaran:

Edit:

• 249: Diganti sys.argv[1:]oleh raw_input().split(), menyimpan aimport sys
• 215: k={'color':'k'}Kemewahan yang dihapus , digantikan savefigolehshow
• 199: Digantikan map(float,s.split(','))oleheval(s)

Python - 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()

Python - 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()

Kredit pergi ke @ richard-green (izin diberikan) untuk solusi asli, saya baru saja mengecilkannya sedikit.

JavaScript (E6) + HTML 322

JSFiddle

Setiap lingkaran dibagi lagi menjadi sekitar 100 busur kecil, dan setiap busur digambar jika titik tengahnya tidak berada di dalam lingkaran lainnya.

<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

Ini mengambil input dari stdin dan memeriksa setiap titik pada tampilan, menggambar piksel satu per satu saat berjalan. Tidak persis efisien tetapi mengikuti semua aturan.

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

Perhatikan bahwa tampilan pygame akan berakhir segera setelah gambar selesai, saya tidak yakin apakah saya harus memasukkannya sebagai bagian dari jawaban saya tetapi untuk melihatnya Anda bisa memasukkan raw_inputdi akhir atau menambahkan sedikit lingkaran jika Anda ingin menghentikan OS dari mengeluh tentang hal itu tidak merespons dan semacamnya:

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

Contoh gambar:

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)."
"

Menulis file pbm ke stdout.

Gambar uji (dikonversi ke png):