Test de divisibilité

39

Tâche

Avec deux entiers strictement positifs n et d en entrée, déterminez si n est divisible par d , c’est-à-dire s’il existe un entier q tel que n = qd.

Vous pouvez écrire un programme ou une fonction et utiliser l’une quelconque de nos méthodes standard de réception d’entrée et de sortie.

Le résultat devrait être une valeur de vérité ou de fausseté ; vérité si n est divisible par d , et fausseté autrement.

Votre code doit uniquement gérer les entiers qu'il peut représenter de manière native, tant qu'il fonctionne pour tous les entiers signés 8 bits. Cependant, votre algorithme doit fonctionner pour des entiers arbitrairement grands.

Vous pouvez utiliser n'importe quel langage de programmation , mais notez que ces failles sont interdites par défaut.

C'est du code-golf , donc la réponse valide la plus courte - mesurée en octets - est gagnante.

Cas de test

 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

Classement

Le fragment de pile au bas de cet article génère le catalogue à partir des réponses a) sous forme de liste des solutions les plus courtes par langue et b) sous forme de classement global.

Pour vous assurer que votre réponse apparaît, commencez votre réponse par un titre, en utilisant le modèle Markdown suivant:

## Language Name, N bytes

où Nest la taille de votre soumission. Si vous améliorez votre score, vous pouvez conserver les anciens scores en les effaçant. Par exemple:

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

Si vous souhaitez inclure plusieurs numéros dans votre en-tête (par exemple, parce que votre score est la somme de deux fichiers ou si vous souhaitez répertorier séparément les pénalités d'indicateur d'interprétation), assurez-vous que le score réel est le dernier numéro de l'en-tête:

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

Vous pouvez également faire du nom de la langue un lien qui apparaîtra ensuite dans l'extrait de code:

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

Afficher l'extrait de code

code-golf  math  arithmetic  decision-problem  division 
— Fuite Nun
source
Cette conversation a été déplacée pour discuter .
— Dennis

Réponses:

29

Brain-Flak , 72 70 64 62 58 46 octets

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

Prend dividende et diviseur (dans cet ordre) en tant qu'entrée et affiche le diviseur (vérité) ou rien. Comme chaque pile a une quantité implicite et infinie de zéros, une sortie vide doit être considérée comme falsifiée.

Bien qu'elle ne soit pas propre à la pile, cette solution utilise une seule pile.

Essayez-le en ligne!

Merci à @WheatWizard pour le golf de 2 octets!

Comment ça marche

                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.

Calcul du module, 42 octets

Le programme complet ci-dessus peut être modifié de manière triviale pour calculer le module à la place.

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

Comme auparavant, cette méthode n’est pas nettoyée, mais elle n’utilise qu’une seule pile. Un module de 0 laissera la pile vide, ce qui revient à peu près à laisser 0 ; chaque pile contient des zéros infinis.

Essayez-le en ligne!

Comment ça marche

Comparez les deux boucles du testeur de divisibilité et du calculateur de module.

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

La seule différence est l'emplacement de {(<()>)}{}, qui permute d et r si d = 0 . Pour calculer le module, nous effectuons cet échange après avoir décrémenté d et incrémenté r .

Ce changement n’affecte pas le résultat si a% b> 0 , mais si a% b = 0 , il part (n, d, r) = (0, b, 0) - plutôt que (n, d, r) = (0, 0, b) - sur la pile.

Ainsi, pour obtenir le module, il suffit de faire apparaître n et d avec {}{}.

Calcul du module d'empilement, 64 octets

L'algorithme de module de 42 octets n'est pas propre à la pile et ne peut donc pas être utilisé tel quel dans tous les programmes. La version suivante extrait dividende et diviseur (dans cet ordre) de la pile active et pousse le module en retour. Il n'a pas d'autres effets secondaires.

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

Cette solution est en grande partie basée sur l'enregistrement précédent de 72 octets de @ WheatWizard, mais elle enregistre 6 octets en ne changeant jamais de piles.

Essayez-le en ligne!

Comment ça marche

             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
source
20

x86_32 code machine, 8 octets

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

C'est ma première réponse au code de golf, alors j'espère que je respecte toutes les règles.

Cela appelle d'abord cdq pour effacer le registre edx, puis effectue une division signée sur le registre ecx, qui stocke le reste dans edx. La ligne de test edx, edx définira l'indicateur zéro si edx est égal à zéro, et sete met un 0 pour false si edx n'est pas nul et un 1 pour true si edx était 0.

Ceci est juste l'extrait de code qui contribue au nombre d'octets, mais pour le test, voici le code C que j'ai écrit avec l'assemblage en ligne, car il est plus facile de gérer les E / S de cette façon.

— davey
source
2
Bienvenue sur PPCG, belle première réponse!
— Leaky Nun
Est-ce que cela doit être un programme complet? Je formais ma réponse un peu en dehors de cette réponse . Et merci! J'espère devenir meilleur en assemblage / code machine pour plus de code de golf!
— davey
1
L'entrée et la sortie dans les registres spécifiés de l'assemblage sont autorisées par défaut: entrée , sortie . C'est une soumission parfaitement acceptable. Bienvenue chez PPCG!
— Mego
Fantastique! Merci!
— davey
17

Hexagonie, 15, 13, 12 10 octets

La langue préférée de tous les hexagones! :RÉ

TL; DR utilise des solutions magiques non formatées avec un nombre d'octets décroissant:

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

Sauvegardé de 2 octets grâce à l'assistant de présentation de @ MartinEnder.

@FryAmTheEggman a économisé 1 octet en utilisant les coins de manière plus créative

@MartinEnder et @FryAmTheEggman ont tous deux proposé une solution à 10 octets qui n'imprime rien pour les valeurs erronées.

Ma solution (15):

Non formaté:

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

Formaté:

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

La solution de @Martin Ender (13):

Non formaté:

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

Formaté:

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

Explication:

D'abord, nous obtenons l'entrée et prenons le module.

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

Ensuite, il vérifie si le module est 0 ou non. Si c'est le cas, l'IP tourne à gauche de 60 degrés, rebondit sur le miroir, définit la cellule sur 1 et imprime.

Ensuite, l'IP continue sur la quatrième ligne. Quand il atteint le >, il tourne à droite à la place (car la valeur de la cellule est maintenant 1). Il disparaît et revient dans le coin inférieur droit en direction du nord-ouest. L'IP frappe le <, va le long de la rangée supérieure et revient dans le coin droit pour frapper la @, arrêtant le programme.

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

Si le module s'avère positif, l'IP tourne de 60 degrés vers la droite. Une fois sorti du coin inférieur droit, il continue sur le bord inférieur gauche en raison des règles d'enveloppement d'Hexagony. Le 'est réutilisé pour que l'adresse IP aille dans une cellule contenant 0. L’IP parcourt ensuite la quatrième rangée, s’enroule autour de la seconde, atteint l’impression et se reflète dans le <. Le reste du chemin @est le même.

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

C'est de la magie sérieuse.

Solution de FryAmTheEggman (12):

Non formaté:

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

Formaté:

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

Explication:

Comme les autres solutions, il obtient l’entrée et prend le module.

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

Ensuite, l'adresse IP est déviée dans le coin inférieur. Si le module est positif, il va sur le bord supérieur gauche. Le ?n'a plus d'entrée, il met donc la cellule à 0. Le !puis imprime le 0 et @met fin au programme.

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

Les choses sont beaucoup plus délicates lorsque le module est 0. Tout d'abord, il est décrémenté, puis réinitialisé à 0, puis à 1, puis imprimé. Ensuite, le 1 est décrémenté à 0. Après cela, le programme s'exécute comme au début jusqu'à ce qu'il essaie de le faire 0%0. Cela le fait jeter une erreur silencieuse et quitter.

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

J'aime beaucoup le truc d'erreur silencieux, mais un moyen plus simple serait de remplacer le (avec par de /manière à ce que l'adresse IP passe par la première fois, mais se reflète dans @la seconde.

Solution collaborative (10):

Non formaté:

?{?!1\@'%<

Formaté:

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

Ce programme démarre de la même manière que tous les autres programmes: il obtient l’entrée et le modifie.

Si l'entrée est 0, l'IP tourne à gauche quand il frappe <. Il est dévié dans 1!@, qui imprime 1 et quitte.

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

Si l'entrée est positive, l'IP tourne à droite quand il frappe <. Il sort par le coin et longe le @ en haut à droite sans imprimer.

  . . ?
 . . . @
. . < . .
 . . . .
  . . .
— Bleu
source
6
Je pense que vous devriez formater votre réponse différemment. Avoir quatre réponses dans un seul bloc de code donne l’impression que votre nombre d’octets est incorrect.
— mbomb007
17

Flocons du cerveau 102, 98, 96 octets

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

Eww. Brut. Je pourrais poster une explication, mais je la comprends à peine moi-même. Cette langue me fait mal au cerveau.

Essayez-le en ligne!

Merci à l'utilisateur de github @Wheatwizard pour avoir fourni un exemple de module. Je n'aurais probablement pas pu comprendre cela moi-même!

En outre, la réponse plus courte est ici .

Explication éventuellement incorrecte:

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

Le reste est assez simple.

{              }            #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
source
The rest is pretty straightforward.Oui, on dirait bien.
— Erik l'Outgolfer
24 octets si vous comptez chaque instruction brainflak comme un octet.
— nozɐɹƆ
12

Javascript (ES6) 17 12 11 octets

a=>b=>a%b<1
  • EDIT: Suppression de 5 octets car 'a> 0' est attendu.
  • EDIT2: Suppression d'un octet grâce à Downgoat .
— ETHproductions
source
Utilisez currying pour sauvegarder un octet: a => b =>
— Réduire
Alors, comment puis-je exécuter cela? Lorsque j'essaie, d=a=>b=>a%b<1suivi de d(32,2)dans la console JS ... je reçois simplement la réponsefunction b=>a%b<1
— WallyWest
@WallyWest utilise le currying pour que vous puissiez taper d(32)(2). Parce que d(32)donne function b=>a%b<1, vous devez alors appeler cette fonction avec votre bvaleur
— Cyoce
9

Vim, 11 frappes

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

Pas mal pour une langue qui ne gère que des chaînes. :RÉ

— DJMcMayhem
source
Que fait <C-Left>-il? Impossible de le tester car il change de fenêtre sous mac> _>
— Rédigé le
1
@Downgoat utilisez-vous ctrl ou commande? Dans tous les cas, cela équivaut à "b", sauf que cela fonctionne aussi en mode insertion.
— DJMcMayhem
Pour être pédant, c'est l'équivalent de Bplutôt que b(et Ctrl+ Rightest l'équivalent de W) - la différence est avec des caractères autres que des mots, mais dans ce cas, il fait exactement la même chose :) vimdoc.sourceforge.net/htmldoc/motion. html # <C-Gauche >
— Christian Rondeau
9

Mathematica - 17 13 3 octets

∣

Merci à @MartinEnder d'avoir économisé une tonne d'octets!

— Yytsi
source
Quel personnage est-ce?
— Cyoce
@Cyoce Je ne connais pas son code Unicode (sur le téléphone pour le moment), mais c'est un opérateur court pour Divisible[].
— Yytsi
@ Cyoce Je pense que c'est le symbole du tuyau, également appelé décalage + barre oblique inverse.
— Pavel
@Pavel Si c'était le symbole du tuyau, ce ne serait pas trois octets.
— Cyoce
@Cyoce c'est le caractère U + 2223: fileformat.info/info/unicode/char/2223/index.htm
— numbermaniac
8

Rétine, 12 octets

^(1+)\1* \1$

Prend une entrée unaire séparant les espaces, comme 111111111111 1111vérifier si 12 est divisible par 4 . Imprime 1 (vrai) ou 0 (faux).

Essayez-le en ligne!

FryAmTheEggman a sauvegardé deux octets. Oups, j'ai réécrit ma réponse pour prendre les arguments dans le bon ordre. (Puis Fry m'a battu dans les commentaires. Je suis lent à regex!)

— Lynn
source
Pour corriger l'ordre, si cela devient nécessaire, je pense que ^(1+)\1* \1$cela fonctionnera.
— FryAmTheEggman
Je suppose qu'avec la nouvelle spécification, l'ordre de saisie opposé est à nouveau correct.
— Martin Ender
8

Lot, 20 octets

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

Les sorties 1 en cas de succès, 0en cas d'échec.

— Neil
source
8

C #, 27 13 12 octets

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

Merci à TuukkaX d’avoir signalé que des lambdas anonymes sont acceptables. Merci à David Conrad de m'avoir dirigé vers un currying dont je n'étais même pas conscient.

Bref et facile, puisque nous ne traitons que de nombres entiers que nous pouvons utiliser <1plutôt que de ==0sauvegarder un octet entier.

— JustinM - Rétablir Monica
source
Je ne suis pas sûr, mais je pense que vous pouvez simplement utiliser un lambda: (a,b)=>a%b<1;. +1
— Yytsi
@TuukkaX, merci, je n'étais pas sûr, cela semble tellement triché.
— JustinM - Réintégrer Monica le
La version JS de ce script a été utilisée pour réduire le nombre d'octets, et cela devrait également fonctionner pour C #: a=>b=>a%b<1;(remarque: vous devez alors l'appeler comme f(a)(b)plutôt que f(a,b))
— David Conrad
1
@ DavidConrad oo c'est bien, merci.
— JustinM - Réintégrer Monica le
7

brainfuck, 53 octets

Prend l'entrée sous forme d'octets, la sortie est une valeur d'octet de 0x00ou 0x01. C'est l' algorithme DivMod suivi d'une négation booléenne .

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

Essayez-le en ligne - Il y a beaucoup de choses supplémentaires à+la fin pour que vous puissiez voir la sortie en ASCII.

— mbomb007
source
Pourriez-vous supprimer la partie "div" de la chose pour économiser des octets?
— Leaky Nun
1
@ LeakyNun C'est l'algorithme le plus court connu qui donne le module. Enlever une partie de celui-ci le rallonge réellement, car vous avez besoin de plus de cellules temporaires. Vous ne pouvez pas trouver un module sans se diviser.
— mbomb007
Je vois, merci.
— Leaky Nun
@ LeakyNun Il suffit de regarder combien de temps l' algorithme de Division est.
— mbomb007
Il y en a probablement de plus courts, mais si c'est le cas, personne ne les a trouvés ou publiés.
— mbomb007
7

Brain-Flak , 88 86 octets

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

Il s'agit d'une version plus dense de l'algorithme de test de divisibilité Brain-Flak original écrit par le Dr Green Eggs, Iron Man DJMcMayhem et moi-même.

Voici une brève explication de son fonctionnement:

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

Essayez-le en ligne!

— Assistant de blé
source
Lien vers l'interprète en ligne?
— Leaky Nun
Bon travail! Bienvenue aussi sur le site! J'espère que vous vous amusez ici. (J'ai certainement)
— DJMcMayhem
Bonne première réponse, bienvenue chez PPCG!
— Leaky Nun
6

C, 60 octets

#include <stdio.h>
main(){int a,b;scanf("%d %d",&a,&b);a%b==0;}
— Ronronner
source
1
Pourquoi -1? Expliquez-moi
— Ronronner le
3
Il est possible que personne n'ait un vote négatif. C'est une réponse courte, elle a donc été automatiquement signalée comme étant de faible qualité, puis vous l'avez modifiée. Pour une raison quelconque, cela déclenche un vote automatique négatif . Désolé pour ça. +1de moi. De plus, nous autorisons les fonctions afin que vous puissiez facilement raccourcir ce int f(a,b){return !(a%b);}délai ou le rendre encore plus court.
— DJMcMayhem
3
Non, ce que je veux dire, c'est que le programme ne doit pas nécessairement être complet. Vous pouvez simplement soumettre une fonction. int f(a,b){return!(a%b);}est de 25 octets, et si vous utilisez le bon compilateur, vous pouvez même le faire f(a,b){return!(a%b);}pour 21 octets.
— DJMcMayhem
3
Soumission de fonction encore plus courte: #define f(a,b)!(a%b)( lien idéal )
— Mego
2
Vous devez définir une fonction ou un programme, pas seulement un extrait de code.
— Leaky Nun
5

R, 22 à 20 octets

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

Comme d'habitude, lit deux nombres à partir de l'entrée qui se termine par une ligne vide.

Mise à jour: merci à Jarko Dubbeldam d' avoir supprimé 2 octets (malgré le fait que son édition ait été rejetée, cela a été très utile!).

— Andreï Kostyrka
source
5

Java 8, 11 octets

a->b->a%b<1

Que diable, il existe des versions JS et C # de cela, pourquoi pas une version Java aussi?

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
source
a->b->a%b<1Cela soulève une erreur de syntaxe, n'est-ce pas?
— Dorukayhan veut que Monica revienne le
2
Non, c'est valide pour Java 8.
— David Conrad
Parfois, même Java ressemble à Perl ...
— Mega Man
Oui, j'ajouterais qu'il s'agit uniquement de Java 8;).
— Magic Octopus Urn
Donc, avec Java 8, nous ne devons compter que les octets d'expression lambda, pas la classe entière et la fonction passe-partout, cool!
— Sikorski
4

Python, 16 octets

lambda D,d:D%d<1
— Dennis
source
1
Notez que cela ne fonctionnerait pas si les entiers négatifs étaient autorisés. Heureusement, les entrées sont strictement positives.
— TLW
Je l'ai fait lambda a,b:1.*a/b==a/b, mais j'ai été très impressionné. C'est un morceau de code si complexe ...
— Erik the Outgolfer -
3

Fortran 95, 78 octets

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

MarioLANG, 121 109 107 octets

14 octets sauvés grâce à Martin Ender

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

Essayez-le en ligne!

Explication

L'algorithme consiste simplement à continuer à soustraire dde npour voir si vous pouvez le faire un nombre entier de fois et ne pas avoir de reste.

;
)
;

>
=
 
 

Tout d'abord, l'entrée est collectée. nest dans la première cellule, ddans la seconde.

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

C'est essentiellement la boucle principale. Il décrémente les première et deuxième cellules et incrémente la troisième.

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

Ceci est la sortie finale. Si, après l'incrémentation / la décrémentation, la première cellule est 0, nous avons éliminé n. Si après cela, la deuxième cellule ( d) est 0, puis dest allé dans nuniformément. Nous incrémentons et imprimons ( 1). Sinon, revenez à la première cellule (qui est 0) et imprimez-la.

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

Cette boucle se produit si la deuxième cellule est 0après incrémentation et décrémentation. Il copie la troisième cellule dans la deuxième cellule. La partie inférieure consiste à contourner la boucle si la cellule ne l’est pas 0.

— Chat d'affaires
source
3

Tcl, 34 octets

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

Ma première / * réussite * / tentative dans codegolf! Ce code doit être exécuté dans le shell Tcl, sinon il ne fonctionnera pas.

Un octet grâce à @Lynn.

Quatre octets grâce à @Lynn et @LeakyNun (maintenant je comprends ce qu'il voulait dire)!

Pouvez-vous omettre ?1:0?
— Leaky Nun
@ LeakyNun c'est une opération ternaire. tu veux dire juste pour retourner qch quand c'est consultable?
Qu'est-ce qui $a%$b==0reviendrait?
— Leaky Nun
1
Je veux dire, votre troisième ligne peut-elle juste être exp $a%$b==0?
— Leaky Nun
1
Ou exp $a%$b<1peut-être?
— Lynn
3

PHP, 23 22 octets

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

affiche 1 pour true, chaîne vide (= rien) pour false

appel de cli avec net dcomme arguments

10 octets pour l'ancien PHP: <?=$n%$d<1

— Titus
source
Si cela ne vous dérange pas l' utilisation PHP4.1: <?=!($A%$B). Les valeurs peuvent être transmises dans le cadre de votre $_SESSION, $_COOKIE, $_POST, $_GETou (si je ne me trompe pas) sur $_ENV.
— Ismael Miguel
@Ismael Miguel: En fait, ce n’est pas le cas, mais j’en ai marre de publier des versions anciennes de PHP et de les ajouter for PHP<5.4 with register_globals=On. Mais je vais l'ajouter pour référence.
— Titus
En fait, vous ne pouvez pas dire " for PHP<5.4 with register_globals=On", car vous devez compter les octets de votre php.inifichier contenant register_globals=On. Cependant, PHP 4.1 est un cas particulier. C'est la dernière version où register_globals=Onest la valeur par défaut, et la plupart des fonctions sont disponibles à partir de PHP 4.1 et plus. Cette version permet également l'utilisation d'autres fonctions, telles que ereget splitsans avertissements.
— Ismael Miguel
3

J, 3 octets

0=|

Usage:

2 (0=|) 10

Je reviendrai 1. Et est équivalent à pseudocode10 MOD 2 EQ 0

Notez que cela ressemble beaucoup à la réponse APL , car J est inspiré profondément par APL

— emiflake
source
Bonne première réponse, bienvenue chez PPCG!
— Leaky Nun
@ LeakyNun Merci, j'ai toujours navigué, c'est bien de pouvoir enfin répondre.
— Emiflake
3

PowerShell v2 +, 20 octets

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

Prend les entrées sous forme de deux arguments de ligne de commande $args, -joinles regroupe dans une chaîne avec %comme séparateur, les tuyaux qui mènent à iex(raccourci pour Invoke-Expressionet similaire à eval). Le résultat est indifférent 0ou non nul; nous prenons donc la valeur booléenne non !ce résultat, ce qui signifie soit $TRUEou $FALSE(les entiers non nuls dans PowerShell sont véridiques). Ce booléen est laissé sur le pipeline et la sortie est implicite.

Versions alternatives, également 20 octets chacune

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

Même concept, juste des manières légèrement différentes de structurer l'entrée. Merci à @DarthTwon pour ces informations.

Exemples

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
source
Dans les deux autres méthodes, j'ai essayé de jouer au golf avec cette question, je les ai aussi param($a,$b)!($a%$b)!($args[0]%$args[1])
— passées
@DarthTwon En effet. Lorsqu’il s’agit de petites quantités d’opérations, il existe généralement au maximum un ou deux octets de différence entre les différentes manières de prendre les arguments en entrée.
— AdmBorkBork
J'espérais arriver à quelque chose de plus court: P mais oui, il y a toujours plusieurs façons de se prendre en peau de chat, surtout dans le PS.
— ThePoShWolf
3

Haskell, 13 11 octets

((1>).).mod

Ceci définit une nouvelle fonction (!) :: Integral n => n -> n -> Bool. Puisque mod n mne renvoie que des nombres positifs si net msont positifs, nous pouvons sauvegarder un octet en utilisant à la 1>place de 0==.

Usage:

ghci> let n!d=1>mod n d
ghci> 100 ! 2
True
ghci> 100 ! 3
False
— Zeta
source
Vous pouvez aller Pointfree et enregistrer 2 octets: ((1>).).mod.
— nimi
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.