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


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


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

Ответы:



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


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

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 .

Используйте карри для сохранения одного байта: 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


Что делает <C-Left>? Не могу проверить это, потому что он переключает окна на Mac> _>
— Downgoat

1
@ Downgoat вы используете Ctrl или команду? В любом случае, это эквивалентно «b», за исключением того, что оно работает и в режиме вставки.
— DJMcMayhem

Быть педантичным, это эквивалент, Bа не b(и Ctrl+ Rightэквивалент W) - разница с несловесными символами, но в этом случае он делает то же самое :) vimdoc.sourceforge.net/htmldoc/motion. html # <C-Left >
— Кристиан Рондо

9

Mathematica - 17 13 3 байта

∣

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


Что это за персонаж?
— Cyoce

@Cyoce Я не знаю его Unicode-код (сейчас на телефоне), но это короткий оператор для Divisible[].
— Yytsi

@Cyoce Я думаю, что это символ трубы, также известный как shift + backslash.
— Павел

@Pavel, если бы это был символ канала, это не было бы три байта.
— Cyoce


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.


Не могли бы вы удалить часть «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

Это полная программа, текущие реализации не требуют 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;}

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






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


Если вы не возражаете против использования 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


Хороший первый ответ, добро пожаловать в 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

В обоих других методах я пытался сыграть в гольф этот вопрос, я также получил их до 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

Вы можете пойти pointfree и сохранить 2 байта: ((1>).).mod.
— Ними
Используя наш сайт, вы подтверждаете, что прочитали и поняли нашу Политику в отношении файлов cookie и Политику конфиденциальности.
Licensed under cc by-sa 3.0 with attribution required.