Prueba de divisibilidad

39

Tarea

Dados dos enteros estrictamente positivos n y d como entrada, determine si n es divisible por d , es decir, si existe un entero q tal que n = qd.

Puede escribir un programa o una función y utilizar cualquiera de nuestros métodos estándar para recibir entradas y proporcionar salidas.

El resultado debe ser un valor verdadero o falso ; verdadero si n es divisible por d , y falso de lo contrario.

Su código solo tiene que manejar enteros que pueda representar de forma nativa, siempre que funcione para todos los enteros de 8 bits con signo. Sin embargo, su algoritmo tiene que funcionar para enteros arbitrariamente grandes.

Puede usar cualquier lenguaje de programación , pero tenga en cuenta que estas lagunas están prohibidas de forma predeterminada.

Este es el código de golf , por lo que gana la respuesta válida más corta, medida en bytes .

Casos de prueba

 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

Tabla de clasificación

El Fragmento de pila al final de esta publicación genera el catálogo a partir de las respuestas a) como una lista de la solución más corta por idioma yb) como una tabla de clasificación general.

Para asegurarse de que su respuesta se muestre, comience con un título, usando la siguiente plantilla de Markdown:

## Language Name, N bytes

¿Dónde Nestá el tamaño de su envío? Si mejora su puntaje, puede mantener los puntajes antiguos en el título, tachándolos. Por ejemplo:

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

Si desea incluir varios números en su encabezado (por ejemplo, porque su puntaje es la suma de dos archivos o desea enumerar las penalizaciones de la bandera del intérprete por separado), asegúrese de que el puntaje real sea el último número en el encabezado:

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

También puede hacer que el nombre del idioma sea un enlace que luego aparecerá en el fragmento:

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

Mostrar fragmento de código

code-golf  math  arithmetic  decision-problem  division 
— Monja permeable
fuente
Esta conversación se ha movido al chat .
— Dennis

Respuestas:

29

Brain-Flak , 72 70 64 62 58 46 bytes

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

Toma dividendo y divisor (en ese orden) como entrada e imprime el divisor (verdad) o nada. Como cada pila tiene una cantidad implícita e infinita de ceros, la salida vacía debe considerarse falsa.

Si bien no es apilada, esta solución usa solo una pila.

Pruébalo en línea!

¡Gracias a @WheatWizard por jugar golf en 2 bytes!

Cómo 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 de módulo, 42 bytes

El programa completo anterior se puede modificar de manera trivial para calcular el módulo en su lugar.

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

Como antes, este método no es de limpieza de pila, pero usa solo una pila. Un módulo de 0 dejará la pila vacía, lo que equivale aproximadamente a dejar 0 ; cada pila contiene ceros infinitos.

Pruébalo en línea!

Cómo funciona

Compare los dos bucles del probador de divisibilidad y la calculadora de módulo.

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

La única diferencia es la ubicación de {(<()>)}{}, que intercambia d y r si d = 0 . Para calcular el módulo, realizamos este intercambio después de disminuir d e incrementar r .

Este cambio no afecta el resultado si a% b> 0 , pero si a% b = 0 , deja (n, d, r) = (0, b, 0) - en lugar de (n, d, r) = (0, 0, b) - en la pila.

Por lo tanto, para obtener el módulo, solo tenemos que hacer estallar n y d con {}{}.

Cálculo del módulo de limpieza de pila, 64 bytes

El algoritmo de módulo de 42 bytes no es limpio de pila, por lo que no se puede usar como está en todos los programas. La siguiente versión extrae dividendos y divisores (en ese orden) de la pila activa y empuja el módulo a cambio. No tiene otros efectos secundarios.

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

Esta solución se basa en gran medida en el registro anterior de 72 bytes de @ WheatWizard, pero ahorra 6 bytes al no cambiar nunca las pilas.

Pruébalo en línea!

Cómo 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
fuente
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 es mi primera respuesta de código de golf, así que espero seguir todas las reglas.

Esto primero llama a cdq para borrar el registro edx, luego realiza una división firmada en el registro ecx, que almacena el resto en edx. La línea edx de prueba, edx establecerá el indicador de cero si edx es cero, y sete pone un 0 para falso si edx no era cero, y pone un 1 para verdadero si edx era 0.

Este es solo el fragmento de código que contribuye al recuento de bytes, pero para la prueba, aquí está el código C que escribí con el ensamblaje en línea porque es más fácil de esta manera manejar E / S.

— davey
fuente
2
Bienvenido a PPCG, buena primera respuesta!
— Leaky Nun
¿Tiene que ser un programa completo? Estaba formateando mi respuesta un poco fuera de esta respuesta . ¡Y gracias! ¡Espero mejorar en el código de ensamblaje / máquina para más golf de código!
— davey
1
La entrada y salida en registros especificados en el ensamblaje está permitida por defecto: entrada , salida . Esta es una presentación perfectamente aceptable. Bienvenido a PPCG!
— Mego
¡Fantástico! ¡Gracias!
— davey
17

Hexagonía, 15, 13, 12 10 bytes

¡El lenguaje basado en hexágonos favorito de todos! :RE

TL; DR funciona utilizando soluciones mágicas y sin formato para disminuir el recuento de bytes:

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

Ahorro de 2 bytes gracias a la magia de diseño de @ MartinEnder.

@FryAmTheEggman guardó 1 byte al usar las esquinas de manera más creativa

Tanto @MartinEnder como @FryAmTheEggman idearon una solución de 10 bytes que no imprime nada con valores falsos.

Mi solución (15):

Sin formato:

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

Formateado:

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

Solución de @Martin Ender (13):

Sin formato:

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

Formateado:

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

Explicación:

Primero, obtenemos la entrada y tomamos el módulo.

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

Luego, verifica si el módulo es 0 o no. Si es así, la IP gira 60 grados a la izquierda, rebota en el espejo, establece la celda en 1 e imprime.

Luego, la IP continúa en la cuarta fila. Cuando alcanza el >, gira a la derecha en su lugar (porque el valor de la celda ahora es 1). Se vuelve loco y vuelve a la esquina inferior derecha en dirección NO. El IP golpea el <, va a lo largo de la fila superior y vuelve a la esquina derecha para golpear el @, deteniendo el programa.

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

Si el módulo resulta positivo, la IP gira 60 grados a la derecha. Una vez que sale de la esquina inferior derecha, continúa en el borde inferior izquierdo debido a las reglas de ajuste de Hexagony. Se 'reutiliza para hacer que la IP vaya a una celda con 0 en ella. La IP luego viaja a lo largo de la cuarta fila, se envuelve a la segunda, golpea la impresión y se refleja en la <. El resto del camino hacia el @es el mismo.

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

Eso es algo de magia seria.

@ Solución FryAmTheEggman (12):

Sin formato:

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

Formateado:

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

Explicación:

Al igual que las otras soluciones, obtiene la entrada y toma el módulo.

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

Luego, la IP se desvía hacia la esquina inferior. Si el módulo es positivo, va en el borde superior izquierdo. El ?no tiene más entrada, por lo que establece la celda en 0. !Luego imprime el 0 y @finaliza el programa.

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

Las cosas son mucho más complicadas para cuando el módulo es 0. En primer lugar, se reduce, luego se restablece a 0, luego se establece en 1, luego se imprime. Luego, el 1 se reduce a 0. Después de eso, el programa se ejecuta como lo hace al principio hasta que intenta hacerlo 0%0. Eso hace que arroje un error silencioso y salga.

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

Realmente me gusta el truco del error silencioso, pero una forma más simple sería reemplazarlo (con /para que la IP pase la primera vez, pero se refleje en @la segunda.

Solución colaborativa (10):

Sin formato:

?{?!1\@'%<

Formateado:

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

Este programa comienza igual que todos los demás programas, obteniendo la entrada y modificándola.

Si la entrada es 0, la IP gira a la izquierda cuando golpea <. Se desvía hacia 1!@, que imprime 1 y se cierra.

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

Si la entrada es positiva, la IP gira a la derecha cuando golpea <. Sale por la esquina y va a lo largo del borde superior derecho golpeando la @ sin imprimir.

  . . ?
 . . . @
. . < . .
 . . . .
  . . .
— Azul
fuente
66
Creo que deberías formatear tu respuesta de manera diferente. Tener cuatro respuestas en un solo bloque de código hace que parezca que su recuento de bytes es incorrecto.
— mbomb007
17

Brain-flak 102, 98, 96 bytes

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

Eww. Bruto. Podría publicar una explicación, pero apenas la entiendo. Este lenguaje me duele el cerebro.

Pruébalo en línea!

Gracias al usuario de github @Wheatwizard por llegar a un ejemplo de módulo. ¡Probablemente no podría haberlo descubierto yo mismo!

Además, la respuesta más corta está aquí .

Posiblemente explicación incorrecta:

(({}<>))                    #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.

El resto es bastante sencillo.

{              }            #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
fuente
The rest is pretty straightforward.Sí, eso parece.
— Erik the Outgolfer
24 bytes si cuenta cada instrucción brainflak como un byte.
— noɥʇʎԀʎzɐɹƆ
12

Javascript (ES6) 17 12 11 bytes

a=>b=>a%b<1
  • EDITAR: se eliminaron 5 bytes porque se espera 'a> 0'.
  • EDIT2: eliminado 1 byte gracias a Downgoat .
— ETHproducciones
fuente
Usa el curry para guardar un byte: a => b =>
— Downgoat
Entonces, ¿cómo ejecuto esto? Cuando trato d=a=>b=>a%b<1seguido d(32,2)en la consola JS ... simplemente recibo la respuestafunction b=>a%b<1
— WallyWest
@WallyWest esto usa curry, por lo que escribiría d(32)(2). Porque d(32)da function b=>a%b<1, entonces tienes que llamar a esa función con tu bvalor
— Cyoce
9

Vim, 11 pulsaciones de teclas

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

No está mal para un lenguaje que solo maneja cadenas. :RE

— DJMcMayhem
fuente
¿Qué <C-Left>hacer? No puedo probarlo porque cambia Windows en Mac> _>
— Downgoat
1
@Downgoat ¿estás usando ctrl o comando? De cualquier manera, es equivalente a "b", excepto que también funciona en modo de inserción.
— DJMcMayhem
Para ser pedante, es el equivalente en Blugar de b(y Ctrl+ Rightes el equivalente de W): la diferencia es con caracteres que no son palabras, pero en este caso está haciendo exactamente lo mismo :) vimdoc.sourceforge.net/htmldoc/motion. html # <C-Left >
— Christian Rondeau
9

Mathematica - 17 13 3 bytes

∣

¡Gracias a @MartinEnder por guardar una tonelada de bytes!

— Yytsi
fuente
¿Qué personaje es ese?
— Cyoce
@Cyoce No sé su código Unicode (en el teléfono en este momento), pero es un operador corto para Divisible[].
— Yytsi
@Cyoce Creo que es el símbolo de la tubería, también conocido como shift + barra invertida.
— Pavel
@Pavel si fuera el símbolo de la tubería, no sería de tres bytes.
— Cyoce
@Cyoce es el carácter U + 2223: fileformat.info/info/unicode/char/2223/index.htm
— numbermaniac
8

Retina, 12 bytes

^(1+)\1* \1$

Toma entradas separadas por espacios en unario, como 111111111111 1111para verificar si 12 es divisible por 4 . Imprime 1 (verdadero) o 0 (falso).

Pruébalo en línea!

FryAmTheEggman guardó dos bytes. Vaya, reescribí mi respuesta para tomar los argumentos en el orden correcto. (Entonces Fry me ganó en los comentarios. ¡Soy lento en expresiones regulares!)

— Lynn
fuente
Para arreglar el orden, si es necesario, creo ^(1+)\1* \1$que funcionará.
— FryAmTheEggman
Supongo que con la nueva especificación, el orden de entrada opuesto está bien nuevamente.
— Martin Ender
8

Lote, 20 bytes

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

Resultados 1en éxito, 0en fracaso.

— Neil
fuente
8

C #, 27 13 12 bytes

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

Gracias a TuukkaX por señalar que las lambdas anónimas son aceptables. Gracias a David Conrad por señalarme al curry que ni siquiera sabía que era una cosa.

Corto y dulce, ya que solo estamos tratando con números enteros que podemos usar en <1lugar de ==0y guardar un byte completo.

— JustinM - Restablece a Monica
fuente
No estoy seguro, pero creo que sólo puede utilizar un lambda: (a,b)=>a%b<1;. +1.
— Yytsi
@ TuukkaX, gracias, no estaba seguro, solo parece muy engañoso.
— JustinM - Restablece a Monica el
La versión JS de esto usaba curry para reducirlo en un byte, y eso también debería funcionar para C #: a=>b=>a%b<1;(nota: luego debe llamarlo como en f(a)(b)lugar de f(a,b))
— David Conrad
1
@DavidConrad oo eso está bien, gracias.
— JustinM - Restablece a Mónica el
7

brainfuck, 53 bytes

Toma la entrada como bytes, la salida es un valor de byte de 0x00o 0x01. Es el algoritmo DivMod seguido de negación booleana .

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

Pruébelo en línea : tiene un montón de elementos adicionales+cerca del final para que pueda ver la salida en ASCII.

— mbomb007
fuente
¿Podría eliminar la parte "div" de la cosa para guardar bytes?
— Leaky Nun
1
@LeakyNun Este es el algoritmo más corto conocido que proporciona el módulo. Eliminar parte de él en realidad lo hace más largo, porque necesita más celdas temporales. No puedes encontrar un módulo sin dividir.
— mbomb007
Ya veo, gracias.
— Leaky Nun
@LeakyNun Solo mira cuánto tiempo dura el algoritmo de División .
— mbomb007
Probablemente hay más cortos, pero si es así, nadie los ha encontrado o publicado.
— mbomb007
7

Brain-Flak , 88 86 bytes

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

Esta es una versión más densa del algoritmo original de prueba de divisibilidad Brain-Flak escrito por el Dr. Green Eggs y Iron Man DJMcMayhem y por mí.

Aquí hay una breve explicación (ish) de cómo 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

Pruébalo en línea!

— Asistente de trigo
fuente
Enlace al intérprete en línea?
— Leaky Nun
¡Buen trabajo! ¡Bienvenido también al sitio! Espero que te diviertas aquí. (Ciertamente tengo)
— DJMcMayhem
Buena primera respuesta, bienvenido a PPCG!
— Leaky Nun
6

C, 60 bytes

#include <stdio.h>
main(){int a,b;scanf("%d %d",&a,&b);a%b==0;}
— Ronronner
fuente
1
¿Por qué -1? Explícame
— Ronronner
3
Es posible que nadie haya votado en contra. Esta es una respuesta corta, por lo que se marcó automáticamente como de baja calidad y luego la editó. Por alguna razón, esto arroja un voto negativo automático . Lo siento por eso. +1de mi parte. Además, permitimos funciones, por lo que puede acortarlo fácilmente int f(a,b){return !(a%b);}o incluso más.
— DJMcMayhem
3
No, mi punto es que no tiene que ser un programa completo. Puede enviar solo una función en su lugar. int f(a,b){return!(a%b);}es de 25 bytes, y si usa el compilador correcto, incluso podría hacerlo f(a,b){return!(a%b);}por 21 bytes.
— DJMcMayhem
3
Presentación de funciones aún más corta: #define f(a,b)!(a%b)( enlace ideone )
— Mego
2
Debe definir una función o un programa, no solo un fragmento.
— Leaky Nun
5

R, 22 20 bytes

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

Como de costumbre, lee dos números de la entrada que termina en una línea vacía.

Actualización: gracias a Jarko Dubbeldam por reducir 2 bytes (a pesar de que su edición fue rechazada, ¡fue muy útil!).

— Andreï Kostyrka
fuente
5

Java 8, 11 bytes

a->b->a%b<1

What the heck, there are JS and C# versions of this, why not a Java version, too?

Usage:

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
fuente
a->b->a%b<1 This raises a syntax error, doesn't it?
— dorukayhan wants Monica back
2
No, it's valid Java 8.
— David Conrad
Sometimes even Java is looking like Perl...
— Mega Man
Yeah, I'd add in that this is Java 8 only ;).
— Magic Octopus Urn
so with Java 8 we have to count only lambda expression bytes not the whole class and function boilerplate, cool !
— Sikorski
4

Python, 16 bytes

lambda D,d:D%d<1
— Dennis
fuente
1
Note that this wouldn't work if negative integers were allowed. Luckily, the inputs are strictly positive.
— TLW
I did lambda a,b:1.*a/b==a/b, but was quite impressed. This is a so complex piece of code...
— Erik the Outgolfer
4

GolfScript, 3 bytes

~%!

Explanation:

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

Try it online!

— Loovjo
fuente
4

CJam, 6 4 bytes

Saved 2 bytes thanks to Dennis

q~%!

Try it online

q    e# Take in the input
 ~   e# Dump the individual values to the stack
  %  e# Modulus
   ! e# Boolean NOT
— Business Cat
fuente
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
fuente
3

MarioLANG, 121 109 107 bytes

Saved 14 bytes thanks to Martin Ender

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

Try it online!

Explanation

The algorithm is simply to keep subtracting d from n to see if you can do it an integer number of times and have no remainder.

;
)
;

>
=
 
 

First, the input is collected. n is in the first cell, d in the second.

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

This is essentially the main loop. It decrements the first and second cells, and increments the third.

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

This is the final output. If after the incrementing/decrementing, the first cell is 0, then we've eliminated n. If after this, the second cell (d) is 0, then d went into n evenly. We increment and print (1). Otherwise, move back to the first cell (which is 0) and print it.

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

This loop happens if the second cell is 0 after incrementing and decrementing. It copies the third cell to the second cell. The part at the bottom is to bypass the loop if the cell is not 0.

— Business Cat
fuente
3

Tcl , 34 bytes

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

My first /*successful*/ attempt in codegolf ! This code must be executed in Tcl shell , otherwise it will not work.

One byte thanks to @Lynn .

Four bytes thanks to @Lynn and @LeakyNun (now I understand what he meant)!

Can you omit ?1:0?
— Leaky Nun
@LeakyNun it's ternary operation . you mean just to return sth when it's devisible ?
What would $a%$b==0 return?
— Leaky Nun
1
I mean, can your third line just be exp $a%$b==0?
— Leaky Nun
1
Or exp $a%$b<1, maybe?
— Lynn
3

PHP, 23 22 bytes

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

prints 1 for true, empty string (=nothing) for false

call from cli with n and d as arguments

10 bytes for ancient PHP: <?=$n%$d<1

— Titus
fuente
If you don't mind using PHP4.1: <?=!($A%$B). The values can be passed as part of your $_SESSION, $_COOKIE, $_POST, $_GET or (if I'm not mistaken) over $_ENV.
— Ismael Miguel
@Ismael Miguel: Actually I don´t, but I am tired of posting for ancient PHP versions and adding for PHP<5.4 with register_globals=On. But I´ll add it for reference.
— Titus
Actually, you can't say "for PHP<5.4 with register_globals=On", since you have to count the bytes of your php.ini file containing register_globals=On. However, PHP4.1 is a special case. It is the last version where register_globals=On is the default value, and most functions are available from PHP4.1 and up. This version also allows the use of other functions, like ereg and split without warnings.
— Ismael Miguel
3

J, 3 bytes

0=|

Usage:

2 (0=|) 10

Will return 1. And is equivalent to pseudocode 10 MOD 2 EQ 0

Note this is very similar to the APL answer, because J is heaviliy inspired by APL

— emiflake
fuente
Nice first answer, welcome to PPCG!
— Leaky Nun
@LeakyNun Thanks, I've always browsed around, nice to finally answer.
— emiflake
3

PowerShell v2+, 20 bytes

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

Takes input as two command-line arguments $args, -joins them together into a string with % as the separator, pipes that to iex (short for Invoke-Expression and similar to eval). The result is either 0 or non-zero, so we take the Boolean not ! of that result, which means either $TRUE or $FALSE (non-zero integers in PowerShell are truthy). That Boolean is left on the pipeline and output is implicit.

Alternative versions, also 20 bytes each

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

Same concept, just slightly different ways of structuring the input. Thanks to @DarthTwon for providing these.

Examples

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
fuente
In both of the other methods I tried golfing this question, I got them to 20 bytes also: param($a,$b)!($a%$b) and !($args[0]%$args[1])
— ThePoShWolf
@DarthTwon Indeed. When dealing with small amounts of operations, there's usually at most one or two bytes differences in the different ways of taking the input arguments.
— AdmBorkBork
I was hoping to come up with something shorter :P but yeah, there's always multiple ways to skin the cat, especially in PS.
— ThePoShWolf
3

Haskell, 13 11 bytes

((1>).).mod

This defines a new function (!) :: Integral n => n -> n -> Bool. Since mod n m returns only positive numbers if n and m are positive, we can save a byte by using 1> instead of 0==.

Usage:

ghci> let n!d=1>mod n d
ghci> 100 ! 2
True
ghci> 100 ! 3
False
— Zeta
fuente
You can go pointfree and save 2 bytes: ((1>).).mod.
— nimi
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.