Dois números são considerados amigáveis se a soma correta do primeiro divisor for igual ao segundo número, a soma adequada do segundo número for igual ao primeiro número e o primeiro e o segundo número não forem iguais.

Vamos definir S(x)como a soma correta do divisor de x. 220 e 284 são amigáveis ​​porque S(220) = 284e S(284) = 200.

Sua tarefa é, sem surpresa, determinar se dois números introduzidos são amigáveis ​​ou não. As entradas serão números inteiros positivos e você pode gerar dois valores consistentes e distintos para amigável ou não.

Esta é a sequência OEIS A259180

Este é um código de golfe, portanto o código mais curto vence.

Casos de teste

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

Gelatina , 5 bytes

QfÆṣ⁼

Um link monádico que obtém uma lista de dois números inteiros que retorna 1 se eles são um par de números amigáveis ​​e 0 caso contrário.

Experimente online!

Quão?

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 graças ao Sr. Xcoder}

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

Experimente online!

Python 2, 71 67 bytes

-4 bytes graças ao xnor

+9 bytes graças a caird coinheringaahing

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

parcialmente inspirado por [esta resposta]

Flacidez cerebral , 178 bytes

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

Experimente online!

Haskell , 53 bytes

-2 bytes graças ao BMO. -1 byte graças a Ørjan Johansen.

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

Experimente online!

Ungolfed with UniHaskell and-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

-Lotes de bytes graças a @cole

-1 mais byte graças a @cole

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

Experimente online!

JavaScript (ES6), 53 bytes

Recebe entrada na sintaxe de currying (a)(b). Retorna 0ou 1.

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

Demo

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

Quão?

Usamos a função g para obter a soma dos divisores adequados de um dado inteiro.

Primeiro calculamos g (a) e comparamos com b . Se g (a) = b , calculamos g (b) e comparamos com a . Caso contrário, calculamos g (1) , que fornece 0 e não pode ser igual a a .

Além disso, verificamos que a não é 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

Solução simples. d resume os divisores (n% i <1 é avaliado para 1 se s divide n). a ^ b é diferente de zero se a! = b. O LHS da desigualdade é, portanto, 0 se os números não forem amigáveis ​​e> 0 em caso contrário.

Ruby , 64 60 59 58 bytes

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

Experimente online!

R , 67 bytes

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

Experimente online!

retorna TRUEpara amigável, FALSEpara não.

Perl 6 , 53 bytes

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

Experimente online!

Recebe a entrada como uma lista de dois 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

Experimente online!

Recebe entrada $a,$b. Define a filter(aqui equivalente a uma função) que recebe entrada $n. Dentro de nós construir um intervalo de 1ao $n-1, retirar aqueles que são divisores, -join-los juntamente com +e enviar para Invoke-Expression(semelhante a eval).

Finalmente, fora do filtro, simplesmente verificamos se a soma do divisor de uma entrada é igual à outra e vice-versa (e validação da entrada para garantir que não sejam iguais). Esse valor booleano é deixado no pipeline e a saída é implícita.

Pitão, 12 bytes

q{_msf!%dTtU

Leva a entrada como uma lista.
Experimente online

Explicação

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¥`_`

Experimente online!

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

Saída 1se os parâmetros forem amigáveis. Funciona subtraindo todos os fatores da soma dos números de entrada para cada número de entrada e, se os dois resultados forem zero, os números são amigáveis.

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

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

Experimente online!

Infix Dfn, corrigido para o caso de entradas iguais.

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

Quão?

{(≠/⍵)∧(⌽⍵)≡+/¨¯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 também me ajudou com uma função tácita de 22 20 bytes equivalente ao Dfn:

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

Experimente online!

Quão?

≠/∧⌽≡(+/∘∊⍳⊆⍨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.

Vermelho , 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]]

Experimente online!

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

Experimente online!

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)

Experimente online!

Define uma função Aque calcula a compatibilidade de dois números, retornando 1para amigável e a sequência vazia para não. O algoritmo é o mesmo da minha resposta anterior, então deixo a explicação antiga abaixo.

	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

Pitão , 13 bytes

&-FQqFms{*MyP

+4 bytes para verificar se os valores são distintos, acho que isso não deveria fazer parte do desafio ...

Quase certamente pode ser jogado muito

Experimente online!

&-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 35 bytes

Reescrito para rejeitar entradas inteiras iguais

Solicita a entrada na tela de um vetor dos dois números inteiros.

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

NARS APL, 38 bytes, 18 caracteres

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

11π⍵ encontre a soma dos divisores de ⍵ em 1..⍵; note que a pergunta quer (11π⍵) -⍵ e no APLsm

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

o teste

  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

Recebe a entrada como uma matriz de 2 números.

®â¬xÃeUâ w

Tente

• Adicionado 3 bytes para lidar [6,11].
• Adicionados mais 3 bytes após a atualização do desafio para exigir validação de entrada. (Boo-urnas em ambas as frentes!)
• Guardado 1 byte graças a Oliver.

Quarto (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 = * * ;

Experimente online!

Quarto (gforth) Sem Locals, 94 bytes

Uma versão mais "digna de nota" que não usa variáveis ​​locais

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

Experimente online!

Braquilog , 9 bytes

≠.{fk+}ᵐ↔

Experimente online!

Recebe as entradas como uma lista e as saídas por sucesso ou falha.

             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.

Quarto (gforth) , 80 bytes

Reformulado solução de reffu .

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

Experimente online!

Como 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