리틀 챈들러는 슬프다. 그를 응원하기 위해 구름을 그립니다.
참고 : 구름을 그리는 것이 실제로 그를 응원하지는 않습니다.

원은 3- 튜플로 정의 될 수 직교 평면상의 원의 X 위치이고, 직교 평면상에서 원의 y 좌표이며, 원의 반경이다. 및 음수 일 수있다. 항상 긍정적입니다. 입력은 공백으로 분리 된 3 개의 튜플 형태의 원 목록입니다. 예를 들어 :(x,y,r)xyrxyr

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

3,1,1수단 "에 중심점 원 3,11 반경이. 3,2,1.5의 중심점 원 수단" 3,21.5 반경을.

이 입력의 모든 원을 그래프에 그리면 다음과 같이 보입니다 (명확성을 위해 그리드 선과 레이블을 포함했지만 필수는 아닙니다).

모든 원이 어떻게 응집되어 있는지 주목하십시오 . 즉, 그것들은 모두 겹치므로 작은 원 그룹이 나머지 그룹과 분리되지 않고 하나의 큰 그룹을 형성합니다. 입력은 응집력 이 보장 됩니다.

이제 우리는 다른 선들없이이 원들에 의해 형성된 "테두리"주위를 이동하는 선을 그립니다. 모든 원에 의해 형성된 실루엣의 테두리를 그리는 것과 같습니다. 결과 클라우드는 다음과 같습니다.

따라서이 구름은 경계를 형성하는 입력의 원호 만 그려 단일 모양으로 만들어졌습니다. 즉, 구름은 다른 원 안에 있지 않은 호만 그려서 형성됩니다. 프로그램은 위에서 설명한 형식으로 입력하고 결과 구름을 표시하는 이미지를 출력합니다. 구름의 전체적인 모양은 정확해야하지만 스케일, 색상, 선 두께 및 정점의 모양은 사용자에게 달려 있습니다. "이 프로그램은 흰 바탕에 흰 구름을 그립니다.", "이 프로그램은 무한히 작은 규모로 구름을 그립니다.", "이 프로그램은 0으로 구름을 그립니다. 경계선의 색은 채우기 또는 배경의 색과 달라야합니다.

또 다른 예. 입력:

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 

산출:

중요한 규칙은 다음과 같습니다. 프로그램은 경계를 형성하는 선만 그려야 합니다 . 즉, 단순히 원을 완전히 그릴 수 없으며 흰색 채우기로 원을 약간 작게 그릴 수는 없습니다.이 방법은 여전히 ​​경계를 형성하지 않는 선을 그립니다. 이 규칙의 목적은 "원을 그린 다음 흰색 채우기로 원을 다시 그립니다"구현 또는 이와 유사한 것을 방지하는 것이 었습니다. 대답은 실제로 그림을 그리기 전에 그림을 그릴 위치를 계산해야합니다.

이것은 코드 골프이므로 가장 짧은 문자 수가 이깁니다.

매쓰 177 126 121 119

디스크 영역으로 해결 : 수학자의 접근

논리는

• 내부가없는 서클 1 (R1)을 만듭니다.
• 원 경계없이 디스크 2 (R2)를 만듭니다.
• 영역 3을 만듭니다 (R3 = R1-R2).
-

이것이 바로 아래 접근 방식입니다. 위의 3 가지 수치를 생성했습니다.

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]

암시 적 영역 # 1은 원의 합집합입니다. 암시 적 영역 # 2는 원 안에있는 디스크의 결합입니다. 그들의 차이점은 국경입니다.

지역 차이 [
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}],
암시 적 지역 ​​[(-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}]]

디스크 영역 별 해결 : 엔지니어의 접근 방식 (119 자)

다음은 디스크 영역을 통합하여 해당 영역을 이산화하여 경계를 찾습니다. 다이어그램의 점은 들로네 메시의 간격을 나타냅니다. 관심 영역 (구름의 윤곽선)을 제공하는 객체를 강조하기 위해 아래에 이산화 된 영역을 표시합니다.

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"

지역 경계는 이산되어 있습니다.

가장자리 감지로 해결 : 사진 작가의 접근 방식-121 자

디스크를 검은 색으로 그리며 이미지를 래스터 화하고 가장자리를 감지하며 흑백으로 반전시킵니다.

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

T-SQL 235 234 229 212 171 73 바이트

이것은 SQL Server 2012+에서 공간 기능을 사용합니다. SSMS (SQL Server Management Studio)에서 실행될 때 공간 결과 창이 나타납니다. 입력은 변수 @i에서 온 것입니다. 입력을 테이블에서 가져올 수 있으면 더 줄일 수 있습니다.

이제 테이블 입력이 허용됩니다.

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

아래에 이전 솔루션을 남겼습니다.

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

편집 : 길 잃은 공간, 잉여 제거 에 와 하위 쿼리를

171 : 테이블 생성을 CTE로, @s를 @로 대체했습니다.

동적 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

매쓰, 175 (158) 149 바이트

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

샌드 박스 에서이 접근법이 유효하다고 가정 한 것을 기억하지만, 그것이 새로운 규칙에 어떻게 적용되는지는 확실하지 않으므로 @Lilac, 이것이 규칙을 위반한다고 생각되면 알려주십시오.

기본적으로 클라우드 내부의 모든 포인트에 대해 true이고 클라우드 외부의 모든 포인트에 대해 false 인 논리 조건을 만들고 있습니다. 나는 그 식을 공급 RegionPlot하여 표현이있는 모든 점의 영역과 True주변의 윤곽 을 렌더링 합니다.

언 골프 드 :

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

3.3 파이썬 ( 183 177 164 160 바이트)

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

80 문자 너비의 콘솔이 필요하며 Windows의 기본값입니다. 콘솔에 사각형 글꼴이있는 경우 가장 잘 작동합니다. 다음은 일부 테스트 입력에서 발췌 한 것입니다.

기발한:

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

다른:

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

구멍:

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

파이썬 - 253 249 215 199

이 멋진에 대한 광고입니다 매끈한 그 구조 작업 원 (= 버퍼 점) 중복 조합의 개요 (들)을 그림으로써 간단한 솔루션을 기록했다 라이브러리 :

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

산출:

편집 :

• 249 : 대체 sys.argv[1:]에 의해 raw_input().split()을 저장,import sys
• 215 : 제거 된 k={'color':'k'}대체 럭셔리, savefig에 의해show
• 199 : 대체 map(float,s.split(','))에 의해eval(s)

파이썬 – 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()

파이썬 – 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()

크레딧은 원래 솔루션에 대한 @ richard-green (권한이 주어짐)으로 이동합니다.

자바 스크립트 (E6) + HTML 322

JSFiddle

각 원은 약 100 개의 작은 호로 세분화되며 중간 점이 다른 원 안에 있지 않으면 각 호가 그려집니다.

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

파이썬 274 바이트

stdin에서 입력을 받아 디스플레이의 모든 지점을 확인하여 픽셀을 하나씩 그립니다. 정확하지는 않지만 모든 규칙을 준수합니다.

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

파이 게임 디스플레이는 그림이 완료되는 즉시 종료됩니다. 응답의 일부로 포함시켜야하는지 확실하지 않지만 그것을 보려면 raw_input끝 부분에 던지 거나 약간의 루프를 추가 할 수 있습니다 OS가 응답하지 않는 것에 대해 불평하는 것을 막고 싶습니다.

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

이미지 예 :

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

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

pbm 파일을 stdout에 씁니다.

테스트 이미지 (png로 변환) :