Introducción y crédito

Todos conocemos y amamos nuestras increíbles reglas para probar si un número es divisible por 11 o 3, que es solo una suma inteligente sobre los dígitos del número. Ahora, este desafío lleva esto a un nuevo nivel, al exigirle que calcule la suma de los dígitos y luego verifique si el resultado es un cuadrado entero perfecto, ninguna de las cuales operaciones generalmente se pueden hacer muy cortas. Como esta propiedad también es muy difícil de ver cuando se mira un número, queremos que esto se haga para listas completas de números para que podamos ahorrar trabajo humano. ¡Así que este es tu desafío ahora!

Esta fue una tarea en el curso de programación funcional de mi universidad. Esta tarea ahora está cerrada y se ha discutido en clase y tengo el permiso de mi profesor para publicarla aquí (pregunté explícitamente).

Especificación

Entrada

Su entrada es una lista de enteros no negativos, en cualquier formato de E / S estándar.
Puede elegir el formato de lista según lo necesite su idioma

Salida

La salida es una lista de enteros, en cualquier formato de E / S estándar.

¿Qué hacer?

Filtre todos los enteros de la lista de entrada para los cuales la suma de los dígitos no es un cuadrado (de un entero).
El orden de los elementos no se puede cambiar, por ejemplo, si se obtiene [1,5,9]puede no volver[9,1]

Posibles casos de esquina

0 es un número entero no negativo y, por lo tanto, una entrada válida y 0 también es una raíz entera válida, por ejemplo, 0 cuenta como un cuadrado entero.
La lista vacía es una entrada y salida válida también.

¿Quién gana?

Este es el código de golf, por lo que gana la respuesta más corta en bytes.
Se aplican reglas estándar, por supuesto.

Casos de prueba

[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] -> []

Ejemplo paso a paso

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

Pruébalo aquí!

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

Mathematica, 39 36 bytes

Una función anónima:

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

LLlAMnYP guardó un byte. ¡Gracias!

Martin Ender salvó tres más al reemplazar IntegerQcon AtomQ. ¡Inteligente! (El resultado de √será exacto, por lo que devuelve una expresión compuesta como Sqrt[5]si su argumento no fuera un cuadrado).

Jalea, 8 7 bytes

1 byte gracias a @ Sp3000 .

DSƲðÐf

Banco de pruebas.

Explicación

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

{ẹ+√ℤ&}ˢ

Pruébalo en línea!

Explicación

{ẹ+√ℤ&}ˢ
{     }ˢ  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

Esto &significa que los elementos de salida son los mismos que los de la lista de entrada, pero se ℤproducirá un error si la entrada del bloque no es un número cuadrado, por lo que obtenemos la lista de entrada con elementos con sumas de dígitos no cuadrados descartados.

Tenga en cuenta que al principio puede parecer que hay un problema de inexactitud de coma flotante aquí (algunos enteros no cuadrados muy grandes tienen raíces cuadradas enteras debido al redondeo). Sin embargo, Brachylog admite aritmética bignum, y en realidad tiene este comportamiento factorizado en su implementación de √: un número que es un cuadrado perfecto tendrá su raíz cuadrada informada como un entero, mientras que un número que no es un cuadrado perfecto (pero lo suficientemente cerca como para que sea raíz cuadrada es integral) tendrá su raíz cuadrada informada como flotante con un valor integral. Convenientemente, ℤsolo permite el primer tipo de valor de retorno, dando una falla de aserción para el segundo.

Pyth, 10 bytes

fsI@sjT;2Q

Banco de pruebas.

Explicación

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

¡Gracias a @FryAmTheEggman por guardar un byte!

{{Ab:+mq_i=},}

Pruébalo en línea!

Este es un bloque sin nombre que espera la lista de entrada en la pila y deja la lista filtrada en ella.

Explicación

{e # comienza un nuevo bloque
 Ab e # convertir a base 10 -> dividir número en dígitos
 : + e # suma th dígitos
 mq e # obtiene la raíz cuadrada
 _ e # duplica el resultado
 es decir, # convertir a entero
 = e # comprueba si la raíz cuadrada convertida y la original son iguales
} e # bloque final
, e # filtra la 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]

Bastante sencillo; calcula la suma de dígitos y comprueba si floor (sqrt (y)) ^ 2 == y

Editar: Robó la idea de verificar la lista de cuadrados de C. Quilley

05AB1E, 19 10 bytes

vySOtDï->—

Explicación

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

Pruébalo en línea

Editar: guardado 9 bytes gracias a @Adnan

R , 57 55 bytes

Uso Filteren el vector. Asume enteros de 32 bits, por lo que 10 dígitos como máximo.

Casos de esquina: devuelve NULLpara el vector vacío y numeric(0)para un vector sin números válidos. Ambos tienen una longitud cero, por lo que deberían ser aceptables.

-2 gracias a @Giuseppe

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

Pruébalo en línea!

PowerShell , 64 54 bytes

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

Pruébalo en línea!

-10 bytes gracias a mazzy

Toma datos como argumentos de línea de comandos (ver ejemplos a continuación), que se procesan en PowerShell en la matriz $args. Lo canalizamos a ?un alias para Where-Object(funciones similares a filter) para seleccionar nuestra salida. Nuestra selección se basa en la llamada .NET [math]::Sqrt()de la suma de dígitos del número con el que es un entero !(...%1). Los enteros resultarán en 0, que cuando noted se convierte Trueen raíces no enteras False.

Como se mencionó en otra parte "devolver" una matriz vacía no tiene sentido, ya que se convierte $nulltan pronto como deja el alcance, por lo que la salida para una entrada vacía no es nada.

Ejemplos

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)

Pruébalo aquí!

Algunos abusos de eval para verificar un número cuadrado, el resto es bastante espectacular.
La sentencia eval se evalúa 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);

Sin golf

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

Brachylog , 26 bytes

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

Ejemplo:

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

Explicación

Esta es una situación en la que algo funciona demasiado bien ... la ~^[X:2]parte es cierta tanto para positivo como para negativo X, por lo que para evitar duplicados tengo que especificar eso X > 0.

La ;.0parte está aquí debido a un error (enumerar no funciona en el entero 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]

Pruébalo en Ideone .

J, 33 27 bytes

6 bytes gracias a @miles .

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

En intérpretes en línea, invno está guardado. Cambia eso a su ^:_1lugar.

Uso

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

¿Dónde >>está STDIN y<<es STDOUT.

Ligeramente no golfista

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)

Versión 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

Donde >>es STDIN y <<es STDOUT.

Ligeramente no golfista

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

Gracias por SergioFC por guardar 7 bytes

Perl 5, 42 bytes

41, más 1 para -pe lugar de-e

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

Explicación:

• -p obtiene cada entero de entrada en una nueva línea y asigna $_ a esa cadena.
• my$s inicializa la variable $s a nada, de nuevo para cada entero de entrada.
• map$s+=$_,/./g toma cada carácter numérico y lo agrega numéricamente a $s . (La nueva línea se convierte en 0 cuando se numera).
• sqrt$s==~~sqrt$sprueba si $stiene una raíz cuadrada no integral, y$_ x= convierte $_en sí mismo o en la cadena vacía dependiendo de esa prueba.
• -p huellas dactilares $_

Gracias a Brad Gilbert b2gills por guardar tres bytes.

También 41 más 1:

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

• s/./$s+=$&/geragrega cada carácter numérico a $s(y la nueva línea es 0 como arriba)

JavaScript (Node.js) , 48 bytes

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

Pruébalo en línea!

Explicación

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

Pruébalo en línea!

Explicación

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

Es bastante fácil ver qué hace esto. digitsconvierte un número en una lista de sus dígitos, sumasí calcula la suma de dígitos, √luego producirá un número entero si el número es un cuadrado, de lo contrario habrá una parte fraccionaria. %1devolverá solo la parte fraccionaria, y si es cero ( ==0),filter mantendrá en la lista, de lo contrario se filtrará.

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

Jolf, 8 bytes

Pruébalo aquí!

ψxd!iUuH

Explicación

ψ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))

Crea una función anónima llamada ans que se puede llamar con una serie como entrada: ans([22228,4,113125,22345]).

Demo en línea . La demostración en línea está en Octave, que no funciona para la entrada vacía, pero MATLAB sí.

Explicación

Convertimos cada elemento en la matriz de entrada a base 10, lo que producirá una matriz de caracteres 2D donde cada fila contiene los dígitos de un número en la matriz. Para convertir estos caracteres en números, restamos 48 (ASCII para '0'). Luego sumamos a través de las filas, sacamos la raíz cuadrada y determinamos si cada valor es un cuadrado perfecto ~mod 1. Luego usamos este booleano para filtrar la 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 la suma de dígitos numéricos y luego filtra aquellos para los cuales no existe un número que al cuadrado sea igual a la suma.

Puede ver el resultado aquí: 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)==^$/}}

Prueba:

#! /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

• guardado 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]);}

Intente sin golf en línea

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 prueba de cuadrados perfectos en la retina. Esto puede ser modificar para el cálculo generalizado de raíz cuadrada entera .

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


\cama y desayuno
PS
+ `(\ bb +) :( bb \ 1)
$ 1 $ 2:
G` (: a | 0 $)
.*una

La entrada es una lista separada por una nueva línea.

Pruébalo en línea.

• Etapa 1: repita el número en cada línea y sepárelo con a
• Etapa 2: convierta cada dígito antes del aunario expresado como bs, separado con espacios
• Etapa 3 - eliminar espacios - cada unario ahora representa la suma de dígitos
• Etapa 4 y 5 - Usa el hecho de que los cuadrados perfectos pueden expresarse 1 + 3 + 5 + 7 + .... Dividir cada unario en consecuencia
• Etapa 6: filtro grep solo los que se dividen exactamente en la forma anterior
• Etapa 7: descarta todo menos el número original

Python, 50 bytes

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

Si n es la lista de entrada de números

Ruby , 39 bytes

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

Pruébalo en línea!

K (oK) , 19 17 13 bytes

Solución:

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

Pruébalo en línea!

Explicación:

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

Notas:

• -2 bytes con una forma más inteligente de identificar cuadrados
• -4 bytes gracias a ngn

MathGolf , 5 4 bytes

gÅΣ°

Pruébalo en línea!

Explicación:

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

MathGolf todavía está en desarrollo, por lo que supongo que pronto llegará una entrada implícita para eliminar ese primer byte. ¡Hurra!