Dadas las coordenadas de los centros y los radios de 2 círculos, genera un valor verdadero de si se superponen o no.

Entrada

• La entrada se puede tomar a través de STDIN o equivalente, argumentos de función, pero no como una variable. Puede tomarlos como una sola variable (lista, cadena, etc.) o como múltiples entradas / argumentos, en el orden que desee.

• La entrada será de seis flotadores. Estas carrozas serán de hasta 3 decimales. Las coordenadas pueden ser positivas o negativas. Los radios serán positivos.

Salida

• La salida puede ser a través de STDOUT o retorno de función.

• El programa debe tener exactamente 2 salidas distintas: una para un valor Verdadero (los círculos se superponen) y otra para una salida Falsa (no se superponen).

Casos de prueba

(La entrada se proporciona como una lista de tuplas [(x1, y1, r1), (x2, y2, r2)]para los casos de prueba; puede tomar la entrada en cualquier formato)

Cierto

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

Falso

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

Este es Code Golf, la respuesta más corta en bytes gana.

Jalea , 5 bytes

IA<S}

Toma dos números complejos (centros) como primer argumento y dos números reales (radios) como segundo argumento.

Pruébalo en línea!

Cómo funciona

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 bytes

Toma la entrada como 6 variables distintas x1 , y1 , r1 , x2 , y2 , r2 .

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

Casos de prueba

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 bytes

gsE.a

Formato de entrada:

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

Pruébalo en línea

Cómo funciona

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

MATL , 5 bytes

ZPis<

El formato de entrada es:

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

Pruébalo en línea! O verificar todos los casos de prueba .

Cómo funciona

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

R , 39 bytes

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

toma entrada k=c(x1,x2,y1,y2)y r=c(r1,r2); vuelve FALSEpara círculos tangentes.

Pruébalo en línea!

27 bytes:

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

Toma la entrada como una matriz con los centros del círculo dados como filas y un vector de radios.

Pruébalo en línea!

Python , 40 bytes

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

Pruébalo en línea!

Utiliza la aritmética compleja de Python para calcular la distancia entre los dos centros. Supongo que no podemos tomar los puntos de entrada directamente como números complejos, por lo que el código los expresa como x+y*1j.

Python 3 , 45 bytes

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

Pruébalo en línea!

05AB1E , 6 bytes

αs--0›

Pruébalo en línea!

-1 byte usando en a - b > 0lugar de(reverse) b - a < 0

Python 3 , 45 bytes

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

Pruébalo en línea!

-8 bytes gracias a Neil / Step Hen

APL (Dyalog) , 10 bytes

Solicita centros de círculo como lista de dos números complejos, luego radios como lista de dos números

(+/⎕)>|-/⎕

Pruébalo en línea!

(+/⎕) [es] la suma de los radios

> mas grande que

| la magnitud de

-/⎕ la diferencia en centros

Mathematica, 16 bytes

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

Entrada: [{x1, y1}, {x2, y2}, r1, r2]

Mathematica tiene una función RegionIntersectionincorporada, pero solo tiene 18 bytes de longitud ...

Versión incorporada:

RegionIntersection@##==EmptyRegion@2&

Toma 2 Diskobjetos. [Disk[{x1, y1}, r1], Disk[{x2, y2}, r2]].

Haskell , 37 36 bytes

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

Pruébalo en línea!

¡Gracias @AndersKaseorg por el -1byte!

Jalea , 12 bytes

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

Pruébalo en línea!

-2 bytes gracias a Dennis

Java (OpenJDK 8) , 38 bytes

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

Pruébalo en línea!

Java 8, 41 38 bytes

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

Pruébalo aquí

Aparentemente, Java también tiene Math.hypot, que es 3 bytes más corto.

EDITAR: Acabo de darme cuenta de que esta respuesta ahora es exactamente la misma que la respuesta de Java 8 de @ OlivierGrégoire , así que por favor, vota a él en lugar de a mí si te gusta la respuesta de 38 bytes.

Respuesta anterior (41 bytes) :

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

Pruébalo aquí

Pyth , 15 bytes

<sm^-EE2 2^+EE2

Toma entrada en el orden x1, x2, y1, y2, r1, r2

¡Banco de pruebas!

Perl 6 , 13 bytes

*+*>(*-*).abs

Pruébalo en línea!

Los dos primeros argumentos son los radios, en cualquier orden. Los argumentos tercero y cuarto son las coordenadas de los centros, como números complejos, en cualquier orden.

Taxi , 1582 bytes

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.

Pruébalo en línea!

Salidas 1para círculos superpuestos.
Salidas 0para círculos no superpuestos (incluidos círculos tangenciales).

Sin golf / formateado:

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 bytes

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

Guardado 9 bytes gracias a @KevinCruijssen.

Scala , 23 bytes

Gracias @Arnauld por su respuesta casi políglota .

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

Pruébalo en línea!

PostgreSQL, 41 caracteres

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

Declaración preparada, toma la entrada como 2 parámetros en cualquier circlenotación .

Ejecución de muestra:

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 bytes

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

Código de máquina x86 (con SSE2), 36 bytes

; 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

La función anterior acepta descripciones de dos círculos (coordenadas x e y del punto central y un radio) y devuelve un valor booleano que indica si se cruzan o no.

Utiliza una convención de llamada vectorial, donde los parámetros se pasan en registros SIMD. En x86-32 y Windows de 64 bits, esta es la __vectorcallconvención de llamada . En Unix / Linux / Gnu de 64 bits, esta es la convención de llamadas estándar de System V AMD64 .

El valor de retorno se deja en el byte bajo de EAX, como es estándar con todas las convenciones de llamadas x86.

Este código funciona igualmente bien en procesadores x86 de 32 bits y 64 bits, siempre que sean compatibles con el conjunto de instrucciones SSE2 (que sería Intel Pentium 4 y posterior, o AMD Athlon 64 y posterior).

Versión AVX, todavía 36 bytes

Si estaba apuntando a AVX , probablemente desee agregar un prefijo VEX a las instrucciones. Esto no cambia el recuento de bytes; solo los bytes reales utilizados para codificar las instrucciones:

; 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

Las instrucciones AVX tienen la ventaja de tomar tres operandos, lo que le permite realizar operaciones no destructivas, pero eso realmente no nos ayuda a compactar el código aquí. Sin embargo, mezclar instrucciones con y sin prefijos VEX puede resultar en un código subóptimo, por lo que generalmente desea seguir todas las instrucciones AVX si está apuntando a AVX, y en este caso, ni siquiera daña su conteo de bytes.

05AB1E , 10 bytes

-¨nOt²¹+θ‹

Pruébalo en línea!

PHP , 66 bytes

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

Pruébalo en línea!

Se ejecuta desde la línea de comando, tomando la entrada como 6 argumentos de parámetros de línea de comando, e imprime 1 si los círculos se superponen, de lo contrario 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)))

Toma seis argumentos: x1, y1, r1, x2, y2, r2. Devuelve verdadero o falso.

Lamentablemente, Clojure no tiene una powfunción de algún tipo. Cuesta muchos bytes.

En realidad , 8 bytes

-)-(h@+>

Pruébalo en línea!

Explicación:

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

Que evalúa la función

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

Donde xestán las coordenadas del círculo 1, yson las coordenadas del círculo 2 y zlos radios.

Calcula la distancia entre los dos centros usando Pitágoras y comprueba si esa distancia es menor que la suma de los radios.

Utiliza la vectorización de R para calcular simultáneamente (x1-x2)^2y (y1-y2)^2. Estos se suman y se enraizan.

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}

Algoritmo bastante simple, igual que varias otras respuestas, excepto que usa el tipo incorporado complexy llama a math / cmplx.Abs ().

Tomar los radios como números complejos no ayuda, porque la conversión a float64 agrega más bytes de los que la declaración de variables guarda (no puede hacer float64 < complex128).

Pruébalo en línea! Incluye los casos de prueba y utiliza el paquete principal en lugar de una biblioteca.