З огляду на додатне ціле число як вхідне, ваше завдання - вивести триєдне значення, якщо число ділиться на подвійне від суми його цифр, а в іншому випадку помилкове значення ( OEIS A134516 ). Іншими словами:

(sum_of_digits)*2 | number

• Замість правдивих / хибних значень для справжнього та помилкового випадків ви можете замість цього вказати будь-який кінцевий набір значень для справжнього / хибного випадку та доповнити їх іншими значеннями. Для простого прикладу, ви можете використовувати 0для справжнього випадку і всі інші числа для помилкового випадку (або навпаки, якщо вам подобається).

• Застосовуються стандартні правила введення та виводу. Також застосовуються лазівки за замовчуванням.

• Ви можете приймати введення як ціле число або як рядкове представлення цього цілого числа.

• Це код-гольф , отже, найкоротший код у байтах виграє!

• Я новачок у PPCG, тому я хотів би, щоб ви написали пояснення, якщо це можливо.

Випробування

Введення - Вихід - (Причина)

80 - Труті - (16 розділів 80)
100 - Truthy - (2 розділи 100)
60 - Труті - (12 розділів 60)
18 - Труті - (18 ділиться 18)
12 - Труті - (6 розділів 12)

4 - Falsy - (8 не ділить 4)
8 - Falsy - (16 не ділить 8)
16 - Falsy - (14 не ділиться 16)
21 - Falsy - (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();
    }
}

Сітківка , 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 для truthy і щось інше для фальшивого, що призводить до лише 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, який буде клобуватися, коли ми проходимо цикл.

Потім ми починаємо циклічне підсумовування та підсумовування цифр у вхідному значенні. Це засновано на DIVінструкції x86 , яка ділиться EDX:EAXза операндом і повертає коефіцієнт на, EAXа решту в EDX. Що ми тут зробимо, це розділити вхідне значення на 10, таким чином, що залишок - це цифра на останньому місці (яку ми додамо до нашого реєстру акумуляторів ECX), а коефіцієнт - цифри, що залишилися.

• CDQІнструкція короткий шлях установки EDX0. Це фактично знаково-розширює значення в EAXдо EDX:EAX, що і DIVвикористовує в якості дивідендів. Тут насправді не потрібно розширення знаків, оскільки вхідне значення не підписане, але CDQце 1 байт, на відміну від використання XORдля очищення EDX, яке було б 2 байти.
• Тоді ми DIVіде 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, якщо значення було рівномірно розділене або ненульове в іншому випадку. Таким чином, коли ми робимо RETурну, 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рівномірно ділиться на подвійну суму його цифр, або не дорівнює нулю в іншому випадку.

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

Безголовки:

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

Як бачимо, цим користуються переваги імпліцитних правил C89. Глобальні змінні sі tнеявно оголошуються як ints. (Вони також неявно ініціалізуються на 0, оскільки вони є глобальними, але ми не можемо скористатися цим, якщо хочемо, щоб функція могла бути викликана кілька разів.)

Аналогічно, функція, fприймає один параметр, x,який неявно є an int, і повертає an 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

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

Математика, 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

Хаскелл , 49 байт

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

Використання

f 80

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

Java , 66 байт

-1 байт завдяки Олів’є

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

Недоліковані та пояснення:

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

Mini-Flak, 296 292 байт

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

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

Посилання TIO має більше коментарів від мене, тому частково простіше читати.

Truthy / Falsey: Truthy (ділиться), якщо друге число дорівнює третьому номеру, фальшиво інакше. Таким чином, і набір правдивих, і фальшивих нескінченний, але я вважаю, що це слід дозволити. +10 байт, якщо це не так.

Примітка: Вхідні / кінцеві нові рядки / пробіли не вводяться.