Un número de Harshad es un número que es divisible por la suma de sus dígitos. Obviamente, esto depende de en qué base se escriba el número entero. Los números de Base 10 Harshad son la secuencia A005349 en el OEIS.

Tu tarea:

Escriba un programa o función que determine si un entero dado es un número Harshad en una base dada.

Entrada:

Un entero positivo <10 ^ 9, y una base entre 2 y 36, O, un entero positivo en su base, usando letras minúsculas para los números del 11-36 y una base entre 2 y 36. Solo debe manejar uno de Estas opciones.

Salida:

Un valor verdadero / falso que indica si la primera entrada es un número de Harshad en la base de la segunda entrada.

Ejemplos:

27,10 ----------> truthy
8,5 ------------> truthy
9,5 ------------> falsy
1a,12 OR 22,12 -> truthy

Puntuación:

Este es el código de golf , gana la puntuación más baja en bytes.

Jalea , 4 bytes

bSḍḷ

Pruébalo en línea!

Cómo funciona

bSḍḷ  Main link. Arguments: n (integer), k (base)

b     Convert n to base k.
 S    Take the sum.
   ḷ  Left; yield n.
  ḍ   Test for divisibility.

Python 2 , 46 bytes

lambda n,b:n%sum(n/b**i%b for i in range(n))<1

Pruébalo en línea!

Python 3 , 73 bytes

def f(n,b):
 if b<2:return 1
 s=0;c=n
 while n:s+=n%b;n//=b
 return c%s<1

Pruébalo en línea!

1 es verdad, ya sabes.

Dyalog APL, 20 bytes

{⍺=1:0⋄⍵|⍨+/⍺⊥⍣¯1⊢⍵}

Pruébalo en línea! _{[15 primeros números en 15 primeras bases]}

Toma el número como argumento derecho y la base como argumento izquierdo, 0 es verdadero.

¿Cómo?

⍺⊥⍣¯1⊢⍵- ⍵en base ⍺como una lista de dígitos

⍵|⍨- ⍵módulo ...

+/ - la suma

Python 2 , 54 47 bytes

n,k=input();m=n;s=0
exec's-=m%k;m/=k;'*n
1>>n%s

El tiempo y la complejidad de la memoria son O (n) , así que no intente 10 ⁹ en TIO.

La salida es a través del código de salida, por lo que 0 es verdadero, 1 es falso. Si este método de salida termina siendo permitido, se puede guardar un byte adicional al convertir el programa en una función.

¡Gracias a @ musicman523 por sugerir códigos de salida!

Pruébalo en línea!

Pyth, 12 7 bytes

!%hQsjF

Pruébalo en línea!

El recuento de bytes ahora es menor ya que ya no se requiere unario.

Explicación

!%hQsjF
     jF    Fold the input over base conversion (converts given number to given base)
    s      Sum the values
  %hQ       Take the first input modulo that sum
!          Logical not, turning 0s from the modulus into True and all else into False

R , 64 60 bytes

(requiere el pryrpaquete)

pryr::f({d=pryr::f('if'(n<b,n,n%%b+d(b,n%/%b)));!n%%d(b,n)})

Esta es una función anónima que toma dos argumentos by nque se evalúa en (que está en TIO):

function(b,n){
   d=function(b,n)
     if(n<b) n else n%%b + d(b,n%/%b)
   !n%%d(b,n)
}

donde dcalcula la suma de dígitos para la base requerida.

Se descartaron 4 bytes una vez que se garantizó que la base era mayor que 1.

Pruébalo en línea!

Japt , 9 bytes

vUsV ¬xnV

Toma la entrada como dos enteros.

Pruébalo en línea!

Javascript (ES6), 68 67 bytes

n=>k=>!(n%eval([...n.toString(k)].map(_=>parseInt(_,k)).join('+')))

Tenga en cuenta que dado que solo estamos obligados a manejar números base- k o base-10 n, supongo que siempre nes un entero base-10.

-1 byte, gracias a TheLethalCoder!

Cómo funciona:

!                                    # Convert to true if 0 else false
 (n%                                 # Compute n modulo
    eval(                            # evaluate string
         [...n.toString(k)]          # convert to array of base-k divisors
         .map(_=>parseInt(_,k))      # map lowercase characters to ints
         .join('+')                  # join array as string of characters
    )                                # get the raw remainder, and let ! do its work
 ) 

Pruébalo en línea!

Javascript ES6, 62 bytes

n=>b=>!(n%[...n.toString(b)].reduce((x,y)=>x+parseInt(x,b),0))

Perl 6 , 40 bytes

{$^b>1??$^a%%[+] $a.polymod($b xx*)!!?1}

Pruébalo

Expandido:

{  # bare block lambda with placeholder parameters ｢$a｣ and ｢$b｣

    $^b > 1          # declare ｢$b｣ and compare against 1

  ??                 # if ｢$b > 1｣ then:

      $^a            # declare ｢$a｣
    %%               # is it divisible by
      [+]            # reduce the following with &infix:<+> (sum)
        $a.polymod(
          $b xx *    # infinite list of ｢$b｣s
        )

  !!                 # if ｢$b <= 1｣ then:

    ? 1              # Boolify 1 (shorter than True)
}

Mathematica, 30 bytes

#2<2||Tr@IntegerDigits@##∣#&

Función pura que toma dos argumentos, el entero y la base (en ese orden), y devuelve Trueo False. Cuidado: los primeros dos |s son solo el carácter ASCII normal, mientras que el último ∣es U + 2223.

#2<2trata el caso especial de la base 1. De lo contrario, Tr@IntegerDigits@##produce la suma de los dígitos del primer argumento cuando se escribe en la base del segundo argumento, y ...∣#prueba si esa suma divide el primer argumento.

Lote, 119 bytes

@if %2==1 echo 1&exit/b
@set/at=%1,s=0
:l
@if %t% gtr 0 set/as+=t%%%2,t/=%2&goto l
@set/at=%1%%s
@if %t%==0 echo 1

Salidas 1 para números Harshad.

Python 3 , 45 bytes

lambda n,b:int(n,b)%sum(int(i,b)for i in n)<1

Pruébalo en línea!

Basado en los formatos actualizados para entrada.

C (gcc) , 57 bytes

f(n,b,t,s){while(b>1&&t){s+=t%b;t/=b;}return b<2||n%s<1;}

Pruébalo en línea!

Pari / GP , 25 bytes

(n,b)->n%sumdigits(n,b)<1

Pruébalo en línea!

Java (OpenJDK 8) , 54 bytes

n->b->{int s=0,c=n;for(;c>0;c/=b)s+=c%b;return n%s<1;}

Pruébalo en línea!