Introduction et crédit

Nous connaissons et aimons tous nos règles géniales pour tester si un nombre est divisible par 11 ou 3, ce qui est juste une somme intelligente sur les chiffres du nombre. Maintenant, ce défi porte cela à un nouveau niveau, en vous obligeant à calculer la somme des chiffres, puis à vérifier si le résultat est un carré entier parfait, aucune des opérations ne pouvant généralement être effectuée très rapidement. Comme cette propriété est également très difficile à voir lorsque l'on regarde un nombre, nous voulons que cela soit fait pour des listes entières de nombres afin que nous puissions économiser du travail humain. C'est donc votre défi maintenant!

C'était une affectation à mon cours universitaire de programmation fonctionnelle. Ce devoir est maintenant fermé et a été discuté en classe et j'ai la permission de mon professeur de le poster ici (j'ai demandé explicitement).

spécification

Contribution

Votre entrée est une liste d'entiers non négatifs, dans n'importe quel format d'E / S standard.
Vous pouvez choisir le format de liste selon votre langue

Sortie

La sortie est une liste d'entiers, dans n'importe quel format d'E / S standard.

Que faire?

Filtrez chaque entier de la liste d'entrée pour lequel la somme des chiffres n'est pas un carré (d'un entier).
L'ordre des éléments ne peut pas être modifié, par exemple, si vous obtenez, [1,5,9]vous ne pouvez pas revenir[9,1]

Boîtes de coin potentielles

0 est un entier non négatif et donc une entrée valide et 0 est également une racine entière valide, par exemple 0 compte comme un carré entier.
La liste vide est également une entrée et une sortie valides.

Qui gagne?

Il s'agit de code-golf, donc la réponse la plus courte en octets l'emporte!
Les règles standard s'appliquent bien sûr.

Cas de test

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

Exemple pas à pas

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 octets

#s,DBq

Essayez-le ici!

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

Mathematica, 39 36 octets

Une fonction anonyme:

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

LLlAMnYP a enregistré un octet. Merci!

Martin Ender a sauvé trois de plus en remplaçant IntegerQpar AtomQ. Intelligent! (Le résultat de √sera exact, il renvoie donc une expression composée comme Sqrt[5]si son argument n'est pas un carré.)

Gelée, 8 7 octets

1 octet grâce à @ Sp3000 .

DSƲðÐf

Suite de tests.

Explication

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

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

Brachylog v2, 8 octets

{ẹ+√ℤ&}ˢ

Essayez-le en ligne!

Explication

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

Les &moyens que la sortie des éléments sont les mêmes que ceux de la liste d'entrée, mais ℤsera erreur si est pas un nombre carré l'entrée du bloc, donc nous obtenons la liste d'entrée avec des éléments avec des sommes de chiffres non carrés mis au rebut.

Notez qu'il peut d'abord sembler y avoir un problème d'imprécision en virgule flottante (certains très grands entiers non carrés ont des racines carrées entières en raison de l'arrondissement). Cependant, Brachylog prend en charge l'arithmétique du bignum, et a en fait ce comportement pris en compte dans son implémentation de √: un nombre qui est un carré parfait verra sa racine carrée rapportée comme un entier, tandis qu'un nombre qui n'est pas un carré parfait (mais suffisamment proche pour que son racine carrée est intégrale) verra sa racine carrée rapportée comme un flottant avec une valeur intégrale. De façon pratique, ℤne permet que le premier type de valeur de retour, ce qui donne un échec d'assertion pour le second.

Pyth, 10 octets

fsI@sjT;2Q

Suite de tests.

Explication

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 octets

Merci à @FryAmTheEggman d'avoir enregistré un octet!

{{Ab:+mq_i=},}

Essayez-le en ligne!

Il s'agit d'un bloc sans nom qui attend la liste d'entrée sur la pile et laisse la liste filtrée dessus.

Explication

{e # commence un nouveau bloc
 Ab e # convertir en base 10 -> diviser le nombre en chiffres
 : + e # somme les chiffres
 mq e # obtenir la racine carrée
 _ e # dupliquer le résultat
 ie # convertir en entier
 = e # vérifie si la racine carrée convertie et l'originale sont égales
} e # bloc de fin
, e # filtre la liste d'entrée

Haskell - 70 60 59 octets

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

Usage:

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

Assez simple; calcule la somme des chiffres et vérifie si le plancher (sqrt (y)) ^ 2 == y

Edit: A volé l'idée de vérifier la liste des carrés de C. Quilley

05AB1E, 19 10 octets

vySOtDï->—

Explication

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

Essayez-le en ligne

Edit: 9 octets enregistrés grâce à @Adnan

R , 57 55 octets

Utiliser Filtersur le vecteur. Suppose des entiers de 32 bits, donc 10 chiffres max.

Cas d'angle: renvoie NULLpour le vecteur vide et numeric(0)pour un vecteur sans nombre valide. Ils ont tous deux une longueur nulle et devraient donc être acceptables.

-2 grâce à @Giuseppe

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

Essayez-le en ligne!

PowerShell , 64 54 octets

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

Essayez-le en ligne!

-10 octets grâce à mazzy

Prend l'entrée comme arguments de ligne de commande (voir les exemples ci-dessous), qui sont traités dans PowerShell dans le tableau $args. Nous redirigeons cela vers ?un alias pour Where-Object(fonctions similaires à filter) afin de sélectionner notre sortie. Notre sélection est basée sur l'appel .NET [math]::Sqrt()de la somme des chiffres du nombre est un entier avec !(...%1). Les entiers donneront 0, qui lorsque noted devient Truealors que les racines non entières le deviennent False.

Comme mentionné ailleurs, «retourner» un tableau vide n'a pas de sens, car il est converti $nulldès qu'il quitte la portée, donc la sortie pour une entrée vide n'est rien.

Exemples

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 octets

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

Essayez-le ici!

Certains abus d'égalité pour vérifier un nombre carré, le reste est assez peu spectaculaire.
L'instruction eval est évaluée à sum(map(int,n ))**.5==int(sum(map(int,n))**.5)

Oracle SQL 11.2, 213 octets

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

Non-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 octets

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

Exemple:

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

Explication

C'est une situation où quelque chose fonctionne un peu trop bien ... la ~^[X:2]partie est vraie à la fois pour le positif et le négatif X, donc pour éviter les doublons, je dois le préciser X > 0.

La ;.0partie est ici en raison d'un bogue (l'énumération ne fonctionne pas sur l'entier 0).

• Prédicat principal

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

• Prédicat 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 octets

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

Testez-le sur Ideone .

J, 33 27 octets

6 octets grâce à @miles .

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

Dans les interprètes en ligne, invn'est pas stocké. Remplacez-le par à la ^:_1place.

Usage

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

Où >>est STDIN et <<STDOUT.

Légèrement non golfé

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)

Version précédente de 33 octets

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

Usage

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

Où >>est STDIN et <<STDOUT.

Légèrement non golfé

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 octets

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

Merci pour SergioFC d'avoir économisé 7 octets

Perl 5, 42 octets

41, plus 1 pour -peau lieu de-e

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

Explication:

• -pobtient chaque entier d'entrée sur une nouvelle ligne et l'affecte $_à cette chaîne.
• my$sinitialise la variable $sà rien, à nouveau pour chaque entier d'entrée.
• map$s+=$_,/./gsaisit chaque caractère numérique et l'ajoute numériquement à $s. (La nouvelle ligne devient 0 lorsqu'elle est numérotée.)
• sqrt$s==~~sqrt$steste si $sa une racine carrée non intégrale, et $_ x=se $_transforme en lui-même ou la chaîne vide en fonction de ce test.
• -p impressions $_

Merci à Brad Gilbert b2gills pour avoir économisé trois octets.

Aussi 41 plus 1:

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

• s/./$s+=$&/gerajoute chaque caractère numérique à $s(et la nouvelle ligne est 0 comme ci-dessus)

JavaScript (Node.js) , 48 octets

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

Essayez-le en ligne!

Explication

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 octets

"@tV!UsX^1\?x

Essayez-le en ligne!

Explication

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

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

C'est assez facile de voir ce que cela fait. digitsconvertit un nombre en une liste de ses chiffres, sumcalcule ainsi la somme des chiffres, √produira alors un nombre entier si le nombre est un carré, sinon il y aura une partie fractionnaire. %1ne renverra que la partie fractionnaire, et si elle est nulle ( ==0), la filtergardera dans la liste, sinon elle sera filtrée.

Utilisé comme ![22228,4,113125,22345]

Jolf, 8 octets

Essayez-le ici!

ψxd!iUuH

Explication

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

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

Crée une fonction anonyme du nom ansqui peut être appelé avec un tableau en entrée: ans([22228,4,113125,22345]).

Démo en ligne . La démo en ligne est en Octave, ce qui ne fonctionne pas pour l'entrée vide, mais MATLAB le fait.

Explication

Nous convertissons chaque élément du tableau d'entrée en base 10, ce qui donnera un tableau de caractères 2D où chaque ligne contient les chiffres d'un nombre dans le tableau. Pour convertir ces caractères en nombres, nous soustrayons 48 (ASCII pour '0'). Nous additionnons ensuite les lignes, prenons la racine carrée et déterminons si chaque valeur est un carré parfait ~mod 1. Nous utilisons ensuite ce booléen pour filtrer le tableau d'entrée.

Clojure, 110 octets

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

Calcule la somme des chiffres, puis filtre ceux pour lesquels il n'existe pas de nombre au carré égal à la somme.

Vous pouvez voir le résultat ici - https://ideone.com/ciKOje

Perl 6 ,  38   35 octets

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

Tester:

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

• enregistré 2 octets, @ 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]);}

Essai non golfé en ligne

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
}

Rétine , 69

Parce que tester des carrés parfaits dans la rétine. Ceci peut être modifié pour le calcul généralisé de la racine carrée entière .

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


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

L'entrée est une liste séparée par des sauts de ligne.

Essayez-le en ligne.

• Étape 1 - répétez le nombre sur chaque ligne et séparez-le avec a
• Étape 2 - convertir chaque chiffre avant l' aunaire exprimé en bs, séparé par des espaces
• Étape 3 - supprimer les espaces - chaque unaire représente désormais la somme des chiffres
• Étape 4 et 5 - Utilisez le fait que les carrés parfaits peuvent être exprimés 1 + 3 + 5 + 7 + .... Divisez chaque unaire en conséquence
• Étape 6 - filtre grep uniquement ceux qui se répartissent exactement dans la forme ci-dessus
• Étape 7 - jetez tout sauf le numéro d'origine

Python, 50 octets

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

Si n est une liste de nombres entrée

Rubis , 39 octets

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

Essayez-le en ligne!

K (oK) , 19 17 13 octets

Solution:

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

Essayez-le en ligne!

Explication:

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

Remarques:

• -2 octets avec une façon plus intelligente d'identifier les carrés
• -4 octets grâce à ngn

MathGolf , 5 4 octets

gÅΣ°

Essayez-le en ligne!

Explication:

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

MathGolf est toujours en développement, donc je suppose que l'entrée implicite arrive bientôt pour raser ce premier octet. Yay!