Dos números se consideran amigables si la suma de divisores del primero es la misma que la del segundo número, la suma de divisores del segundo número es igual al primer número y los números primero y segundo no son iguales.

Definamos S(x)ser la suma de divisores adecuada de x. 220 y 284 son amigables porque S(220) = 284y S(284) = 200.

Su tarea es, como era de esperar, determinar si dos números ingresados ​​son amigables o no. Las entradas serán enteros positivos y puede generar dos valores distintos y consistentes para amistoso o no.

Esta es la secuencia OEIS A259180

Este es un código de golf por lo que gana el código más corto.

Casos de prueba

input, input => output
220, 284 => 1
52, 100 => 0
10744, 10856 => 1
174292, 2345 => 0
100, 117 => 0
6, 11 => 0
495, 495 => 0
6, 6 => 0

Jalea , 5 bytes

QfÆṣ⁼

Un enlace monádico que toma una lista de dos enteros que devuelve 1 si son un par de números amistosos y 0 en caso contrario.

Pruébalo en línea!

¿Cómo?

QfÆṣ⁼ - Link: pair of numbers L, [a, b]   e.g. [220,284]  or [6,6]  or [6,11]  or [100,52]
Q     - de-duplicate L                         [220,284]     [6]       [6,11]     [100,52]
  Æṣ  - proper divisor sum of L (vectorises)   [284,220]     [6]       [6,1]      [117,46]
 f    - filter keep left if in right           [220,284]     [6]       [6]        []
    ⁼ - equal to L?                            1             0         0          0

Python 2 , 65 63 66 bytes

^{-2 bytes gracias al Sr. Xcoder}

lambda c:[sum(i*(n%i<1)for i in range(1,n))for n in c]==c[::-1]!=c

Pruébalo en línea!

Python 2, 71 67 bytes

-4 bytes gracias a xnor

+9 bytes gracias a caird coinheringaahing

lambda c:[sum(i for i in range(1,x)if x%i<1)for x in c]==c[::-1]!=c

en parte inspirado por [esta respuesta]

Brain-Flak , 178 bytes

{(({})(<>))<>({<<>(({})<<>{(({})){({}[()])<>}{}}>)<>([{}](({}[()])))>{[()]((<{}{}>))}{}{}}{}<>)<>}<>(({}<>)<>[({}{}<>)])({<{}({<({}<>[{}])>{()(<{}>)}{}})>(){[()](<{}>)}}<{}{}{}>)

Pruébalo en línea!

Haskell , 53 bytes

-2 bytes gracias a BMO. -1 byte gracias a Ørjan Johansen.

a!b=a==sum[i|i<-[1..b-1],b`mod`i<1,a/=b]
a#b=a!b&&b!a

Pruébalo en línea!

Ungolfed con UniHaskell y-XUnicodeSyntax

import UniHaskell

equalsOmega       ∷ Int → Int → Bool
a `equalsOmega` b = a ≡ sum [i | i ← 1 … pred b, i ∣ b, a ≢ b]

areAmicable       ∷ Int → Int → Bool
areAmicable a b   = (a `equalsOmega` b) ∧ (b `equalsOmega` a)

J, 51 28 27 24 Bytes

-Muchos bytes gracias a @cole

-1 byte más gracias a @cole

~.-:[:|.(1#.i.*0=i.|])"0

Pruébalo en línea!

JavaScript (ES6), 53 bytes

Toma entrada en la sintaxis de curry (a)(b). Devoluciones 0o 1.

a=>b=>a!=b&a==(g=n=>--a&&a*!(n%a)+g(n))(a=g(a)-b?1:b)

Manifestación

let f =

a=>b=>a!=b&a==(g=n=>--a&&a*!(n%a)+g(n))(a=g(a)-b?1:b)

console.log(f(220)(284))  // => 1
console.log(f(52)(100))   // => 0
console.log(f(100)(117))  // => 0
console.log(f(6)(6))      // => 0

¿Cómo?

Usamos la función g para obtener la suma de los divisores propios de un entero dado.

Primero calculamos g (a) y lo comparamos con b . Si g (a) = b , calculamos g (b) y lo comparamos con a . De lo contrario, calculamos g (1) , que da 0 y no puede ser igual a un .

También verificamos que a no sea igual a b .

Python 3, 84 bytes

d=lambda n:sum(i*(n%i<1)for i in range(1,n))
f=lambda a,b:(d(a)==b)*(d(b)==a)*(a^b)>0

Solución directa. d resume los divisores (n% i <1 se evalúa a 1 si divide i). a ^ b no es cero si a! = b. El LHS de la desigualdad es, por lo tanto, 0 si los números no son amigables y> 0 de lo contrario.

Ruby , 64 60 59 58 bytes

->c{c.map{|i|(1...i).sum{|j|i%j<1?j:0}}==c.rotate&&c==c&c}

Pruébalo en línea!

R , 67 bytes

function(a,b)sum(which(!a%%1:a))-a==b&sum(which(!b%%1:b))-b==a&b!=a

Pruébalo en línea!

vuelve TRUEpor amistoso, FALSEpor no.

Perl 6 , 53 bytes

{([!=] $_)&&[eqv] .map: {set +$_,sum grep $_%%*,^$_}}

Pruébalo en línea!

Toma la entrada como una lista de dos números.

PowerShell , 87 96 bytes

param($a,$b)filter f($n){(1..($n-1)|?{!($n%$_)})-join'+'|iex}(f $a)-eq$b-and(f $b)-eq$a-and$a-$b

Pruébalo en línea!

Toma entrada $a,$b. Define un filter(aquí equivalente a una función) que toma entrada $n. Dentro construimos un rango de 1a $n-1, sacamos aquellos que son divisores, -joinlos juntamos +y los enviamos a Invoke-Expression(similar a eval).

Finalmente, fuera del filtro, simplemente verificamos si la suma de divisores de una entrada es igual a la otra y viceversa (y validación de entrada para asegurarnos de que no sean iguales). Ese valor booleano se deja en la tubería y la salida es implícita.

Pyth, 12 bytes

q{_msf!%dTtU

Toma la entrada como una lista.
Pruébalo en línea

Explicación

q{_msf!%dTtU
   m         Q    For each element d of the (implicit) input...
          tUd     ... get the range [1, ..., d - 1]...
     f!%dT        ... filter those that are factors of d...
    s             ... and take the sum.
 {_               Reverse and deduplicate...
q             Q   ... and check if the end result is the same as the input.

05AB1E , 8 7 bytes

ÙÑO¥`_`

Pruébalo en línea!

Lote, 127 bytes

@if %1==%2 exit/b
@set/as=t=%1+%2
@for /l %%i in (1,1,%s%)do @set/as-=%%i*!(%1%%%%i),t-=%%i*!(%2%%%%i)
@if %s%%t%==00 echo 1

Salidas 1si los parámetros son amigables. Funciona restando todos los factores de la suma de los números de entrada para cada número de entrada, y si ambos resultados son cero, entonces los números son amigables.

APL (Dyalog Unicode) , 45 38 44 36 35 20 bytes

{(≠/⍵)∧(⌽⍵)≡+/¨¯1↓¨(0=⍵|⍨⍳¨⍵)/¨⍳¨⍵}

Pruébalo en línea!

Infix Dfn, corregido para el caso de entradas iguales.

Gracias @Uriel por 8 bytes; @cole para 1 byte; @ Adám por 15 bytes.

¿Cómo?

{(≠/⍵)∧(⌽⍵)≡+/¨¯1↓¨(0=⍵|⍨⍳¨⍵)/¨⍳¨⍵} ⍝ Main function, infix. Input is ⍵.
{                               ⍳¨⍵} ⍝ Generate the range [1,n] for each element of ⍵.
                              /¨     ⍝ Replicate into each the resulting vectors of:
                   (  ⍵|⍨⍳¨⍵)        ⍝ ⍵ modulo each element of the ranges;
                    0=               ⍝ Equals 0?
               ¯1↓¨                  ⍝ Drop the last element of each
            +/¨                      ⍝ Sum of each
       (⌽⍵)≡                         ⍝ Check if the results match the inverse of ⍵.
      ∧                              ⍝ Logical AND.
 (≠/⍵)                               ⍝ Inputs are different

@ Adám también me ha ayudado con una función tácita de 22 20 bytes que es equivalente a la Dfn:

≠/∧⌽≡(+/∘∊⍳⊆⍨0=⍳|⊢)¨

Pruébalo en línea!

¿Cómo?

≠/∧⌽≡(+/∘∊⍳⊆⍨0=⍳|⊢)¨⍝ Tacit fn, takes one right argument.
     (            )¨ ⍝ For each element e of the argument
               ⍳|⊢   ⍝ e modulo range [1,e]
             0=      ⍝ Equals 0? This generates a boolean vector
            ⍨        ⍝ Swap arguments for the following op/fn
           ⊆         ⍝ Partition. This partitions the right vector argument according to 1-runs from a left boolean vector argument of same size.
          ⍳          ⍝ Range [1,e]
         ∊           ⍝ Enlist; dump all elements into a single vector.
        ∘            ⍝ And then
      +/             ⍝ Sum the elements
   ⌽≡                ⍝ Check if the resulting sums match the inverse of the argument
  ∧                  ⍝ Logical AND
≠/                   ⍝ The elements of the argument are different.

Rojo , 117 bytes

d: func[n][s: 0 repeat i n / 2[if n // i = 0[s: s + i]]]
a: func[n m][either(m = d n)and(n = d m)and not n = m[1][0]]

Pruébalo en línea!

Java (OpenJDK 9) , 87 bytes

a->b->a!=b&f(a)==b&f(b)==a
int f(int n){int s=0,d=0;for(;++d<n;)s+=n%d<1?d:0;return s;}

Pruébalo en línea!

SNOBOL4 (CSNOBOL4) , 153 146 bytes

	DEFINE('D(X)I')
	DEFINE('A(M,N)')
A	A =EQ(D(M),N) EQ(D(N),M) ~EQ(N,M) 1 :(RETURN)
D	I =LT(I,X - 1) I + 1	:F(RETURN)
	D =EQ(REMDR(X,I)) D + I	:(D)

Pruébalo en línea!

Define una función Aque calcula la amabilidad de dos números, devolviendo 1para amigable y la cadena vacía para no. El algoritmo es el mismo que mi respuesta anterior, así que dejo la explicación anterior a continuación.

	DEFINE('D(X)I')					;*function definition
	M =INPUT					;*read M,N as input
	N =INPUT
	OUTPUT =EQ(D(M),N) EQ(D(N),M) ~EQ(N,M) 1 :(END)	;* if D(M)==N and D(N)==M and N!=M, output 1. goto end.
D	I =LT(I,X - 1) I + 1	:F(RETURN)		;* function body: increment I so long as I+1<X, return if not.
	D =EQ(REMDR(X,I)) D + I	:(D)			;* add I to D if D%%I==0, goto D
END

Pyth , 13 bytes

&-FQqFms{*MyP

+4 bytes para verificar si los valores son distintos, creo que eso no debería ser parte del desafío ...

Es casi seguro que se puede jugar mucho al golf

Pruébalo en línea!

&-FQqFms{*MyP     Full program, takes input from stdin and outputs to stdout
 -FQ              Q0 - Q1 is true, meaning elements are distinct
&                  and
      m       Q   for each element of the input list, apply
           yPd    take the powerset of the prime factors
        {*M       multiply each list and deduplicate
       s          and sum the list (this represents S(n)+n )
    qF            and fold over equality, returning whether the two elements are equal

APL + WIN, 49 54 41 40 35bytes

Reescrito para rechazar entradas enteras iguales

Solicita la entrada de pantalla de un vector de los dos enteros.

(≠/n)×2=+/n=⌽+/¨¯1↓¨(0=m|n)×m←⍳¨n←⎕

NARS APL, 38 bytes, 18 caracteres

{≠/⍵∧∧/⍵=⌽-⍵-11π⍵}

11π⍵ encuentra la suma de los divisores de ⍵ en 1..⍵; tenga en cuenta que la pregunta want (11π⍵) -⍵ y en APLsm

-⍵-11π⍵=-(⍵-11π⍵)=(11π⍵)-⍵

la prueba

  t←{≠/⍵∧∧/⍵=⌽-⍵-11π⍵}
  t 284 220⋄t 52 100⋄t 10744 10856 ⋄t 174292 2345
1
0
1
0
  t 100 117⋄t 6 11⋄t 495 495⋄t 6 6
0
0
0
0

Japt , 7 12 10 bytes

Toma la entrada como una matriz de 2 números.

®â¬xÃeUâ w

Intentalo

• Se agregaron 3 bytes para manejar [6,11] .
• Se agregaron otros 3 bytes después de actualizar el desafío para requerir la validación de entrada. (¡Boo-urnas en ambos frentes!)
• Guardado 1 byte gracias a Oliver.

Adelante (gforth) , 91 86 bytes

: d { n } 0 n 1 do n i mod 0= i * - loop ; 
: f { a b } a b = 1+ a d b = b d a = * * ;

Pruébalo en línea!

Adelante (gforth) Sin locales, 94 bytes

Una versión más "Forthy" que no usa variables locales

: d 0 over 1 do over i mod 0= i * - loop nip ;
: f 2dup = 1+ -rot 2dup d -rot d = -rot = * * ;

Pruébalo en línea!

Brachylog , 9 bytes

≠.{fk+}ᵐ↔

Pruébalo en línea!

Toma la entrada como una lista y las salidas a través de éxito o fracaso.

             The input
≠            which contains no duplicate values
 .           is the output variable,
  {   }ᵐ     and its elements'
    k        proper
   f         divisor
     +       sums
        ↔    reversed
             are also the output variable.

Adelante (gforth) , 80 bytes

Solución de reffujo refactorizada .

: d { n } 0 n 1 do n i mod 0= i * - loop ;
: f 2dup <> -rot 2dup d swap d d= * ;

Pruébalo en línea!

Cómo funciona

: d { n -- divsum } \ Takes a number and gives its divisor sum (excluding self)
                    \ Store n as a local variable
  0 n 1 do          \ Push 0 (sum) and loop through 1 to n-1...
    n i mod 0=      \   If n % i == 0, push -1 (built-in true in Forth); otherwise push 0
    i * -           \   If the value above is -1, add i to the sum
  loop ;            \ End loop and leave sum on the stack

: f ( n1 n2 -- f )  \ Main function f. Takes two numbers and gives if they are amicable
  2dup <>           \ Are they not equal? ( stack: n1 n2 n1<>n2 )
  -rot              \ Move the boolean under n1 n2 ( stack: n1<>n2 n1 n2 )
  2dup d swap d     \ Copy two numbers, apply d to both and swap
                    \ ( stack: n1<>n2 n1 n2 n2.d n1.d )
  d=                \ Compare two 2-cell numbers for equality; n1=n2.d && n2=n1.d
  * ;               \ Return the product of the two booleans