Tarefa

Dado dois números inteiros estritamente positivos n e d como entrada, determine se n é divisível igualmente por d , ou seja, se existe um número inteiro q tal que n = qd.

Você pode escrever um programa ou uma função e usar qualquer um dos nossos métodos padrão de recebimento de entrada e saída.

A saída deve ser um valor verdadeiro ou falso ; verdade se n é divisível por d , e falsifique o contrário.

Seu código precisa lidar apenas com números inteiros que podem representar nativamente, desde que funcione para todos os números inteiros de 8 bits assinados. No entanto, seu algoritmo precisa funcionar para números inteiros arbitrariamente grandes.

Você pode usar qualquer linguagem de programação , mas observe que essas brechas são proibidas por padrão.

Isso é código-golfe , então a resposta mais curta e válida - medida em bytes - vence.

Casos de teste

 n,  d    output

 1,  1    truthy
 2,  1    truthy
 6,  3    truthy
17, 17    truthy
22,  2    truthy
 1,  2    falsy
 2,  3    falsy
 2,  4    falsy
 3,  9    falsy
15, 16    falsy

Entre os melhores

O snippet de pilha na parte inferior desta postagem gera o catálogo a partir das respostas a) como uma lista da solução mais curta por idioma eb) como uma tabela geral de líderes.

Para garantir que sua resposta seja exibida, inicie-a com um título, usando o seguinte modelo de remarcação:

## Language Name, N bytes

onde Nestá o tamanho do seu envio. Se você melhorar sua pontuação, poderá manter as pontuações antigas no título, identificando-as. Por exemplo:

## Ruby, <s>104</s> <s>101</s> 96 bytes

Se você quiser incluir vários números em seu cabeçalho (por exemplo, porque sua pontuação é a soma de dois arquivos ou deseja listar as penalidades de sinalizador de intérprete separadamente), verifique se a pontuação real é o último número no cabeçalho:

## Perl, 43 + 3 (-p flag) = 45 bytes

Você também pode transformar o nome do idioma em um link que será exibido no snippet:

## [><>](http://esolangs.org/wiki/Fish), 121 bytes

<style>body { text-align: left !important} #answer-list { padding: 10px; width: 290px; float: left; } #language-list { padding: 10px; width: 290px; float: left; } table thead { font-weight: bold; } table td { padding: 5px; }</style><script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="language-list"> <h2>Shortest Solution by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr> </thead> <tbody id="languages"> </tbody> </table> </div> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr> </thead> <tbody id="answers"> </tbody> </table> </div> <table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr> </tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr> </tbody> </table><script>var QUESTION_ID = 86149; var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe"; var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk"; var OVERRIDE_USER = 48934; var answers = [], answers_hash, answer_ids, answer_page = 1, more_answers = true, comment_page; function answersUrl(index) { return "https://api.stackexchange.com/2.2/questions/" + QUESTION_ID + "/answers?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + ANSWER_FILTER; } function commentUrl(index, answers) { return "https://api.stackexchange.com/2.2/answers/" + answers.join(';') + "/comments?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + COMMENT_FILTER; } function getAnswers() { jQuery.ajax({ url: answersUrl(answer_page++), method: "get", dataType: "jsonp", crossDomain: true, success: function (data) { answers.push.apply(answers, data.items); answers_hash = []; answer_ids = []; data.items.forEach(function(a) { a.comments = []; var id = +a.share_link.match(/\d+/); answer_ids.push(id); answers_hash[id] = a; }); if (!data.has_more) more_answers = false; comment_page = 1; getComments(); } }); } function getComments() { jQuery.ajax({ url: commentUrl(comment_page++, answer_ids), method: "get", dataType: "jsonp", crossDomain: true, success: function (data) { data.items.forEach(function(c) { if (c.owner.user_id === OVERRIDE_USER) answers_hash[c.post_id].comments.push(c); }); if (data.has_more) getComments(); else if (more_answers) getAnswers(); else process(); } }); } getAnswers(); var SCORE_REG = /<h\d>\s*([^\n,<]*(?:<(?:[^\n>]*>[^\n<]*<\/[^\n>]*>)[^\n,<]*)*),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/; var OVERRIDE_REG = /^Override\s*header:\s*/i; function getAuthorName(a) { return a.owner.display_name; } function process() { var valid = []; answers.forEach(function(a) { var body = a.body; a.comments.forEach(function(c) { if(OVERRIDE_REG.test(c.body)) body = '<h1>' + c.body.replace(OVERRIDE_REG, '') + '</h1>'; }); var match = body.match(SCORE_REG); if (match) valid.push({ user: getAuthorName(a), size: +match[2], language: match[1], link: a.share_link, }); else console.log(body); }); valid.sort(function (a, b) { var aB = a.size, bB = b.size; return aB - bB }); var languages = {}; var place = 1; var lastSize = null; var lastPlace = 1; valid.forEach(function (a) { if (a.size != lastSize) lastPlace = place; lastSize = a.size; ++place; var answer = jQuery("#answer-template").html(); answer = answer.replace("{{PLACE}}", lastPlace + ".") .replace("{{NAME}}", a.user) .replace("{{LANGUAGE}}", a.language) .replace("{{SIZE}}", a.size) .replace("{{LINK}}", a.link); answer = jQuery(answer); jQuery("#answers").append(answer); var lang = a.language; lang = jQuery('<a>'+lang+'</a>').text(); languages[lang] = languages[lang] || {lang: a.language, lang_raw: lang.toLowerCase(), user: a.user, size: a.size, link: a.link}; }); var langs = []; for (var lang in languages) if (languages.hasOwnProperty(lang)) langs.push(languages[lang]); langs.sort(function (a, b) { if (a.lang_raw > b.lang_raw) return 1; if (a.lang_raw < b.lang_raw) return -1; return 0; }); for (var i = 0; i < langs.length; ++i) { var language = jQuery("#language-template").html(); var lang = langs[i]; language = language.replace("{{LANGUAGE}}", lang.lang) .replace("{{NAME}}", lang.user) .replace("{{SIZE}}", lang.size) .replace("{{LINK}}", lang.link); language = jQuery(language); jQuery("#languages").append(language); } }</script>

Geléia , 1 byte

ḍ

Isso me levou horas para jogar golfe.

Experimente online!

Flacidez Cerebral , 72 70 64 62 58 46 bytes

{({}[()]{(<()>)}{}<({}[()]<({}())>)>)}{}{{}}{}

Pega dividendo e divisor (nessa ordem) como entrada e imprime o divisor (verdade) ou nada. Como cada pilha possui uma quantidade implícita e infinita de zeros, a saída vazia deve ser considerada falsa.

Embora não esteja limpa da pilha, esta solução usa apenas uma única pilha.

Experimente online!

Graças a @WheatWizard por jogar fora 2 bytes!

Como funciona

                INPUT: a (dividend), b (divisor)
                INITIAL STACK: n = a, d = b, r = 0
                               An infinite amount of zeroes follows.

{               While n is non-zero:
  (
    {}              Pop n from the stack.
    [()]            Yield -1.
    {               While the top of the stack (initially, d) is non-zero:
      (<()>)          Push 0.
    }
    {}              Pop 0. This will remove d from the stack if d = 0, leaving r
                    on top. We can think of this as performing the assignment
                    (d, r) = (r, d) if d = 0.
    <
      (
        {}              Pop d.
        [()]            Yield -1.
        <
          (
            {}              Pop r.
            ()              Yield 1.
          )               Push r + 1.
        >               Yield 0.
      )               Push d + (-1) + 0 = d - 1.
    >               Yield 0.
  )               Push n + (-1) + 0 + 0 + 0 = n - 1.
}               Each iteration decrements n, swaps d and r if d = 0, decrements d,
                and increments r.
                FINAL VALUES: n = 0
                              d = b - r
                              r = a % b if a % b > 0 else b
{}              Pop n.
{               While the top of the stack is non-zero:
  {}              Pop it.
}               This pops d and r if d > 0 (and, thus, a % b > 0) or noting at all.
{}              Pop d or a 0, leaving r if r = b and, thus, a % b = 0.

Cálculo do módulo, 42 bytes

O programa completo acima pode ser modificado de maneira trivial para calcular o módulo.

{({}[()]<({}[()]<({}())>)>{(<()>)}{})}{}{}

Como antes, esse método não é limpo de pilha, mas usa apenas uma única pilha. Um módulo de 0 deixará a pilha vazia, o que é aproximadamente equivalente a deixar 0 ; cada pilha contém zeros infinitos.

Experimente online!

Como funciona

Compare os dois loops do testador de divisibilidade e a calculadora do módulo.

{({}[()]{(<()>)}{}<({}[()]<({}())>)>)}
{({}[()]<({}[()]<({}())>)>{(<()>)}{})}

A única diferença é a localização de {(<()>)}{}, que troca de d e r , se d = 0 . Para calcular o módulo, realizamos esta troca após decrementing d e incrementando r .

Essa alteração não afeta o resultado se a% b> 0 , mas se a% b = 0 , deixa (n, d, r) = (0, b, 0) - em vez de (n, d, r) = (0, 0, b) - na pilha.

Assim, para obter o módulo, precisamos apenas aparecer n e d com {}{}.

Cálculo do módulo de limpeza de pilha, 64 bytes

O algoritmo de módulo de 42 bytes não é limpo de pilha, portanto, não pode ser usado como em todos os programas. A versão a seguir exibe dividendos e divisores (nessa ordem) da pilha ativa e empurra o módulo de volta. Não tem outros efeitos colaterais.

({}(<()>)){({}[()]<(({}()[({})])){{}(<({}({}))>)}{}>)}({}{}<{}>)

Essa solução é amplamente baseada no registro anterior de 72 bytes do @ WheatWizard, mas economiza 6 bytes nunca trocando pilhas.

Experimente online!

Como funciona

             INPUT: a (dividend), b (divisor)
             INITIAL STACK: n = a, b

(
  {}         Pop and yield n = a.
  (<()>)       Push d = 0.
)              Push n + 0 = n.
             STACK: n, d = 0, b
{(           While n in non-zero:
  {}           Pop and yield n.
  [()]         Yield -1.
  <
   ((
     {}         Pop and yield d.
     ()         Yield 1.
     [({})]     Pop b, push it back on the stack, and yield -b.
   ))         Push d + 1 + -b = d + 1 - b twice.
   {          While/if d + 1 - b is non-zero, i.e., if d < b - 1
     {}         Pop d + 1 - b (second copy).
     (<(
       {}         Pop d + 1 - b (first copy).
       ({})       Pop b and push it back on the stack.
     )>)        Push d + 1 - b + b = d + 1, then 0.
   }          If the loop wasn't skipped entirely, pushing 0 breaks out.
              If d < b - 1, it essentially performs the assignment d = d + 1.
              However, if d = b - 1, we get d = d + 1 - b = b - 1 + 1 - b = 0.
              In all cases, we wind up with d = (d + 1) % b.
   {}         Pop 0.
  >         Yield 0.
)}        Push n + -1 + 0 = n - 1. Break if n - 1 = 0.
          STACK: n = 0, d = a % b, b
(
  {}        Pop and yield n = 0.
  {}        Pop and d = a % b.
  <{}>      Pop b, but yield 0.
)         Push 0 + a % b + 0 = a % b.

código de máquina x86_32, 8 bytes

08048550 <div7>:
 8048550:   99                      cdq   
 8048551:   f7 f9                   idiv   %ecx
 8048553:   85 d2                   test   %edx,%edx
 8048555:   0f 94 c0                sete   %al

Esta é a minha primeira resposta de código de golfe, por isso espero seguir todas as regras.

Isso primeiro chama o cdq para limpar o registro edx e, em seguida, executa a divisão assinada no registro ecx, que armazena o restante no edx. A linha de teste edx, edx definirá o sinalizador zero se edx for zero, e sete coloca 0 para false se edx não for zero e coloca 1 para true se edx for 0.

Este é apenas o trecho de código que contribui para a contagem de bytes, mas para testar, aqui está o código C que escrevi com o assembly em linha, porque é mais fácil lidar com E / S.

Hexagonia, 15, 13, 12 10 bytes

A linguagem favorita de todos, baseada em hexágonos! : D

TL; DR trabalha usando soluções mágicas não formatadas para diminuir a contagem de bytes:

?{?..>1'%<.@!'/
?{?!1\.'%<@.>
?{?\!1@'%\!(
?{?!1\@'%<

Economizou 2 bytes graças à magia de layout do @ MartinEnder.

@FryAmTheEggman salvou 1 byte usando os cantos de forma mais criativa

O @MartinEnder e o @FryAmTheEggman vieram com uma solução de 10 bytes que não imprime nada por valores falsamente.

Minha solução (15):

Não formatado:

?{?..>1'%<.@!'/

Formatado:

  ? { ?
 . . > 1
' % < . @
 ! ' / .
  . . .

Solução de Martin Ender (13):

Não formatado:

?{?!1\.'%<@.>

Formatado:

  ? { ?
 ! 1 \ .
' % < @ .
 > . . .
  . . .

Explicação:

Primeiro, obtemos a entrada e pegamos o módulo.

  ? { ?
 . . . .
' % . . .
 . . . .
  . . .

Em seguida, verifica se o módulo é 0 ou não. Se for, o IP vira 60 graus para a esquerda, ricocheteia no espelho, define a célula para 1 e imprime.

Então, o IP continua na quarta linha. Quando atinge o >, ele vira para a direita (porque o valor da célula agora é 1). Ele dispara e volta ao canto inferior direito, na direção NW. O IP atinge o <, vai ao longo da linha superior e volta no canto direito para acessar o @, interrompendo o programa.

  . . .
 ! 1 \ .
. . < @ .
 > . . .
  . . .

Se o módulo for positivo, o IP girará 60 graus para a direita. Depois de sair pelo canto inferior direito, continua no canto inferior esquerdo por causa das regras de quebra automática do Hexagony. O 'é reutilizado para fazer o IP ir para uma célula com 0 nele. O IP viaja ao longo da quarta linha, passa para a segunda, pressiona impressão e é refletido na <. O restante do caminho para o @é o mesmo.

  . . .
 ! . \ .
' . < @ .
 > . . .
  . . .

Isso é uma magia séria.

@ Solução de FryAmTheEggman (12):

Não formatado:

?{?\!1@'%\!(

Formatado:

  ? { ?
 \ ! 1 @
' % \ ! (
 . . . .
  . . .

Explicação:

Como as outras soluções, obtém a entrada e aceita o módulo.

  ? { ?
 . . . .
' % . . .
 . . . .
  . . .

Em seguida, o IP é desviado para o canto inferior. Se o módulo for positivo, ele ficará no canto superior esquerdo. Como ?não há mais entrada, define a célula como 0. Em !seguida, imprime o 0 e @finaliza o programa.

  ? . .
 \ ! . @
. . \ . .
 . . . .
  . . .

As coisas são muito mais complicadas quando o módulo é 0. Primeiro, ele é diminuído, depois redefinido para 0, depois definido como 1 e impresso. Em seguida, o 1 é decrementado para 0. Depois disso, o programa é executado como no início até tentar 0%0. Isso faz com que ele gere um erro silencioso e saia.

  ? { ?
 . . 1 .
' % \ ! (
 . . . .
  . . .

Eu realmente gosto do truque do erro silencioso, mas uma maneira mais simples seria substituí (- /lo por, para que o IP passe pela primeira vez, mas seja refletido na @segunda.

Solução colaborativa (10):

Não formatado:

?{?!1\@'%<

Formatado:

  ? { ?
 ! 1 \ @
' % < . .
 . . . .
  . . .

Este programa inicia da mesma forma que todos os outros programas, obtendo a entrada e modificando-a.

Se a entrada for 0, o IP vira à esquerda quando atinge <. Ele é desviado para 1!@, que imprime 1 e sai.

  . . .
 ! 1 \ @
. . < . .
 . . . .
  . . .

Se a entrada for positiva, o IP vira à direita quando atinge <. Ele sai pelo canto e segue pela borda superior direita, atingindo o @ sem imprimir.

  . . ?
 . . . @
. . < . .
 . . . .
  . . .

Flacidez cerebral 102, 98, 96 bytes

(({}<>))<>{({}[()])<>(({}[()])){{}(<({}[({})])>)}{}({}({}))<>}{}<>([{}]{}){<>(([()])())}({}{}())

Eww. Bruto. Eu posso postar uma explicação, mas eu mal entendo. Essa linguagem machuca meu cérebro.

Experimente online!

Agradecemos ao usuário do github @Wheatwizard por apresentar um exemplo de módulo. Eu provavelmente não poderia ter descoberto isso sozinho!

Além disso, a resposta mais curta está aqui .

Explicação possivelmente incorreta:

(({}<>))                    #Push this element onto the other stack
<>                          #Move back to stack one.
{                           #While the top element is non-zero:
 ({}[()])                   #  Decrement the number on top
 <>                         #  Move to the other stack
 (({}[()]))                 #  Push the top element minus one twice
 {                          #  While the top element is non-zero:
  {}                        #    Pop the top element
  (<          >)            #    Push a zero
        ({})                #    Push the second from top element
       [    ]               #    Evalue this second from top element as negative
    ({}      )              #    And push that negative plus the top element
 }
 {}                         #  Pop the top element
 ({}({}))                   #  Push the top element plus the second from the top, AND push the second from top
 <>                         #  Switch stacks
}

{}                          #Pop the stack
<>                          #Switch to the other stack
([{}]{})                    #And push the top element minus the second element.

O resto é bem direto.

{              }            #While the top element is non-zero:
 <>                         #Move to the other stack
   (([()])  )               #Push a negative one
          ()                #AND push the previously pushed value + 1 (e.g. 0)

                 (      )   #Push:
                  {}{}      #The top two elements added together
                      ()    #Plus one

Javascript (ES6) 17 12 11 bytes

a=>b=>a%b<1

• EDIT: Removidos 5 bytes porque é esperado 'a> 0'.
• EDIT2: Removido 1 byte graças ao Downgoat .

Vim, 11 pressionamentos de tecla

C<C-r>=<C-r>"<C-Left>%<C-Right><1<cr>

Nada mal para um idioma que lida apenas com seqüências de caracteres. : D

Mathematica - 17 13 3 bytes

∣

Agradecemos a @MartinEnder por salvar uma tonelada de bytes!

Retina, 12 bytes

^(1+)\1* \1$

Pega a entrada separada por espaço em unário, gostaria 111111111111 1111de verificar se 12 se divisível por 4 . Imprime 1 (verdadeiro) ou 0 (falso).

Experimente online!

FryAmTheEggman salvou dois bytes. Ops, reescrevi minha resposta para colocar os argumentos na ordem certa. (Então Fry me venceu nos comentários. Eu sou lento em regex!)

Lote, 20 bytes

@cmd/cset/a!(%1%%%2)

Resultados 1com sucesso, 0com falha.

C #, 27 13 12 bytes

a=>b=>a%b<1;

Obrigado a TuukkaX por apontar lambdas anônimas são aceitáveis. Agradeço a David Conrad por me indicar um curry que eu nem sabia que era uma coisa.

Curto e doce, já que estamos lidando apenas com números inteiros, podemos usar <1e não ==0salvar um byte inteiro.

brainfuck, 53 bytes

Pega a entrada como bytes, a saída é um valor de byte de 0x00ou 0x01. É o algoritmo DivMod seguido por negação booleana .

,>,<[->-[>+>>]>[+[-<+>]>+>>]<<<<<]>,>[<+>,]+<[>-<-]>.

Experimente on-line - Possui muitos extras+no final para que você possa ver a saída em ASCII.

Brain-Flak , 88 86 bytes

(<({}<>)>)<>{({}[()])<>(({}()[({})])){{}(<({}({}))>)}{}<>}<>(({}<{}>)){{}{}(<(())>)}{}

Esta é uma versão mais densa do algoritmo original de teste de divisibilidade Brain-Flak, escrito por Dr Green Eggs e Iron Man DJMcMayhem e por mim.

Aqui está uma breve (ish) explicação de como funciona:

  ({}<>)        #Move the top of the stack to the other stack #Start Mod
(<      >)      #Push zero
<>              #Switch stacks
{               #While the top of the stack is not zero
 ({}[()])       #Subtract one from the top of the stack
 <>             #Switch stacks
   {}()         #Pop the top, add one and ...
       [({})]   #Subtract the second element on the stack
 ((          )) #Push twice
 {              #If the top is not zero
  {}            #Pop the duplicate
    ({}({}))    #Add the second element to the first
  (<        >)  #Push zero
 }              #End if
 {}             #Pop the zero
 <>             #Switch back
}               #End While
<>              #Switch to the other stack
 ({}<{}>)       #Remove the second value on the stack         #End Mod
(        )      #Duplicate the result of modulation
{               #If the top is not zero
 {}{}           #Pop the top two elements
 (<(())>)       #Push a one and a zero
}               #End if
{}              #Pop the zero

Experimente Online!

LOLCODE, 74 64 bytes

HOW IZ I f YR a AN YR b
BOTH SAEM MOD OF a AN b AN 0
IF U SAY SO

C, 60 bytes

#include <stdio.h>
main(){int a,b;scanf("%d %d",&a,&b);a%b==0;}

Dyalog APL , 3 bytes

0=|

O zero é igual ao restante da divisão?

R, 22 20 bytes

a=scan();!a[1]%%a[2]

Como de costume, lê dois números da entrada que é finalizada por uma linha vazia.

Atualização: obrigado a Jarko Dubbeldam por cortar 2 bytes (apesar de sua edição ter sido rejeitada, foi muito útil!).

Java 8, 11 bytes

a->b->a%b<1

Que diabos, existem versões JS e C # disso, por que não uma versão Java também?

Uso:

import java.util.function.Function;

public class Program {
    public static void main(String[] args) {
        System.out.printf("%d, %d %b%n", 9, 3, divides(9, 3, a->b->a%b<1));
        System.out.printf("%d, %d %b%n", 3, 9, divides(3, 9, a->b->a%b<1));
    }

    public static boolean divides(int a, int b,
            Function<Integer, Function<Integer, Boolean>> f) {
        return f.apply(a).apply(b);
    }
}

Python, 16 bytes

lambda D,d:D%d<1

GolfScript, 3 bytes

~%!

Explicação:

~    # Evaluate the input
 %   # Take the first modulus the second
  !  # Boolean not

Experimente online!

CJam, 6 4 bytes

Economizou 2 bytes graças a Dennis

q~%!

Experimente online

q    e# Take in the input
 ~   e# Dump the individual values to the stack
  %  e# Modulus
   ! e# Boolean NOT

Braquilog , 2 bytes

%0

Experimente online!

Julia, 9 bytes

D\d=D%d<1

Experimente online!

Fortran 95, 78 bytes

function f(i,j)result(k)
integer::i,j,k
k=merge(1,0,MOD(i,j)<1)
end function f

MarioLANG, 121 109 107 bytes

Economizou 14 bytes graças a Martin Ender

;>(-)-)+(([!)
)"=========#[
; +(![-)< )<!+
  ==#==="  "#:
>!< >(+ !![(<
=#"="===##=:"
  !      <
  #======"

Experimente online!

Explicação

O algoritmo é simplesmente manter subtraindo da partir npara ver se você pode fazê-lo um número inteiro de vezes e não têm nenhum restante.

;
)
;

>
=
 
 

Primeiro, a entrada é coletada. nestá na primeira célula, dna segunda.

 >(-)-)+(([!
 "=========#
          )<
           "
 !
 #"="===##=
  
  

Este é essencialmente o loop principal. Diminui a primeira e a segunda célula e incrementa a terceira.

           [!)
           =#[
             !+
             #:
            (<
            :"
 
 

Esta é a saída final. Se após o incremento / decréscimo, a primeira célula for 0, eliminamos n. Se depois disso, a segunda célula ( d) for 0, então dentrará nuniformemente. Nós incrementamos e imprimimos ( 1). Caso contrário, volte para a primeira célula (que é 0) e imprima-a.

 
 
  +(![-)<  
  ==#==="  
 !< >(+ !![
 #"="===##=
  !      <
  #======"

Esse loop ocorre se a segunda célula for 0após incrementar e decrementar. Ele copia a terceira célula para a segunda célula. A parte na parte inferior é ignorar o loop, se a célula não estiver 0.

Tcl, 34 bytes

ge stdin a
ge stdin b
exp $a%$b<1

Minha primeira / * tentativa bem-sucedida * / no codegolf! Este código deve ser executado no shell Tcl, caso contrário não funcionará.

Um byte graças a @Lynn.

Quatro bytes graças a @Lynn e @LeakyNun (agora entendo o que ele quis dizer)!

PHP, 23 22 bytes

<?=$argv[1]%$argv[2]<1

imprime 1 como verdadeiro, sequência vazia (= nada) para falso

chamar de cli com ne dcomo argumentos

10 bytes para o PHP antigo: <?=$n%$d<1

J, 3 bytes

0=|

Uso:

2 (0=|) 10 

Voltará 1. E é equivalente ao pseudocódigo10 MOD 2 EQ 0

Observe que isso é muito semelhante à resposta da APL , porque J é fortemente inspirado na APL

PowerShell v2 +, 20 bytes

!($args-join'%'|iex)

Recebe a entrada como dois argumentos da linha de comando $args, -joinagrupa-os em uma sequência de caracteres com %o separador, canaliza isso para iex(abreviado Invoke-Expressione semelhante a eval). O resultado é 0igual a ou diferente de zero; portanto, não consideramos o resultado booleano !, o que significa um $TRUEou outro $FALSE(números inteiros diferentes de zero no PowerShell são verdadeiros). Esse booleano é deixado no pipeline e a saída está implícita.

Versões alternativas, também 20 bytes cada

param($a,$b)!($a%$b)
!($args[0]%$args[1])

Mesmo conceito, apenas maneiras ligeiramente diferentes de estruturar a entrada. Obrigado a @DarthTwon por fornecê-los.

Exemplos

PS C:\Tools\Scripts\golfing> .\divisibility-test.ps1 24 12
True

PS C:\Tools\Scripts\golfing> .\divisibility-test.ps1 24 13
False

PS C:\Tools\Scripts\golfing> .\divisibility-test.ps1 12 24
False

Haskell, 13 11 bytes

((1>).).mod

Isso define uma nova função (!) :: Integral n => n -> n -> Bool. Como mod n mretorna apenas números positivos se ne mforem positivos, podemos salvar um byte usando em 1>vez de 0==.

Uso:

ghci> let n!d=1>mod n d
ghci> 100 ! 2
True
ghci> 100 ! 3
False