Учитывая положительное целое число в качестве входных данных, ваша задача состоит в том, чтобы вывести истинное значение, если число делится на двойную сумму его цифр, а в противном случае - на ложное значение ( 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)

Нейм , 3 байта

𝐬ᚫ𝕞

Объяснение:

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

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

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

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

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

let f =

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

console.log('[Truthy]');
console.log(f("80"))
console.log(f("100"))
console.log(f("60"))
console.log(f("18"))
console.log(f("12"))

console.log('[Falsy]');
console.log(f("4"))
console.log(f("8"))
console.log(f("16"))
console.log(f("21"))
console.log(f("78"))
console.log(f("110"))
console.log(f("111"))
console.log(f("390"))

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

Retina , 38 27 байт

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

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

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

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

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

$
$_¶$_

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

.+$|.
$*

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

^(.+)¶\1+$

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

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

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?

Машинный код 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, если входное значение делится на двойную сумму его цифр, или ненулевое значение в противном случае.

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

Japt , 7 4 байта

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

%²¬x

Попробуй это

объяснение

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

²

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

¬

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

x

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

%

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

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);
}

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

ẹ+×₂;I×?

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

объяснение

ẹ+           Sum the digits
  ×₂         Double
    ;I×?     There is an integer I such that I×(double of the sum) = Input

Python 2 , 34 32 байта

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

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

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

Mathematica, 26 байтов

(2Tr@IntegerDigits@#)∣#&

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

PHP , 41 байт

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

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

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

Excel, 63 байта

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

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

Perl 6 , 19 байт

{$_%%(2*.comb.sum)}

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

Шелуха , 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.

Haskell , 38 37 42 байта

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

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

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

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

Python 3, 35 байт

lambda a:a%(sum(map(int,str(a)))*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

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

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

Haskell , 49 байт

f x=(==) 0.mod x.(*)2.sum.map(read.return).show$x

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

f 80

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

Джава , 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
}

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?

Ом , 5 байт

D}Σd¥

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

tcl, 45

puts [expr 1>$n%(2*([join [split $n ""] +]))]

демонстрация

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

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

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;'

объяснение

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

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

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

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

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

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

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

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