Mi amigo y yo estábamos trabajando en un laboratorio en nuestra clase de informática AP y decidimos codificar uno de los problemas ya que todavía teníamos la mitad de la clase libre después de terminar. Aquí está la pregunta:

Dado un número n, ¿es n divisible por cada uno de sus dígitos?

Por ejemplo, 128 pasará esta prueba, es divisible por 1,2 y 8. Cualquier número con un cero descalifica automáticamente el número. Si bien puede usar otros idiomas y publicar soluciones con ellos si lo desea, estamos más interesados ​​en ver cómo las personas compactas pueden hacer el programa en Java, ya que ese es el lenguaje que usamos en la clase. Hasta ahora, ambos tenemos 51. Aquí está mi código actual:

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.

Requisitos

La firma del método puede ser lo que quieras. Solo cuenta el cuerpo de la función. Sin embargo, asegúrese de que el método devuelva un valor booleano y solo pase un parámetro numérico (no una cadena).

El código debe poder pasar todos estos casos (para mantenerse fiel a las instrucciones de la pregunta original, solo los valores booleanos de verdadero y falso cuentan si el idioma admite booleanos. Si y solo si su idioma no tiene variables booleanas usted puede representar falso con 0 y verdadero con cualquier número entero distinto de cero (preferiblemente 1 o -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

Además, no contamos los espacios en blanco, así que siéntete libre de hacer lo mismo, a menos que el espacio en blanco es esencial para el funcionamiento del programa (por lo que los saltos de línea en Java no cuentan, pero un solo espacio entre inty x=1hace el recuento.) Buena suerte !

Perl 6, 13

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

Utiliza la variable implícita $_- $_ %% .comb.alles equivalente a $_ %% all($_.comb). %%es el operador "es divisible" y combsin argumento adicional devuelve una lista de los caracteres en una cadena. Como ejemplo, si el argumento es 123, entonces la función evalúa

123 %% all(123.comb)

cual es

123 %% all(1, 2, 3)

el enhebrado automático lo hace

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

cual es

all(True, False, True)

lo cual es falso en el contexto booleano porque es una unión "total" y claramente no todos sus elementos son verdaderos.

Debería ser posible forzar el valor de retorno Booly ocultar la unión de los llamadores haciendo la firma de la función sub golf($_ --> Bool()), pero las coacciones en las firmas de la función aún no funcionan en Rakudo. El valor de retorno sigue siendo correctamente verdadero o falso, simplemente no es Trueo False.

C # y System.Linq - 26/40

Según las reglas, sin contar la declaración del método en sí.

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

Mostrando eso una vez más, C # es la mejor opción cuando Java está bajo consideración ... ¡Bromeo, bromeo!

Desafortunadamente, esta función (y muchas en otras respuestas) no producirá resultados correctos para la entrada negativa. Podemos solucionar esto, pero la solución pierde mucho de su encanto (y crece hasta 46 caracteres de longitud):

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

Editar : afeitó a un personaje con la sugerencia de Tim.

Editar : con la introducción de miembros con cuerpo de expresión en C # 6, podemos reducir esto aún más cortando el return:

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

para un total de 26 caracteres (en mi opinión, =>no se deben incluir más de lo que se incluirían los corchetes). La versión que maneja números negativos puede acortarse de manera similar.

APL ( 13 11)

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

Explicación:

• ⍎¨⍕⍵: evalúa cada carácter en la representación de cadena de ⍵
• ⍵|⍨: para cada uno de ellos, encuentre el módulo del mismo y ⍵
• 0∧.=: ver si todos son iguales a 0

Casos de prueba:

      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

Python 2: 43 caracteres

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

Comprueba si el número tiene algún resto distinto de cero módulo sus dígitos, y genera la negación de eso. Los dígitos cero se manejan de manera extraña: dado que la informática %0causa un error, los dígitos de 0se reemplazan con .3, lo que parece dar siempre un resultado distinto de cero debido a imprecisiones de coma flotante.

El cuerpo de la función es de 32 caracteres.

Perl - 27 bytes

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

Sin contar la firma de la función, como se indica.

Uso de muestra:

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

Salida de muestra:

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

Abordar la especificación del problema: "Solo los valores booleanos de verdadero y falso cuentan. Los valores de verdad / falsey no cuentan".

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

Salidas:

1
""

'Verdadero' y 'Falso' se definen como 1y "".

Errata:
Como Brad Gilbert señala correctamente , Perl define verdadero como un escalar que es tanto el entero 1como la cadena "1"simultáneamente, y falso como un escalar que es tanto el entero 0como la cadena ""simultáneamente.

CJam, 11 10 bytes

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

Esto define una función llamada Fy descarta el bloque de la pila.

Pruébalo en línea.

Casos de prueba

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

Cómo 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)

Gracias core1024 por la sugerencia de reemplazar (""+v).split("")con [...""+v], y openorclose por sugerir el uso de everyla función.

La respuesta actualmente no contiene un bit de mi código: O

Solución previa

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

==""no es una forma válida de verificar si una matriz está vacía, ya que [""]==""devuelve true, pero se garantiza que la matriz contiene cadenas no vacías, por lo que funciona aquí.

El resto son conversiones de tipo abreviado bastante estándar en JavaScript.

Java 8, 46 Bytes (cuerpo del método)

Usando la conversión de Jeroen Mostert al doble truco.

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

Pyth, 12 bytes

!f|!vT%vzvTz

Esto filtra los caracteres en la cadena por ser cero ( !vT) o no dividir la entrada ( %vzvT), luego toma el no lógico de la lista resultante.

Pruébalo aquí

Ruby, 44 bytes (cuerpo de la función: 37)

Probablemente tiene potencial para jugar más al golf.

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

Entrada tomada a través de la función f. Ejemplo 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`)

Estoy seguro de que hay una manera más rápida ... oh, bueno.

Editar - Gracias a FryAmTheEggman por los consejos de golf.

Edición 2 : FryAmTheEggman también podría haber escrito esto en este momento, ¡vaya!

Edición 3 : manos arriba si ni siquiera sabías que los genexps eran una cosa. ...¿Solo yo?

Pyth 11

!f%Q|vT.3`Q

Esto combina las respuestas de @ isaacg y @ xnor . Filtra los dígitos de la entrada al verificar el valor de input % (eval(current_digit) or .3). Luego comprueba si la cadena resultante está vacía o no.

Encontré otras dos variantes de la misma longitud:

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

Pruébalo en línea.

Bash + coreutils, 44 bytes

La definición de la función completa es:

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

No estoy seguro de cómo calificar esto, ya que normalmente las funciones de shell usan un solo conjunto de {}o ()para contener el cuerpo de la función. Encontré aquí que también podría usar el doble (())para contener el cuerpo de la función que causa una expansión aritmética, que es lo que necesito aquí. Así que por ahora estoy contando solo un par de esos corchetes; cualquier discusión adicional sobre esto es bienvenida.

Salida:

$ 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 char

El cuerpo de la función es la porción después de =:. Si queremos minimizar el recuento de caracteres para toda la función, esos son los 15 caracteres */@(0=,.&.":|]).

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

,.&.":es la forma más corta en J de expandirse como número en una lista de sus dígitos decimales: convertir en cadena, separar los dígitos y convertir cada dígito nuevamente en un número. ,.&.":|]toma el número de entrada ( ]) módulo ( |) esos dígitos. 0*/@:=devuelve verdadero si todos los resultados fueron 0, de lo contrario da un falso.

   f 162
1
   f every 204 212 213
0 1 0

Java - 121 102 97 79 78 bytes

Solo sé que esto será golpeado más tarde. Oh bien.

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

Vuelvo enseguida.

Haskell - 100 54 38

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

Aún aprendiendo, las críticas apreciadas

CJam, 15 bytes

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

Este es un bloque, lo más parecido a una función en CJam. Solo estoy contando el cuerpo (es decir, omitiendo las llaves). Puede usarlo de la siguiente manera:

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

O si desea probar una serie de entradas, puede hacer

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

El bloque sale 0(falso) o 1(verdadero) en la pila para indicar el resultado. (CJam no tiene un tipo booleano).

Pruébalo aquí.

Explicación:

_               "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, también 15 bytes

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

Explicación

: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!}

{}es lo más parecido a una función en CJam. Solo estoy contando el cuerpo de la función

Úselo así:

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

Para obtener 1(si el número es divisible) o 0(si el número no es divisible por sus dígitos).

Pruébalo en línea aquí

Explicación

_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 no tiene un tipo booleano. Espero que funcione. También usé un segundo parámetro para pasar una copia del número original a través de la pila, pero la definición puede ser cualquier cosa. Para obtener el resultado correcto solo tiene que llamar a la función con el mismo valor para ambos parámetros ( d(128, 128)).

EDITAR: ediciones sugeridas aplicadas por un usuario anónimo

C11 - 44 Bytes en el cuerpo de la función

Otra versión en C, no recursiva y sin una excepción de coma flotante.

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

Esto también funcionará en C ++, Java y la mayoría de los otros lenguajes tipo C.

Editado para incluir la mejora del comentario de primo.

Julia 32 25 23

Mejorado usando dígitos

También corrige problemas con números negativos

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

Método antiguo

Todos los dígitos se dividen si la suma de todos los restos es 0. Al igual que otros, tiene un problema con los números negativos.

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

Salida

[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

El método mejorado también maneja BigInt

selfDivides(BigInt(11111111111111111111111111111111111111112))
true

sin embargo

selfDivides(BigInt(11111111111111111111111111111111111111113))
false

porque

BigInt(11111111111111111111111111111111111111113) %3
1

C / C ++, 58 bytes (44 en el cuerpo)

Invoca comportamientos indefinidos (ver comentarios)

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

truey false son 1 y 0, pero puede agregar un carácter a la firma para devolver a bool.

Y por diversión, una versión recursiva que es más pequeña si permite llamadas del formulario r(128,128)

Editar : Ahora no permitido por las reglas:

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

R: 72 67 65

La función

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

Gracias a @AlexA y @plannapus por los ahorros

Prueba de funcionamiento

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

La parte contada:

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

Toda la función:

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

    return ! r
}

Como Awk no tiene valores booleanos, devuelve 1 tor verdadero y 0 para falso.

JavaScript (ES6) 30

Función con un parámetro numérico. Usando% y sustracción, no es necesario poner el caso especial '0' porque 0% 0 es NaN en JavaScript.

Editar Guardado 1 char thx DocMax

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

Solo por diversión, abusando de la regla de no contar la firma de la función, 4

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

Prueba en la consola FireFox / FireBug

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

Salida

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 en el cuerpo)

Para que esta función funcione, simplemente pase una cadena o un número.

0 correctamente devolverá falso.

El código:

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

¡Por favor, NO CONFIGURE EL 2º PARÁMETRO!

Javascript: 76 bytes (61 bytes en el cuerpo)

Esta es una reescritura de la función anterior.

No ha cambiado mucho entre ambas versiones.

Aquí está el código:

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

Políglota: Javascript + PHP 187 217 bytes (76 84 bytes sin repetitivo):

¿Por qué lo hice?

¡Por razones y tal vez porque puedo!

Simplemente ignore el error en PHP: ¡funciona de todos modos!
Ya no es necesario, esto se solucionó eliminando 3 bytes.

Aquí está la obra maestra:

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

¡Puede ejecutar este código tanto en su consola como en un intérprete PHP!

Versión antigua:

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

Octava, 33 (39 incluyendo configuración de funciones)

Usando la conversión numérica a matriz:

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

Divida el número por elemento por la matriz X, donde X se forma al convertir el número en una cadena y restar 48 para pasar de los valores ASCII a los números nuevamente. Tome el módulo 1 para obtener la parte decimal de cada división, confirme que todos estos son cero (si alguno es NaN debido a / 0, la suma será NaN y, por lo tanto, no será cero).

Entrada de muestra 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

Salida:

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

pruebas

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

Golfizado:

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

Menos golfizado:

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

Resultados de la prueba:

(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; }

(Salida)

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