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 é , 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


Esta conversa foi movida para o bate-papo .
Dennis

Respostas:



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.

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.


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.

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

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

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 .

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


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!


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


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


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.


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.


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.


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!


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

C, 60 bytes

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

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

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


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

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

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





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

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.


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


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


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


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

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

Você pode ir pointfree e salvar 2 bytes: ((1>).).mod.
N
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.