Introdução e Crédito

Todos conhecemos e amamos nossas regras impressionantes para testar se um número é divisível por 11 ou 3, o que é apenas uma soma inteligente sobre os dígitos do número. Agora, esse desafio leva isso a um novo nível, exigindo que você calcule a soma dos dígitos e, em seguida, verifique se o resultado é um quadrado inteiro perfeito, e nenhuma das operações geralmente pode ser realizada com muito pouco tempo. Como essa propriedade também é muito difícil de ver quando se olha para um número, queremos que isso seja feito para listas inteiras de números, para que possamos salvar o trabalho humano. Portanto, este é o seu desafio agora!

Esta foi uma tarefa no meu curso de programação funcional da universidade. Esta tarefa está encerrada e foi discutida em sala de aula e tenho a permissão do meu professor para publicá-la aqui (perguntei explicitamente).

Especificação

Entrada

Sua entrada é uma lista de números inteiros não negativos, em qualquer formato de E / S padrão.
Você pode escolher o formato da lista conforme seu idioma precisar

Saída

A saída é uma lista de números inteiros, em qualquer formato de E / S padrão.

O que fazer?

Filtre todos os números inteiros da lista de entrada para os quais a soma dos dígitos não é um quadrado (de um número inteiro).
A ordem dos elementos não podem ser alterados, por exemplo, se você conseguir [1,5,9]você pode não retornar[9,1]

Casos de canto em potencial

0 é um número inteiro não negativo e, portanto, uma entrada válida e 0 também é uma raiz inteira válida, por exemplo, 0 conta como um quadrado inteiro.
A lista vazia também é uma entrada e saída válida.

Quem ganha?

Isso é código-golfe, então a resposta mais curta em bytes vence!
Regras padrão se aplicam, é claro.

Casos de teste

[1,4,9,16,25,1111] -> [1,4,9,1111]
[1431,2,0,22,999999999] -> [1431,0,22,999999999]
[22228,4,113125,22345] -> [22228,4,22345]
[] -> []
[421337,99,123456789,1133557799] -> []

Exemplo passo a passo

Example input: [1337,4444]
Handling first number:
Sum of the digits of 1337: 1+3+3+7=14
14 is not an integer square, thus will be dropped!
Handling second number:
Sum of the digits of 4444: 4+4+4+4=16
16 is an integer square because 4*4=16, can get into the output list!
Example output: [4444]

Pyke, 6 bytes

#s,DBq

Experimente aqui!

#      - Filter list on truthiness:
 s     -    digital_root(^)
  ,    -   sqrt(^)
    Bq -  int(^) == ^

Mathematica, 39 36 bytes

Uma função anônima:

Select[AtomQ@√Tr@IntegerDigits@#&]

LLlAMnYP salvou um byte. Obrigado!

Martin Ender economizou mais três substituindo IntegerQpor AtomQ. Inteligente! (O resultado de √será exato, portanto, ele retornará uma expressão composta como Sqrt[5]se o argumento não fosse um quadrado.)

Geléia, 8 7 bytes

1 byte graças a @ Sp3000 .

DSƲðÐf

Suíte de teste.

Explicação

DSƲðÐf  Main monadic chain. Argument: z

     Ðf  Filter for truthiness:
D            convert to base 10
 S           sum
  Ʋ         is perfect square

Brachylog v2, 8 bytes

{ẹ+√ℤ&}ˢ

Experimente online!

Explicação

{ẹ+√ℤ&}ˢ
{     }ˢ  Map the following operation over {the input}, discarding elements that error:
 ẹ         Split into a list of digits
  +        Sum that list
   √       Take its square root
    ℤ      Assert that the result is an integer
     &     Return to the original value

o & meios que a saída elementos são os mesmos que aqueles na lista de entrada, mas o ℤserá erro se a entrada do bloco não é um número quadrado, então temos a lista de entrada com elementos com somas dígitos não quadrados descartados.

Observe que, a princípio, pode parecer um problema de imprecisão de ponto flutuante aqui (alguns números inteiros não quadrados muito grandes têm raízes quadradas inteiras devido ao arredondamento). No entanto, o Brachylog suporta a aritmética do bignum e, na verdade, tem esse comportamento levado em consideração na implementação de √: um número que é um quadrado perfeito terá sua raiz quadrada relatada como um número inteiro, enquanto um número que não é um quadrado perfeito (mas próximo o suficiente para sua raiz quadrada é integral) terá sua raiz quadrada relatada como um valor flutuante com um valor integral. Convenientemente, ℤapenas permite o primeiro tipo de valor de retorno, dando uma falha de afirmação para o último.

Pitão, 10 bytes

fsI@sjT;2Q

Suíte de teste.

Explicação

fsI@sjT;2Q

f        Q  Filter for the following in Q(input):
     jT;        convert to base 10
    s           sum
   @    2       square-root
 sI             is integer (is invariant under flooring)

CJam, 14 bytes

Obrigado a @FryAmTheEggman por salvar um byte!

{{Ab:+mq_i=},}

Experimente online!

Este é um bloco sem nome que espera a lista de entrada na pilha e deixa a lista filtrada nela.

Explicação

{e # inicie um novo bloco
 Ab e # converter para a base 10 -> dividir o número em dígitos
 : + e # soma os dígitos
 mq e # obter a raiz quadrada
 _ e # duplicar o resultado
 ou seja, # converter para inteiro
 = e # verifique se a raiz quadrada convertida e a raiz original são iguais
} e # end block
, e # filtre a lista de entrada

Haskell - 70 60 59 bytes

f=filter(\x->elem(sum.map(read.pure).show$x)$map(^2)[0..x])

Uso:

> f [0..100]
[0,1,4,9,10,13,18,22,27,31,36,40,45,54,63,72,79,81,88,90,97,100]

Bem direto; calcula a soma dos dígitos e verifica se floor (sqrt (y)) ^ 2 == y

Edit: Roubou a idéia de verificar a lista de quadrados de C. Quilley

05AB1E, 19 10 bytes

vySOtDï->—

Explicação

vy                     # for each int in list
  SO                   # digit sum
    tDï-               # difference between sqrt() and int(sqrt())
        >              # increase by 1 giving 1 (true) when equal
         —             # print current int in list if truthy

Experimente online

Editar: salvou 9 bytes graças a @Adnan

R , 57 55 bytes

Use Filterno vetor. Assume números inteiros de 32 bits, com no máximo 10 dígitos.

Caixas de canto: retorna NULLpara o vetor vazio e numeric(0)para um vetor sem números válidos. Como ambos têm comprimento zero, devem ser aceitáveis.

-2 graças a @Giuseppe

Filter(function(n)!sum(n%/%10^(0:10)%%10)^.5%%1,scan())

Experimente online!

PowerShell , 64 54 bytes

$args|?{!([math]::Sqrt(([char[]]"$_"-join'+'|iex))%1)}

Experimente online!

-10 bytes graças ao mazzy

Recebe entrada como argumentos de linha de comando (veja exemplos abaixo), que são processados ​​no PowerShell na matriz $args. Nós canalizamos isso para ?um alias para Where-Object(funções semelhantes a filter) para selecionar nossa saída. Nossa seleção é baseada na chamada .NET [math]::Sqrt()da soma de dígitos do número com um número inteiro !(...%1). Inteiros resultarão em 0, que quando noted se torna Trueenquanto raízes não inteiras se tornam False.

Como mencionado em outro lugar, "retornando" uma matriz vazia não faz sentido, pois é convertida para $nullassim que sai do escopo; portanto, a saída para uma entrada vazia não é nada.

Exemplos

PS C:\Tools\Scripts\golfing> .\return-integers-with-square-digit-sums.ps1 1 4 9 16 25 1111
1
4
9
1111

PS C:\Tools\Scripts\golfing> .\return-integers-with-square-digit-sums.ps1 1431 2 0 22 999999999
1431
0
22
999999999

PS C:\Tools\Scripts\golfing> .\return-integers-with-square-digit-sums.ps1 22228 4 113125 22345
22228
4
22345

PS C:\Tools\Scripts\golfing> .\return-integers-with-square-digit-sums.ps1 

PS C:\Tools\Scripts\golfing> .\return-integers-with-square-digit-sums.ps1 1337 4444
4444

Python 2, 76 bytes

lambda l:filter(lambda n:eval(("sum(map(int,`n`))**.5==int("*2)[:-6]+")"),l)

Experimente aqui!

Algum abuso de avaliação para verificar um número quadrado, o resto é bastante espetacular.
A declaração eval é avaliada como sum(map(int,n ))**.5==int(sum(map(int,n))**.5)

Oracle SQL 11.2, 213 bytes

WITH v AS(SELECT a,SQRT(XMLQUERY(REGEXP_REPLACE(a,'(\d)','+\1')RETURNING CONTENT).GETNUMBERVAL())s FROM(SELECT TRIM(COLUMN_VALUE)a FROM XMLTABLE(('"'||REPLACE(:1,',','","')||'"'))))SELECT a FROM v WHERE s=CEIL(s);

Sem golfe

WITH v AS
(  
  SELECT a,SQRT(XMLQUERY( 
                   REGEXP_REPLACE(a,'(\d)','+\1')  -- Add a + in front of each digit 
                   RETURNING CONTENT
               ).GETNUMBERVAL())s                  -- Evaluate the expression generated by the added +
  FROM 
  (SELECT TRIM(COLUMN_VALUE)a FROM XMLTABLE(('"'||REPLACE(:1,',','","')||'"'))) -- Split string on ','
)
SELECT a FROM v WHERE s=CEIL(s) -- Is a square if square has no decimal part

Braquilog , 26 bytes

:1f.
e.(:ef+~^[X:2]h>0;.0)

Exemplo:

?- run_from_file('code.brachylog',[1431:2:0:22:999999999],Z).
Z = [1431, 0, 22, 999999999]

Explicação

Essa é uma situação em que algo funciona um pouco bem demais ... a ~^[X:2]parte é verdadeira tanto positiva quanto negativa X, para evitar duplicatas, preciso especificar isso X > 0.

A ;.0parte está aqui devido a um erro (enumerar não funciona no número inteiro 0).

• Predicado principal

  :1f.                Find all values of Input which satisfy predicate 1
  

• Predicado 1

  e.                  Unify output with an element of the input
  (
    :ef               Find all elements of Output (i.e. all digits)
       +              Sum the digits
        ~^[X:2]       True if that sum is the result of X², whatever X is
               h>0    Impose that X > 0
  ;                   OR
    .0                True if Output is 0
  )
  

Python 2, 53 bytes

lambda x:[n for n in x if sum(map(int,`n`))**.5%1==0]

Teste em Ideone .

J, 33 27 bytes

6 bytes graças a @miles .

#~[:(=<.)@%:+/"1@(10&#.inv)

Em intérpretes online, invnão é instalado. Mude isso para ^:_1.

Uso

>> f =: #~[:(=<.)@%:+/"1@(10&#.inv)
>> f 1 4 9 16 25 1111 0
<< 1 4 9 1111 0

Onde >>está STDIN e <<está STDOUT.

Ligeiramente não-destruído

to_base_10 =: 10&#.^:_1
sum        =: +/"1
sqrt       =: %:
floor      =: <.
itself     =: ]
equals     =: =
of         =: @
is_integer =: equals floor
test       =: is_integer of sqrt
copies_of  =: #
f =: copies_of~ [: test (sum of to_base_10)

Versão anterior de 33 bytes

(]=*:@<.@%:)@(+/"1@(10#.^:_1]))#]

Uso

>> f =: (]=*:@<.@%:)@(+/"1@(10#.^:_1]))#]
>> f 1 4 9 16 25 1111 0
<< 1 4 9 1111 0

Onde >>está STDIN e <<está STDOUT.

Ligeiramente não-destruído

to_base_10 =: 10#.^:_1]
sum        =: +/"1
sqrt       =: %:
floor      =: <.
square     =: *:
itself     =: ]
equals     =: =
of         =: @
test       =: itself equals square of floor of sqrt
copies_of  =: #
f =: (test of (sum of to_base_10)) copies_of itself

Javascript 66 bytes

a=>a.filter(b=>(e=Math.sqrt((b+"").split``.reduce((c,d)=>c-+-d)))==(e|0))

Obrigado por SergioFC por salvar 7 bytes

Perl 5, 42 bytes

41, mais 1 para em -pevez de-e

my$s;map$s+=$_,/./g;$_ x=sqrt$s==~~sqrt$s

Explicação:

• -p obtém cada número inteiro de entrada em uma nova linha e atribui $_ a essa sequência.
• my$s inicializa a variável $s para nada, novamente para cada número inteiro de entrada.
• map$s+=$_,/./g pega cada caractere numérico e o adiciona numericamente ao $s . (A nova linha se torna 0 quando numerada.)
• sqrt$s==~~sqrt$stesta se $spossui uma raiz quadrada não-íntegra e $_ x=cria $_em si mesma ou na cadeia vazia, dependendo desse teste.
• -p impressões $_

Graças a Brad Gilbert b2gills por salvar três bytes.

Também 41 mais 1:

my$s;s/./$s+=$&/ger;$_ x=sqrt$s==~~sqrt$s

• s/./$s+=$&/geradiciona cada caractere numérico a $s(e a nova linha é 0 como acima)

JavaScript (Node.js) , 48 bytes

a=>a.filter(b=>eval([...b+""].join`+`)**.5%1==0)

Experimente online!

Explicação

a =>                                  // lambda function taking one argument
    a.filter(                         // filter the list
        eval(                         // begin eval
            [...b+""]                 // convert number to array of digits 
                .join`+`              // join them with + sign
            )                         // close eval. we achieved sum of all digits of number
        **.5                          // square root of number
        %1==0                         // check for perfect square
    )                                 // end filter and return value

MATL, 16 14 13 bytes

"@tV!UsX^1\?x

Experimente Online!

Explicação

        % Implicitly grab input
"       % For each number in the input
  @t    % Get this element and duplicate
  V     % Convert to it's string representation
  !     % Transpose the string so each digit is on it's own row
  U     % Convert each row to a number (separates the digits)
  s     % Compute the sum of the digits
  X^    % Compute the square root
  1\    % mod with 1 to determine if the square root is an integer
  ?x    % If there is a remainder, then remove this element from the stack
        % Implicitly display the stack contents

Julia - 38 bytes

!X=filter(i->√sum(digits(i))%1==0,X)

É muito fácil ver o que isso faz. digitsconverte um número em uma lista de seus dígitos, sumcalcula a soma dos dígitos √e produz um número inteiro se o número for um quadrado; caso contrário, haverá uma parte fracionária. %1retornará apenas a parte fracionária e, se for zero ( ==0), filtera manterá na lista, caso contrário, será filtrada.

Usado como ![22228,4,113125,22345]

Jolf, 8 bytes

Experimente aqui!

ψxd!iUuH

Explicação

ψxd!iUuH
ψxd       filter the input according to the input
      uH  digit sum of H (element)
     U    sqrt of
   !i     is an integer?

MATLAB, 52 43 42 bytes

@(x)x(~mod(sum(dec2base(x,10)'-48).^.5,1))

Cria uma função anônima chamada ansque pode ser chamada com uma matriz como entrada:ans([22228,4,113125,22345]) .

Demo Online . A demonstração online está no Octave, que não funciona para a entrada vazia, mas o MATLAB funciona.

Explicação

Convertemos cada elemento da matriz de entrada na base 10, o que produzirá uma matriz de caracteres 2D em que cada linha contém os dígitos de um número na matriz. Para converter esses caracteres em números, subtraímos 48 (ASCII para '0'). Em seguida, somamos as linhas, obtemos a raiz quadrada e determinamos se cada valor é um quadrado perfeito ~mod 1. Em seguida, usamos esse booleano para filtrar a matriz de entrada.

Clojure, 110 bytes

(fn[t](filter(fn[x](let[a(reduce +(*(count(str x))-48)(map int(str x)))](some #(=(* % %)a)(range(inc a)))))t))

Calcula a soma dos dígitos dos números e depois filtra aqueles para os quais não existe um número ao quadrado igual à soma.

Você pode ver o resultado aqui - https://ideone.com/ciKOje

Perl 6 ,  38   35 bytes

{.grep: {($/=sqrt [+] .comb)==$/.Int}}
{.grep: {($/=.comb.sum.sqrt)==$/.Int}}
{.grep: {($/=sqrt [+] .comb)==^$/}}
{.grep: {($/=.comb.sum.sqrt)==^$/}}

Teste:

#! /usr/bin/env perl6

use v6.c;
use Test;

my @tests = (
  [1,4,9,16,25,1111] => [1,4,9,1111],
  [1431,2,0,22,999999999] => [1431,0,22,999999999],
  [22228,4,113125,22345] => [22228,4,22345],
  [] => [],
  [421337,99,123456789,1133557799] => [],
);

plan +@tests;

my &sq-digit-sum = {.grep: {($/=sqrt [+] .comb)==^$/}}

for @tests -> $_ ( :key($input), :value($expected) ) {
  is sq-digit-sum($input), $expected, .gist
}

1..5
ok 1 - [1 4 9 16 25 1111] => [1 4 9 1111]
ok 2 - [1431 2 0 22 999999999] => [1431 0 22 999999999]
ok 3 - [22228 4 113125 22345] => [22228 4 22345]
ok 4 - [] => []
ok 5 - [421337 99 123456789 1133557799] => []

C, 143 141 bytes

• salvou 2 bytes, @ user6188402

i;q(char*n){double m=0;while(*n)m+=*n++-48;m=sqrt(m)-(int)sqrt(m);return !m;}s(n,s)char**n;{i=-1;while(++i<s)if(q(n[i]))printf("%s\n",n[i]);}

Tentativa sem golfe online

int q(char*n)
{
    double m=0;

    while(*n) // sum digits
        m+=*n++-48;

    // get the decimal part of its square root
    m=sqrt(m)-(int)sqrt(m);

    // true if decimal part is zero
    return !m;
}

// input is text, can be a file
void s(char**n, int s)
{
    int i=-1;

    while(++i<s) // for each number in input
        if(q(n[i])) // if is square
            printf("%s\n",n[i]); // output is terminal
}

Retina , 69

Porque testar quadrados perfeitos na retina. Isso pode ser modificado para o cálculo da raiz quadrada inteira generalizada .

. +
$ & a $ &
+ `\ b \ d
$ * b 


\ bb
$ &:
+ `(\ bb +) :( bb \ 1)
$ 1 $ 2:
G` (: a | 0 $)
.*uma

Entrada é uma lista separada por nova linha.

Experimente online.

• Etapa 1 - repita o número em cada linha e separe com a
• Etapa 2 - converta cada dígito antes do aunário, expresso como bs, separado por espaços
• Etapa 3 - remover espaços - cada unário agora representa a soma dos dígitos
• Fase 4 e 5 - Use o fato de que quadrados perfeitos podem ser expressos 1 + 3 + 5 + 7 + .... Divida cada unidade em conformidade
• Etapa 6 - filtro grep apenas aqueles que se dividem exatamente na forma acima
• Etapa 7 - descartar tudo, exceto o número original

Python, 50 bytes

filter(lambda x:sum(map(int,str(x)))**0.5%1==0,in)

Se n for a lista de entrada de números

Ruby , 39 bytes

->a{a.reject{|x|x.digits.sum**0.5%1>0}}

Experimente online!

K (oK) , 19 17 13 bytes

Solução:

(~1!%+/.:'$)#

Experimente online!

Explicação:

(~1!%+/.:'$)# / the solution
(          )# / apply function to list
          $   / convert to string
       .:'    / value (.:) each (')
     +/       / sum
    %         / square-root
  1!          / modulo 1
 ~            / not

Notas:

• -2 bytes com uma maneira mais inteligente de identificar quadrados
• -4 bytes graças a ngn

MathGolf , 5 4 bytes

gÅΣ°

Experimente online!

Explicação:

gÅ    Filter by the next two instructions
  Σ   The digit sum
   °  Is a perfect square?

O MathGolf ainda está em desenvolvimento, portanto, suponho que em breve haverá entrada implícita para eliminar esse primeiro byte. Yay!