Soma

17

Seja (Entrada)n=42

Então os divisores são: 1, 2, 3, 6, 7, 14, 21, 42

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

Tomando soma (adicionando): 2500

Como , retornamos um valor verdadeiro. Se não for um quadrado perfeito, retorne um valor falso.50×50=2500

Exemplos :

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

Este é o código-golfe, pelo que o código mais curto em bytes para cada idioma ganha

Obrigado a @Arnauld por apontar a sequência: A046655

code-golf  math  number  decision-problem 
— Usuário Any3nymous
fonte
2
O programa pode produzir 0 se o resultado for verdadeiro e qualquer outro número se o resultado for falso?
— JosiahRyanW

Respostas:

6

R , 39 37 bytes

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

Experimente online!

Usa a abordagem clássica "teste se quadrado perfeito", obtendo a parte não integral da raiz quadrada S^.5%%1e a negação lógica dela, pois mapeia zero (quadrado perfeito) para TRUEe diferente de zero para FALSE.

Agradecemos a Robert S por salvar alguns bytes!

— Giuseppe
fonte
1
Você poderia usar scan()para salvar alguns bytes?
— Robert S.
3
@RobertS. doh! Ultimamente tenho feito muita codificação R "real"!
— Giuseppe
6

JavaScript (ES7),  46 44  42 bytes

Guardado 1 byte graças a @Hedi

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

Experimente online!

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
fonte
1
Você pode salvar um byte com dindo de nque 0, em vez 2da nassim:n=>!((g=d=>d?d*d*!(n%d)+g(d-1):0)(n)**.5%1)
— Hedi
5

Linguagem de programação de 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

Experimente online!

-13 bytes graças a Jo King!

Saídas 1para resultado verdadeiro, saídas 0para resultado falso.

— JosiahRyanW
fonte
415 bytes com um terceiro caractere
— Jo King
3

Neim , 5 bytes

𝐅ᛦ𝐬q𝕚

Explicação:

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

Experimente online!

— Okx
fonte
3

Braquilog , 12 8 bytes

f^₂ᵐ+~^₂

-4 bytes graças a Fatelize porque eu não percebi que o braquilog possui um fator de funções

explicação

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

Experimente online!

— Kroppeb
fonte
f^₂ᵐé 4 bytes menor queḋ{⊇×^₂}ᵘ
— Fatalize
3

MathGolf , 5 4 bytes

─²Σ°

Experimente online!

Explicação

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

Muito semelhante a outras respostas, em comparação com 05AB1E, ganho um byte para o meu operador "é quadrado perfeito".

— maxb
fonte
Você sabe, algo chamado "MathGolf" realmente deve ter um operador norma ... que teria chegado você para baixo a 3 bytes :)
— Misha Lavrov
@MishaLavrov isso não é uma má ideia! Agora eu não tenho como muitas operações vectoriais, como eu gostaria, um dia desses eu vou mudar isso
— maxb
3

MATL , 9 bytes

Z\UsX^tk=

Experimente online!

Tão simples quanto possível

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
fonte
2

PowerShell , 68 56 bytes

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

Experimente online!

Parece longo ...
-12 bytes graças a mazzy

Faz exatamente o que diz na lata. Pega o intervalo de 1entrada $ne multiplica os $_*$_tempos quadrados , seja um divisor ou não !($n%$_). Isso torna os divisores iguais a um número diferente de zero e os não-divisores iguais a zero. Em seguida, tomamos a soma deles com nosso acumulador $a. Em seguida, fazemos um loop novamente de 1até $ae retirar esses números, onde |?{...}ele quadrado é -equal a $a. Isso é deixado no pipeline e a saída está implícita.

Emite um número inteiro positivo para verdade e nada para falsey.

— AdmBorkBork
fonte
caso raro onde $args[0]é mais curto :)1..$args[0]|%{$a+=$_*$_*!($n%$_)};1..$a|?{$_*$_-eq$a}
— Mazzy
1
@mazzy Não é, porque você precisa $ndentro do loop !($n%$_). Mas, sua reescrita da soma economizou 12 bytes, então obrigado!
— AdmBorkBork 10/09
que pena. então eu gostaria de encontrar um caso em que $args[0]é mais curto :)
— Mazzy
2

APL (Dyalog Unicode) , 18 bytes

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

Experimente online!

Lambda anônimo. Retorna 1 para verdade e 0 para falsidade (os casos de teste no TIO são prettificados).

Gritos para @ H.PWiz por 4 bytes!

Quão:

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é
fonte
Você pode fazer o equivalente notao invés 0=de salvar um byte?
— Streetster
@ streetster infelizmente, não posso por 2 razões. Primeiro, o notoperador da APL ( ~), quando usado monadicamente, funciona apenas com booleanos (0 ou 1). Como qualquer número do módulo 1 nunca é igual a 1, se eu usasse em ~vez de 0=, obteria um domain errorem qualquer número que não seja um quadrado perfeito, pois os valores decimais estão fora do ~domínio de. Além disso, não posso simplesmente omitir o 0=, já que o valor de verdade da APL é 1, e não 0, e não teria uma saída consistente para valores de falsidade.
— J. Sallé
2

K (oK) , 26 25 22 bytes

Solução:

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

Experimente online!

Explicação:

{~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 inspirando-se na solução PowerShell
  • -3 bytes inspirando-se na solução APL
— rua
fonte
2

Matlab, 39 37 bytes

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

Infelizmente, ele não funciona no Octave (no tio), portanto não há link para o tio.

Nota Como o @LuisMendo afirmou, divisors()pertence à Symbolic Toolbox.

— DimChtz
fonte
1
Parece divisorspertencer à caixa de ferramentas simbólica. Você deve indicar isso no título. Além disso, você pode usar em ~···vez de···==0
— Luis Mendo
Você pode encurtar isso usando em sum(...)^.5vez desqrt(sum(...))
— Sanchises
2

Haskell , 78 64 53 bytes

-14 bytes graças a Ørjan Johansen . -11 bytes graças a ovs .

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

Experimente online!

Ei, já faz um tempo desde que eu ... escrevi qualquer código, então meu Haskell e golfe podem ficar um pouco enferrujados. Esqueci os problemáticos tipos numéricos de Haskell. : P

— totalmente humano
fonte
1
É mais curto (mas mais lento) evitar essas conversões pesquisando a raiz quadrada com outra compreensão da lista. Experimente online!
— Ørjan Johansen
1
Menor: fx | s <-soma [i ^ 2 | i <- [1..x], mod x i <1] = round (sqrt $ toEnum s) ^ 2 == s
— Damien
2
Com base na sugestão de Ørjan Johansen, isso deve funcionar para 53 bytes.
— ovs 11/09/18
2

Pyt , 7 bytes

ð²ƩĐř²∈

Experimente online!

Explicação

            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

ð²Ʃ√ĐƖ=

Experimente online!

Explicação

            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%¬

Experimente online!

Explicação

            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
fonte
1

Casca , 6 bytes

£İ□ṁ□Ḋ

Experimente online!

Explicação

£İ□ṁ□Ḋ  -- 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,..
— ბიმო
fonte
1

Mathematica, 32 bytes

IntegerQ@Sqrt[2~DivisorSigma~#]&

Função pura. Pega um número como entrada e retorna Trueou Falsecomo saída. Não tenho certeza se existe um método mais curto para verificar quadrados perfeitos.

— LegionMammal978
fonte
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)

Experimente online!

Portanto, dobtém os divisores para todos os números entre 1 e ninclusive. Na função principal u, a primeira linha atribui a soma de todos os divisores ao quadrado m. A segunda linha obtém os divisores para me determina se algum deles ao quadrado é igual m.

— Ciaran_McCarthy
fonte
1

Perl 5, 47 bytes

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

Retorna 1 para true e nada para false.

Explicação:

$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.
— user591898
fonte
1

Groovy , 47 bytes

Um lambda aceitando um argumento numérico.

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

Explicação

(1..n) cria uma matriz dos valores de 1 a n

n%ié falso (como 0 é falso) se idivide nsem deixar resto

n%i ? 0 : i*ié a soma do quadrado do valor ise ele dividir nsem deixar resto, caso contrário, é 0

sum{ i-> n%i ? 0 : i*i }soma o resultado anterior em todo io array.

s%Math.sqrt(s)é falso (como 0 é falso) se o sqrt de se sdividir ssem deixar resto

!(s%Math.sqrt(s))retorna do lambda ( returnimplícito na última instrução) !falsequando o sqrt de sdivide ssem resto

Experimente online!

— archangel.mjj
fonte
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 graças a @ archangel.mjj .

Experimente online.

Explicação:

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
fonte
1
Oi, você pode cortar 5 bytes, removendo a variável t (fazer o eval e atribuição dentro do corpo do loop for), assim: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, claro. Não tenho certeza de como eu perdi isso. Obrigado! :)
— Kevin Cruijssen 13/09/18
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.