Zadanie

Biorąc pod uwagę dwie ściśle dodatnie liczby całkowite n i d jako dane wejściowe, określ, czy n jest równomiernie podzielne przez d , tj. Czy istnieje taka liczba całkowita q , że n = qd.

Możesz napisać program lub funkcję i użyć dowolnej z naszych standardowych metod otrzymywania danych wejściowych i dostarczania danych wyjściowych.

Wynik powinien być wartością prawdomówną lub fałszem ; prawda, jeśli n jest podzielne przez d , a fałsz w przeciwnym razie.

Twój kod musi obsługiwać tylko liczby całkowite, które może reprezentować w sposób natywny, o ile działa dla wszystkich liczb całkowitych ze znakiem 8-bitowych. Jednak Twój algorytm musi działać dla dowolnie dużych liczb całkowitych.

Możesz używać dowolnego języka programowania , ale pamiętaj, że te luki są domyślnie zabronione.

To jest golf golfowy , więc wygrywa najkrótsza ważna odpowiedź - mierzona w bajtach .

Przypadki testowe

 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

Tabela liderów

Fragment kodu na dole tego postu generuje katalog na podstawie odpowiedzi a) jako listy najkrótszych rozwiązań dla każdego języka oraz b) jako ogólnej tabeli wyników.

Aby upewnić się, że twoja odpowiedź się pojawi, zacznij od nagłówka, korzystając z następującego szablonu Markdown:

## Language Name, N bytes

gdzie Njest rozmiar twojego zgłoszenia. Jeśli poprawić swój wynik, to może zachować stare porachunki w nagłówku, uderzając je przez. Na przykład:

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

Jeśli chcesz umieścić w nagłówku wiele liczb (np. Ponieważ twój wynik jest sumą dwóch plików lub chcesz osobno wymienić kary za flagi tłumacza), upewnij się, że rzeczywisty wynik jest ostatnią liczbą w nagłówku:

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

Możesz także ustawić nazwę języka jako link, który pojawi się we fragmencie:

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

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

Galaretka , 1 bajt

ḍ

Zajęło mi to godziny gry w golfa.

Wypróbuj online!

Brain-Flak , 72 70 64 62 58 46 bajtów

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

Bierze dywidendę i dzielnik (w tej kolejności) jako dane wejściowe i drukuje dzielnik (prawda) lub nic. Ponieważ każdy stos ma niejawną, nieskończoną liczbę zer, puste dane wyjściowe należy uznać za fałsz.

Rozwiązanie to, choć nie wymaga czyszczenia stosu, wykorzystuje tylko jeden stos.

Wypróbuj online!

Dzięki @WheatWizard za grę w golfa z 2 bajtów!

Jak to działa

                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.

Obliczanie modułu, 42 bajty

Powyższy pełny program można zmodyfikować w trywialny sposób, aby zamiast tego obliczyć moduł.

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

Tak jak poprzednio, ta metoda nie jest czyszczona przy stosach, ale używa tylko jednego stosu. Moduł 0 pozostawi stos pusty, co z grubsza odpowiada pozostawieniu 0 ; każdy stos zawiera nieskończone zera.

Wypróbuj online!

Jak to działa

Porównaj dwie pętle testera podzielności i kalkulatora modułu.

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

Jedyną różnicą jest to położenie {(<()>)}{}, które swapy d i r , gdy d = 0 . Aby obliczyć moduł, wykonujemy tę zamianę po zmniejszeniu d i zwiększeniu r .

Ta zmiana nie wpływa na wynik, jeśli % b> 0 , ale jeśli % b = 0 , pozostawia (n, d, r) = (0, b, 0) - zamiast (n, d, r) = (0, 0, b) - na stosie.

W ten sposób, w celu uzyskania modułu, mamy tylko pop n i d z {}{}.

Obliczanie modułu czyszczenia stosu, 64 bajty

42-bajtowy algorytm modułu nie jest czyszczony na stosie, więc nie można go używać tak jak we wszystkich programach. Następująca wersja wyrzuca dywidendę i dzielnik (w tej kolejności) z aktywnego stosu i wypycha moduł w zamian. Nie ma innych skutków ubocznych.

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

To rozwiązanie jest w dużej mierze oparte na poprzednim 72-bajtowym rekordzie @ WheatWizard, ale oszczędza 6 bajtów, nigdy nie zmieniając stosów.

Wypróbuj online!

Jak to działa

             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.

kod maszynowy x86_32, 8 bajtów

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

To jest moja pierwsza odpowiedź na golfa, więc mam nadzieję, że przestrzegam wszystkich zasad.

Najpierw wywołuje cdq, aby wyczyścić rejestr edx, a następnie wykonuje podpisany podział na rejestrze ecx, który przechowuje resztę w edx. Testowa linia edx, edx ustawi flagę zerową, jeśli edx wynosi zero, a sete ustawia 0 na fałsz, jeśli edx nie był równy zero, i ustawia 1 na true, jeśli edx miał wartość 0.

Jest to tylko fragment kodu, który przyczynia się do liczenia bajtów, ale do testowania oto kod C, który napisałem z zestawem wbudowanym, ponieważ w ten sposób łatwiej jest obsługiwać operacje we / wy.

Sześciokąt, 15, 13, 12 10 bajtów

Ulubiony język oparty na sześciokącie! :RE

TL; DR działa przy użyciu magicznych, niesformatowanych rozwiązań zmniejszających liczbę bajtów:

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

Zaoszczędzono 2 bajty dzięki kreacji układu @ MartinEnder.

@FryAmTheEggman oszczędził 1 bajt, wykorzystując narożniki w bardziej kreatywny sposób

Zarówno @MartinEnder, jak i @FryAmTheEggman opracowały 10-bajtowe rozwiązanie, które nie drukuje niczego dla fałszywych wartości.

Moje rozwiązanie (15):

Niesformatowany:

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

Sformatowany:

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

@Martin Ender's Solution (13):

Niesformatowany:

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

Sformatowany:

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

Wyjaśnienie:

Najpierw otrzymujemy dane wejściowe i bierzemy moduł.

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

Następnie sprawdza, czy moduł wynosi 0, czy nie. Jeśli tak, IP obraca się o 60 stopni w lewo, odbija się od lustra, ustawia komórkę na 1 i drukuje.

Następnie adres IP przechodzi do czwartego rzędu. Kiedy osiągnie >, skręca w prawo (ponieważ wartość komórki wynosi teraz 1). Przechodzi i wraca w prawym dolnym rogu pod nagłówkiem NW. Adres IP uderza w <, przechodzi wzdłuż górnego rzędu i wraca w prawym rogu, aby trafić @, zatrzymując program.

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

Jeśli moduł okaże się dodatni, IP skręca o 60 stopni w prawo. Po wyjściu z prawego dolnego rogu, kontynuuje na lewym dolnym brzegu ze względu na zasady owijania Sześciokąta. 'Jest wykorzystywany, aby IP przejdź do celi z 0 w nim. Następnie IP przemieszcza się wzdłuż czwartego rzędu, owija się do drugiego, uderza w druk i zostaje odbity na <. Reszta ścieżki do @tego samego jest taka sama.

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

To poważna magia.

@ FryAmTheEggman's Solution (12):

Niesformatowany:

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

Sformatowany:

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

Wyjaśnienie:

Podobnie jak inne rozwiązania, pobiera dane wejściowe i przyjmuje moduł.

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

Następnie adres IP jest odchylany w dolnym rogu. Jeśli moduł jest dodatni, idzie na lewą górną krawędź. Nie ?ma już danych wejściowych, więc ustawia komórkę na 0. !Następnie wypisuje 0 i @kończy działanie programu.

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

Sprawa jest znacznie trudniejsza, gdy moduł wynosi 0. Po pierwsze, zmniejsza się, następnie resetuje do 0, następnie ustawia na 1, a następnie drukuje. Następnie wartość 1 jest zmniejszana do 0. Następnie program działa tak jak na początku, dopóki nie spróbuje 0%0. To sprawia, że ​​rzuca cichy błąd i kończy pracę.

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

Naprawdę chciałbym cichej błędu podstęp, ale prostszy sposób będzie zastąpić (w /taki sposób, że przechodzi przez IP po raz pierwszy, ale pobiera odzwierciedlone w @drugim.

Rozwiązanie oparte na współpracy (10):

Niesformatowany:

?{?!1\@'%<

Sformatowany:

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

Ten program zaczyna się tak samo, jak wszystkie inne programy, uzyskując dane wejściowe i modyfikując je.

Jeśli wejście ma wartość 0, adres IP skręca w lewo, gdy uderza <. Zostaje odchylony na 1!@, co drukuje 1 i kończy pracę.

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

Jeśli sygnał wejściowy jest dodatni, adres IP skręca w prawo po trafieniu <. Wychodzi przez narożnik i biegnie wzdłuż prawej górnej krawędzi, uderzając w @ bez drukowania.

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

Płat mózgowy 102, 98, 96 bajtów

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

Eww. Obrzydliwy. Mogę opublikować wyjaśnienie, ale sam ledwo je rozumiem. Ten język boli mój mózg.

Wypróbuj online!

Podziękowania dla użytkownika github @Wheatwizard za wymyślenie przykładu modułu. Prawdopodobnie sam tego nie wymyśliłem!

Krótsza odpowiedź jest tutaj .

Prawdopodobnie nieprawidłowe wyjaśnienie:

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

Reszta jest dość prosta.

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

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

JavaScript (ES6) 17 12 11 bajtów

a=>b=>a%b<1

• EDYCJA: Usunięto 5 bajtów, ponieważ spodziewane jest „a> 0”.
• EDYCJA 2: Usunięto 1 bajt dzięki Downgoat .

Vim, 11 naciśnięć klawiszy

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

Nieźle jak na język, który obsługuje tylko ciągi znaków. :RE

Mathematica - 17 13 3 bajtów

∣

Dzięki @MartinEnder za oszczędność tony bajtów!

Siatkówka, 12 bajtów

^(1+)\1* \1$

Pobiera wejście rozdzielone spacją jako jednoargumentowe, na przykład 111111111111 1111sprawdza, czy 12, jeśli dzieli się przez 4 . Drukuje 1 (prawda) lub 0 (fałsz).

Wypróbuj online!

FryAmTheEggman zapisał dwa bajty. Ups, przepisałem moją odpowiedź, aby uporządkować argumenty we właściwej kolejności. (Potem Fry pobił mnie do tego w komentarzach. Jestem powolny w wyrażeniach regularnych!)

Partia, 20 bajtów

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

Wyniki 1w przypadku sukcesu, 0niepowodzenia.

C #, 27 13 12 bajtów

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

Dzięki TuukkaX za wskazanie anonimowych lambd są dopuszczalne. Dzięki Davidowi Conradowi za nakłonienie mnie do curry, którego nawet nie zdawałem sobie sprawy, było czymś.

Krótko i słodko, ponieważ mamy do czynienia tylko z liczbami całkowitymi, których możemy użyć, <1a nie ==0uratować cały bajt.

pieprzenie mózgu, 53 bajty

Pobiera dane wejściowe jako bajty, dane wyjściowe są wartością bajtów 0x00lub 0x01. Jest to algorytm DivMod, po którym następuje logiczna negacja .

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

Wypróbuj online - ma kilka dodatkowych+pod koniec, dzięki czemu możesz zobaczyć dane wyjściowe w ASCII.

Brain-Flak , 88 86 bajtów

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

To jest gęstsza wersja oryginalnego algorytmu testu podzielności Brain-Flaka napisanego przez Dr Green Eggs i Iron Man DJMcMayhem i mnie.

Oto krótkie (ish) wyjaśnienie, jak to działa:

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

Wypróbuj online!

LOLCODE, 74 64 bajtów

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

C, 60 bajtów

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

Dyalog APL , 3 bajty

0=|

Czy zero jest równe pozostałej części podziału?

R, 22 20 bajtów

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

Jak zwykle odczytuje dwie liczby z wejścia zakończonego pustą linią.

Aktualizacja: dzięki Jarko Dubbeldamowi za zgolenie 2 bajtów (pomimo faktu, że jego edycja została odrzucona, była bardzo pomocna!).

Java 8, 11 bajtów

a->b->a%b<1

Co do cholery, istnieją wersje JS i C #, dlaczego też nie wersja Java?

Stosowanie:

import java.util.function.Function;

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

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

Python, 16 bajtów

lambda D,d:D%d<1

GolfScript, 3 bajty

~%!

Wyjaśnienie:

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

Wypróbuj online!

CJam, 6 4 bajtów

Zaoszczędzono 2 bajty dzięki Dennisowi

q~%!

Wypróbuj online

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

Brachylog , 2 bajty

%0

Wypróbuj online!

Julia, 9 bajtów

D\d=D%d<1

Wypróbuj online!

Fortran 95, 78 bajtów

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

MarioLANG, 121 109 107 bajtów

Zaoszczędzono 14 bajtów dzięki Martinowi Enderowi

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

Wypróbuj online!

Wyjaśnienie

Algorytm polega po prostu na odejmowaniu dod, naby sprawdzić, czy można to zrobić liczbę całkowitą razy i nie pozostawiać żadnych.

;
)
;

>
=
 
 

Najpierw gromadzone są dane wejściowe. njest w pierwszej komórce, dw drugiej.

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

Jest to zasadniczo główna pętla. Zmniejsza pierwszą i drugą komórkę i zwiększa trzecią.

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

To jest końcowy wynik. Jeśli po zwiększeniu / zmniejszeniu pierwsza komórka ma wartość 0, to wyeliminowaliśmy n. Jeśli po tym, druga komórka ( d) jest 0, to dposzła nrównomiernie. Zwiększamy i drukujemy ( 1). W przeciwnym razie przejdź z powrotem do pierwszej komórki (która jest 0) i wydrukuj ją.

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

Ta pętla ma miejsce, jeśli druga komórka jest 0po inkrementacji i dekrementacji. Kopiuje trzecią komórkę do drugiej komórki. Część na dole ma obejść pętlę, jeśli komórka nie jest 0.

Tcl, 34 bajty

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

Moja pierwsza / * udana * / próba w codegolf! Ten kod musi być wykonany w powłoce Tcl, w przeciwnym razie nie będzie działał.

Jeden bajt dzięki @Lynn.

Cztery bajty dzięki @Lynn i @LeakyNun (teraz rozumiem, co miał na myśli)!

PHP, 23 22 bajtów

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

wypisuje 1 dla true, pusty łańcuch (= nic) dla false

zadzwonić z CLI z na djako argumenty

10 bajtów dla starożytnego PHP: <?=$n%$d<1

J, 3 bajty

0=|

Stosowanie:

2 (0=|) 10 

Powróci 1. I jest równoważne pseudokodowi10 MOD 2 EQ 0

Zauważ, że jest to bardzo podobne do odpowiedzi APL , ponieważ J jest mocno zainspirowany APL

PowerShell v2 +, 20 bajtów

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

Pobiera dane wejściowe jako dwa argumenty wiersza poleceń $args, -joinłączy je razem w ciąg znaków %jako separator, potoki do iex(skrót Invoke-Expressioni podobne do eval). Wynik jest albo 0niezerowy, więc bierzemy wartość logiczną nie !tego wyniku, co oznacza albo $TRUEalbo $FALSE(niezerowe liczby całkowite w PowerShell są prawdziwe). To, że wartość logiczna jest pozostawiona w potoku, a dane wyjściowe są niejawne.

Alternatywne wersje, również po 20 bajtów

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

Ta sama koncepcja, tylko nieco inne sposoby strukturyzacji danych wejściowych. Dziękujemy @DarthTwon za ich dostarczenie.

Przykłady

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

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

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

Haskell, 13 11 bajtów

((1>).).mod

To definiuje nową funkcję (!) :: Integral n => n -> n -> Bool. Od mod n mzwraca tylko dodatnie liczby jeśli ni msą pozytywne, możemy zapisać bajt stosując 1>zamiast 0==.

Stosowanie:

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