Могу ли я делиться на двойную сумму моих цифр?

40

Учитывая положительное целое число в качестве входных данных, ваша задача состоит в том, чтобы вывести истинное значение, если число делится на двойную сумму его цифр, а в противном случае - на ложное значение ( OEIS A134516 ). Другими словами:

(sum_of_digits)*2 | number
  • Вместо истинных / ложных значений для истинных и ложных случаев вы можете указать любой конечный набор значений для истинного / ложного случаев и дополнить их другими значениями. Для простого примера вы можете использовать 0для истинного регистра и все другие числа для ложного регистра (или наоборот, если хотите).

  • Применяются стандартные правила ввода и вывода. Лазейки по умолчанию также применяются.

  • Вы можете принять входные данные как целое число или как строковое представление этого целого числа.

  • Это , поэтому выигрывает самый короткий код в байтах!

  • Я новичок в PPCG, поэтому я хотел бы, чтобы вы опубликовали объяснение, если это возможно.


Тестовые случаи

Ввод - вывод - (причина)

80 - Истина - (16 делит 80)
100 - Истина - (2 делит 100)
60 - Истина - (12 делит 60)
18 - Истина - (18 делит 18)
12 - Истина - (6 делит 12)

4 - Ложь - (8 не делит 4)
8 - Ложь - (16 не делит 8)
16 - Ложь - (14 не делит 16)
21 - Ложь - (6 не делит 21)
78 - Ложь - (30 не делит 78)
110 - Ложь - (4 не исчезает 110)
111 - Ложь - (6 не делит 111)
390 - Ложь - (24 не делит 390)

источник
Хороший вызов, добро пожаловать в PPCG!
Скидсдев
@Mayube Спасибо, это мой второй вызов, но первый был закрыт: P
Разрешено ли нам принимать цифры как список целых чисел?
Генри
4
@ Генри Нет, это было бы слишком тривиально
1
Действительно, два предложения «Вместо истинных / ложных значений для истинных и ложных случаев вы можете вместо этого указать любой конечный набор значений для истинного случая и их дополнение для ложных. Для простого примера вы можете использовать 0 для истинного случая и все другие числа для ложного случая (или наоборот, если хотите) «кажутся противоречащими друг другу (в частности,« конечный »и« или наоборот »).
Грег Мартин

Ответы:

7

Нейм , 3 байта

𝐬ᚫ𝕞

Объяснение:

𝐬      Implicitly convert to int array and sum the digits
 ᚫ     Double
  𝕞   Is it a divisor of the input?

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

Подробная версия

Okx
источник
Хм ... вы должны проверить, если входное значение кратно двойной сумме цифр, а не наоборот.
Эрик Outgolfer
@EriktheOutgolfer Что ты имеешь в виду? Я проверяю, является ли вход кратным двойной суммы цифр. Возможно, я не правильно объяснил.
Okx
4
Neim должен стать еще более привлекательным - когда количество заявок становится слишком длинным, мой браузер начинает зависать.
Esolanging Fruit
1
@ Challenger5 Я искренне извиняюсь за отсутствие игры в гольф. Я попробую еще раз в следующий раз. Опять извините за это.
Okx
@Okx И я искренне извиняюсь за то, что слишком ленив, чтобы найти ответ Нейма, который был лучшей демонстрацией того, о чем я говорил.
Esolanging Fruit
16

JavaScript (ES6), 31 29 27 байт

Принимает ввод в виде строки. Возвращает ноль для правды и ненулевой для фальсификации.

n=>n%eval([...n+n].join`+`)

комментарии

n => n % eval([...n + n].join`+`)
n =>                                   // take input string n  -> e.g. "80"
                  n + n                // double the input     -> "8080"
              [...     ]               // split                -> ["8", "0", "8", "0"]
                        .join`+`       // join with '+'        -> "8+0+8+0"
         eval(                  )      // evaluate as JS       -> 16
     n %                               // compute n % result   -> 80 % 16 -> 0

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

Arnauld
источник
Я никогда раньше не видел [... x] метод расщепления, есть ли название для этого?
Джейкоб Перси
7

C #, 46 байт

using System.Linq;n=>n%(n+"").Sum(c=>c-48)*2<1

Полная / Отформатированная версия:

using System;
using System.Linq;

class P
{
    static void Main()
    {
        Func<int, bool> f = n => n % (n + "").Sum(c => c - 48) * 2 < 1;

        Console.WriteLine(f(80));
        Console.WriteLine(f(100));
        Console.WriteLine(f(60));

        Console.WriteLine();

        Console.WriteLine(f(16));
        Console.WriteLine(f(78));
        Console.WriteLine(f(390));

        Console.ReadLine();
    }
}
TheLethalCoder
источник
4

Retina , 38 27 байт

-11 байт и исправили ошибку с кодом благодаря @MartinEnder

$
$_¶$_
.+$|.
$*
^(.+)¶\1+$

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

Выводит 1, если делится, 0 в противном случае

Объяснение (надеюсь, я правильно понял)

$
$_¶$_

Добавляет весь ввод, плюс перевод строки, плюс ввод снова

.+$|.
$*

Преобразует каждое совпадение в унарное (либо всю вторую строку, которая является исходным вводом, либо каждую цифру в первой строке)

^(.+)¶\1+$

Проверьте, является ли первая строка (удвоенная сумма цифр) делителем второй строки

PunPun1000
источник
4

MATL , 7 байт

tV!UsE\

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

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

объяснение

t   % Implicit input. Duplicate
V!U % Convert to string, transpose, convert to number: gives column vector of digits
s   % Sum
E   % Times 2
\   % Modulus. Implicit display
Луис Мендо
источник
4

05AB1E , 5 4 байта

-1 байт благодаря Okx

SO·Ö

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

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

объяснение

SO·Ö
SO    # Separate the digits and sum them
  ·   # Multiply the result by two
   Ö  # Is the input divisible by the result?
Datboi
источник
Вы можете увеличить его до 4 байтов, заменив %_на Ö.
Okx
4

Машинный код x86-64, 24 байта

6A 0A 5E 31 C9 89 F8 99 F7 F6 01 D1 85 C0 75 F7 8D 04 09 99 F7 F7 92 C3

Приведенный выше код определяет функцию в 64-битном машинном коде x86, которая определяет, делится ли входное значение на двойную сумму его цифр. Функция соответствует соглашению о вызовах System V AMD64, поэтому ее можно вызывать практически из любого языка, как если бы она была функцией C.

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

Он возвращает свой результат в EAXрегистр, опять же, в соответствии с соглашением о вызовах. Результат будет 0 , если значение входного сигнала был делится на сумму своих цифр, и не ноль в противном случае. (По сути, обратный логический тип, в точности как в примере, приведенном в правилах вызова.)

Его прототип C будет:

int DivisibleByDoubleSumOfDigits(int value);

Ниже приведены инструкции на языке ассемблера без аннотации с кратким объяснением цели каждой инструкции:

; EDI == input value
DivisibleByDoubleSumOfDigits:
   push 10
   pop  rsi             ; ESI <= 10
   xor  ecx, ecx        ; ECX <= 0
   mov  eax, edi        ; EAX <= EDI (make copy of input)

SumDigits:
   cdq                  ; EDX <= 0
   div  esi             ; EDX:EAX / 10
   add  ecx, edx        ; ECX += remainder (EDX)
   test eax, eax
   jnz  SumDigits       ; loop while EAX != 0

   lea  eax, [rcx+rcx]  ; EAX <= (ECX * 2)
   cdq                  ; EDX <= 0
   div  edi             ; EDX:EAX / input
   xchg edx, eax        ; put remainder (EDX) in EAX
   ret                  ; return, with result in EAX

В первом блоке мы делаем предварительную инициализацию регистров:

  • PUSH+POP инструкции используются как медленный, но короткий способ инициализации ESIдо 10. Это необходимо, потому чтоDIV инструкция для x86 требует операнда регистра. (Нет формы, которая делится на непосредственное значение, скажем, 10.)
  • XORиспользуется как короткий и быстрый способ очистки ECXрегистра. Этот регистр будет служить «аккумулятором» внутри предстоящего цикла.
  • Наконец, копия входного значения (из EDI) создается и сохраняется вEAX , которая будет перекрыта при прохождении цикла.

Затем мы начинаем цикл и суммируем цифры во входном значении. Это основано на x86 DIVинструкции, которая делит EDX:EAXна операнде и возвращает частное в EAXи остаток в EDX. Здесь мы разделим входное значение на 10, так что остаток будет цифрой в последнем месте (которую мы добавим в наш регистр аккумулятора,ECX ), а частное - это оставшиеся цифры.

  • CDQИнструкция короткий путь установки EDX0. Это фактически знаково-расширяет значение в EAXк EDX:EAX, что и DIVиспользует в качестве дивидендов. На самом деле здесь нам не нужно расширение знака, потому что входное значение является беззнаковым, но CDQсоставляет 1 байт, в отличие от использования XORдля очистки EDX, что составляет 2 байта.
  • Тогда мы DIVIde EDX:EAXпо ESI(10).
  • Остаток ( EDX) добавляется в аккумулятор ( ECX).
  • EAXРегистр (фактор) проверяется , чтобы увидеть , если он равен 0. Если это так, мы сделали это через все цифры , и мы провалиться. Если нет, у нас все еще есть больше цифр для суммирования, поэтому мы возвращаемся к началу цикла.

Наконец, после завершения цикла мы реализуем number % ((sum_of_digits)*2):

  • LEAИнструкция используется как короткий способ умножить ECXна 2 (или, что то же самое, добавить ECXк себе), и сохранить результат в другом регистре (в данном случае, EAX).

    (Мы могли бы также сделать add ecx, ecx+ xchg ecx, eax; оба - 3 байта, но LEAинструкция более быстрая и более типичная.)

  • Затем мы CDQснова готовимся к разделению. Поскольку EAXбудет положительным (то есть без знака), это будет иметь эффект обнуления EDX, как и раньше.
  • Далее идет деление, на этот раз деление EDX:EAXна входное значение (немоледированная копия которого все еще находится в EDI). Это эквивалентно модулю с остатком в EDX. (Коэффициент также вводится EAX, но нам это не нужно.)
  • Наконец, мы XCHG(обмениваемся) содержимым EAXи EDX. Обычно вы делаете MOVздесь, но XCHGэто всего 1 байт (хотя и медленнее). Поскольку EDXсодержит остаток после деления, он будет равен 0, если значение было равномерно делимым или отличным от нуля в противном случае. Таким образом, когда мы RETurn, EAX(результат) равен 0, если входное значение делится на двойную сумму его цифр, или ненулевое значение в противном случае.

Надеюсь, этого достаточно для объяснения.
Это не самая короткая запись, но, похоже, она превосходит почти все языки без игры в гольф! :-)

Коди Грей
источник
3

Japt , 7 4 байта

Принимает ввод в виде строки. Выходы 0для trueили число больше, чем 0для false, который, по мнению других решений, будет действительным. Если нет, дайте мне знать, и я сделаю откат.

%²¬x

Попробуй это


объяснение

Неявный ввод строки U.
"390"

²

Повторите Uдважды.
"390390"

¬

Разделить на массив отдельных символов.
["3","9","0","3","9","0"]

x

Сократить путем суммирования, автоматически приведя каждого персонажа к целому числу в процессе.
24

%

Получите остаток от деления Uна результат, также автоматически приведя Uк целому числу в процессе. Неявно выведите полученное целое число.
6 (=false)

мохнатый
источник
2
Ваши объяснения обычно занимают много вертикального пространства, которое, я считаю, не нужно. В любом случае, это твой ответ.
Okx
@Okx; Я не знаю, насколько «обычно» это может быть, когда я переключился на этот формат всего пару дней назад.
Лохматый
4
Мне понравился формат объяснения. Было легко следовать, особенно для этой задачи, так как это было линейное сокращение и сдвигало страницу вниз, как математическая задача. Просто мои два цента.
Генри
3
Этот формат объяснения намного лучше, чем обычный формат, особенно для тех, кто не знаком с языками. Я хотел бы, чтобы другие игроки в гольф, использующие эти языки игры в гольф, сделали это тоже.
Peter1807
3

C89, 55 53 байта

(Спасибо Steadybox!

s,t;f(x){for(t=x,s=0;t;t/=10)s+=t%10;return x%(s*2);}

Требуется один вход, xкоторый является значением для проверки. Возвращает 0, еслиx он делится равномерно на двойную сумму его цифр, или ненулевое значение в противном случае.

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

Ungolfed:

/* int */ s, t;
/*int */ f(/* int */ x)
{
    for (t = x, s = 0; t /* != 0 */; t /= 10)
        s += (t % 10);
    return x % (s * 2);
}

Как вы можете видеть, здесь используются правила неявного int в C89. Глобальные переменные sиt неявно объявлены как ints. (Они также неявно инициализируются в 0, потому что они являются глобальными, но мы не можем воспользоваться этим, если хотим, чтобы функция вызывалась несколько раз.)

Точно так же функция, fпринимает один параметр, x,который неявно являетсяint , и возвращает int.

Код внутри функции довольно прост, хотя forцикл будет выглядеть очень странно, если вы не знакомы с синтаксисом. По сути, forзаголовок цикла в C состоит из трех частей:

for (initialization; loop condition; increment)

В разделе «инициализация» мы инициализировали наши глобальные переменные. Это будет выполнено один раз, прежде чем цикл будет введен.

В разделе «условие цикла» мы указали, при каком условии цикл должен продолжаться. Это должно быть очевидно.

В разделе «приращения» мы в основном поместили произвольный код, так как он будет выполняться в конце каждого цикла.

Большая цель цикла - перебирать каждую цифру во входном значении, добавляя их к s. Наконец, после того, как цикл завершен, sон удваивается и берется по модулю, xчтобы увидеть, делится ли он равномерно. (Лучшее, более подробное объяснение логики здесь можно найти в моем другом ответе , на котором основан этот.)

Человекочитаемая версия:

int f(int x)
{
    int temp = x;
    int sum  = 0;
    while (temp > 0)
    {
        sum  += temp % 10;
        temp /= 10;
    }
    return x % (sum * 2);
}
Коди Грей
источник
Вы можете сохранить два байта, если будете использовать tвместо t>0условия цикла .
Steadybox
Ах, конечно! Хороший улов, @Steadybox. Не уверен, как я это пропустил, так как тестирование против 0 - это именно то, что сделала моя реализация asm, на которой в значительной степени был основан этот ответ.
Коди Грей,
45
PrincePolka
2

Python 2 , 34 32 байта

-2 байта благодаря @Rod

lambda n:n%sum(map(int,`n`)*2)<1

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

овс
источник
6
основываясь на примере «четко различимого», приведенном в вопросе, я считаю, что вы можете удалить <1.
Пшеничный волшебник
2

Mathematica, 26 байтов

(2Tr@IntegerDigits@#)∣#&

Понятия не имею, почему имеет более высокий приоритет, чем умножение ...

Мартин Эндер
источник
2

PHP , 41 байт

печатает ноль, если делится, в противном случае положительное целое число.

<?=$argn%(2*array_sum(str_split($argn)));

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

Йорг Хюльсерманн
источник
Вы помещаете назначение в блок заголовка. Вы можете также использовать $a=10, но вы забыли посчитать , что к вашему счетчику байтов
aross
@aross почему я должен считать входные данные до моего количества байтов. $argnдоступно с -F(в данном случае) или -Rопцией
Jörg Hülsermann
Хм, интересно. Я не знал о -F. Но это не отражено в вашем TIO (поддерживает ли он эхо от STDIN?).
aross
@aross работает так, как будто вы используете только файл вместо кода и -Fопцию вместо -R php.net/manual/en/features.commandline.options.php Если вы нашли лучший способ сделать то же самое в tio, как в commnd линия, дайте мне знать
Йорг Хюльсерманн
2

Excel, 63 байта

=MOD(A1,2*SUMPRODUCT(--MID(A1,ROW(OFFSET(A$1,,,LEN(A1))),1)))=0

Суммирующие цифры - это длинный бит.

Wernisch
источник
2

Шелуха , 9 8 байт

Спасибо Лео за сохранение 1 байта.

Ṡ¦ȯ*2ṁis

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

объяснение

Ṡ¦ȯ         Test whether f(x) divides x, where f is the function obtained by
            composing the next 4 functions.
       s    Convert x to a string.
     ṁi     Convert each character to an integer and sum the result.
   *2       Double the result.
Мартин Эндер
источник
Вы можете использовать ṁ для отображения и суммирования с помощью одной команды, сохраняя один байт
Лев
2

Haskell , 38 37 42 байта

Благодаря Zgarb для игры в гольф от 1 байта

f x=read x`mod`foldr((+).(*2).read.pure)0x

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

Принимает ввод в виде строки; возвращает 0, если делится и ненулевой в противном случае.

Юлианский волк
источник
(:[])может быть pure.
Згарб
Вы сэкономите 1 байт, заменив лямбду на объявление функции
bartavelle
@bartavelle: Уверен, что это мытье. Пример?
Джулиан Вольф
Вы правы, это точно такая же длина. Не уверен, как это
пришло
2

Python 3, 35 байт

lambda a:a%(sum(map(int,str(a)))*2)
wrymug
источник
Здравствуйте и добро пожаловать на сайт. Вы можете удалить некоторые пробелы здесь. В частности , вокруг =и после )дюйма int(c). Кроме того, поскольку вы sumможете взять генератор в качестве аргумента, вы можете удалить его [..]изнутри. Если у вас есть дополнительные вопросы, не стесняйтесь пинговать меня.
Пшеничный волшебник
int(c)for c in aтакже может быть map(int,a), чтобы сохранить несколько байтов.
Пшеничный волшебник
Это не работает - или, скорее, работает в обратном направлении. Легко исправляется с помощью 4 дополнительных байтов:lambda a:not a%(sum(map(int,str(a)))*2)
osuka_
@osuka_ см. пункт 1 пули в описании вопроса
wrymug
2

TI-BASIC, 27 26 21 байт

-5 благодаря @Oki

:fPart(Ans/sum(2int(10fPart(Ans10^(~randIntNoRep(1,1+int(log(Ans

Это усложняется тем фактом, что в TI-BASIC нет краткого способа суммирования целых чисел . Возвращает 0для Trueи другой номер для False.

Объяснение:

:fPart(Ans/sum(2int(10fPart(Ans10^(-randIntNoRep(1,1+int(log(Ans
                               10^(-randIntNoRep(1,1+int(log(Ans #Create a list of negative powers of ten, based off the length of the input, i.e. {1,0.1,0.01}
                            Ans                                  #Scalar multiply the input into the list
                    10fPart(                                     #Remove everything left of the decimal point and multiply by 10
               2int(                                             #Remove everything right of the decimal point and multiply by 2
           sum(                                                  #Sum the resulting list
       Ans/                                                      #Divide the input by the sum
:fPart(                                                          #Remove everything left of the decimal, implicit print
Скотт Милнер
источник
2
10^-randIntNoRep(1,1+int(log(Ansделает то же самое, что и seq(10^(~A-1),A,0,log(Ansв меньшем количестве байтов, поскольку порядок не имеет значения (при условии версии 2.55MP)
Oki
1

Braingolf , 13 12 байт

VR.Mvd&+2*c%

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

Выводит 0 для истины, любой другой номер для фальси.

объяснение

VR.Mvd&+2*c%  Implicit input from command-line args
VR            Create stack2, return to stack1
  .M          Duplicate input to stack2
    vd        Switch to stack2, split into digits
      &+      Sum up all digits
        2*    Double
          c   Collapse stack2 back into stack1
           %  Modulus
              Implicit output of last item on stack
Skidsdev
источник
1

Japt , 7 байт

vUì x*2

Возвращает 1для true, 0дляfalse

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

объяснение

vUì x*2
v        // Return 1 if the input is divisible by:
 Uì      //   Input split into a base-10 array
    x    //   Sum the array
     *2  //   While mapped by *2
Оливер
источник
Я также предложил несколько других 7-байтовых решений для этого (хотя, я не думаю, что это было одно из них) - я уверен, что есть более короткое решение.
Лохматый
1

Джава , 66 байт

-1 байт благодаря Оливье

a->{int i=0;for(int b:(""+a).getBytes())i+=b-48;return a%(i*2)<1;}

Ungolfed & объяснение:

a -> {
    int i = 0;

    for(int b : (""+a).getBytes()) { // Loop through each byte of the input converted to a string
        i += b-48; // Subtract 48 from the byte and add it to i
    }

    return a % (i*2) < 1 // Check if a % (i*2) is equal to one
    // I use <1 here for golfing, as the result of a modulus operation should never be less than 0
}
Okx
источник
Используйте intвместо того, byteчтобы сохранить ... байт.
Оливье Грегуар
@ OlivierGrégoire Спасибо. Не заметил этого.
Okx
@Okx Нужно также изменить гольф-код.
Генри
Ваш (играющий в гольф) код дает неверные значения для 110, 111. Вероятно a%i*2, это анализируется, (a%i)*2поскольку модули и умножение имеют одинаковый порядок.
Оливье Грегуар
@ OlivierGrégoire Ах, это отстой.
Okx
1

J 15 байт

0 указывает на правдивость, ненулевой указывает на ложь.

|~[:+/2#"."0@":

объяснение

        "."0@":  convert to list of digits
  [:+/2#         sum 2 copies of the list ([: forces monadic phrase)
|~               residue of sum divided by argument?
hoosierEE
источник
Очень умный способ избежать паренов или множественных @или [:!
Иона
1
Я обсуждал публикацию этого как мой собственный ответ, но это не совсем отличается. |~2*1#.,.&.":для 13 байтов.
Коул
Я получаю «доменную ошибку» для этого в моей QT IDE. (| ~ [: + / 2 # "." 0 @ ": 112) Тогда для кода Коула я получаю (| ~ 2 * 1 #.,. &.": 112) = 0. : / Возможно, что-то не так с моей стороны.
DrQuarius
1

Haskell , 35 34 байта

f x=mod x$2*sum[read[c]|c<-show x]

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

Возвращает «0» в истинном случае, остальное в противном случае.

Haskell , pointfree edition от nimi, 34 байта

mod<*>(2*).sum.map(read.pure).show

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

bartavelle
источник
То же количество байт , если вы идете pointfree:mod<*>(2*).sum.map(read.pure).show
Ними
Выглядит хорошо, я добавил это в свое представление.
Bartavelle
1

PHP, 44 байта

for(;~$d=$argn[$i++];)$t+=2*$d;echo$argn%$t;

Запустите так:

echo 80 | php -nR 'for(;~$d=$argn[$i++];)$t+=2*$d;echo$argn%$t;'

объяснение

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

aross
источник
1

Java (OpenJDK 8) , 55 53 байта

a->{int i=0,x=a;for(;x>0;x/=10)i+=x%10*2;return a%i;}

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

Возвращаемое значение 0 означает правдивое, все остальное означает ложь.

Так как мой комментарий в ответе Окса не имел никакой пульсации, я удалил его и опубликовал как этот ответ, играя в гольф еще немного.

Дальнейшая игра в гольф благодаря @KrzysztofCichocki и @Laikoni, которые справедливо показали мне, что мне не нужно отвечать истинным / ложным значением, но любым значением, пока я описываю результат.

Оливье Грегуар
источник
Вы можете удалить часть <1 в конце, так что результатом будет 0 для true и> 0 для false, что является приемлемым, это приведет к дополнительным -2 байтам, так что вы ответите как 53 байта.
Кшиштоф
@KrzysztofCichoki Нет, я не могу: это Java. Только truthy значение true.
Оливье Грегуар
@ OlivierGrégoire Несмотря на то, что это правда, если ничего не указано, в этой задаче конкретно говорится Instead of truthy / falsy values for the true and false cases, you may instead specify any finite set of values for the true/false case, and their complement the other values..
Лайкони
@KrzysztofCichocki и Laikoni Извините, что неправильно прочитал эту часть, я просто исправил ее! Спасибо вам обоим :) Кроме того, извините за отклонение редактирования, которое было действительно уместно в этом случае.
Оливье Грегуар,
1

Мини-Флак, 296 292 байта

({}((()[()]))){(({}[((((()()()){}){}){}){}])({}(((({})){}){}{}){})[({})])(({}({})))({}(({}[{}]))[{}])({}[({})](({}{})(({}({})))({}(({}[{}]))[{}])({}[({})]))[{}])(({}({})))({}(({}[{}]))[{}])({}[({})])}{}({}(((({}){})))[{}]){({}((({}[()]))([{(({})[{}])()}{}]()){{}{}(({}))(()[()])}{})[{}][()])}

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

Ссылка на TIO содержит больше комментариев от меня, поэтому ее легче читать.

Истина / Ложь: Истина (делимая), если второе число равно третьему, ложь в противном случае. Таким образом, и набор правды, и ложь бесконечны, но я полагаю, что это должно быть разрешено. +10 байт, если это не так.

Примечание: начальные / завершающие символы новой строки / пробелы не допускаются при вводе.

user202729
источник