Sea (entrada)$n=42$

Entonces los divisores son: 1, 2, 3, 6, 7, 14, 21, 42

Cuadrando cada divisor: 1, 4, 9, 36, 49, 196, 441, 1764

Sumando (sumando): 2500

Como por lo tanto, devolvemos un valor verdadero. Si no es un cuadrado perfecto, devuelve un valor falso.$50\times 50=2500$

Ejemplos:

42  ---> true
1   ---> true
246 ---> true
10  ---> false
16  ---> false

Este es el código de golf, por lo que el código más corto en bytes para cada idioma gana

Gracias a @Arnauld por señalar la secuencia: A046655

R , 39 37 bytes

!sum((y=1:(x=scan()))[!x%%y]^2)^.5%%1

Pruébalo en línea!

Utiliza el enfoque clásico de "prueba si cuadrado perfecto", que toma la parte no integral de la raíz cuadrada S^.5%%1y toma la negación lógica de la misma, ya que asigna cero (cuadrado perfecto) TRUEy no cero a FALSE.

¡Gracias a Robert S por guardar un par de bytes!

JavaScript (ES7),  46 44  42 bytes

Guardado 1 byte gracias a @Hedi

n=>!((g=d=>d&&d*d*!(n%d)+g(d-1))(n)**.5%1)

Pruébalo en línea!

Comentado

n =>             // n = input
  !(             // we will eventually convert the result to a Boolean
    (g = d =>    // g is a recursive function taking the current divisor d
      d &&       //   if d is equal to 0, stop recursion 
      d * d      //   otherwise, compute d²
      * !(n % d) //   add it to the result if d is a divisor of n
      + g(d - 1) //   add the result of a recursive call with the next divisor
    )(n)         // initial call to g with d = n
    ** .5 % 1    // test whether the output of g is a perfect square
  )              // return true if it is or false otherwise

05AB1E , 5 bytes

ÑnOŲ

Pruébalo en línea!

¿Cómo?

ÑnOŲ
Ñ     - divisors
 n    - square
  O   - sum
   Ų - is square?

Lenguaje de programación Shakespeare , 434 428 415 bytes

,.Ajax,.Ford,.Puck,.Act I:.Scene I:.[Enter Ajax and Ford]Ford:Listen tothy.Scene V:.Ajax:You be the sum ofyou a cat.Ford:Is the remainder of the quotient betweenyou I worse a cat?[Exit Ajax][Enter Puck]Ford:If soyou be the sum ofyou the square ofI.[Exit Puck][Enter Ajax]Ford:Be you nicer I?If solet usScene V.[Exit Ford][Enter Puck]Puck:Is the square ofthe square root ofI worse I?You zero.If notyou cat.Open heart

Pruébalo en línea!

-13 bytes gracias a Jo King!

Salidas 1para resultado verdadero, salidas 0para resultado falso.

Python 2 , 55 bytes

lambda n:sum(i*i*(n%i<1)for i in range(1,n+1))**.5%1==0

Pruébalo en línea!

Neim , 5 bytes

𝐅ᛦ𝐬q𝕚

Explicación:

𝐅      Factors
 ᛦ      Squared
  𝐬     Summed
    𝕚   is in?
   q    infinite list of square numbers

Pruébalo en línea!

C (gcc) , 67 63 60 59 bytes

-1 bytes gracias a @JonathanFrech

i,s;f(n){for(s=i=0;i++<n;)s+=n%i?0:i*i;n=sqrt(s);n=n*n==s;}

Pruébalo en línea!

Brachylog , 12 8 bytes

f^₂ᵐ+~^₂

-4 bytes gracias a Fatelize porque no me di cuenta de que brachylog tiene funciones de factores

explicación

f^₂ᵐ+~^₂            #   full code
f                   #       get divisors
 ^₂ᵐ                #           square each one
    +               #       added together
      ~^₂           #       is the result of squaring a number

Pruébalo en línea!

MathGolf , 5 4 bytes

─²Σ°

Pruébalo en línea!

Explicación

─     Get all divisors as list (implicit input)
 ²    Square (implicit map)
  Σ   Sum
   °  Is perfect square?

Muy similar a otras respuestas, en comparación con 05AB1E, obtengo un byte para mi operador "es cuadrado perfecto".

MATL , 9 bytes

Z\UsX^tk=

Pruébalo en línea!

Tan simple como se pone

Z\ % Divisors of (implicit) input
U  % Square
s  % Sum
X^ % Square root
t  % Duplicate this value
k= % Is it equal to its rounded value?

PowerShell , 68 56 bytes

param($n)1..$n|%{$a+=$_*$_*!($n%$_)};1..$a|?{$_*$_-eq$a}

Pruébalo en línea!

Parece largo ...
-12 bytes gracias a mazzy

Hace exactamente lo que dice en la lata. Toma el rango de 1a input $ny multiplica los cuadrados por $_*$_si es un divisor o no !($n%$_). Esto hace que los divisores sean iguales a un número distinto de cero y los no divisores iguales a cero. Luego tomamos la suma de ellos con nuestro acumulador $a. Luego, volvemos a recorrer de 1arriba a abajo $ay sacamos esos números donde el |?{...}cuadrado es -equal$a . Eso se deja en la tubería y la salida es implícita.

Produce un número entero positivo para la verdad, y nada para Falsey.

Japt , 11 9 7 bytes

-2 bytes de @Giuseppe y otro -2 de @Shaggy

â x²¬v1

â x²¬v1             Full program. Implicity input U
â                   get all integer divisors of U
  x²                square each element and sum
    ¬               square root result
     v1           return true if divisible by 1

Pruébalo en línea!

APL (Dyalog Unicode) , 18 bytes

0=1|.5*⍨2+.*⍨∘∪⍳∨⊢

Pruébalo en línea!

Lambda anónima. Devuelve 1 para verdadero y 0 para falso (los casos de prueba en TIO están prettified).

¡Saludos a @ H.PWiz por 4 bytes!

Cómo:

0=1|.5*⍨2+.*⍨∘∪⍳∨⊢   ⍝ Main function, argument ⍵ → 42
                ∨⊢   ⍝ Greatest common divisor (∨) between ⍵ (⊢)
               ⍳      ⍝ and the range (⍳) [1..⍵]
              ∪      ⍝ Get the unique items (all the divisors of 42; 1 2 3 6 7 14 21 42)
             ∘        ⍝ Then
            ⍨         ⍝ Swap arguments of
        2+.*          ⍝ dot product (.) of sum (+) and power (*) between the list and 2 
                      ⍝ (sums the result of each element in the vector squared)
       ⍨              ⍝ Use the result vector as base
    .5*               ⍝ Take the square root
  1|                  ⍝ Modulo 1
0=                    ⍝ Equals 0

K (oK) , 26 25 22 bytes

Solución:

{~1!%+/x*x*~1!x%:1+!x}

Pruébalo en línea!

Explicación:

{~1!%+/x*x*~1!x%:1+!x} / the solution
{                    } / lambda taking x as input
                   !x  / range 0..x-1                        \
                 1+    / add 1                               |
              x%:      / x divided by and save result into x |
            1!         / modulo 1                            | get divisors
           ~           / not                                 |
         x*            / multiply by x                       /
       x*              / multiply by x (aka square)          > square
     +/                / sum up                              > sum up
    %                  / square root                         \  
  1!                   / modulo 1                            | check if a square
 ~                     / not                                 / 

Notas:

• -1 bytes inspirados en la solución PowerShell
• -3 bytes inspirados en la solución APL

Pari / GP , 23 bytes

n->issquare(sigma(n,2))

Pruébalo en línea!

Matlab, 39 37 bytes

@(v)~mod(sqrt(sum(divisors(v).^2)),1)

Desafortunadamente, no funciona en Octave (en tio), por lo que no hay tio link.

Nota Como dijo @LuisMendo, divisors()pertenece a Symbolic Toolbox.

Haskell , 78 64 53 bytes

-14 bytes gracias a Ørjan Johansen . -11 bytes gracias a los ovs .

f x=sum[i^2|i<-[1..x],x`mod`i<1]`elem`map(^2)[1..x^2]

Pruébalo en línea!

Oye, ha pasado un tiempo desde que ... escribí cualquier código, así que mi Haskell y el golf podrían estar un poco oxidados. Olvidé los problemáticos tipos numéricos de Haskell. :PAG

Pyt , 7 bytes

ð²ƩĐř²∈

Pruébalo en línea!

Explicación

            Implicit input
ð           Get list of divisors
 ²          Square each element
  Ʃ         Sum the list [n]
   Đ        Duplicate the top of the stack
    ř²      Push the first n square numbers
      ∈     Is n in the list of square numbers?
            Implicit output

ð²Ʃ√ĐƖ=

Pruébalo en línea!

Explicación

            Implicit input
ð           Get list of divisors
 ²          Square each element
  Ʃ         Sum the list [n]
   √        Take the square root of n
    Đ       Duplicate the top of the stack
     Ɩ      Cast to an integer
      =     Are the top two elements on the stack equal to each other?
            Implicit output

ð²Ʃ√1%¬

Pruébalo en línea!

Explicación

            Implicit input
ð           Get list of divisors
 ²          Square each element
  Ʃ         Sum the list [n]
   √        Take the square root of n
    1%      Take the square root of n modulo 1
      ¬     Negate [python typecasting ftw :)]
            Implicit output

Casco , 6 bytes

£İ□ṁ□Ḋ

Pruébalo en línea!

Explicación

£İ□ṁ□Ḋ  -- example input 12
     Ḋ  -- divisors: [1,2,3,4,6,12]
   ṁ    -- map the following ..
    □   -- | square: [1,4,9,16,36,144]
        -- .. and sum: 210
£       -- is it element of (assumes sorted)
 İ□     -- | list of squares: [1,4,9,16..196,225,..

Jalea , 6 bytes

ÆD²SƲ

Pruébalo en línea! O vea el conjunto de pruebas .

¿Cómo?

ÆD²SƲ - Main Link: integer
ÆD     - divisors
  ²    - square
   S   - sum
    Ʋ - is square?

Protón , 41 bytes

a=>sum(q*q for q:1..a+1if a%q<1)**.5%1==0

Pruébalo en línea!

Enfoque similar a la respuesta de Python.

Mathematica, 32 bytes

IntegerQ@Sqrt[2~DivisorSigma~#]&

Pura función. Toma un número como entrada y devuelve Trueo Falsecomo salida. No estoy del todo seguro si hay un método más corto para verificar cuadrados perfectos.

Octava / MATLAB, 43 bytes

@(n)~mod(sqrt(sum(find(~mod(n,1:n)).^2)),1)

Pruébalo en línea!

Rojo , 67 bytes

func[n][s: 0 repeat d n[if n % d = 0[s: d * d + s]](sqrt s)% 1 = 0]

Pruébalo en línea!

Scala , 68 67 bytes

def j(s:Int)=Math.sqrt((1 to s).filter(s%_<1).map(a=>a*a).sum)%1==0

Pruébalo en línea!

Perl 6 , 34 bytes

-1 byte gracias a nwellnhof

{grep($_%%*,1..$_)>>².sum**.5%%1}

Pruébalo en línea!

F #, 111 bytes

let d n=Seq.where(fun v->n%v=0){1..n}
let u n=
 let m=d n|>Seq.sumBy(fun x->x*x)
 d m|>Seq.exists(fun x->x*x=m)

Pruébalo en línea!

Entonces dobtiene los divisores para todos los números entre 1 e ninclusive. En la función principal u, la primera línea asigna la suma de todos los divisores al cuadrado m. La segunda línea obtiene los divisores my determina si alguno de ellos al cuadrado es igual m.

Perl 5, 47 bytes

$a+=$_*$_*!($n%$_)for 1..$n;$a=!($a**.5=~/\D/); 

Devuelve 1 para verdadero y nada para falso.

Explicación:

$a+=              for 1..$n;                      sum over i=1 to n
    $_*$_                                         square each component of the sum
         *!($n%$_)                                multiply by 1 if i divides n.
                            $a=                   a equals
                                ($a**.5           whether the square root of a
                               !       =~/\D/);   does not contain a non-digit.

Groovy , 47 bytes

Una lambda que acepta un argumento numérico.

n->s=(1..n).sum{i->n%i?0:i*i}
!(s%Math.sqrt(s))

Explicación

(1..n) crea una matriz de los valores de 1 a n

n%ies falso (ya que 0 es falso) si idividen sin resto

n%i ? 0 : i*ies la suma del cuadrado del valor isi dividen sin resto, de lo contrario es 0

sum{ i-> n%i ? 0 : i*i } suma el resultado anterior en todos i de la matriz.

s%Math.sqrt(s)es falso (ya que 0 es falso) si el sqrt de sdivides sin resto

!(s%Math.sqrt(s))regresa de lambda ( returnimplícito en la última instrucción) !falsecuando el sqrt de sdivides sin resto

Pruébalo en línea!

Java 8, 75 70 bytes

n->{int s=0,i=0;for(;++i<=n;)s+=n%i<1?i*i:0;return Math.sqrt(s)%1==0;}

-5 bytes gracias a @ archangel.mjj .

Pruébalo en línea.

Explicación:

n->{             // Method with integer parameter and boolean return-type
  int s=0,       //  Sum-integer, starting at 0
      i=0;       //  Divisor integer, starting at 0
  for(;++i<=n;)  //  Loop `i` in the range [1, n]
    s+=n%i<1?    //   If `n` is divisible by `i`:
        i*i      //    Increase the sum by the square of `i`
       :         //   Else:
        0;       //    Leave the sum the same by adding 0
  return Math.sqrt(s)%1==0;}
                 //  Return whether the sum `s` is a perfect square