Diberikan bilangan bulat positif sebagai input, tugas Anda adalah menampilkan nilai kebenaran jika angka tersebut dapat dibagi dengan dua kali lipat dari jumlah digitnya, dan nilai palsu sebaliknya ( OEIS A134516 ). Dengan kata lain:

(sum_of_digits)*2 | number

• Alih-alih nilai true / falsy untuk kasus benar dan salah, Anda dapat menentukan set nilai terbatas untuk kasus benar / salah, dan melengkapi nilai-nilai lainnya. Untuk contoh sederhana, Anda dapat menggunakan 0untuk case nyata dan semua angka lain untuk case palsu (atau sebaliknya, jika Anda suka).

• Aturan input dan output standar berlaku. Celah Default juga berlaku.

• Anda dapat mengambil input sebagai integer atau sebagai representasi string dari integer itu.

• Ini adalah kode-golf , maka kode terpendek dalam byte menang!

• Saya baru mengenal PPCG, jadi saya ingin Anda memposting penjelasan jika memungkinkan.

Uji Kasus

Input - Output - (Alasan)

80 - Truthy - (16 membagi 80)
100 - Truthy - (2 membagi 100)
60 - Truthy - (12 membagi 60)
18 - Truthy - (18 membagi 18)
12 - Truthy - (6 membagi 12)

4 - Falsy - (8 tidak membagi 4)
8 - Falsy - (16 tidak membagi 8)
16 - Falsy - (14 tidak membagi 16)
21 - Falsy - (6 tidak membagi 21)
78 - Falsy - (30 tidak membagi 78)
110 - Falsy - (4 tidak dide 110)
111 - Falsy - (6 tidak membagi 111)
390 - Falsy - (24 tidak membagi 390)

Neim , 3 byte

𝐬ᚫ𝕞

Penjelasan:

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

Cobalah online!

Versi terperinci

JavaScript (ES6), 31 29 27 byte

Mengambil input sebagai string. Mengembalikan nol untuk kebenaran dan bukan nol untuk kepalsuan.

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

Berkomentar

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

Uji kasus

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

Versi Lengkap / Terformat:

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 byte

-11 byte dan memperbaiki kesalahan dengan kode terima kasih kepada @MartinEnder

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

Cobalah online!

Mencetak 1 jika dapat dibagi, 0 sebaliknya

Penjelasan (saya harap ini benar)

$
$_¶$_

Tambahkan seluruh input, plus baris baru, ditambah input lagi

.+$|.
$*

Mengonversi setiap kecocokan menjadi unary (baik seluruh baris kedua yang merupakan input asli, atau setiap digit di baris pertama)

^(.+)¶\1+$

Periksa apakah baris pertama (jumlah digit dua kali lipat) adalah pembagi dari baris kedua

MATL , 7 byte

tV!UsE\

Keluaran 0jika dapat dibagi, bilangan bulat positif sebaliknya. Secara khusus, ini mengeluarkan sisa dari membagi angka dengan dua kali jumlah digitnya.

Cobalah online!

Penjelasan

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 terima kasih kepada Okx

SO·Ö

Cobalah online!

Anda juga dapat menghapus Ö terakhir untuk mendapatkan 0 untuk truey dan sesuatu yang lain untuk falsy yang hanya menghasilkan 3 byte tetapi bagi saya yang sepertinya tidak sesuai dengan definisi.

Penjelasan

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

x86-64 Kode Mesin, 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

Kode di atas mendefinisikan fungsi dalam kode mesin x86 64-bit yang menentukan apakah nilai input dapat dibagi dengan menggandakan jumlah digitnya. Fungsi ini sesuai dengan konvensi pemanggilan System V AMD64, sehingga dapat dipanggil dari hampir semua bahasa, sama seperti fungsi C.

Dibutuhkan parameter tunggal sebagai input melalui EDIregister, sesuai dengan konvensi pemanggilan, yang merupakan bilangan bulat untuk diuji. (Ini dianggap bilangan bulat positif , konsisten dengan aturan tantangan, dan diperlukan untuk CDQinstruksi yang kami gunakan untuk bekerja dengan benar.)

Ini mengembalikan hasilnya dalam EAXregister, sekali lagi, sesuai dengan konvensi pemanggilan. Hasilnya akan 0 jika nilai masukan adalah dibagi dengan jumlah digit, dan non-nol sebaliknya. (Pada dasarnya, Boolean terbalik, persis seperti contoh yang diberikan dalam aturan tantangan.)

Prototipe C-nya adalah:

int DivisibleByDoubleSumOfDigits(int value);

Berikut adalah instruksi bahasa majelis yang tidak diseragamkan, dijelaskan dengan penjelasan singkat tentang tujuan dari setiap instruksi:

; 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

Di blok pertama, kami melakukan beberapa inisialisasi awal register:

• PUSH+ POPinstruksi digunakan sebagai cara lambat tapi pendek untuk menginisialisasi ESIke 10. Ini diperlukan karena DIVinstruksi pada x86 memerlukan operan register. (Tidak ada bentuk yang membelah dengan nilai langsung, katakanlah, 10.)
• XORdigunakan sebagai cara singkat dan cepat untuk menghapus ECXregister. Register ini akan berfungsi sebagai "akumulator" di dalam loop yang akan datang.
• Akhirnya, salinan nilai input (dari EDI) dibuat, dan disimpan EAX, yang akan musnah saat kita melewati loop.

Kemudian, kita mulai mengulang dan menjumlahkan digit dalam nilai input. Ini didasarkan pada DIVinstruksi x86 , yang membaginya EDX:EAXdengan operandnya, dan mengembalikan hasil bagi EAXdan sisanya masuk EDX. Apa yang akan kita lakukan di sini adalah membagi nilai input dengan 10, sehingga sisanya adalah digit di tempat terakhir (yang akan kita tambahkan ke register akumulator kami, ECX), dan hasil bagi adalah digit yang tersisa.

• The CDQinstruksi adalah cara singkat pengaturan EDXke 0. Ini sebenarnya tanda-meluas nilai dalam EAXuntuk EDX:EAX, yang adalah apa yang DIVmenggunakan sebagai dividen. Kami sebenarnya tidak perlu ekstensi-tanda di sini, karena nilai input tidak ditandatangani, tetapi CDQ1 byte, sebagai lawan menggunakan XORuntuk menghapus EDX, yang akan menjadi 2 byte.
• Lalu kami DIVide EDX:EAXdengan ESI(10).
• Sisa ( EDX) ditambahkan ke akumulator ( ECX).
• The EAXregister (hasil bagi) diuji untuk melihat apakah itu adalah sama dengan 0. Jika demikian, kita telah berhasil melewati semua angka dan kami jatuh. Jika tidak, kami masih memiliki lebih banyak digit untuk dijumlahkan, jadi kami kembali ke atas loop.

Akhirnya, setelah loop selesai, kami menerapkan number % ((sum_of_digits)*2):

• The LEAinstruksi digunakan sebagai cara singkat untuk kalikan ECXdengan 2 (atau, sama, menambahkan ECXuntuk dirinya sendiri), dan menyimpan hasilnya dalam register yang berbeda (dalam hal ini, EAX).

  ^{(Kami juga bisa melakukan add ecx, ecx+ xchg ecx, eax; keduanya 3 byte, tetapi LEAinstruksi lebih cepat dan lebih khas.)}

• Kemudian, kami melakukan CDQlagi untuk mempersiapkan pembagian. Karena EAXakan positif (yaitu, tidak ditandatangani), ini memiliki efek zeroing EDX, seperti sebelumnya.
• Berikutnya adalah divisi, kali ini membaginya EDX:EAXdengan nilai input (salinan tanpa gangguan yang masih berada di dalamnya EDI). Ini setara dengan modulo, dengan sisanya dalam EDX. (Hasil bagi juga dimasukkan EAX, tetapi kami tidak membutuhkannya.)
• Akhirnya, kami XCHG(bertukar) isi EAXdan EDX. Biasanya, Anda akan melakukannya di MOVsini, tetapi XCHGhanya 1 byte (walaupun lebih lambat). Karena EDXberisi sisa setelah pembagian, itu akan menjadi 0 jika nilainya dibagi rata atau tidak nol. Jadi, ketika kita RETurn, EAX(hasilnya) adalah 0 jika nilai input dibagi dengan dua kali lipat jumlah digitnya, atau bukan nol.

Semoga cukup untuk penjelasan.
Ini bukan entri terpendek, tapi hei, sepertinya itu mengalahkan hampir semua bahasa non-golf! :-)

Japt , 7 4 byte

Mengambil input sebagai string. Output 0untuk trueatau angka yang lebih besar daripada 0untuk false, yang, dari solusi lain, akan tampak valid. Jika tidak, beri tahu saya dan saya akan mengembalikannya.

%²¬x

Menguji

Penjelasan

Input string yang tersirat U.
"390"

²

Ulangi Udua kali.
"390390"

¬

Pisahkan ke berbagai karakter individu.
["3","9","0","3","9","0"]

x

Kurangi dengan menjumlahkan, secara otomatis casting setiap karakter ke integer dalam proses.
24

%

Dapatkan sisa pembagian Udengan hasilnya, juga secara otomatis melakukan casting Uke integer dalam proses. Secara implisit mengeluarkan bilangan bulat yang dihasilkan.
6 (=false)

C89, 55 53 byte

^{(Terima kasih kepada Steadybox!}

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

Dibutuhkan satu input x,, yang merupakan nilai untuk diuji. Mengembalikan 0 jika xhabis dibagi dua kali lipat dari jumlah digitnya, atau bukan nol.

Cobalah online!

Tidak Disatukan:

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

Seperti yang Anda lihat, ini memanfaatkan aturan implisit-int C89. Variabel global sdan tsecara implisit dinyatakan sebagai ints. (Mereka secara implisit diinisialisasi ke 0 karena mereka adalah global, tetapi kita tidak dapat mengambil keuntungan dari ini jika kita ingin fungsi tersebut dapat dipanggil beberapa kali.)

Demikian pula, fungsi,, fmengambil parameter tunggal, x,yang secara implisit merupakan int, dan mengembalikan sebuah int.

Kode di dalam fungsi ini cukup mudah, meskipun forloop akan terlihat sangat aneh jika Anda tidak terbiasa dengan sintaks. Pada dasarnya, forheader loop di C berisi tiga bagian:

for (initialization; loop condition; increment)

Di bagian "inisialisasi", kami telah menginisialisasi variabel global kami. Ini akan berjalan sekali, sebelum loop dimasukkan.

Di bagian "kondisi loop", kami telah menentukan pada kondisi apa loop harus dilanjutkan. Sebanyak ini harus jelas.

Di bagian "kenaikan", pada dasarnya kami telah meletakkan kode arbitrer, karena ini akan berjalan di akhir setiap loop.

Tujuan yang lebih besar dari loop adalah untuk mengulangi setiap digit pada nilai input, menambahkannya ke s. Akhirnya, setelah loop selesai, sdigandakan dan diambil modulo xuntuk melihat apakah itu dapat dibagi secara merata. (Penjelasan logika yang lebih baik dan lebih terperinci di sini dapat ditemukan dalam jawaban saya yang lain , yang menjadi dasar jawaban ini.)

Versi yang bisa dibaca manusia:

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×?

Cobalah online!

Penjelasan

ẹ+           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 terima kasih kepada @Rod

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

Cobalah online!

Mathematica, 26 byte

(2Tr@IntegerDigits@#)∣#&

Tidak ada petunjuk mengapa ∣memiliki prioritas lebih tinggi dari pada perkalian ...

PHP , 41 byte

mencetak nol jika habis, bilangan bulat positif sebaliknya.

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

Cobalah online!

Excel, 63 byte

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

Penjumlahan digit adalah bit yang panjang.

Perl 6 , 19 byte

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

Cobalah online!

Sekam , 9 8 byte

Terima kasih kepada Leo karena telah menghemat 1 byte.

Ṡ¦ȯ*2ṁis

Cobalah online!

Penjelasan

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

Terima kasih kepada Zgarb karena bermain golf dengan 1 byte

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

Cobalah online!

Mengambil input sebagai string; mengembalikan 0 jika dapat dibagi dan bukan nol sebaliknya.

Python 3, 35 byte

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

TI-BASIC, 27 26 21 byte

Terima kasih kepada @Oki

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

Ini dibuat lebih rumit oleh fakta bahwa tidak ada cara ringkas untuk menjumlahkan angka integer dalam TI-BASIC . Pengembalian 0untuk True, dan nomor berbeda untuk False.

Penjelasan:

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

Cobalah online!

Output 0 untuk truey, angka lain untuk falsey.

Penjelasan

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

Pengembalian 1untuk true, 0untukfalse

Cobalah online!

Penjelasan

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 Bytes

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

Pemakaian

f 80

Cobalah online!

Jawa , 66 byte

-1 byte terima kasih kepada Olivier

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

Tidak digabungkan & penjelasan:

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 menunjukkan kebenaran, bukan nol menunjukkan kepalsuan.

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

Penjelasan

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

Ohm , 5 byte

D}Σd¥

Cobalah online!

tcl, 45

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

demo

Haskell , 35 34 byte

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

Cobalah online!

Mengembalikan '0' dalam kasus sebenarnya, sisanya sebaliknya.

Haskell , edisi pointfree oleh nimi, 34 byte

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

Cobalah online!

PHP, 44 byte

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

Jalankan seperti ini:

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

Penjelasan

Iterate atas digit untuk menghitung total, kemudian output modulo seperti kebanyakan jawaban.

Java (OpenJDK 8) , 55 53 byte

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

Cobalah online!

Nilai balik 0berarti jujur, yang lain berarti palsu.

Karena komentar saya dalam jawaban Okx tidak membuat riak, saya menghapusnya dan mempostingnya sebagai jawaban ini, bahkan sedikit lebih golf.

Lebih lanjut bermain golf berkat @KrzysztofCichocki dan @Laikoni yang menunjukkan kepada saya bahwa saya tidak perlu menjawab nilai kebenaran / kepalsuan, tetapi nilai apa pun selama saya menggambarkan hasilnya.

Mini-Flak, 296 292 byte

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

Cobalah online!

TIO link memiliki lebih banyak komentar dari saya, sehingga sebagian lebih mudah dibaca.

Truthy / Falsey: Truthy (habis dibagi) jika angka kedua sama dengan angka ketiga, sebaliknya falsy. Jadi perangkat kebenaran dan kepalsuan tidak terbatas, tetapi saya kira itu harus diizinkan. +10 byte jika tidak.

Catatan: Leading / trailing newlines / spasi putih tidak diizinkan dalam input.