Biorąc pod uwagę współrzędne centrów i promienie 2 okręgów, wyprowadzaj prawdziwą wartość, czy się pokrywają, czy nie.

Wkład

• Dane wejściowe mogą być pobierane przez STDIN lub równoważne argumenty funkcji, ale nie jako zmienna. Możesz je traktować jako pojedynczą zmienną (listę, łańcuch itp.) Lub jako wiele danych wejściowych / argumentów, w dowolnej kolejności.

• Dane wejściowe będą wynosić sześć liczb zmiennoprzecinkowych. Te liczby zmiennoprzecinkowe będą miały maksymalnie 3 miejsca po przecinku. Współrzędne mogą być dodatnie lub ujemne. Promienie będą dodatnie.

Wydajność

• Wyjście może być przez STDOUT lub powrót funkcji.

• Program musi mieć dokładnie 2 różne wyniki - jeden dla wartości True (koła nakładają się) i jeden dla False (nie nakładają się).

Przypadki testowe

(Dane wejściowe są podawane jako lista krotek [(x1, y1, r1), (x2, y2, r2)]dla przypadków testowych; dane wejściowe można przyjmować w dowolnym formacie)

Prawdziwe

[(5.86, 3.92, 1.670), (11.8, 2.98, 4.571)]
[(8.26, -2.72, 2.488), (4.59, -2.97, 1.345)]
[(9.32, -7.77, 2.8), (6.21, -8.51, 0.4)]

Fałszywe

[(4.59, -2.97, 1.345), (11.8, 2.98, 4.571)]
[(9.32, -7.77, 2.8), (4.59, -2.97, 1.345)]
[(5.86, 3.92, 1.670), (6.21, -8.51, 0.4)]

To jest Code Golf, wygrywa najkrótsza odpowiedź w bajtach.

Galaretka , 5 bajtów

IA<S}

Traktuje dwie liczby zespolone (centra) jako pierwszy argument i dwie liczby rzeczywiste (promienie) jako drugi argument.

Wypróbuj online!

Jak to działa

IA<S}  Main link.
       Left argument:  [x1 + iy1, x2 + iy2]
       Right argument: [r1, r2]

I      Increments; yield (x2 - x1) + i(y2 - y1).
 A     Absolute value; yield √((x2 - x1)² + (y2 - y1)²).
   S}  Take the sum of the right argument, yielding r1 + r2.
  <    Compare the results.

JavaScript (ES6), 38 bajtów

Przyjmuje dane wejściowe jako 6 różnych zmiennych x1 , y1 , r1 , x2 , y2 , r2 .

(x,y,r,X,Y,R)=>Math.hypot(x-X,y-Y)<r+R

Przypadki testowe

let f =

(x,y,r,X,Y,R)=>Math.hypot(x-X,y-Y)<r+R

// True
console.log(f(5.86, 3.92, 1.670, 11.8, 2.98, 4.571))
console.log(f(8.26, -2.72, 2.488, 4.59, -2.97, 1.345))
console.log(f(9.32, -7.77, 2.8, 6.21, -8.51, 0.4))

// False
console.log(f(4.59, -2.97, 1.345, 11.8, 2.98, 4.571))
console.log(f(9.32, -7.77, 2.8, 4.59, -2.97, 1.345))
console.log(f(5.86, 3.92, 1.670, 6.21, -8.51, 0.4))

Pyth, 5 bajtów

gsE.a

Format wejściowy:

[x1, y1], [x2, y2]
r1, r2

Wypróbuj online

Jak to działa

     Q   autoinitialized to eval(input())
   .a    L2 norm of vector difference of Q[0] and Q[1]
gsE      sum(eval(input()) >= that

MATL , 5 bajtów

ZPis<

Format wejściowy to:

[x1, y1]
[x2, y2]
[r1, r2]

Wypróbuj online!Lub sprawdź wszystkie przypadki testowe .

Jak to działa

ZP   % Take two vectors as input. Push their Euclidean distance
i    % Input the vector of radii
s    % Sum of vector
<    % Less than?

R , 39 bajtów

function(k,r)dist(matrix(k,2,2))<sum(r)

przyjmuje dane wejściowe k=c(x1,x2,y1,y2)i r=c(r1,r2); zwraca FALSEdla okręgów stycznych.

Wypróbuj online!

27 bajtów:

function(m,r)dist(m)<sum(r)

Pobiera dane wejściowe jako macierz z centrami okręgu podanymi jako rzędy i wektorem promieni.

Wypróbuj online!

Python , 40 bajtów

lambda x,y,r,X,Y,R:abs(x-X+(y-Y)*1j)<r+R

Wypróbuj online!

Wykorzystuje złożoną arytmetykę Pythona do obliczania odległości między dwoma centrami. Zakładam, że nie możemy traktować punktów wejściowych bezpośrednio jako liczb zespolonych, więc kod wyraża je w ten sposób x+y*1j.

Python 3 , 45 bajtów

lambda X,Y,R,x,y,r:(X-x)**2+(Y-y)**2<(R+r)**2

Wypróbuj online!

05AB1E , 6 bajtów

αs--0›

Wypróbuj online!

-1 bajt przy użyciu a - b > 0zamiast(reverse) b - a < 0

Python 3 , 45 bajtów

lambda a,b,c,d,e,f:(a-d)**2+(b-e)**2<(c+f)**2

Wypróbuj online!

-8 bajtów dzięki Neil / Step Hen

APL (Dyalog) , 10 bajtów

Monituje o środki okręgu jako listę dwóch liczb zespolonych, a następnie o promienie jako listę dwóch liczb

(+/⎕)>|-/⎕

Wypróbuj online!

(+/⎕) [jest] sumą promieni

> Lepszy niż

| wielkość

-/⎕ różnica w centrach

Mathematica, 16 bajtów

Norm[#-#2]<+##3&

Wkład: [{x1, y1}, {x2, y2}, r1, r2]

Mathematica ma RegionIntersectionwbudowaną funkcję , ale sama w sobie ma 18 bajtów ...

Wersja wbudowana:

RegionIntersection@##==EmptyRegion@2&

Zabiera 2 Diskprzedmioty. [Disk[{x1, y1}, r1], Disk[{x2, y2}, r2]].

Haskell , 37 36 bajtów

(u#v)r x y s=(u-x)^2+(v-y)^2<(r+s)^2

Wypróbuj online!

Dzięki @AndersKaseorg za -1bajt!

Galaretka , 12 bajtów

I²+⁴I²¤<⁵S²¤

Wypróbuj online!

-2 bajty dzięki Dennisowi

Java (OpenJDK 8) , 38 bajtów

(a,b,c,x,y,z)->Math.hypot(a-x,b-y)<c+z

Wypróbuj online!

Java 8, 41 38 bajtów

(x,y,r,X,Y,R)->Math.hypot(x-X,y-Y)<r+R

Wypróbuj tutaj.

Najwyraźniej Java też ma Math.hypot , czyli 3 bajty krócej.

EDYCJA: Właśnie zdałem sobie sprawę, że ta odpowiedź jest teraz dokładnie taka sama jak odpowiedź Java 8 autorstwa OlivierGrégoire , więc proszę głosować na niego zamiast mnie, jeśli podoba ci się odpowiedź 38-bajtowa.

Stara odpowiedź (41 bajtów) :

(x,y,r,X,Y,R)->(x-=X)*x+(y-=Y)*y<(r+=R)*r

Wypróbuj tutaj.

Pyth , 15 bajtów

<sm^-EE2 2^+EE2

Przyjmuje dane wejściowe w kolejności x1, x2, y1, y2, r1, r2

Zestaw testowy!

Perl 6 , 13 bajtów

*+*>(*-*).abs

Wypróbuj online!

Pierwsze dwa argumenty to promienie, w dowolnej kolejności. Trzeci i czwarty argument to współrzędne centrów, jako liczby zespolone, w dowolnej kolejności.

Taxi , 1582 bajtów

Go to Post Office:w 1 l 1 r 1 l.Pickup a passenger going to The Babelfishery.Pickup a passenger going to Tom's Trims.Pickup a passenger going to Tom's Trims.Go to Tom's Trims:n.[a]Go to Post Office:s.Pickup a passenger going to The Babelfishery.Go to The Babelfishery:s 1 l 1 r.Pickup a passenger going to What's The Difference.Pickup a passenger going to What's The Difference.Go to What's The Difference:n 5 l.Pickup a passenger going to Cyclone.Go to Cyclone:e 1 r.Pickup a passenger going to Multiplication Station.Pickup a passenger going to Multiplication Station.Go to Multiplication Station:s 1 l 2 r 4 l.Pickup a passenger going to Addition Alley.Go to Tom's Trims:s 1 r 3 r.Pickup a passenger going to The Babelfishery.Switch to plan "b" if no one is waiting.Switch to plan "a".[b]Go to Addition Alley:n 1 r 1 l 3 l 1 l.Pickup a passenger going to Magic Eight.Go to Post Office:n 1 r 1 r 3 r 1 l.Pickup a passenger going to The Babelfishery.Go to The Babelfishery:s 1 l 1 r.Pickup a passenger going to Addition Alley.Pickup a passenger going to Addition Alley.Go to Addition Alley:n 5 l 1 l.Pickup a passenger going to Cyclone.Go to Cyclone:n 1 l 1 l.Pickup a passenger going to Multiplication Station.Pickup a passenger going to Multiplication Station.Go to Multiplication Station:s 1 l 2 r 4 l.Pickup a passenger going to Magic Eight.Go to Magic Eight:s 1 r.Switch to plan "c" if no one is waiting.'1' is waiting at Writer's Depot.[c]'0' is waiting at Writer's Depot.Go to Writer's Depot:w 1 l 2 l.Pickup a passenger going to Post Office.Go to Post Office:n 1 r 2 r 1 l.

Wypróbuj online!

Dane wyjściowe 1dla nakładających się kręgów.
Dane wyjściowe 0dla niezachodzących na siebie okręgów (w tym okręgów stycznych).

Niegolfowane / sformatowane:

Go to Post Office: west 1st left 1st right 1st left.
Pickup a passenger going to The Babelfishery.
Pickup a passenger going to Tom's Trims.
Pickup a passenger going to Tom's Trims.
Go to Tom's Trims: north.
[a]
Go to Post Office: south.
Pickup a passenger going to The Babelfishery.
Go to The Babelfishery: south 1st left 1st right.
Pickup a passenger going to What's The Difference.
Pickup a passenger going to What's The Difference.
Go to What's The Difference: north 5th left.
Pickup a passenger going to Cyclone.
Go to Cyclone: east 1st right.
Pickup a passenger going to Multiplication Station.
Pickup a passenger going to Multiplication Station.
Go to Multiplication Station: south 1st left 2nd right 4th left.
Pickup a passenger going to Addition Alley.
Go to Tom's Trims: south 1st right 3rd right.
Pickup a passenger going to The Babelfishery.
Switch to plan "b" if no one is waiting.
Switch to plan "a".
[b]
Go to Addition Alley: north 1st right 1st left 3rd left 1st left.
Pickup a passenger going to Magic Eight.
Go to Post Office: north 1st right 1st right 3rd right 1st left.
Pickup a passenger going to The Babelfishery.
Go to The Babelfishery: south 1st left 1st right.
Pickup a passenger going to Addition Alley.
Pickup a passenger going to Addition Alley.
Go to Addition Alley: north 5th left 1st left.
Pickup a passenger going to Cyclone.
Go to Cyclone: north 1st left 1st left.
Pickup a passenger going to Multiplication Station.
Pickup a passenger going to Multiplication Station.
Go to Multiplication Station: south 1st left 2nd right 4th left.
Pickup a passenger going to Magic Eight.
Go to Magic Eight: south 1st right.
Switch to plan "c" if no one is waiting.
'1' is waiting at Writer's Depot.
[c]
'0' is waiting at Writer's Depot.
Go to Writer's Depot: west 1st left 2nd left.
Pickup a passenger going to Post Office.
Go to Post Office: north 1st right 2nd right 1st left.

C #, 50 41 bajtów

(x,y,r,X,Y,R)=>(x-=X)*x+(y-=Y)*y<(r+=R)*r

Zaoszczędź 9 bajtów dzięki @KevinCruijssen.

Scala , 23 bajty

Dzięki @Arnauld za jego prawie poliglotyczną odpowiedź .

math.hypot(a-x,b-y)<r+q

Wypróbuj online!

PostgreSQL, 41 znaków

prepare f(circle,circle)as select $1&&$2;

Przygotowana instrukcja przyjmuje dane wejściowe jako 2 parametry w dowolnej circlenotacji .

Przykładowy przebieg:

Tuples only is on.
Output format is unaligned.
psql (9.6.3, server 9.4.8)
Type "help" for help.

psql=# prepare f(circle,circle)as select $1&&$2;
PREPARE

psql=# execute f('5.86, 3.92, 1.670', '11.8, 2.98, 4.571');
t

psql=# execute f('8.26, -2.72, 2.488', '4.59, -2.97, 1.345');
t

psql=# execute f('9.32, -7.77, 2.8', '6.21, -8.51, 0.4');
t

psql=# execute f('4.59, -2.97, 1.345', '11.8, 2.98, 4.571');
f

psql=# execute f('9.32, -7.77, 2.8', '4.59, -2.97, 1.345');
f

psql=# execute f('5.86, 3.92, 1.670', '6.21, -8.51, 0.4');
f

Java, 50 38 bajtów

(x,y,r,X,Y,R)->Math.hypot(x-X,y-Y)<r+R

Kod maszynowy x86 (z SSE2), 36 bajtów

; bool CirclesOverlap(double x1, double y1, double r1,
;                     double x2, double y2, double r2);
F2 0F 5C C3        subsd   xmm0, xmm3      ; x1 - x2
F2 0F 5C CC        subsd   xmm1, xmm4      ; y1 - y2
F2 0F 58 D5        addsd   xmm2, xmm5      ; r1 + r2
F2 0F 59 C0        mulsd   xmm0, xmm0      ; (x1 - x2)^2
F2 0F 59 C9        mulsd   xmm1, xmm1      ; (y1 - y2)^2
F2 0F 59 D2        mulsd   xmm2, xmm2      ; (r1 + r2)^2
F2 0F 58 C1        addsd   xmm0, xmm1      ; (x1 - x2)^2 + (y1 - y2)^2
66 0F 2F D0        comisd  xmm2, xmm0
0F 97 C0           seta    al              ; ((r1 + r2)^2) > ((x1 - x2)^2 + (y1 - y2)^2)
C3                 ret

Powyższa funkcja przyjmuje opisy dwóch okręgów (współrzędne xiy punktu środkowego i promienia) i zwraca wartość logiczną wskazującą, czy się przecinają.

Wykorzystuje konwencję wywoływania wektorów, w której parametry są przekazywane do rejestrów SIMD. W systemach Windows x86-32 i 64-bitowych jest to __vectorcallkonwencja wywoływania . W 64-bitowych systemów Unix / Linux / GNU, to jest standard wywoływania System V AMD64 konwencja .

Zwracana wartość jest pozostawiana w dolnym bajcie EAX, co jest standardem we wszystkich konwencjach wywoływania x86.

Ten kod działa równie dobrze na 32-bitowych i 64-bitowych procesorach x86, o ile obsługują one zestaw instrukcji SSE2 (którym byłby Intel Pentium 4 i nowsze wersje lub AMD Athlon 64 i nowsze wersje).

Wersja AVX, wciąż 36 bajtów

Jeśli celowałeś w AVX , prawdopodobnie chciałbyś dodać przedrostek VEX do instrukcji. Nie zmienia to liczby bajtów; tylko rzeczywiste bajty użyte do zakodowania instrukcji:

; bool CirclesOverlap(double x1, double y1, double r1,
;                     double x2, double y2, double r2);
C5 FB 5C C3      vsubsd   xmm0, xmm0, xmm3   ; x1 - x2
C5 F3 5C CC      vsubsd   xmm1, xmm1, xmm4   ; y1 - y2
C5 EB 58 D5      vaddsd   xmm2, xmm2, xmm5   ; r1 + r2
C5 FB 59 C0      vmulsd   xmm0, xmm0, xmm0   ; (x1 - x2)^2
C5 F3 59 C9      vmulsd   xmm1, xmm1, xmm1   ; (y1 - y2)^2
C5 EB 59 D2      vmulsd   xmm2, xmm2, xmm2   ; (r1 + r2)^2
C5 FB 58 C1      vaddsd   xmm0, xmm0, xmm1   ; (x1 - x2)^2 + (y1 - y2)^2
C5 F9 2F D0      vcomisd  xmm2, xmm0
0F 97 C0         seta     al                 ; ((r1 + r2)^2) > ((x1 - x2)^2 + (y1 - y2)^2)
C3               ret

Zalety instrukcji AVX polegają na przyjmowaniu trzech operandów, co pozwala na wykonywanie nieniszczących operacji, ale tak naprawdę nie pomaga nam to tutaj spakować kodu. Jednak mieszanie instrukcji z prefiksami VEX i bez nich może spowodować, że kod nie będzie optymalny, więc na ogół chcesz trzymać się wszystkich instrukcji AVX, jeśli celujesz w AVX, aw tym przypadku nawet nie zaszkodzi to twojej liczbie bajtów.

05AB1E , 10 bajtów

-¨nOt²¹+θ‹

Wypróbuj online!

PHP , 66 bajtów

<?php $i=$argv;echo hypot($i[1]-$i[4],$i[2]-$i[5])<$i[3]+$i[6]?:0;

Wypróbuj online!

Runs from the command line, taking input as 6 command-line parameter arguments, and prints 1 if the circles overlap, else 0.

Julia 0.6.0 (46 bytes)

a->((a[1]-a[2])^2+(a[3]-a[4])^2<(a[5]+a[6])^2)

Clojure, 68 bytes

#(<(+(*(- %4 %)(- %4 %))(*(- %5 %2)(- %5 %2)))(*(+ %6 %3)(+ %6 %3)))

Takes six arguments: x1, y1, r1, x2, y2, r2. Returns true or false.

Sadly, Clojure does not have a pow function of some sorts. Costs a lot of bytes.

Actually, 8 bytes

-)-(h@+>

Try it online!

Explanation:

-)-(h@+>  (implicit input: [y1, y2, x1, x2, r1, r2])
-         y2-y1 ([y2-y1, x1, x2, r1, r2])
 )-       move to bottom, x1-x2 ([x1-x2, r1, r2, y2-y1])
   (h     move from bottom, Euclidean norm ([sqrt((y2-y1)**2+(x2-x1)**2), r1, r2])
     @+   r1+r2 ([r1+r2, norm])
       >  is r1+r2 greater than norm?

R (+pryr), 31 bytes

pryr::f(sum((x-y)^2)^.5<sum(r))

Which evaluates to the function

function (x, y, z) 
sum((x - y)^2)^0.5 < sum(z)

Where x are the coordinates of circle 1, y are the coordinates of circle 2 and z the radii.

Calculates the distance between the two centers using Pythagoras and tests if that distance is smaller than the sum of the radii.

Makes use of R's vectorisation to simultaneously calculate (x1-x2)^2 and (y1-y2)^2. These are then summed and squarely rooted.

Go, 93 bytes

package q
import c "math/cmplx"
func o(a,b complex128,r,R float64)bool{return c.Abs(b-a)<r+R}

Fairly simple algorithm, same as several other answers, except it uses the built-in complex type and calls math/cmplx.Abs().

Taking the radii as complex numbers doesn't help, because the cast to float64 adds more bytes than the variable declaration saves (can't do float64 < complex128).

Try it online! Includes the test cases, and uses package main instead of a library.