Teste de divisibilidade

39

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

Mostrar snippet de código

code-golf math arithmetic decision-problem division Freira Furada
fonte
Esta conversa foi movida para o bate-papo .
Dennis

Respostas:

41

Geléia , 1 byte

ḍ

Isso me levou horas para jogar golfe.

Experimente online!

DJMcMayhem
fonte
12
uau, isso é muito, muito complexo!
@MatthewRoh Yep. Como eu disse, levei horas para chegar. : P
DJMcMayhem
29

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.
Dennis
fonte
20

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.

davey
fonte
2
Bem-vindo ao PPCG, boa primeira resposta!
Leaky Nun
Precisa ser um programa completo? Eu estava formatando minha resposta meio que fora dessa resposta . E obrigada! Espero melhorar o código de montagem / máquina para obter mais códigos de golfe!
Davey
1
A entrada e a saída nos registros especificados na montagem são permitidas por padrão: entrada , saída . Esta é uma submissão perfeitamente aceitável. Bem-vindo ao PPCG!
Mego
Fantástico! Obrigado!
Davey
17

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.

  . . ?
 . . . @
. . < . .
 . . . .
  . . .
Azul
fonte
6
Eu acho que você deveria formatar sua resposta de maneira diferente. Ter quatro respostas em um único bloco de código faz parecer que sua contagem de bytes está incorreta.
Mbomb007
17

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
DJMcMayhem
fonte
The rest is pretty straightforward.Sim, parece que sim.
Erik the Outgolfer 10/10
24 bytes se você contar cada instrução brainflak como um byte.
noɥʇʎԀʎzɐɹƆ
12

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 .
ETHproductions
fonte
Use currying para salvar um byte: a => b =>
Downgoat
Então, como faço para executar isso? Quando tento d=a=>b=>a%b<1seguido por d(32,2)no console JS ... Eu simplesmente obter a respostafunction b=>a%b<1
Wally West
@WallyWest usa currying, para que você digite d(32)(2). Porque d(32)dá function b=>a%b<1, então você tem que chamar essa função com o seu bvalor
Cyoce
9

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

DJMcMayhem
fonte
O que <C-Left>faz? Não é possível testá-lo porque ele muda o Windows no mac> _>
Downgoat
1
@Downgoat você está usando ctrl ou comando? De qualquer forma, é equivalente a "b", exceto que também funciona no modo de inserção.
DJMcMayhem
Para ser pedante, é o equivalente ao Binvés de b(e Ctrl+ Righté o equivalente a W) - a diferença é com caracteres que não são palavras, mas neste caso está fazendo exatamente a mesma coisa :) vimdoc.sourceforge.net/htmldoc/motion. html # <C-Left >
Christian Rondeau 5/16
9

Mathematica - 17 13 3 bytes

∣

Agradecemos a @MartinEnder por salvar uma tonelada de bytes!

Yytsi
fonte
Que personagem é esse?
Cyoce 4/10/16
@ Cyoce Eu não sei seu código Unicode (no telefone no momento), mas é um operador curto para Divisible[].
Yytsi 4/10/16
@ Cyoce Eu acho que é o símbolo do tubo, também conhecido como shift + barra invertida.
Pavel
@ Pavel, se fosse o símbolo do pipe, não seria de três bytes.
Cyoce 07/10
@Cyoce é o U + 2223 caracteres: fileformat.info/info/unicode/char/2223/index.htm
numbermaniac
8

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

Lynn
fonte
Para consertar o pedido, se necessário, acho ^(1+)\1* \1$que funcionará.
FryAmTheEggman
Eu acho que com a nova especificação, a ordem de entrada oposta está correta novamente.
Martin Ender
8

Lote, 20 bytes

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

Resultados 1com sucesso, 0com falha.

Neil
fonte
8

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.

JustinM - Restabelecer Monica
fonte
Eu não tenho certeza, mas acho que você pode apenas usar um lambda: (a,b)=>a%b<1;. +1.
Yytsi 22/07/16
@TuukkaX, obrigado, eu não tinha certeza, parece tão barato.
JustinM - Restabelece Monica
A versão JS deste currying usado para reduzi-la por um byte, e que deve trabalhar para C #, também: a=>b=>a%b<1;(nota: então você deve chamá-lo como f(a)(b)ao invés de f(a,b))
David Conrad
1
@DavidConrad oo que é legal, obrigado.
JustinM - Reinstate Monica
7

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.

mbomb007
fonte
Você poderia remover a parte "div" da coisa para salvar bytes?
Freira vazando
1
@LeakyNun Este é o algoritmo mais curto conhecido que fornece o módulo. A remoção de parte dela realmente a torna mais longa, porque você precisa de mais células temporárias. Você não pode encontrar um módulo sem dividir.
mbomb007
Entendo obrigado.
Leaky Nun
@LeakyNun Basta ver quanto tempo dura o algoritmo de divisão .
mbomb007
Provavelmente existem outras mais curtas, mas, se houver, ninguém as encontrou ou publicou.
mbomb007
7

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!

Assistente de Trigo
fonte
Link para intérprete online?
Leaky Nun
Bom trabalho! Bem-vindo também ao site! Espero que você se divirta aqui. (Eu certamente tenho)
DJMcMayhem
Boa primeira resposta, bem-vindo ao PPCG!
Freira vazando
6

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
OldBunny2800
fonte
É um programa completo, implementações atuais não requerem HAI e KTHXBYE
OldBunny2800
OK vou tentar. Um segundo ...
OldBunny2800
Não, é mais dois bytes.
OldBunny2800
O RLY?Eu não sabia disso! mudando.
OldBunny2800
BTW aqui estão dicas de golfe.
Freira vazando
6

C, 60 bytes

#include <stdio.h>
main(){int a,b;scanf("%d %d",&a,&b);a%b==0;}
Ronronner
fonte
1
Por que -1? Explicar
Ronronner
3
É possível que ninguém tenha votado mal. Esta é uma resposta curta, por isso foi sinalizada automaticamente como de baixa qualidade e você a editou. Por alguma razão, isso lança um voto negativo automático . Me desculpe por isso. +1de mim. Além disso, permitimos funções, para que você possa reduzi-lo facilmente int f(a,b){return !(a%b);}ou até mesmo mais curto.
DJMcMayhem
3
Não, meu argumento é que ele não precisa ser um programa completo. Você pode enviar apenas uma função. int f(a,b){return!(a%b);}é de 25 bytes e, se você usar o compilador certo, poderá fazê-lo f(a,b){return!(a%b);}por 21 bytes.
DJMcMayhem
3
Envio de função ainda mais curto: #define f(a,b)!(a%b)( link ideone )
Mego
2
Você precisa definir uma função ou um programa, não apenas um trecho.
Leaky Nun
5

Dyalog APL , 3 bytes

0=|

O zero é igual ao restante da divisão?

Adão
fonte
3
Isso funciona em J também.
milhas
5

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!).

Andreï Kostyrka
fonte
5

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);
    }
}
David Conrad
fonte
a->b->a%b<1Isso gera um erro de sintaxe, não é?
dorukayhan quer Monica de volta
2
Não, é válido Java 8.
David Conrad
Às vezes, até o Java está parecendo o Perl ...
Mega Man
Sim, eu acrescentaria que este é apenas o Java 8;).
Magic Octopus Urn
então, com o Java 8, temos que contar apenas os bytes de expressão lambda e não toda a classe e função, clichê!
Sikorski
4

Python, 16 bytes

lambda D,d:D%d<1
Dennis
fonte
1
Observe que isso não funcionaria se números inteiros negativos fossem permitidos. Felizmente, as entradas são estritamente positivas.
TLW 24/07
Eu fiz lambda a,b:1.*a/b==a/b, mas fiquei bastante impressionado. Esta é uma peça tão complexa de código ...
Erik o Outgolfer
4

GolfScript, 3 bytes

~%!

Explicação:

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

Experimente online!

Loovjo
fonte
4

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
Gato de negócios
fonte
3

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
Jeremy
fonte
3

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.

Gato de negócios
fonte
3

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


fonte
Você pode omitir ?1:0?
Leaky Nun
@LeakyNun é operação ternária. você quer dizer apenas retornar quando for inevitável?
O que $a%$b==0retornaria?
Leaky Nun
1
Quero dizer, sua terceira linha pode ser apenas exp $a%$b==0?
Leaky Nun
1
Ou exp $a%$b<1talvez?
Lynn
3

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

Titus
fonte
Se você não se importa com PHP4.1: <?=!($A%$B). Os valores podem ser passados como parte da sua $_SESSION, $_COOKIE, $_POST, $_GETou (se não me engano) mais $_ENV.
Ismael Miguel
@Ismael Miguel: Na verdade não, mas estou cansado de postar versões antigas do PHP e adicionar for PHP<5.4 with register_globals=On. Mas vou adicioná-lo para referência.
Titus
Na verdade, você não pode dizer " for PHP<5.4 with register_globals=On", já que precisa contar os bytes do seu php.iniarquivo que contém register_globals=On. No entanto, o PHP4.1 é um caso especial. É a última versão onde register_globals=Onestá o valor padrão, e a maioria das funções está disponível a partir do PHP4.1 ou superior. Esta versão também permite o uso de outras funções, como erege splitsem avisos.
Ismael Miguel
3

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

emiflake
fonte
Boa primeira resposta, bem-vindo ao PPCG!
Leaky Nun
@LeakyNun Obrigado, eu sempre procurei, bom finalmente responder.
emiflake
3

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
AdmBorkBork
fonte
Em ambos os outros métodos que eu tentei jogar golfe esta pergunta, eu tenho-os a 20 bytes também: param($a,$b)!($a%$b)e!($args[0]%$args[1])
ThePoShWolf
@DarthTwon Indeed. Ao lidar com pequenas quantidades de operações, geralmente há no máximo diferenças de um ou dois bytes nas diferentes maneiras de obter os argumentos de entrada.
AdmBorkBork
Eu esperava encontrar algo mais curto: P, mas sim, sempre há várias maneiras de esfolar o gato, especialmente no PS.
ThePoShWolf
3

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
Zeta
fonte
Você pode ir pointfree e salvar 2 bytes: ((1>).).mod.
N