Meu amigo e eu estávamos trabalhando em um laboratório em nossa aula de Ciência da Computação da AP e decidimos codificar um dos problemas, já que ainda tínhamos metade da aula livre depois que terminamos. Aqui está a pergunta:

Dado um número n, n é divisível por cada um de seus dígitos?

Por exemplo, 128 será aprovado neste teste - é divisível por 1,2 e 8. Quaisquer números com zero desqualificam automaticamente o número. Embora você possa usar outras linguagens e publicar soluções com elas, se quiser, estamos mais interessados ​​em ver como pessoas compactas podem criar o programa em Java, pois essa é a linguagem que usamos na classe. Até agora, nós dois temos 51. Aqui está o meu código atual:

public boolean dividesSelf(int n){for(int p=n;n%10>0;)n/=p%(n%10)>0?.1:10;return n<1;}
// 51 characters

// Breakdown:
// for(int p=n;         Saves one semicolon to put declaration into for loop
// n%10>0;)             Basic check-for-zero
// n/=                  Pretty simple, discarding one number off of n at a time
// p%(n%10)>0?          If p (the given value) is not divisible by n%10 (the current digit)...
// .1:10;               Divide by .1 (multiply by 10) so it fails the check next iteration. If it is divisible, divide by 10 to truncate the last digit
// return n<1           If the number was fully divisible, every digit would be truncated, and n would be 0. Else, there would still be non-zero digits.

Exigências

A assinatura do método pode ser o que você quiser. Apenas conte o corpo da função. Certifique-se, no entanto, de que o método retorne um valor booleano e passe apenas em um parâmetro numérico (não em uma string).

O código deve ser capaz de passar todos esses casos (para permanecer fiel às instruções da pergunta original, somente valores booleanos verdadeiros e falsos contam se o idioma suportar booleanos. Se e somente se o seu idioma não tiver variáveis ​​booleanas, você pode representar false com 0 e true com qualquer número inteiro diferente de zero (de preferência 1 ou -1):

128 -> true
 12 -> true
120 -> false
122 -> true
 13 -> false
 32 -> false
 22 -> true
 42 -> false
212 -> true
213 -> false
162 -> true
204 -> false

Além disso, não contamos o espaço em branco, portanto, sinta-se à vontade para fazer o mesmo, a menos que o espaço em branco seja essencial para o funcionamento do programa (para que as novas linhas em Java não sejam contadas, mas um único espaço entre inte x=1conte). Boa sorte !

Perl 6, 13

sub golf($_) {
   $_%%.comb.all
}

Usa a variável implícita $_- $_ %% .comb.allé equivalente a $_ %% all($_.comb). %%é o operador "é divisível" e, combsem argumento adicional, retorna uma lista dos caracteres em uma sequência. Como exemplo, se o argumento for 123, a função avaliará

123 %% all(123.comb)

qual é

123 %% all(1, 2, 3)

autothreading de junção torna

all(123 %% 1, 123 %% 2, 123 %% 3)

qual é

all(True, False, True)

o que é falso no contexto booleano porque é uma junção "todos" e claramente nem todos os seus elementos são verdadeiros.

Deve ser possível coagir o valor de retorno Boole ocultar a junção dos chamadores fazendo a assinatura da função sub golf($_ --> Bool()), mas as coerções nas assinaturas das funções ainda não funcionam no Rakudo. O valor de retorno ainda é corretamente verdadeiro ou falso, apenas não é Trueou False.

C # e System.Linq - 26/40

Pelas regras, sem contar a própria declaração do método.

bool dividesSelf(int i) { 
    return(i+"").All(d=>i%(d-48d)<1);
}

Mostrando que mais uma vez, o C # é a escolha superior quando o Java está sendo considerado ... Brincadeira, brincadeira!

Infelizmente, esta função (e muitas outras respostas) não produzirá resultados corretos para dados negativos. Podemos corrigir isso, mas a solução perde muito de seu charme (e cresce para 46 caracteres):

return(i+"").All(d=>d>48&&i%(d-48)==0||d==45);

Edit : raspou um personagem com a sugestão de Tim.

Edit : com a introdução de membros com expressão no C # 6, podemos reduzir isso ainda mais cortando o return:

bool dividesSelf(int i) =>
    (i+"").All(d=>i%(d-48d)<1);

para um total de 26 caracteres (na minha opinião, =>não deve ser incluído mais do que chaves). A versão que manipula números negativos pode ser reduzida de forma semelhante.

APL ( 13 11)

{0∧.=⍵|⍨⍎¨⍕⍵}

Explicação:

• ⍎¨⍕⍵: avalie cada caractere na representação de sequência de ⍵
• ⍵|⍨: para cada um deles, encontre o módulo e ⍵
• 0∧.=: veja se todos são iguais a 0

Casos de teste:

      N,[.5] {0∧.=⍵|⍨⍎¨⍕⍵} ¨ N←128 12 120 122 13 32 22 42 212 213 162 204
128 12 120 122 13 32 22 42 212 213 162 204
  1  1   0   1  0  0  1  0   1   0   1   0

Caracteres Python 2: 43

f=lambda n:any(n%(int(d)or.3)for d in`n`)<1

Verifica se o número tem algum resto diferente de zero, modula seus dígitos e gera a negação disso. Os dígitos zero são tratados de maneira estranha: como a computação %0causa um erro, os dígitos de 0são substituídos por .3, o que parece sempre fornecer um resultado diferente de zero devido às imprecisões dos pontos flutuantes.

O corpo da função é de 32 caracteres.

Perl - 27 bytes

sub dividesSelf{
    $_=pop;s/./!$&||$_%$&/ger<1
}

Não contando a assinatura da função, conforme as instruções.

Uso da amostra:

use Data::Dump qw(dump);
for $i (128, 12, 120, 122, 13, 32, 22, 42, 212, 213, 162, 204) {
  printf "%3d -> %s\n", $i, dump(dividesSelf $i);
}

Saída de amostra:

128 -> 1
 12 -> 1
120 -> ""
122 -> 1
 13 -> ""
 32 -> ""
 22 -> 1
 42 -> ""
212 -> 1
213 -> ""
162 -> 1
204 -> ""

Dirigindo-se à especificação do problema: "Somente valores booleanos verdadeiros e falsos contam. Valores truthy / falsey não contam."

use Data::Dump qw(dump);
dump(1 == 1);
dump(0 == 1);

Saídas:

1
""

'True' e 'False' são definidos como 1e "".

Errata:
Como Brad Gilbert aponta corretamente , o perl define verdadeiro como um escalar que é simultaneamente o número inteiro 1e a sequência "1"e falso como um escalar que é o número inteiro 0e a sequência ""simultaneamente.

CJam, 11 10 bytes

{
    _Ab:df%:+!
}:F;

Isso define uma função nomeada Fe descarta o bloco da pilha.

Experimente online.

Casos de teste

$ cjam <(echo '{_Ab:df%:+!}:F;[128 12 120 122 13 32 22 42 212 213 162 204]{F}%p')
[1 1 0 1 0 0 1 0 1 0 1 0]

Como funciona

_      " Copy the integer on the stack.                                          ";
Ab     " Push the array of its digits in base 10.                                ";
:d     " Cast each digit to Double.                                              ";
f%     " Take the integer on the stack modulus each of its digits.               ";
:+     " Add the results.                                                        ";
!      " Push the logical NOT of the sum.                                        ";

JavaScript ES6, 39 32 28 bytes

v=>[...""+v].every(x=>v%x<1)

Obrigado core1024 pela sugestão de substituição (""+v).split("")por [...""+v], e abra ou feche por sugerir o uso da everyfunção.

A resposta atualmente não contém um pouco do meu código: O

Solução anterior

v=>[...""+v].filter(x=>v%x|!+x)==""

==""não é uma maneira válida de verificar se uma matriz está vazia, pois [""]==""retorna true, mas a matriz tem garantia de conter uma seqüência de caracteres não vazia, por isso funciona aqui.

O restante são conversões de tipo abreviado bastante padrão em JavaScript.

Java 8, 46 bytes (corpo do método)

Usando a conversão de Jeroen Mostert para truque duplo.

public static boolean dividesSelf(int n) {
    return(""+n).chars().allMatch(x->n%(x-48d)<1);
}

Pitão, 12 bytes

!f|!vT%vzvTz

Isso filtra os caracteres na cadeia de caracteres como sendo zero ( !vT) ou não dividindo a entrada ( %vzvT) e, em seguida, assume o não lógico da lista resultante.

Experimente aqui.

Ruby, 44 bytes (corpo da função: 37)

Provavelmente tem potencial para ser jogado mais.

f=->n{n.to_s.chars.all?{|x|x>?0&&n%x.hex<1}}

Entrada obtida através da função f. Exemplo de uso:

f[128] # => true
f[12]  # => true
f[120] # => false
...

Python - 59 50 49 47 bytes

f=lambda n:all(c>'0'and 0==n%int(c)for c in`n`)

Tenho certeza de que há uma maneira mais rápida ... tudo bem.

Editar - Obrigado a FryAmTheEggman pelas dicas de golfe.

Edit 2 - FryAmTheEggman pode muito bem ter escrito isso neste momento, oops

Edit 3 - Hands up, se você nem sabia que genexps eram uma coisa. ...Apenas eu?

Pitão 11

!f%Q|vT.3`Q

Isso combina as respostas de @ isaacg e @ xnor . Ele filtra os dígitos da entrada verificando o valor de input % (eval(current_digit) or .3). Em seguida, verifica se a sequência resultante está vazia ou não.

Me deparei com outras variantes do mesmo comprimento:

!f%Q|T.3jQT
!f|!T%QTjQT

Experimente online.

Bash + coreutils, 44 bytes

A definição completa da função é:

f()((`tr 0-9 \10<<<$1``sed "s/./||$1%&/g"<<<$1`))

Não sei como pontuar isso, pois normalmente as funções de shell usam um único conjunto de {}ou ()para conter o corpo da função. Eu descobri aqui que eu também poderia usar double (())para conter o corpo da função que causa uma expansão aritmética, que é o que eu preciso aqui. Por enquanto, estou contando apenas um par desses colchetes - uma discussão mais aprofundada sobre isso é bem-vinda.

Resultado:

$ for i in 128 12 120 122 13 32 22 42 212 213 162 204; do f $i; printf "%d " $?; done
1 1 0 1 0 0 1 0 1 0 1 0 $
$

J - 14 car

O corpo da função é a parte após o =:. Se queremos minimizar a contagem de caracteres para toda a função, esse é o valor de 15 caracteres */@(0=,.&.":|]).

f=:0*/@:=,.&.":|]

,.&.":é o caminho mais curto em J para expandir como número em uma lista de seus dígitos decimais: converter em sequência, separar os dígitos e converter cada dígito novamente em um número. ,.&.":|]pega o número da entrada ( ]) modulo ( |) esses dígitos. 0*/@:=retorna true se todos os resultados forem 0, caso contrário, fornece um false.

   f 162
1
   f every 204 212 213
0 1 0

Java - 121 102 97 79 78 bytes

Eu só sei que isso será derrotado mais tarde. Ah bem.

boolean b(int a){int m=10,j,t=1;for(;m<a*10;m*=10){j=10*(a%m)/m;if(j==0||a%j>0)t=0;}return t>0;}

Eu voltarei.

Haskell - 100 54 38

f x=all(\y->y>'0'&&x`mod`read[y]<1)$show x

Ainda aprendendo, críticas apreciadas

CJam, 15 bytes

{_Abf{_g{%}*}:|!}

Este é um bloco, a coisa mais próxima de uma função no CJam. Estou apenas contando o corpo (ou seja, omitindo o aparelho). Você pode usá-lo da seguinte maneira:

128{_Abf{_g{%}*}:|!}~

Ou, se você quiser testar uma série de entradas, pode fazer

[128 12 120 122 13 32 22 42 212 213 162 204]{{_Abf{_g{%}*}:|!}~}%

O bloco deixa 0(falsy) ou 1(truth) na pilha para indicar o resultado. (CJam não tem um tipo booleano.)

Teste aqui.

Explicação:

_               "Duplicate input.";
 Ab             "Get base-10 digits.";
   f{      }    "This maps the block onto the list of digits, supplying the input each time.";
     _g         "Duplicate digit, get signum S (0 or 1).";
       { }*     "Repeat this block S times.";
        %       "Take input modulo digit.";
                "This leaves an array of zeroes for divisible digits, non-zeroes
                 for non-divisible digits, and non-zero junk for zeroes.";
            :|  "Fold OR onto this list. One could also sum the list with :+";
              ! "Logical NOT. Turns 0 into 1, and non-zero values into 0.";

Alternativa, também 15 bytes

{:XAb{X\_X)?%},!}

Explicação

:X              "Store input in X.";
  Ab            "Get base-10 digits.";
    {       },  "Filter this list by the result of the block.";
     X\         "Push another copy of X, swap with digit.";
       _        "Duplicate digit.";
        X)      "Push X+1.";
          ?     "Select digit itself or X+1, depending on whether digit is 0 or not.";
           %    "Take modulo. X%(X+1) will always be nonzero for positive integers.";
              ! "Logical NOT. Turns an empty list into 1 and a non-empty list into 0.";

CJam, 15 bytes

{_Abf{_{%}1?}1b!}

{}é a coisa mais próxima de uma função no CJam. Estou apenas contando o corpo da função

Use-o assim:

128{_Abf{_{%}1?}1b!}~

Para obter 1(se o número é divisível) ou 0(se o número não é divisível por seus dígitos).

Experimente online aqui

Explicação

_Ab                "Copy the number and split it to its digits";
   f{      }       "For each digit, run this code block on the number";
     _{%}1?        "If the digit is 0, put 1, otherwise perform number modulus digit";
            1b     "We now have an array of modulus corresponding to each digit. Sum it up";
              !    "Negate the sum. If all digits were divisible, sum of modules will be"
                   "0, thus answer should be 1 and vice versa";

C89, 43 bytes

unsigned char d(int n, int c) {
        int a=n%10;return!n||a&&!(c%a)&&d(n/10,c);
}

C89 não tem um tipo booleano. Espero que funcione. Também usei um segundo parâmetro para passar uma cópia do número original pela pilha, mas a definição pode ser qualquer coisa. Para obter o resultado correto, basta chamar a função com o mesmo valor para os dois parâmetros ( d(128, 128)).

EDIT: edições sugeridas aplicadas por um usuário anônimo

C11 - 44 bytes no corpo da função

Outra versão C, não recursiva e sem uma exceção de ponto flutuante.

bool digit_multiple(int i)
{
    for(int n=i;i%10&&n%(i%10)<1;i/=10);return!i;
}

Isso também funcionará em C ++, Java e na maioria das outras linguagens C.

Editado para incluir a melhoria do comentário do primo.

Julia 32 25 23

Melhorado usando dígitos

Também corrige o problema com números negativos

selfDivides(x)=sum(x%digits(x).^1.)==0

Método antigo

Todos os dígitos se dividem se a soma de todos os demais for 0. Como outros, tem um problema com números negativos.

selfDivides(x)=sum(x.%(Float64["$x"...]-48))==0

Resultado

[selfDivides(x) for x in [128,12,120,122,13,32,22,42,212,213,162,204]]
12-element Array{Any,1}:
  true
  true
 false
  true
 false
 false
  true
 false
  true
 false
  true
 false

O método aprimorado também lida com o BigInt

selfDivides(BigInt(11111111111111111111111111111111111111112))
true

Contudo

selfDivides(BigInt(11111111111111111111111111111111111111113))
false

Porque

BigInt(11111111111111111111111111111111111111113) %3
1

C / C ++, 58 bytes (44 no corpo)

Invoca comportamento indefinido (ver comentários)

int d(int i){int j=i;while(i&&!(j%(i%10)))i/=10;return!i;}

truee false são 1 e 0, mas fique à vontade para adicionar um caractere à assinatura para retornar a bool.

E por diversão, uma versão recursiva que é menor se você permitir chamadas do formulário r(128,128)

Edit : Agora não permitido pelas regras:

int r(int i,int j){return!i||!(j%(i%10))&&r(i/10,j);}

R: 72 67 65

A função

f<-function(a)!(anyNA(a%%(d=as.double(strsplit(paste0(a),"")[[1]])))|sum(a%%d))

Agradecemos a @AlexA e @plannapus pela economia

Execução de teste

i=c(128,12,120,122,13,32,22,42,212,213,162,204)
for(a in i){print(f(a))}
[1] TRUE
[1] TRUE
[1] FALSE
[1] TRUE
[1] FALSE
[1] FALSE
[1] TRUE
[1] FALSE
[1] TRUE
[1] FALSE
[1] TRUE
[1] FALSE

GNU Awk: 53 caracteres

A parte contada:

for(;++i<=split($1,a,//);)r=r||!a[i]||v%a[i];return!r

Toda a função:

function self_divisible(v, i, r)
{
    for (; ++i <= split($1, a, //); )
        r = r || ! a[i] || v % a[i]

    return ! r
}

Como o Awk não possui valores booleanos, retorna 1 para true e 0 para false.

JavaScript (ES6) 30

Função com um parâmetro numérico. Usando% e subtração, não é necessário o caso especial '0' porque 0% 0 é NaN em JavaScript.

Editar salvos 1 char thx DocMax

F=n=>[for(d of t=n+'')t-=n%d]&&t==n 

Apenas por diversão, abusando da regra de não contar a assinatura da função, 4

Check=(n,t=n+'',q=[for(d of t)n-=t%d])=>t==n

Teste no console do FireFox / FireBug

console.log([128, 12, 120, 122, 13, 32, 22, 42, 212, 213, 162, 204]
.map(x=>+x + ' -> ' + F(x)).join('\n'))

Resultado

128 -> true
12 -> true
120 -> false
122 -> true
13 -> false
32 -> false
22 -> true
42 -> false
212 -> true
213 -> false
162 -> true
204 -> false

PHP: 85 bytes (64 bytes no corpo)

Para que essa função funcione, basta passar uma string ou um número.

0 retornará corretamente false.

O código:

function f($n,$i=0){for($n.='';$n[$i]&&$t=!($n%$n[$i++]););return$t&&$i==strlen($n);}

Por favor, NÃO AJUSTE O 2º PARÂMETRO!

Javascript: 76 bytes (61 bytes no corpo)

Esta é uma reescrita da função anterior.

Não mudou muito entre as duas versões.

Aqui está o código:

function f(n){for(i=0,n+='';n[i]/1&&(t=!(n%n[i++])););return t&&i==n.length}

Poliglota: Javascript + PHP 187 217 bytes (76 84 bytes sem clichê):

Por que eu fiz isso?

Por causa da razão e talvez porque eu possa!

Apenas ignore o erro no PHP: ele funciona de qualquer maneira!
Não é mais necessário, isso foi corrigido com a remoção de 3 bytes.

Aqui está a obra-prima:

if('\0'=="\0"){function strlen($s){return $s['length'];}}
function toString(){return'';}
function f($n){for($i=0,$n=$n.toString();$n[$i]/1&&($t=!($n%$n[$i++])););return $t&&$i==strlen($n);}

Você pode executar esse código no console e em um intérprete PHP!

Versão antiga:

if('\0'=="\0"){function strlen($s){return $s['length'];}}
function s($s){return('\0'=="\0")?$s+'':str_replace('','',$s);}
function f($n,$i){for($i=0,$n=s($n);$n[$i]/1&&($t=!($n%$n[$i++])););return $t&&$i==strlen($n);}

Oitava, 33 (39 incluindo configuração de função)

Usando a conversão numérica em matriz:

f=@(a)sum(mod(a./(num2str(a)-48),1))==0

Divida o número elemento a elemento pela matriz X, em que X é feito convertendo o número em sequência e subtraindo 48 para passar dos valores ASCII para números novamente. Tome o módulo 1 para obter a parte decimal de cada divisão, confirme que tudo isso é zero (se houver NaN por causa de / 0, a soma será NaN e, portanto, não é zero).

Exemplo de entrada usando www.octave-online.net:

f=@(a)sum(mod(a./(num2str(a)-48),1))==0
for j=[128,12,120,122,13,32,22,42,212,213,162,204]
f(j)
end

Resultado:

ans =  1
ans =  1
ans = 0
ans =  1
ans = 0
ans = 0
ans =  1
ans = 0
ans =  1
ans = 0
ans =  1
ans = 0

MATLAB - 39 caracteres

function [b] = dividesSelf(i)
b=all(~mod(i,sscanf(num2str(i),'%1d')))
end

BASH - 117 caracteres

f(){ [[ $1 =~ 0 ]]&& return 0 || r=;n=$1;for((i=0;i<${#n};i++));do r=$(($r+${n}%${n:$i:1}));done;return $(($r==0));}

testes

for N in 128 12 120 122 13 32 22 42 212 213 162 204; do
  f $N
  echo "${N} ->  $?"
done

128 ->  1
12 ->  1
120 ->  0
122 ->  1
13 ->  0
32 ->  0
22 ->  1
42 ->  0
212 ->  1
213 ->  0
162 ->  1
204 ->  0

PHP - 74 71 64 caracteres

Golfe:

function t($n){while($n>1){if(!($b=$n%10)||($n%$b)){return 0;}$n/=10;}return 1;}

Menos Golfe:

function t($n){
    while($n>1){
        if( !($b=$n%10) || ($n%$b) )
            { return 0; }
        $n/=10;
    }
    return 1;
}

Resultado dos testes:

(Código)

$ans = array(128,12,120,122,13,32,22,42,212,213,162,204);
foreach($ans as $a)
{ echo "$a -> ".(t($a)?"True":"False").PHP_EOL; }

(Resultado)

128 -> True
12 -> True
120 -> False
122 -> True
13 -> False
32 -> True
22 -> True
42 -> True
212 -> True
213 -> True
162 -> False
204 -> False