задача

Даны два строго положительные целые числа п и д в качестве входных данных, определить , является ли п является равномерно делится на д , то есть, если существует целое число д такое , что n = qd.

Вы можете написать программу или функцию и использовать любой из наших стандартных методов получения ввода и предоставления вывода.

Вывод должен быть истинным или ложным значением ; правда, если n делится на d , и ложно в противном случае.

Ваш код должен обрабатывать только целые числа, которые он может представлять нативно, если он работает для всех 8-битных целых чисел со знаком. Однако ваш алгоритм должен работать для сколь угодно больших целых чисел.

Вы можете использовать любой язык программирования , но учтите, что эти лазейки по умолчанию запрещены.

Это код-гольф , поэтому самый короткий действительный ответ - измеренный в байтах - выигрывает.

Контрольные примеры

 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

Leaderboard

Фрагмент стека в нижней части этого поста создает каталог из ответов а) в виде списка кратчайшего решения для каждого языка и б) в качестве общей таблицы лидеров.

Чтобы убедиться, что ваш ответ обнаружен, начните его с заголовка, используя следующий шаблон уценки:

## Language Name, N bytes

где Nразмер вашего представления. Если вы улучшите свой счет, вы можете сохранить старые результаты в заголовке, вычеркнув их. Например:

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

Если вы хотите включить в заголовок несколько чисел (например, потому что ваш результат равен сумме двух файлов или вы хотите перечислить штрафы за флаг интерпретатора отдельно), убедитесь, что фактический результат является последним числом в заголовке:

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

Вы также можете сделать имя языка ссылкой, которая будет отображаться во фрагменте кода:

## [><>](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>

Желе , 1 байт

ḍ

Это заняло у меня несколько часов в гольф.

Попробуйте онлайн!

Brain-Flak , 72 70 64 62 58 46 байт

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

Принимает дивиденд и делитель (в этом порядке) в качестве входных данных и печатает делитель (истинный) или ничего. Поскольку каждый стек имеет неявное, бесконечное количество нулей, пустой вывод следует считать ложным.

Хотя это решение не является чистым в стеке, оно использует только один стек.

Попробуйте онлайн!

Спасибо @WheatWizard за удаление 2 байта!

Как это работает

                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.

Расчет модуля, 42 байта

Приведенную выше полную программу можно изменить тривиальным образом, чтобы вместо этого рассчитать модуль.

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

Как и прежде, этот метод не является чистым стеком, но использует только один стек. Модуль 0 оставит стек пустым, что примерно эквивалентно оставлению 0 ; каждый стек содержит бесконечные нули.

Попробуйте онлайн!

Как это работает

Сравните две петли тестера делимости и калькулятора модулей.

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

Единственная разница заключается в расположении {(<()>)}{}, которое меняет местами d и r, если d = 0 . Чтобы вычислить модуль, мы выполним этот обмен после уменьшения d и увеличения r .

Это изменение не влияет на результат, если a% b> 0 , но если a% b = 0 , оно оставляет (n, d, r) = (0, b, 0) - вместо (n, d, r) = (0, 0, б) - в стеке.

Таким образом, чтобы получить модуль, нам нужно только сложить n и d с {}{}.

Расчет модуля очистки стека, 64 байта

Алгоритм 42-байтового модуля не является чистым стеком, поэтому его нельзя использовать как есть во всех программах. Следующая версия извлекает дивиденды и делители (в этом порядке) из активного стека и возвращает модуль в ответ. У него нет других побочных эффектов.

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

Это решение в значительной степени основано на предыдущей 72-байтовой записи @ WheatWizard, но оно экономит 6 байтов, никогда не переключая стеки.

Попробуйте онлайн!

Как это работает

             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.

машинный код x86_32, 8 байт

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

Это мой первый кодовый гольф-ответ, так что, надеюсь, я следую всем правилам.

Сначала вызывается cdq для очистки регистра edx, затем выполняется деление со знаком для регистра ecx, в котором остаток сохраняется в edx. Тест edx, строка edx установит нулевой флаг, если edx равен нулю, и sete устанавливает 0 для false, если edx не был нулем, и устанавливает 1 для true, если edx было 0.

Это просто фрагмент кода, который вносит вклад в подсчет байтов, но для тестирования приведу код C, который я написал со встроенной сборкой, потому что таким способом проще обрабатывать ввод / вывод.

Гексагония, 15, 13, 12 10 байт

Всеми любимый язык на основе шестиугольника! : D

TL; DR работает с использованием волшебных, неформатированных решений в уменьшении количества байтов:

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

Сохранено 2 байта благодаря мастерству компоновки @ MartinEnder.

@FryAmTheEggman сэкономил 1 байт, используя более творческие углы

И @MartinEnder, и @FryAmTheEggman предложили 10-байтовое решение, которое ничего не печатает для ложных значений.

Мое решение (15):

Unformatted:

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

отформатирован:

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

Решение @Martin Ender (13):

Unformatted:

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

отформатирован:

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

Объяснение:

Сначала мы получаем входные данные и берем модуль.

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

Затем он проверяет, равен ли модуль 0 или нет. Если это так, IP поворачивается на 60 градусов влево, отскакивает от зеркала, устанавливает ячейку в 1 и печатает.

Затем IP продолжается на четвертый ряд. Когда он достигает >, он поворачивается вправо (потому что значение ячейки теперь 1). Он выходит из строя и возвращается в правый нижний угол, заголовок NW. IP попадает в <, проходит по верхнему ряду и возвращается в правый угол, чтобы ударить @, останавливая программу.

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

Если модуль оказывается положительным, IP поворачивается на 60 градусов вправо. Как только он выходит из нижнего правого угла, он продолжается по нижнему левому краю из-за правил обтекания Hexagony. 'Повторно используется , чтобы сделать IP перейти к ячейке с 0 в нем. Затем IP перемещается по четвертому ряду, переходит ко второму, нажимает на печать и отражается в <. Остальная часть пути к @тому же.

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

Это серьезное волшебство.

Решение @ FryAmTheEggman (12):

Unformatted:

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

отформатирован:

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

Объяснение:

Как и другие решения, он получает входные данные и принимает модуль.

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

Затем IP отклоняется в нижний угол. Если модуль положительный, он идет по верхнему левому краю. У ?него больше нет входных данных, поэтому он устанавливает ячейку в 0. Затем !он печатает 0 и @завершает программу.

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

Ситуация намного сложнее, когда модуль равен 0. Прежде всего, он уменьшается, затем сбрасывается на 0, затем устанавливается на 1, затем печатается. Затем 1 уменьшается до 0. После этого программа работает так же, как и в начале, пока не попытается это сделать 0%0. Это заставляет его выдать тихую ошибку и выйти.

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

Мне очень нравится немой трюк ошибок, но более простой способ было бы заменить (с /тем чтобы IP проходит через первый раз, но получает отражение в @секунду.

Совместное решение (10):

Unformatted:

?{?!1\@'%<

отформатирован:

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

Эта программа запускается так же, как и все другие программы, получая ввод и модифицируя его.

Если вход 0, IP поворачивается налево, когда он попадает <. Это отклоняется в 1!@, который печатает 1 и выходит.

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

Если вход положительный, IP поворачивается направо при попадании <. Он выходит через угол и идет по верхнему правому краю, ударяя @ без печати.

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

Brain-flak 102, 98, 96 байтов

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

Eww. Валовой. Я мог бы опубликовать объяснение, но сам едва понимаю его. Этот язык вредит моему мозгу.

Попробуйте онлайн!

Спасибо пользователю github @Wheatwizard за то, что он предложил пример модуля. Я, вероятно, не мог понять это сам!

Также более короткий ответ здесь .

Возможно неправильное объяснение:

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

Остальное довольно просто.

{              }            #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 байт

a=>b=>a%b<1

• РЕДАКТИРОВАТЬ: Удалено 5 байтов, потому что ожидается «a> 0».
• EDIT2: удален 1 байт благодаря Downgoat .

Vim, 11 нажатий клавиш

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

Неплохо для языка, который обрабатывает только строки. : D

Mathematica - 17 13 3 байта

∣

Спасибо @MartinEnder за сохранение тонны байтов!

Сетчатка, 12 байт

^(1+)\1* \1$

Принимает разделенный пробелами ввод в унарном виде, например, 111111111111 1111чтобы проверить, если 12 делится на 4 . Выводит 1 (true) или 0 (false).

Попробуйте онлайн!

FryAmTheEggman сохранил два байта. Ой, переписал мой ответ, чтобы рассуждать в правильном порядке. (Затем Фрай опередил меня в комментариях. Я опаздываю!)

Пакетный, 20 байтов

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

Выходы 1на успех, 0на провал.

C #, 27 13 12 байт

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

Спасибо TuukkaX за указание на анонимные лямбды. Спасибо Дэвиду Конраду за то, что он указал мне на карри, о котором я даже не подозревал.

Коротко и приятно, поскольку мы имеем дело только с целыми числами, которые мы можем использовать, <1а не ==0сохранять целый байт.

брейкфук, 53 байта

Принимает входные данные как байты, выходные данные являются байтовыми значениями 0x00или0x01 . Это алгоритм DivMod, за которым следует логическое отрицание .

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

Попробуйте онлайн - +в конце есть куча дополнительных, чтобы вы могли увидеть результат в ASCII.

Brain-Flak , 88 86 байт

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

Это более плотная версия оригинального алгоритма теста делимости Brain-Flak написанного доктором Green Eggs и Iron Man DJMcMayhem и мной.

Вот краткое (ish) объяснение того, как это работает:

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

Попробуйте онлайн!

LOLCODE, 74 64 байта

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

C, 60 байт

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

Дьялог АПЛ , 3 байта

0=|

Ноль равен остатку от деления?

R 22 22 байта

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

Как обычно, читает два числа из входа, который заканчивается пустой строкой.

Обновление: спасибо Jarko Dubbeldam за то, что он сбрил 2 байта (несмотря на то, что его редактирование было отклонено, это было очень полезно!).

Java 8, 11 байт

a->b->a%b<1

Какого черта, есть версии на JS и C #, почему не версия на Java тоже?

Использование:

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 байт

lambda D,d:D%d<1

GolfScript, 3 байта

~%!

Объяснение:

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

Попробуйте онлайн!

CJam, 6 4 байта

Сохранено 2 байта благодаря Денису

q~%!

Попробуйте онлайн

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

Брахилог , 2 байта

%0

Попробуйте онлайн!

Юлия, 9 байт

D\d=D%d<1

Попробуйте онлайн!

Фортран 95, 78 байт

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 байт

Сохранено 14 байтов благодаря Мартину Эндеру

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

Попробуйте онлайн!

объяснение

Алгоритм просто держать вычитая dиз , nчтобы увидеть , если вы можете сделать это целое число раз и не имеют никакого остатка.

;
)
;

>
=
 
 

Во-первых, вход собирается. nнаходится в первой ячейке, dво второй.

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

Это по сути основной цикл. Уменьшает первую и вторую ячейки и увеличивает третью.

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

Это окончательный вывод. Если после увеличения / уменьшения первая ячейка равна 0, то мы исключили n. Если после этого вторая ячейка ( d) есть 0, то dвошла nравномерно. Увеличиваем и печатаем ( 1). В противном случае вернитесь к первой ячейке (которая есть 0) и распечатайте ее.

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

Этот цикл происходит, если вторая ячейка находится 0после увеличения и уменьшения. Копирует третью ячейку во вторую ячейку. Часть внизу - это обход цикла, если ячейка отсутствует 0.

Tcl, 34 байта

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

Моя первая / * успешная * / попытка в Codegolf! Этот код должен выполняться в оболочке Tcl, иначе он не будет работать.

Один байт благодаря @Lynn.

Четыре байта благодаря @Lynn и @LeakyNun (теперь я понимаю, что он имел в виду)!

PHP, 23 22 байта

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

печатает 1 для истины, пустая строка (= ничего) для ложного

вызов из кли с nи в dкачестве аргументов

10 байт для древнего PHP: <?=$n%$d<1

J, 3 байта

0=|

Использование:

2 (0=|) 10 

Вернется 1. И эквивалентно псевдокоду10 MOD 2 EQ 0

Обратите внимание, что это очень похоже на ответ APL , потому что J вдохновлен APL

PowerShell v2 +, 20 байт

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

Принимает входные данные как два аргумента командной строки $args, -joinобъединяет их в строку с %разделителем и передает их iex(сокращение от Invoke-Expressionи аналогично eval). В результате либо 0или не равен нулю, поэтому мы возьмем булеву не !из этого результата, что означает либо $TRUEили$FALSE , отличное (ненулевые целые числа в PowerShell верны). Это логическое значение остается в конвейере, а вывод неявным.

Альтернативные версии, также 20 байтов каждая

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

Та же концепция, только немного разные способы структурирования ввода. Спасибо @DarthTwon за предоставление этого.

Примеры

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 байт

((1>).).mod

Это определяет новую функцию (!) :: Integral n => n -> n -> Bool. Поскольку mod n mвозвращает только положительные числа, если nи mявляются положительными, мы можем сохранить байт, используя 1>вместо 0==.

Использование:

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