Cho một dương nguyên như đầu vào, nhiệm vụ của bạn là để ra một giá trị truthy nếu số là chia hết cho bằng cú đúp của tổng các chữ số của nó, và một giá trị falsy khác ( OEIS A134516 ). Nói cách khác:

(sum_of_digits)*2 | number

• Thay vì các giá trị trung thực / giả cho các trường hợp đúng và sai, thay vào đó bạn có thể chỉ định bất kỳ bộ giá trị hữu hạn nào cho trường hợp đúng / sai và bổ sung cho các giá trị khác. Đối với một ví dụ đơn giản, bạn có thể sử dụng 0cho trường hợp đúng và tất cả các số khác cho trường hợp sai (hoặc ngược lại, nếu bạn muốn).

• Quy tắc đầu vào và đầu ra tiêu chuẩn được áp dụng. Lỗ hổng mặc định cũng được áp dụng.

• Bạn có thể lấy đầu vào là một số nguyên hoặc làm đại diện chuỗi của số nguyên đó.

• Đây là mã golf , do đó mã ngắn nhất tính bằng byte sẽ thắng!

• Tôi chưa quen với PPCG, vì vậy tôi muốn bạn đăng một lời giải thích nếu có thể.

Các trường hợp thử nghiệm

Đầu vào - Đầu ra - (Lý do)

80 - Sự thật - (16 chia 80)
100 - Sự thật - (2 chia 100)
60 - Sự thật - (12 chia 60)
18 - Sự thật - (18 chia 18)
12 - Sự thật - (6 chia 12)

4 - Falsy - (8 không chia 4)
8 - Falsy - (16 không chia 8)
16 - Falsy - (14 không chia 16)
21 - Falsy - (6 không chia 21)
78 - Falsy - (30 không chia 78)
110 - Falsy - (4 không giảm 110)
111 - Falsy - (6 không chia 111)
390 - Falsy - (24 không chia 390)

Neim , 3 byte

𝐬ᚫ𝕞

Giải trình:

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

Hãy thử trực tuyến!

Phiên bản chi tiết

JavaScript (ES6), 31 29 27 byte

Đưa đầu vào dưới dạng một chuỗi. Trả về số 0 cho giá trị trung thực và số không cho giá trị giả.

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

Đã bình luận

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

Các trường hợp thử nghiệm

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 byte

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

Phiên bản đầy đủ / được định dạng:

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

Võng mạc , 38 27 byte

-11 byte và đã sửa lỗi với mã nhờ @MartinEnder

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

Hãy thử trực tuyến!

In 1 nếu chia hết, 0 nếu không

Giải thích (hy vọng tôi hiểu đúng)

$
$_¶$_

Nối toàn bộ đầu vào, cộng với một dòng mới, cộng với đầu vào một lần nữa

.+$|.
$*

Chuyển đổi từng trận đấu thành đơn nguyên (toàn bộ dòng thứ hai là đầu vào ban đầu hoặc từng chữ số trong dòng đầu tiên)

^(.+)¶\1+$

Kiểm tra xem dòng đầu tiên (tổng số có hai chữ số) có phải là ước của dòng thứ hai không

MATL , 7 byte

tV!UsE\

Đầu ra 0nếu chia hết, số nguyên dương khác. Cụ thể, nó xuất ra phần còn lại của việc chia số cho hai lần tổng các chữ số của nó.

Hãy thử trực tuyến!

Giải trình

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 byte

-1 byte nhờ Okx

SO·Ö

Hãy thử trực tuyến!

Bạn cũng có thể loại bỏ cuối cùng để lấy 0 cho sự thật và một cái gì đó khác cho kết quả sai chỉ dẫn đến 3 byte nhưng với tôi điều đó dường như không phù hợp với định nghĩa.

Giải trình

SO·Ö
SO    # Separate the digits and sum them
  ·   # Multiply the result by two
   Ö  # Is the input divisible by the result?

Mã máy x86-64, 24 byte

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

Đoạn mã trên xác định một hàm trong mã máy 64 bit x86 để xác định xem giá trị đầu vào có chia hết cho gấp đôi tổng các chữ số của nó hay không. Hàm này tuân theo quy ước gọi AMD64 của System V, do đó nó có thể gọi được từ hầu hết mọi ngôn ngữ, giống như là chức năng C.

Nó nhận một tham số duy nhất làm đầu vào thông qua thanh EDIghi, theo quy ước gọi, là số nguyên để kiểm tra. (Điều này được giả định là một tích cực số nguyên, phù hợp với các quy tắc thách thức, và là cần thiết cho CDQgiảng dạy, chúng tôi sử dụng để làm việc một cách chính xác.)

Nó trả về kết quả của nó trong thanh EAXghi, một lần nữa, theo quy ước gọi. Kết quả sẽ là 0 nếu giá trị đầu vào là chia hết cho tổng các chữ số của nó, và không-zero khác. (Về cơ bản, một Boolean nghịch đảo, giống hệt như ví dụ được đưa ra trong các quy tắc thử thách.)

Nguyên mẫu C của nó sẽ là:

int DivisibleByDoubleSumOfDigits(int value);

Dưới đây là các hướng dẫn ngôn ngữ lắp ráp không được chỉnh sửa, được chú thích với một lời giải thích ngắn gọn về mục đích của mỗi hướng dẫn:

; 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

Trong khối đầu tiên, chúng tôi thực hiện một số khởi tạo sơ bộ của các thanh ghi:

• PUSH+ POPhướng dẫn được sử dụng như một cách chậm nhưng ngắn để khởi tạo ESIthành 10. Điều này là cần thiết bởi vì DIVhướng dẫn trên x86 yêu cầu một toán hạng đăng ký. (Không có hình thức nào chia cho giá trị ngay lập tức của, giả sử, 10.)
• XORđược sử dụng như một cách ngắn và nhanh chóng để xóa ECXsổ đăng ký. Thanh ghi này sẽ đóng vai trò là "bộ tích lũy" bên trong vòng lặp sắp tới.
• Cuối cùng, một bản sao của giá trị đầu vào (từ EDI) được tạo ra và được lưu trữ trong EAXđó sẽ bị ghi đè khi chúng ta đi qua vòng lặp.

Sau đó, chúng tôi bắt đầu lặp và tổng hợp các chữ số trong giá trị đầu vào. Điều này dựa trên lệnh x86 DIV, chia EDX:EAXcho toán hạng của nó và trả về thương số trong EAXvà phần còn lại trong EDX. Những gì chúng ta sẽ làm ở đây là chia giá trị đầu vào cho 10, sao cho phần còn lại là chữ số ở vị trí cuối cùng (chúng ta sẽ thêm vào thanh ghi tích lũy của mình, ECX) và thương số là các chữ số còn lại.

• Các CDQhướng dẫn là một cách ngắn thiết EDXđể 0. Nó thực sự đăng ký mở rộng giá trị trong EAXđể EDX:EAX, đó là những gì DIVsử dụng như số bị chia. Chúng tôi thực sự không cần phần mở rộng đăng nhập ở đây, vì giá trị đầu vào không được ký, nhưng CDQlà 1 byte, trái ngược với việc sử dụng XORđể xóa EDX, sẽ là 2 byte.
• Sau đó, chúng tôi DIVide EDX:EAXbởi ESI(10).
• Phần còn lại ( EDX) được thêm vào bộ tích lũy ( ECX).
• Thanh EAXghi (thương số) được kiểm tra để xem nó có bằng 0. Nếu vậy, chúng tôi đã thực hiện thông qua tất cả các chữ số và chúng tôi rơi qua. Nếu không, chúng ta vẫn có nhiều chữ số để tính tổng, vì vậy chúng ta quay lại đầu vòng lặp.

Cuối cùng, sau khi vòng lặp kết thúc, chúng tôi thực hiện number % ((sum_of_digits)*2):

• Các LEAhướng dẫn được sử dụng như một cách ngắn để nhân ECXbởi 2 (hoặc tương đương, thêm ECXvào chính nó), và lưu trữ kết quả trong một thanh ghi khác nhau (trong trường hợp này, EAX).

  ^{(Chúng tôi cũng có thể đã thực hiện add ecx, ecx+ xchg ecx, eax; cả hai đều là 3 byte, nhưng LEAhướng dẫn nhanh hơn và điển hình hơn.)}

• Sau đó, chúng tôi làm một CDQlần nữa để chuẩn bị cho sự phân chia. Bởi vì EAXsẽ là tích cực (tức là không dấu), điều này có tác dụng của zeroing EDX, giống như trước đây.
• Tiếp theo là sự phân chia, lần này chia EDX:EAXcho giá trị đầu vào (một bản sao không bị biến dạng vẫn còn tồn tại EDI). Điều này tương đương với modulo, với phần còn lại trong EDX. (Thương số cũng được đưa vào EAX, nhưng chúng tôi không cần nó.)
• Cuối cùng, chúng tôi XCHG(trao đổi) nội dung của EAXvà EDX. Thông thường, bạn sẽ làm MOVở đây, nhưng XCHGchỉ 1 byte (mặc dù chậm hơn). Vì EDXchứa phần còn lại sau khi chia, nó sẽ là 0 nếu giá trị chia đều hoặc khác không. Do đó, khi chúng ta khởi động RET, EAX(kết quả) là 0 nếu giá trị đầu vào chia hết cho gấp đôi tổng các chữ số của nó, hoặc khác không.

Hy vọng rằng đủ cho một lời giải thích.
Đây không phải là mục ngắn nhất, nhưng này, có vẻ như nó đánh bại hầu hết các ngôn ngữ không chơi gôn! :-)

Japt , 7 4 byte

Đưa đầu vào dưới dạng một chuỗi. Các đầu ra 0cho truehoặc một số lớn hơn 0cho false, từ các giải pháp khác, dường như là hợp lệ. Nếu không, hãy cho tôi biết và tôi sẽ quay lại.

%²¬x

Kiểm tra nó

Giải trình

Đầu vào ngầm định của chuỗi U.
"390"

²

Lặp lại Uhai lần.
"390390"

¬

Chia thành mảng các ký tự riêng lẻ.
["3","9","0","3","9","0"]

x

Giảm bằng cách tính tổng, tự động chuyển từng ký tự thành một số nguyên trong quy trình.
24

%

Lấy phần còn lại của chia Ucho kết quả, cũng tự động truyền Utới một số nguyên trong quy trình. Ngẫu nhiên xuất số nguyên kết quả.
6 (=false)

C89, 55 53 byte

^{(Cảm ơn Steadybox!}

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

Nó nhận một đầu vào duy nhất x, đó là giá trị để kiểm tra. Nó trả về 0 nếu xchia hết cho hai lần tổng các chữ số của nó, hoặc khác không.

Hãy thử trực tuyến!

Ung dung:

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

Như bạn có thể thấy, điều này tận dụng các quy tắc ngầm của C89. Các biến toàn cục svà tđược khai báo ngầm là ints. (Chúng cũng được khởi tạo ngầm thành 0 vì chúng là toàn cầu, nhưng chúng ta không thể tận dụng lợi thế này nếu chúng ta muốn hàm có thể gọi được nhiều lần.)

Tương tự, hàm, flấy một tham số duy nhất, x,hoàn toàn là một tham số intvà nó trả về một int.

Mã bên trong hàm khá đơn giản, mặc dù forvòng lặp sẽ trông cực kỳ lạ nếu bạn không quen với cú pháp. Về cơ bản, một fortiêu đề vòng lặp trong C chứa ba phần:

for (initialization; loop condition; increment)

Trong phần "khởi tạo", chúng tôi đã khởi tạo các biến toàn cục của mình. Điều này sẽ chạy một lần, trước khi vòng lặp được nhập.

Trong phần "điều kiện vòng lặp", chúng tôi đã chỉ định điều kiện nào vòng lặp sẽ tiếp tục. Điều này nhiều nên được rõ ràng.

Trong phần "gia tăng", về cơ bản chúng tôi đã đặt mã tùy ý, vì mã này sẽ chạy ở cuối mỗi vòng lặp.

Mục đích lớn hơn của vòng lặp là lặp qua từng chữ số trong giá trị đầu vào, thêm chúng vào s. Cuối cùng, sau khi vòng lặp kết thúc, sđược nhân đôi và lấy modulo xđể xem nó có chia hết không. (Một lời giải thích tốt hơn, chi tiết hơn về logic ở đây có thể được tìm thấy trong câu trả lời khác của tôi , dựa trên câu trả lời này.)

Phiên bản có thể đọc được của con người:

int f(int x)
{
    int temp = x;
    int sum  = 0;
    while (temp > 0)
    {
        sum  += temp % 10;
        temp /= 10;
    }
    return x % (sum * 2);
}

Brachylog , 8 byte

ẹ+×₂;I×?

Hãy thử trực tuyến!

Giải trình

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

Python 2 , 34 32 byte

-2 byte nhờ @Rod

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

Hãy thử trực tuyến!

Toán học, 26 byte

(2Tr@IntegerDigits@#)∣#&

Không có lý do tại sao ∣có độ ưu tiên cao hơn phép nhân ...

PHP , 41 byte

in số 0 nếu chia hết, số nguyên dương khác.

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

Hãy thử trực tuyến!

Excel, 63 byte

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

Các chữ số tổng hợp là bit dài.

Perl 6 , 19 byte

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

Hãy thử trực tuyến!

Husk , 9 8 byte

Cảm ơn Leo vì đã tiết kiệm 1 byte.

Ṡ¦ȯ*2ṁis

Hãy thử trực tuyến!

Giải trình

Ṡ¦ȯ         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 byte

Cảm ơn Zgarb vì đã chơi golf 1 byte

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

Hãy thử trực tuyến!

Lấy đầu vào dưới dạng một chuỗi; trả về 0 nếu chia hết và khác không.

Python 3, 35 byte

lambda a:a%(sum(map(int,str(a)))*2)

TI-BASIC, 27 26 21 byte

-5 cảm ơn @Oki

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

Điều này được thực hiện phức tạp hơn bởi thực tế là không có cách nào ngắn gọn để tính tổng các chữ số nguyên trong TI-BASIC . Lợi nhuận 0cho True, và một số khác nhau cho False.

Giải trình:

: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 byte

VR.Mvd&+2*c%

Hãy thử trực tuyến!

Đầu ra 0 cho sự thật, bất kỳ số nào khác cho falsey.

Giải trình

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 byte

vUì x*2

Trả lại 1cho true, 0chofalse

Hãy thử trực tuyến!

Giải trình

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 byte

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

Sử dụng

f 80

Hãy thử trực tuyến!

Java , 66 byte

-1 byte nhờ Olivier

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

Ung dung & giải thích:

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 byte

0 chỉ sự thật, nonzero chỉ sự giả dối.

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

Giải trình

        "."0@":  convert to list of digits
  [:+/2#         sum 2 copies of the list ([: forces monadic phrase)
|~               residue of sum divided by argument?

Ồ , 5 byte

D}Σd¥

Hãy thử trực tuyến!

tcl, 45

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

bản giới thiệu

Haskell , 35 34 byte

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

Hãy thử trực tuyến!

Trả về '0' trong trường hợp thực, phần còn lại nếu không.

Haskell , phiên bản miễn phí của nimi, 34 byte

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

Hãy thử trực tuyến!

PHP, 44 byte

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

Chạy như thế này:

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

Giải trình

Lặp lại các chữ số để tính tổng, sau đó đưa ra modulo giống như hầu hết các câu trả lời.

Java (OpenJDK 8) , 55 53 byte

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

Hãy thử trực tuyến!

Giá trị trả về 0có nghĩa là trung thực, bất cứ điều gì khác có nghĩa là giả.

Vì nhận xét của tôi trong câu trả lời của Okx không bị gợn, tôi đã xóa nó và đăng nó dưới dạng câu trả lời này, chơi gôn nhiều hơn một chút.

Chơi golf thêm nhờ @KrzysztofCichocki và @Laikoni, người đã cho tôi thấy một cách đúng đắn tôi không cần phải trả lời một giá trị trung thực / giả dối, nhưng bất kỳ giá trị nào miễn là tôi mô tả kết quả.

Mini-Flak, 296 292 byte

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

Hãy thử trực tuyến!

Liên kết TIO có nhiều nhận xét từ tôi hơn, vì vậy nó dễ đọc hơn một phần.

Truthy / Falsey: Truthy (chia hết) nếu số thứ hai bằng số thứ ba, giả là khác. Vì vậy, cả bộ trung thực và giả đều là vô hạn, nhưng tôi cho rằng điều đó nên được cho phép. +10 byte nếu không.

Lưu ý: Không cho phép các dòng mới / dấu trắng hàng đầu / dấu trắng trong đầu vào.