Um número Harshad é um número que é divisível pela soma dos seus dígitos. Obviamente, isso depende da base em que o número inteiro está escrito. Os números da Base 10 Harshad são a sequência A005349 no OEIS.

Sua tarefa:

Escreva um programa ou função que determine se um número inteiro é um número Harshad em uma determinada base.

Entrada:

Um número inteiro positivo <10 ^ 9 e uma base entre 2 e 36, OU, um número inteiro positivo em sua base, usando letras minúsculas para os números de 11 a 36 e uma base entre 2 e 36. Você só precisa manipular um dos essas opções.

Resultado:

Um valor verdade / falso indicando se a primeira entrada é um número Harshad na base da segunda entrada.

Exemplos:

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

Pontuação:

Isso é código-golfe , a menor pontuação em bytes ganha.

Gelatina , 4 bytes

bSḍḷ

Experimente online!

Como 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

Experimente online!

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

Experimente online!

1 é verdade, você sabe.

Dyalog APL, 20 bytes

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

Experimente online! _{[15 primeiros números nas 15 primeiras bases]}

Pega o número como argumento da direita e a base como argumento da esquerda, 0 é verdade.

Quão?

⍺⊥⍣¯1⊢⍵- ⍵na base ⍺como uma lista de dígitos

⍵|⍨- ⍵módulo ...

+/ - a soma

Python 2 , 54 47 bytes

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

O tempo e a complexidade da memória são O (n) , portanto, não tente 10 ⁹ no TIO.

A saída é via código de saída; portanto, 0 é verdade e 1 é falso. Se esse método de saída acabar sendo permitido, um outro byte pode ser salvo ao transformar o programa em uma função.

Obrigado a @ musicman523 por sugerir códigos de saída!

Experimente online!

Pitão, 12 7 bytes

!%hQsjF

Experimente online!

A contagem de bytes agora está mais baixa, pois o unário não é mais necessário.

Explicação

!%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 bytes 60

(requer o pryrpacote)

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

Essa é uma função anônima que recebe dois argumentos be navalia como (que está no TIO):

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

Onde d calcula a soma dos dígitos para a base necessária.

Eliminados 4 bytes assim que a base foi garantida como maior que 1.

Experimente online!

Japonês , 9 bytes

vUsV ¬xnV

Aceita entrada como dois números inteiros.

Experimente online!

Javascript (ES6), 68 67 bytes

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

Observe que, como somos obrigados a lidar apenas com números de base- k ou base-10 n, presumo que nseja sempre um número inteiro de base-10.

-1 byte, graças a TheLethalCoder!

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

Experimente online!

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}

Teste-o

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@##∣#&

Função pura usando dois argumentos, o inteiro e a base (nessa ordem) e retornando Trueou False. Cuidado: os dois primeiros |s são apenas o caractere ASCII normal, enquanto o último∣ é U + 2223.

#2<2 lida com o caso especial da base 1. Caso contrário, Tr@IntegerDigits@## produz a soma dos dígitos do primeiro argumento quando escrito na base do segundo argumento e ...∣#testa se essa soma divide o primeiro 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

Saídas 1 para números Harshad.

Python 3 , 45 bytes

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

Experimente online!

Com base nos formatos atualizados 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;}

Experimente online!

Pari / GP , 25 bytes

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

Experimente online!

Java (OpenJDK 8) , 54 bytes

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

Experimente online!