Sum

17

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

code-golf  math  number  decision-problem 
— Usuario Any3nymous
fuente
2
¿Puede el programa generar 0 si el resultado es verdadero y cualquier otro número si el resultado es falso?
— JosiahRyanW

Respuestas:

6

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!

— Giuseppe
fuente
1
¿Podría usar scan()para guardar algunos bytes?
— Robert S.
3
@RobertS. doh! ¡He estado haciendo demasiada codificación R "real" últimamente!
— Giuseppe
6

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
— Arnauld
fuente
1
Puede guardar un byte con el dpasar de nque 0en lugar de 2a nla siguiente:n=>!((g=d=>d?d*d*!(n%d)+g(d-1):0)(n)**.5%1)
— Hedi
5

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.

— JosiahRyanW
fuente
415 bytes con un tercer personaje
— Jo King
3

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!

— Kroppeb
fuente
f^₂ᵐes 4 bytes más corto queḋ{⊇×^₂}ᵘ
— Fatalize
3

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".

— maxb
fuente
Ya sabes, algo llamado "MathGolf" realmente debería tener un operador normal ... que te hubiera reducido a 3 bytes :)
— Misha Lavrov
¡@MishaLavrov no es una mala idea! En este momento no tengo tantas operaciones vectoriales como me gustaría, uno de estos días lo cambiaré
— maxb
3

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?
— Sanchises
fuente
2

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.

— AdmBorkBork
fuente
el raro caso donde $args[0]es más corto :)1..$args[0]|%{$a+=$_*$_*!($n%$_)};1..$a|?{$_*$_-eq$a}
— mazzy
1
@mazzy No lo es, porque necesitas $ndentro del bucle para !($n%$_). Pero, su reescritura de la suma ahorró 12 bytes, ¡así que gracias!
— AdmBorkBork
qué lástima. así que me gustaría encontrar un caso donde $args[0]sea ​​más corto :)
— mazzy
2

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
— J. Sallé
fuente
¿Se puede hacer el equivalente en notlugar de 0=guardar un byte?
— Callejero
@streetster desafortunadamente, no puedo por 2 razones. Primero, el notoperador de APL ( ~), cuando se usa de manera monádica, solo funciona con booleanos (0 o 1). Como cualquier número de módulo 1 nunca es igual a 1, si lo usara en ~lugar de 0=, obtendría un domain errornúmero que no sea un cuadrado perfecto, ya que los valores decimales están fuera del ~dominio de. Además, no puedo omitir simplemente 0=, ya que el valor verdadero de APL es 1, no 0, y no tendría una salida consistente para valores falsos.
— J. Sallé
2

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
— callejero
fuente
2

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.

— DimChtz
fuente
1
Parece que divisorspertenece a la Caja de herramientas simbólica. Deberías indicarlo en el título. Además, puede usar en ~···lugar de···==0
— Luis Mendo
Puede acortar esto usando en sum(...)^.5lugar desqrt(sum(...))
— Sanchises
2

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

— totalmente humano
fuente
1
Es más corto (pero más lento) para evitar esas conversiones buscando la raíz cuadrada con otra comprensión de la lista. Pruébalo en línea!
— Ørjan Johansen
1
Más corto: fx | s <-sum [i ^ 2 | i <- [1..x], mod x i <1] = round (sqrt $ toEnum s) ^ 2 == s
— Damien
2
A partir de la sugerencia de Ørjan Johansen, esto debería funcionar para 53 bytes.
— ovs
2

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
— mudkip201
fuente
1

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,..
— ბიმო
fuente
1

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.

— LegionMammal978
fuente
1

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.

— Ciaran_McCarthy
fuente
1

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.
— usuario591898
fuente
1

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!

— archangel.mjj
fuente
1

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
— Kevin Cruijssen
fuente
1
Hola, puede cortar 5 bytes eliminando la variable t (realice la evaluación y la asignación dentro del cuerpo del bucle for), de esta manera:n->{int s=0,i=0;for(;++i<=n;)s+=n%i<1?i*i:0;return Math.sqrt(s)%1==0;}
— archangel.mjj
@ archangel.mjj Ah, por supuesto. No estoy seguro de cómo me perdí eso. ¡Gracias! :)
— Kevin Cruijssen
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.