Introduzione e credito

Conosciamo tutti e amiamo le nostre fantastiche regole per testare se un numero è divisibile per 11 o 3, che è solo una somma intelligente sulle cifre del numero. Ora questa sfida porta questo a un nuovo livello, richiedendo di calcolare la somma delle cifre e quindi controllando se il risultato è un quadrato intero perfetto, nessuna delle quali operazioni di solito possono essere eseguite molto brevi. Poiché questa proprietà è anche molto difficile da vedere quando si guarda un numero, vogliamo che ciò avvenga per interi elenchi di numeri in modo da poter salvare il lavoro umano. Quindi questa è la tua sfida ora!

Questo è stato un incarico nel mio corso di programmazione funzionale all'università. Questo compito è ora chiuso ed è stato discusso in classe e ho il permesso del mio professore di pubblicarlo qui (ho chiesto esplicitamente).

specificazione

Ingresso

Il tuo input è un elenco di numeri interi non negativi, in qualsiasi formato I / O standard.
Puoi scegliere il formato dell'elenco secondo la tua lingua

Produzione

L'output è un elenco di numeri interi, in qualsiasi formato I / O standard.

Cosa fare?

Filtra ogni numero intero dall'elenco di input per il quale la somma delle cifre non è un quadrato (di un numero intero).
L'ordine degli elementi non può essere modificato, ad esempio, se si ottiene [1,5,9]si può non tornare[9,1]

Casi d'angolo potenziali

0 è un numero intero non negativo e quindi un input valido e 0 è anche un numero intero valido, ad es. 0 conta come un numero intero.
L'elenco vuoto è anche un input e un output validi.

Chi vince?

Questo è code-golf quindi vince la risposta più breve in byte!
Ovviamente si applicano le regole standard.

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

Esempio passo-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 byte

#s,DBq

Provalo qui!

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

Mathematica, 39 36 byte

Una funzione anonima:

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

LLlAMnYP ha salvato un byte. Grazie!

Martin Ender ne ha salvati altri tre sostituendoli IntegerQcon AtomQ. Intelligente! (Il risultato di √sarà esatto, quindi restituisce un'espressione composta come Sqrt[5]se il suo argomento non fosse un quadrato.)

Gelatina, 8 7 byte

1 byte grazie a @ Sp3000 .

DSƲðÐf

Suite di test.

Spiegazione

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

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

Brachylog v2, 8 byte

{ẹ+√ℤ&}ˢ

Provalo online!

Spiegazione

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

Ciò &significa che gli elementi in uscita sono gli stessi di quelli nella lista di input, ma ℤsi cancellerà se l'input del blocco non è un numero quadrato, quindi otteniamo la lista di input con elementi con somme di cifre non quadrate scartate.

Si noti che all'inizio potrebbe esserci un problema di inesattezza in virgola mobile qui (alcuni interi non quadrati molto grandi hanno radici quadrate intere dovute all'arrotondamento). Tuttavia, Brachylog supporta l'aritmetica del bignum e in realtà ha questo comportamento preso in considerazione nella sua implementazione di √: un numero che è un quadrato perfetto avrà la sua radice quadrata riportata come un intero, mentre un numero che non è un quadrato perfetto (ma abbastanza vicino che il suo la radice quadrata è integrale) avrà la radice quadrata riportata come float con un valore integrale. Convenientemente, ℤconsente solo il primo tipo di valore di ritorno, dando un errore di asserzione per quest'ultimo.

Pyth, 10 byte

fsI@sjT;2Q

Suite di test.

Spiegazione

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 byte

Grazie a @FryAmTheEggman per aver salvato un byte!

{{Ab:+mq_i=},}

Provalo online!

Questo è un blocco senza nome che si aspetta l'elenco di input nello stack e lascia su di esso l'elenco filtrato.

Spiegazione

{e # avvia un nuovo blocco
 Ab e # converte in base 10 -> numero diviso in cifre
 : + e # somma cifre
 mq e # ottiene la radice quadrata
 _ e # duplica il risultato
 cioè # converti in numero intero
 = e # controlla se la radice quadrata convertita e quella originale sono uguali
} e # blocco finale
, e # filtra l'elenco di input

Haskell - 70 60 59 byte

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]

Abbastanza semplice; calcola la somma delle cifre e controlla se floor (sqrt (y)) ^ 2 == y

Modifica: rubato l'idea di controllare l'elenco dei quadrati da C. Quilley

05AB1E, 19 10 byte

vySOtDï->—

Spiegazione

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

Provalo online

Modifica: salvato 9 byte grazie a @Adnan

R , 57 55 byte

Usa Filtersul vettore. Presuppone numeri interi a 32 bit, quindi max 10 cifre.

Casi angolari: restituisce NULLper il vettore vuoto e numeric(0)per un vettore senza numeri validi. Entrambi hanno lunghezza zero quindi dovrebbe essere accettabile.

-2 grazie a @Giuseppe

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

Provalo online!

PowerShell , 64 54 byte

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

Provalo online!

-10 byte grazie a mazzy

Accetta input come argomenti della riga di comando (vedere gli esempi seguenti), che vengono elaborati in PowerShell nell'array $args. Lo colleghiamo ad ?un alias per Where-Object(funzioni simili a filter) per selezionare il nostro output. La nostra selezione si basa sulla chiamata .NET [math]::Sqrt()della cifra cifra del numero è un numero intero con !(...%1). I numeri interi comporteranno 0, che quando notdiventa diventa Truementre diventano radici non intere False.

Come menzionato altrove, "restituire" un array vuoto non ha senso, poiché viene convertito $nullnon appena lascia l'ambito, quindi l'output per un input vuoto non è nulla.

Esempi

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 byte

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

Provalo qui!

Qualche abuso di eval per verificare un numero quadrato, il resto è piuttosto spettacolare.
I Esamina istruzione eval per sum(map(int,n ))**.5==int(sum(map(int,n))**.5)

Oracle SQL 11.2, 213 byte

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

Un-golfed

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 byte

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

Esempio:

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

Spiegazione

Questa è una situazione in cui qualcosa funziona un po 'troppo bene ... il ~^[X:2] parte è vera sia per il positivo che per il negativo X, quindi per evitare duplicati devo specificarlo X > 0.

La ;.0parte è qui a causa di un bug (l'enumerato non funziona sull'intero 0).

• Predicato principale

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

• Predicato 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 byte

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

Provalo su Ideone .

J, 33 27 byte

6 byte grazie a @miles .

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

Negli interpreti online, invnon è presente. Cambialo in^:_1 invece.

uso

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

Dov'è >>STDIN e<<è STDOUT.

Leggermente ungolfed

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)

Versione precedente a 33 byte

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

uso

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

Dov'è >>STDIN ed <<è STDOUT.

Leggermente ungolfed

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 byte

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

Grazie per SergioFC per aver salvato 7 byte

Perl 5, 42 byte

41, più 1 per -peanziché-e

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

Spiegazione:

• -p ottiene ogni numero intero di input su una nuova riga e assegna $_ a quella stringa.
• my$sinizializza la variabile $ssu nulla, di nuovo per ogni numero intero di input.
• map$s+=$_,/./gprende ogni carattere numerico e lo aggiunge numericamente a $s. (La nuova riga diventa 0 quando è numerata.)
• sqrt$s==~~sqrt$sverifica se $sha una radice quadrata non integrata e $_ x=crea $_se stesso o la stringa vuota a seconda di quel test.
• -p stampe $_

Grazie a Brad Gilbert b2gills per aver salvato tre byte.

Anche 41 più 1:

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

• s/./$s+=$&/geraggiunge ogni carattere numerico a $s(e la nuova riga è 0 come sopra)

JavaScript (Node.js) , 48 byte

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

Provalo online!

Spiegazione

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 byte

"@tV!UsX^1\?x

Provalo online!

Spiegazione

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

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

È abbastanza facile vedere cosa fa. digitsconverte un numero in un elenco delle sue cifre, sumquindi calcola la somma delle cifre, √quindi produrrà un numero intero se il numero è un quadrato, altrimenti ci sarà una parte frazionaria. %1restituirà solo la parte frazionaria e se è zero ( ==0),filter la manterrà nell'elenco, altrimenti verrà filtrata.

Usato come ![22228,4,113125,22345]

Jolf, 8 byte

Provalo qui!

ψxd!iUuH

Spiegazione

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

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

Crea una funzione anonima di nome ansche può essere chiamata con un allineamento come input: ans([22228,4,113125,22345]).

Demo online . La demo online è in Octave che non funziona per l'input vuoto, ma MATLAB funziona.

Spiegazione

Convertiamo ogni elemento nella matrice di input in base 10 che produrrà una matrice di caratteri 2D in cui ogni riga contiene le cifre di un numero nella matrice. Per convertire questi caratteri in numeri, sottraggiamo 48 (ASCII per '0'). Quindi sommiamo le righe, prendiamo la radice quadrata e determiniamo se ogni valore è un quadrato perfetto ~mod 1. Quindi utilizziamo questo booleano per filtrare l'array di input.

Clojure, 110 byte

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

Calcola la somma delle cifre dei numeri e quindi filtra quelle per le quali non esiste un numero al quadrato uguale alla somma.

Puoi vedere il risultato qui - https://ideone.com/ciKOje

Perl 6 ,  38   35 byte

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

Test:

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

• salvato 2 byte, @ 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]);}

Ungolfed prova 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

Perché test per i quadrati perfetti nella retina. Questo può essere modificato per il calcolo della radice quadrata intera generalizzata .

. +
$ E un $ &
+ \ B \ d `
$ B * 


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

L'input è un elenco separato da una nuova riga.

Provalo online.

• Fase 1: ripetere il numero su ciascuna riga e separare con a
• Fase 2: converti ogni cifra prima che ain unaria espressa come bs, separata da spazi
• Fase 3: rimuovere gli spazi: ogni unario ora rappresenta la somma delle cifre
• Fase 4 e 5 - Usa il fatto che i quadrati perfetti possono essere espressi 1 + 3 + 5 + 7 + .... Dividi ogni unario di conseguenza
• Fase 6: filtro grep solo quelli che si dividono esattamente nella forma sopra
• Fase 7: scarta tutto tranne il numero originale

Python, 50 byte

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

Se n è un elenco di numeri di input

Rubino , 39 byte

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

Provalo online!

K (oK) , 19 17 13 byte

Soluzione:

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

Provalo online!

Spiegazione:

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

Gli appunti:

• -2 byte con un modo più intelligente di identificare i quadrati
• -4 byte grazie a ngn

MathGolf , 5 4 byte

gÅΣ°

Provalo online!

Spiegazione:

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

MathGolf è ancora in fase di sviluppo, quindi suppongo che l'input implicito arriverà presto per radere via quel primo byte. Sìì!