Der kleine Chandler ist traurig. Zeichne ihm eine Wolke, um ihn aufzuheitern.
Hinweis: Das Zeichnen einer Wolke wird ihn nicht wirklich aufheitern.

Ein Kreis kann als 3-Tupel definiert werden, (x,y,r)wobei xdie x-Position des Kreises auf einer kartesischen Ebene, ydie y-Position des Kreises auf einer kartesischen Ebene und rder Radius des Kreises ist. xund ykann negativ sein. rist immer positiv. Die Eingabe ist eine Liste von Kreisen in Form von durch Leerzeichen getrennten 3-Tupeln. Zum Beispiel:

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

Das 3,1,1bedeutet "Ein Kreis mit Mittelpunkt bei 3,1mit 1 Radius. 3,2,1.5" Ein Kreis mit Mittelpunkt bei 3,2mit 1,5 Radius.

Wenn wir alle diese Kreise der Eingabe in einem Diagramm zeichnen, sieht es so aus (ich habe nur zur Verdeutlichung Gitterlinien und Beschriftungen eingefügt; diese sind nicht erforderlich):

Beachten Sie, wie alle Kreise zusammenhängend sind . Das heißt, sie sind alle so überlappt, dass sie eine große Gruppe bilden, ohne dass kleine Gruppen von Kreisen vom Rest getrennt sind. Die Eingabe ist garantiert kohäsiv.

Nehmen wir nun an, wir zeichnen eine Linie, die um die von diesen Kreisen gebildete "Grenze" verläuft, ohne eine der anderen Linien. Es wäre, als würde man den Rand der Silhouette zeichnen, die von allen Kreisen gebildet wird. Die resultierende Wolke würde ungefähr so ​​aussehen:

Diese Wolke wurde also gebildet, indem nur die Bögen der Kreise in der Eingabe gezeichnet wurden, die eine Grenze bilden, was zu einer einzigen Form führte. Mit anderen Worten, die Wolke wird gebildet, indem nur die Bögen gezeichnet werden, die sich nicht innerhalb eines anderen Kreises befinden. Ihr Programm nimmt Eingaben in der oben erläuterten Form auf und gibt ein Bild aus, das die resultierende Wolke anzeigt. Die Gesamtform der Wolke muss korrekt sein, aber der Maßstab, die Farbe, die Linienstärke und das Aussehen der Scheitelpunkte liegen bei Ihnen. Beachten Sie, dass die Wolke sichtbar sein muss, damit Sie nichts wie "Dieses Programm zeichnet eine weiße Wolke auf einem weißen Hintergrund", "Dieses Programm zeichnet eine Wolke in einem infinitesimal kleinen Maßstab", "Dieses Programm zeichnet eine Wolke mit 0" ziehen können Strichstärke "usw. Beachten Sie außerdem, dass sich die Farbe des Rahmens von der Farbe der Füllung oder des Hintergrunds unterscheiden muss.

Ein anderes Beispiel. Eingang:

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

Ausgabe:

Wenn es ein "Loch" in der Wolke gibt, sollten Sie das Loch auch zeichnen. Eingang:

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 

Ausgabe:

Hier ist eine wichtige Regel: Ihr Programm darf nur die Linien zeichnen , die den Rand bilden. Das bedeutet, dass Sie die Kreise NICHT einfach vollständig und dann mit einer weißen Füllung etwas kleiner zeichnen können - da bei dieser Methode immer noch Linien gezeichnet werden, die keinen Rand bilden, werden sie anschließend nur überdeckt. Der Zweck der Regel bestand darin, zu verhindern, dass Implementierungen wie "Kreise zeichnen, dann Kreise mit weißer Füllung erneut zeichnen" oder ähnliches implementiert werden. Es wird erwartet, dass die Antwort tatsächlich berechnet, wo die Dinge gezeichnet werden sollen, bevor sie gezeichnet werden.

Dies ist Codegolf, also gewinnt die kürzeste Anzahl an Zeichen.

Mathematica 177 126 121 119

Lösen nach Datenträgerregionen: der Ansatz des Mathematikers

Die Logik ist zu

• Erstelle Region 1 (R1), die Kreise (ohne ihre Innenräume);
• Erstellen Sie Region 2 (R2), die Datenträger (ohne die Kreisränder).
• Bereich 3 erstellen (R3 = R1-R2).
-

Dies ist genau der Ansatz, der im Folgenden verfolgt wird. Es wurden die 3 obigen Zahlen erstellt.

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]

Implizite Region # 1 ist die Vereinigung der Kreise. Der implizite Bereich # 2 ist die Vereinigung der in den Kreisen liegenden Scheiben. Ihr Unterschied ist die Grenze.

RegionDifference [
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}]]

Lösen nach Festplattenregionen: der Ansatz des Ingenieurs (119 Zeichen)

Im Folgenden wird die Vereinigung der Festplattenregionen herangezogen, diese Region diskretisiert und ihre Grenze ermittelt. Die Punkte im Diagramm markieren die Intervalle des Delaunay-Netzes. Wir zeigen den diskretisierten Bereich unten an, um das Objekt hervorzuheben, das die interessierende Grenze bildet (den Umriss der Wolke).

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

Die Bereichsgrenze wird diskretisiert.

Lösen durch Erkennen von Kanten: Der Ansatz des Fotografen - 121 Zeichen

Es zeichnet die Datenträger in Schwarz, rastert das Bild, erkennt die Ränder und kehrt Schwarzweiß um.

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

T-SQL 235 234 229 212 171 73 Bytes

Dies nutzt räumliche Funktionen in SQL Server 2012+. Wenn es in SSMS (SQL Server Management Studio) ausgeführt wird, wird ein räumlicher Ergebnisbereich erstellt. Die Eingabe erfolgt von der Variablen @i. Ich könnte es weiter reduzieren, wenn die Eingabe aus einer Tabelle entnommen werden könnte.

Da Tabelleneingabe jetzt erlaubt ist.

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

Ich habe die vorherige Lösung unten gelassen.

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

Bearbeiten : Entfernen Sie den Streuraum , den Überschuss in und die Unterabfrage

171: Tabellenerstellung durch CTE und @s durch @ ersetzt.

Aufschlüsselung des Dynamic SQL

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 Bytes

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

Ich erinnere mich an die Diskussion in der Sandbox, dass dieser Ansatz gültig sein sollte, aber ich bin mir nicht ganz sicher, wie er mit dem neuen Wortlaut der Regeln übereinstimmt. Also, @Lilac, lassen Sie mich wissen, wenn Sie glauben, dass dies gegen die Regeln verstößt.

Grundsätzlich erstelle ich eine logische Bedingung, die für alle Punkte innerhalb der Wolke wahr und für alle Punkte außerhalb der Wolke falsch ist. Ich füttere das, RegionPlotworaufhin der Bereich aller Punkte, an denen der Ausdruck ist True, sowie ein Umriss um ihn herum gerendert wird.

Ungolfed:

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

Es erfordert eine 80 Zeichen breite Konsole, von der ich weiß, dass sie die Standardeinstellung in Windows ist. Es funktioniert am besten, wenn Ihre Konsole eine quadratische Schrift hat. Hier einige Auszüge aus einigen Testeingaben.

Original:

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

Ein weiterer:

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

Loch:

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

Python - 253 249 215 199

Dies ist eine Werbung für die großartige, formschöne Bibliothek, deren Geometrieoperationen das Schreiben der Lösung durch Zeichnen der Umrisse der Vereinigung von überlappenden Kreisen (= gepufferten Punkten) vereinfacht haben:

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

Ausgabe:

Bearbeiten:

• 249: Ersetzt sys.argv[1:]durch raw_input().split()Speichern von aimport sys
• 215: k={'color':'k'}Luxus entfernt, ersetzt savefigdurchshow
• 199: Ersetzt map(float,s.split(','))durcheval(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()

Die ursprüngliche Lösung wurde an @ richard-green (Erlaubnis wurde erteilt) gutgeschrieben. Ich habe sie nur ein wenig heruntergeschraubt.

JavaScript (E6) + HTML 322

JSFiddle

Jeder Kreis ist in ungefähr 100 kleine Bögen unterteilt, und jeder Bogen wird gezeichnet, wenn sein Mittelpunkt nicht in einem der anderen Kreise liegt.

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

Dies nimmt die Eingabe von stdin entgegen und überprüft jeden Punkt auf der Anzeige, wobei die Pixel nacheinander gezeichnet werden. Nicht gerade effizient, aber es folgt allen Regeln.

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

Beachten Sie, dass die Pygame-Anzeige beendet wird, sobald die Zeichnung fertig ist. Ich war mir nicht sicher, ob ich sie als Teil meiner Antwort einschließen sollte, aber um sie anzuzeigen, können Sie entweder raw_inputam Ende einwerfen oder eine kleine Schleife hinzufügen, wenn Sie möchten möchte das Betriebssystem daran hindern, sich darüber zu beschweren, dass es nicht reagiert, und so weiter:

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

Beispielbilder:

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

Schreibt eine pbm-Datei nach stdout.

Testbild (in PNG konvertiert):