Тест делимости

39

задача

Даны два строго положительные целые числа п и д в качестве входных данных, определить , является ли п является равномерно делится на д , то есть, если существует целое число д такое , что 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

Дрянная Монахиня
источник
Этот разговор был перемещен в чат .
Деннис

Ответы:

41

Желе , 1 байт

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

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

DJMcMayhem
источник
12
вау это очень и очень сложно!
@MatthewRoh Да. Как я уже сказал, мне потребовались часы, чтобы придумать. : P
DJMcMayhem
29

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.
Деннис
источник
20

машинный код 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, который я написал со встроенной сборкой, потому что таким способом проще обрабатывать ввод / вывод.

Davey
источник
2
Добро пожаловать в PPCG, хороший первый ответ!
Дрянная Монахиня
Это должна быть полная программа? Я форматировал свой ответ вроде этого ответа . И благодарю вас! Я надеюсь поправиться в сборке / машинном коде для большего количества кода игры в гольф!
Дэйви
1
Ввод и вывод в указанные регистры в сборке разрешены по умолчанию: ввод , вывод . Это совершенно приемлемое представление. Добро пожаловать в PPCG!
Mego
Фантастика! Спасибо!
Дэйви
17

Гексагония, 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 поворачивается направо при попадании <. Он выходит через угол и идет по верхнему правому краю, ударяя @ без печати.

  . . ?
 . . . @
. . < . .
 . . . .
  . . .
синий
источник
6
Я думаю, что вы должны отформатировать свой ответ по-другому. Наличие четырех ответов в одном блоке кода создает впечатление, что ваш счетчик байтов неверен.
mbomb007
17

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
DJMcMayhem
источник
The rest is pretty straightforward.Да, похоже на это.
Эрик Outgolfer
24 байта, если вы считаете каждую инструкцию мозгового флажка байтом.
noɥʇʎԀʎzɐɹƆ
12

Javascript (ES6) 17 12 11 байт

a=>b=>a%b<1
  • РЕДАКТИРОВАТЬ: Удалено 5 байтов, потому что ожидается «a> 0».
  • EDIT2: удален 1 байт благодаря Downgoat .
ETHproductions
источник
Используйте карри для сохранения одного байта: a => b =>
Downgoat
Так как мне это выполнить? Когда я пытаюсь d=a=>b=>a%b<1следовать d(32,2)в консоли JS ... я просто получаю ответfunction b=>a%b<1
WallyWest
@WallyWest это использует карри, поэтому вы должны ввести d(32)(2). Потому что d(32)дает function b=>a%b<1, тогда вы должны вызвать эту функцию с вашим bзначением
Cyoce
9

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

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

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

DJMcMayhem
источник
Что делает <C-Left>? Не могу проверить это, потому что он переключает окна на Mac> _>
Downgoat
1
@ Downgoat вы используете Ctrl или команду? В любом случае, это эквивалентно «b», за исключением того, что оно работает и в режиме вставки.
DJMcMayhem
Быть педантичным, это эквивалент, Bа не bCtrl+ Rightэквивалент W) - разница с несловесными символами, но в этом случае он делает то же самое :) vimdoc.sourceforge.net/htmldoc/motion. html # <C-Left >
Кристиан Рондо
9

Mathematica - 17 13 3 байта

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

Yytsi
источник
Что это за персонаж?
Cyoce
@Cyoce Я не знаю его Unicode-код (сейчас на телефоне), но это короткий оператор для Divisible[].
Yytsi
@Cyoce Я думаю, что это символ трубы, также известный как shift + backslash.
Павел
@Pavel, если бы это был символ канала, это не было бы три байта.
Cyoce
@Cyoce - это символ U + 2223: fileformat.info/info/unicode/char/2223/index.htm
число людей
8

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

^(1+)\1* \1$

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

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

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

Линн
источник
Чтобы исправить порядок, если это станет необходимым, я думаю, ^(1+)\1* \1$будет работать.
FryAmTheEggman
Я думаю, с новой спецификацией, обратный порядок ввода снова в порядке.
Мартин Эндер
8

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

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

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

Нил
источник
8

C #, 27 13 12 байт

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

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

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

ДжастинМ - Восстановить Монику
источник
Я не уверен, но я думаю, что вы можете просто использовать лямбда (a,b)=>a%b<1;. +1.
Yytsi
@TuukkaX, спасибо, я не был уверен, это просто кажется обманным.
ДжастинМ - Восстановить Монику
В этой версии JS используется каррирование, чтобы уменьшить его на один байт, и это должно работать и для C #: a=>b=>a%b<1;(примечание: тогда вы должны вызывать его как, f(a)(b)а не как f(a,b))
Дэвид Конрад,
1
@DavidConrad oO это здорово, спасибо.
ДжастинМ - Восстановить Монику
7

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

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

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

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

mbomb007
источник
Не могли бы вы удалить часть «div», чтобы сохранить байты?
Утренняя монахиня
1
@LeakyNun Это самый короткий известный алгоритм, который дает модуль. Удаление части этого фактически делает это дольше, потому что вам нужно больше временных ячеек. Вы не можете найти модуль без деления.
mbomb007
Ясно спасибо .
Утренняя монахиня
@LeakyNun Просто посмотрите, как долго работает алгоритм деления .
mbomb007
Есть, вероятно, более короткие, но если так, никто не нашел или отправил их.
mbomb007
7

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

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

Мастер пшеницы
источник
Ссылка на онлайн переводчика?
Утренняя монахиня
Хорошо сделано! Также добро пожаловать на сайт! Я надеюсь, вам здесь весело. (У меня, конечно, есть)
DJMcMayhem
Хороший первый ответ, добро пожаловать в PPCG!
Утренняя монахиня
6

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
OldBunny2800
источник
Это полная программа, текущие реализации не требуют HAI и KTHXBYE
OldBunny2800
Хорошо, я попытаюсь. Одна секунда…
OldBunny2800
Нет, это на два байта больше.
OldBunny2800
O RLY?Я этого не знал! меняется.
OldBunny2800
BTW Вот советы по игре в гольф.
Утренняя монахиня
6

C, 60 байт

#include <stdio.h>
main(){int a,b;scanf("%d %d",&a,&b);a%b==0;}
Ronronner
источник
1
Почему -1? Объясни мне
Ронроннер
3
Вполне возможно, что никто не проголосовал. Это короткий ответ, поэтому он был автоматически помечен как некачественный, а затем вы отредактировали его. По какой-то причине это приводит к автоматическому понижению . Прости за это. +1от меня. Кроме того, мы разрешаем функции, чтобы вы могли легко сократить это int f(a,b){return !(a%b);}или, возможно, даже сократить.
DJMcMayhem
3
Нет, я хочу сказать, что это не обязательно полная программа. Вы можете отправить только функцию вместо этого. int f(a,b){return!(a%b);}составляет 25 байтов, и если вы используете правильный компилятор, вы могли бы даже сделать f(a,b){return!(a%b);}для 21 байта.
DJMcMayhem
3
Еще более короткая функция представления: #define f(a,b)!(a%b)( ideone link )
Mego
2
Вам нужно определить функцию или программу, а не просто фрагмент.
Утренняя монахиня
5

R 22 22 байта

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

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

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

Андрей Костырка
источник
5

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);
    }
}
Дэвид Конрад
источник
a->b->a%b<1Это вызывает синтаксическую ошибку, не так ли?
Дорукаяхан хочет вернуть Монику
2
Нет, это действительно Java 8.
Дэвид Конрад
Иногда даже Java выглядит как Perl ...
Mega Man
Да, я бы добавил, что это только Java 8;).
Волшебная Урна Осьминога
так что с Java 8 мы должны считать только байты лямбда-выражения, а не весь класс и шаблон функции, круто!
Сикорски
4

Python, 16 байт

lambda D,d:D%d<1
Деннис
источник
1
Обратите внимание, что это не сработает, если разрешить отрицательные целые числа. К счастью, входные данные строго положительны.
TLW
Я сделал lambda a,b:1.*a/b==a/b, но был весьма впечатлен. Это такой сложный кусок кода ...
Эрик Outgolfer
4

CJam, 6 4 байта

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

q~%!

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

q    e# Take in the input
 ~   e# Dump the individual values to the stack
  %  e# Modulus
   ! e# Boolean NOT
Бизнес Кот
источник
3

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

function f(i,j)result(k)
integer::i,j,k
k=merge(1,0,MOD(i,j)<1)
end function f
Джереми
источник
3

MarioLANG, 121 109 107 байт

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

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

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

объяснение

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

;
)
;

>
=
 
 

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

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

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

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

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

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

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

Бизнес Кот
источник
3

Tcl, 34 байта

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

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

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

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


источник
Можете ли вы опустить ?1:0?
Дрянная Монахиня
@ LeakyNun это троичная операция. ты имеешь в виду просто вернуть что-то, когда это возможно?
Что бы $a%$b==0вернуться?
Утренняя монахиня
1
Я имею в виду, может ли быть ваша третья строка exp $a%$b==0?
Утренняя монахиня
1
Или exp $a%$b<1, может быть?
Линн
3

PHP, 23 22 байта

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

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

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


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

Titus
источник
Если вы не возражаете против использования PHP4.1: <?=!($A%$B). Значения могут быть переданы как часть вашего $_SESSION, $_COOKIE, $_POST, $_GETболее или (если я не ошибаюсь) $_ENV.
Исмаэль Мигель
@ Ismael Miguel: На самом деле я не знаю, но я устал от публикации старых версий PHP и добавления for PHP<5.4 with register_globals=On. Но я добавлю это для справки.
Тит
На самом деле, вы не можете сказать « for PHP<5.4 with register_globals=On», так как вы должны сосчитать байты вашего php.iniфайла, содержащие register_globals=On. Тем не менее, PHP4.1 является особым случаем. Это последняя версия, где register_globals=Onзадано значение по умолчанию, и большинство функций доступны с PHP4.1 и выше. Эта версия также позволяет использовать другие функции, как eregи splitбез предупреждений.
Исмаэль Мигель
3

J, 3 байта

0=|

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

2 (0=|) 10 

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

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

emiflake
источник
Хороший первый ответ, добро пожаловать в PPCG!
Дрянная Монахиня
@LeakyNun Спасибо, я всегда осматривался, приятно наконец ответить.
Emiflake
3

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
AdmBorkBork
источник
В обоих других методах я пытался сыграть в гольф этот вопрос, я также получил их до 20 байт: param($a,$b)!($a%$b)и!($args[0]%$args[1])
ThePoShWolf
@DarthTwon Действительно. При работе с небольшим количеством операций обычно существует не более одного или двух байтов различий в разных способах получения входных аргументов.
AdmBorkBork
Я надеялся придумать что-нибудь более короткое: P, но да, всегда есть несколько способов снять шкуру с кошки, особенно в PS.
ThePoShWolf
3

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
Zeta
источник
Вы можете пойти pointfree и сохранить 2 байта: ((1>).).mod.
Ними