Завдання

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

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

Вихід повинен бути правдою або помилковим значенням ; truthy, якщо 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

Таблиця лідерів

Фрагмент стека внизу цієї публікації генерує каталог з відповідей а) як список найкоротших варіантів для кожної мови та б) як загальний таблиця лідерів.

Щоб переконатися, що ваша відповідь відображається, будь ласка, почніть свою відповідь із заголовка, використовуючи наступний шаблон Markdown:

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

ḍ

Це займало у мене години на гольф.

Спробуйте в Інтернеті!

Брейн-Флак , 72 70 64 62 58 46 байт

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

Бере дивіденд і дільник (у такому порядку) як вхідний і друкує дільник (truthy) або нічого. Оскільки кожен стек має неявну, нескінченну кількість нулів, порожній вихід повинен вважатися хибним.

Хоча це не є чистим стеком, це рішення використовує лише один стек.

Спробуйте в Інтернеті!

Дякуємо @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 .

Ця зміна не впливає на результат, якщо % b> 0 , але якщо % b = 0 , він залишає (n, d, r) = (0, b, 0) - а не (n, d, r) = (0, 0, б) - на стеку.

Таким чином, щоб отримати модуль пружності, ми маємо тільки поп - н і д з {}{}.

Обчислення модуля стека-чисті, 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):

Неформатоване:

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

Відформатовано:

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

Рішення @Martin Ender (13):

Неформатоване:

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

Відформатовано:

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

Пояснення:

Спочатку отримуємо вхід і приймаємо модуль.

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

Потім він перевіряє, чи модуль дорівнює 0 чи ні. Якщо він є, IP повертає на 60 градусів ліворуч, відбивається від дзеркала, встановлює клітинку на 1 і друкує.

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

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

Якщо модуль виявиться позитивним, IP повертається на 60 градусів праворуч. Після того, як він вийде з правого нижнього кута, він продовжується в нижньому лівому краї через правила шестикутників. Повторне 'використання використовується для переходу IP до комірки з 0. IP-адреса потім рухається по четвертому ряду, загортається на другий, натискає на друк і потрапляє до відображення <. Решта шляху до @того ж.

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

Це якась серйозна майстерність.

@ Рішення FryAmTheEggman (12):

Неформатоване:

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

Відформатовано:

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

Пояснення:

Як і інші рішення, він отримує вхід і приймає модуль.

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

Потім, IP відхиляється в нижньому куті. Якщо модуль позитивний, він переходить у лівий верхній край. ?Має не більше вхідного сигналу, тому він задає осередок 0. !Потім друкує 0, і @завершує програму.

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

Речі набагато складніше, коли модуль дорівнює 0. Перш за все, він зменшується, потім скидається до 0, потім встановлюється в 1, потім друкується. Потім 1 зменшується до 0. Після цього програма запускається так, як це робиться на початку, поки не намагається це зробити 0%0. Це змушує кинути мовчазну помилку і кинути.

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

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

Спільний розчин (10):

Неформатоване:

?{?!1\@'%<

Відформатовано:

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

Ця програма запускається так само, як і всі інші програми, отримуючи введення та модеруючи її.

Якщо вхід 0, IP-адреса повертає ліворуч при попаданні <. Він відхиляється в 1!@, який друкує 1 і закриває.

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

Якщо вхід позитивний, IP-адреса стає правильним, коли він потрапляє <. Він виходить через кут і йде уздовж правого верхнього краю, натискаючи кнопку @ без друку.

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

Брейн-лок 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

• EDIT: Видалено 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 (правда) або 0 (помилково).

Спробуйте в Інтернеті!

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.

Мозг-Флак , 88 86 байт

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

Це більш щільна версія оригінального алгоритму випробування на роздільність Brain-Flak, написаного доктором Green Eggs та Iron Man DJMcMayhem і я.

Ось коротке (іш) пояснення, як це працює:

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

Діалог APL , 3 байти

0=|

Чи дорівнює нулю залишок ділення?

R, 22 20 байт

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

Як зазвичай, з вводу читається два числа, які закінчуються порожнім рядком.

Оновлення: дякую Ярко Дуббелдам за бриття 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);
    }
}

Пітон, 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 для true, порожній рядок (= нічого) для false

дзвінок із cli з аргументами 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