Dadas as coordenadas dos centros e os raios de 2 círculos, produza um valor verdadeiro de que elas se sobrepõem ou não.

Entrada

• A entrada pode ser obtida via STDIN ou argumentos de função equivalentes, mas não como uma variável. Você pode tomá-los como uma única variável (lista, string etc.) ou como várias entradas / argumentos, na ordem que desejar.

• A entrada será seis carros alegóricos. Esses carros alegóricos terão até três casas decimais. As coordenadas podem ser positivas ou negativas. Os raios serão positivos.

Saída

• A saída pode ser via STDOUT ou retorno de função.

• O programa deve ter exatamente 2 saídas distintas - uma para um valor True (os círculos se sobrepõem) e outra para uma saída False (elas não se sobrepõem).

Casos de teste

(A entrada é fornecida como uma lista de tuplas [(x1, y1, r1), (x2, y2, r2)]para os casos de teste; você pode receber entradas em qualquer formato)

Verdade

[(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 é o Code Golf, a resposta mais curta em bytes ganha.

Geléia , 5 bytes

IA<S}

Toma dois números complexos (centros) como primeiro argumento e dois números reais (raios) como segundo argumento.

Experimente online!

Como 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

Aceita entrada como 6 variáveis ​​distintas x1 , y1 , r1 , x2 , y2 , r2 .

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

Casos de teste

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

Pitão, 5 bytes

gsE.a

Formato de entrada:

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

Experimente online

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

O formato de entrada é:

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

Experimente online! Ou verifique todos os casos de teste .

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

recebe entrada k=c(x1,x2,y1,y2)e r=c(r1,r2); retorna FALSEpara círculos tangentes.

Experimente online!

27 bytes:

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

Recebe entrada como uma matriz com os centros dos círculos dados como linhas e um vetor de raios.

Experimente online!

Python , 40 bytes

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

Experimente online!

Usa a aritmética complexa do Python para calcular a distância entre os dois centros. Estou assumindo que não podemos pegar os pontos de entrada diretamente como números complexos, então o código os expressa como x+y*1j.

Python 3 , 45 bytes

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

Experimente online!

05AB1E , 6 bytes

αs--0›

Experimente online!

-1 byte usando em a - b > 0vez 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

Experimente online!

-8 bytes graças a Neil / Step Hen

APL (Dyalog) , 10 bytes

Solicita centros circulares como lista de dois números complexos e, em seguida, raios como lista de dois números

(+/⎕)>|-/⎕

Experimente online!

(+/⎕) [é] a soma dos raios

> Melhor que

| a magnitude de

-/⎕ a diferença de centros

Mathematica, 16 bytes

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

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

O Mathematica possui um RegionIntersectionbuiltin, mas só ele possui 18 bytes de comprimento ...

Versão incorporada:

RegionIntersection@##==EmptyRegion@2&

Leva 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

Experimente online!

Obrigado @AndersKaseorg pelo -1byte!

Gelatina , 12 bytes

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

Experimente online!

-2 bytes graças a Dennis

Java (OpenJDK 8) , 38 bytes

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

Experimente online!

Java 8, 41 38 bytes

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

Experimente aqui.

Aparentemente, Java também possui Math.hypot, que é 3 bytes mais curto.

EDIT: Acabei de perceber que esta resposta agora é exatamente a mesma que a resposta do Java 8 de @ OlivierGrégoire , portanto, faça um voto positivo em vez de mim, se você gosta da resposta de 38 bytes.

Resposta antiga (41 bytes) :

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

Experimente aqui.

Pitão , 15 bytes

<sm^-EE2 2^+EE2

Recebe entradas na ordem x1, x2, y1, y2, r1, r2

Suíte de teste!

Perl 6 , 13 bytes

*+*>(*-*).abs

Experimente online!

Os dois primeiros argumentos são os raios, em qualquer ordem. O terceiro e o quarto argumentos são as coordenadas dos centros, como números complexos, em qualquer ordem.

Táxi , 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.

Experimente online!

Saídas 1para círculos sobrepostos.
Saídas0 para círculos sem sobreposição (incluindo círculos tangenciais).

Sem Golfe / formatado:

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 graças a @KevinCruijssen.

Scala , 23 bytes

Obrigado @Arnauld por sua resposta quase poliglota .

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

Experimente online!

PostgreSQL, 41 caracteres

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

Instrução preparada, recebe entrada como 2 parâmetros em qualquer circlenotação .

Exemplo de execução:

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 da máquina x86 (com 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

A função acima aceita descrições de dois círculos (coordenadas x e y do ponto central e um raio) e retorna um valor booleano indicando se eles se cruzam ou não.

Ele usa uma convenção de chamada de vetor, na qual os parâmetros são passados ​​nos registros SIMD. No Windows x86-32 e 64 bits, esta é a __vectorcallconvenção de chamada . No Unix / Linux / Gnu de 64 bits, esta é a convenção de chamada padrão do System V AMD64 .

O valor de retorno é deixado no byte baixo de EAX, como é padrão em todas as convenções de chamada x86.

Esse código funciona igualmente bem em processadores x86 de 32 e 64 bits, desde que eles suportem o conjunto de instruções SSE2 (que seria Intel Pentium 4 e posterior, ou AMD Athlon 64 e posterior).

Versão AVX, ainda 36 bytes

Se você estava segmentando o AVX , provavelmente desejaria adicionar um prefixo VEX às instruções. Isso não altera a contagem de bytes; apenas os bytes reais usados ​​para codificar as instruções:

; 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

As instruções do AVX têm a vantagem de levar três operandos, permitindo executar operações não destrutivas, mas isso não nos ajuda a compactar o código aqui. No entanto, misturar instruções com e sem prefixos VEX pode resultar em código subótimo; portanto, você geralmente deseja seguir todas as instruções do AVX se estiver direcionando o AVX e, nesse caso, nem sequer prejudica sua contagem de bytes.

05AB1E , 10 bytes

-¨nOt²¹+θ‹

Experimente online!

PHP , 66 bytes

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

Experimente online!

Executa a partir da linha de comando, recebendo a entrada como 6 argumentos de parâmetro da linha de comando e imprime 1 se os círculos se sobrepõem, caso contrário, 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)))

Leva seis argumentos: x1, y1, r1, x2, y2, r2. Retorna verdadeiro ou falso.

Infelizmente, Clojure não tem uma powfunção de algum tipo. Custa muitos bytes.

Na verdade , 8 bytes

-)-(h@+>

Experimente online!

Explicação:

-)-(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 avalia a função

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

Onde xestão as coordenadas do círculo 1, ysão as coordenadas do círculo 2 ez os raios.

Calcula a distância entre os dois centros usando Pitágoras e testa se essa distância é menor que a soma dos raios.

Utiliza a vetorização de R para calcular (x1-x2)^2e (y1-y2)^2. Estes são então somados e diretamente enraizados.

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 simples, igual a várias outras respostas, exceto que ele usa o complextipo interno e chama math / cmplx.Abs ().

Tomar os raios como números complexos não ajuda, porque a conversão para float64 adiciona mais bytes do que a declaração da variável salva (não é possível fazer float64 < complex128 ).

Experimente online! Inclui os casos de teste e usa o pacote principal em vez de uma biblioteca.