Girdi olarak pozitif bir tamsayı verildiğinde , göreviniz, sayı hanelerin toplamının iki katı ile bölünebiliyorsa , bir asi değeri, aksi takdirde sahte bir değer vermektir ( OEIS A134516 ). Başka bir deyişle:

(sum_of_digits)*2 | number

• Doğru ve yanlış durumlar için truthy / falsy değerleri yerine, bunun yerine doğru / yanlış durum için sonlu bir değer kümesini belirtebilir ve diğer değerleri tamamlayabilirsiniz. Basit bir örnek olarak, 0gerçek durum için ve yanlış durum için diğer tüm sayıları kullanabilirsiniz (veya isterseniz tam tersi).

• Standart giriş ve çıkış kuralları geçerlidir. Varsayılan Loopholes da uygulanır.

• Girdiyi bir tamsayı olarak veya o tamsayıya ait dize temsili olarak alabilirsiniz.

• Bu kod-golf , dolayısıyla bayttaki en kısa kod kazanır!

• PPCG'de yeniyim, bu yüzden mümkünse bir açıklama göndermenizi istiyorum.

Test Kılıfları

Giriş - Çıkış - (Sebep)

80 - Gerçek - (16 bölü 80)
100 - Gerçek - - (2 100 bölü)
60 - Gerçeği - (12 bölü 60)
18 - Gerçek - (18 18 bölü)
12 - Gerçeği - (6 bölü 12)

4 - Falsy - (8 4'ü bölmez)
8 - Falsy - (16 8'i bölmez)
16 - Falsy - (14, 16'yı bölmez)
21 - Falsy - (6 21'i bölmez)
78 - Falsy - (30 bölünmez 78)
110 - Falsy - (4 110 ölmez)
111 - Falsy - (6, 111'i bölmez)
390 - Falsy - (24 390'u bölmez)

Neim , 3 bayt

𝐬ᚫ𝕞

Açıklama:

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

Çevrimiçi deneyin!

Detaylı versiyon

JavaScript (ES6), 31 29 27 bayt

Bir dize olarak girdi alır. Hakikat için sıfır, sıfır olmayan sıfır için döndürür.

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

Yorumlananlar

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

Test durumları

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 bayt

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

Tam / Biçimli sürüm:

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 bayt

-11 bayt ve @MartinEnder sayesinde kod ile ilgili bir hata düzeltildi

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

Çevrimiçi deneyin!

Bölünebilirse 1, aksi takdirde 0 yazdırır

Açıklama (umarım bu hakkı almışımdır)

$
$_¶$_

Tüm girişi, yeni bir satır ekini ve tekrar girişi ekler

.+$|.
$*

Her eşleşmeyi tek tek dönüştürür (orijinal giriş olan tüm ikinci satırın tamamı veya ilk satırdaki her hane)

^(.+)¶\1+$

İlk satırın (iki haneli rakam toplamı) ikinci satırın böleni olup olmadığını kontrol edin

MATL , 7 bayt

tV!UsE\

0Bölünebilir ise çıkışlar , aksi takdirde pozitif tamsayı Spesifik olarak, sayıyı, sayılarının toplamının iki katı ile bölmenin geri kalan kısmını çıkarır.

Çevrimiçi deneyin!

açıklama

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 bayt

Okx sayesinde -1 bayt

SO·Ö

Çevrimiçi deneyin!

Ayrıca son Ö'yü, sadece 3 byte ile sonuçlanan, sadece gerçeğe uygunluk için 0, sahte için başka bir şey elde etmek için kaldırabilirsiniz.

açıklama

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

x86-64 Makine Kodu, 24 bayt

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

Yukarıdaki kod, 64-bit x86 kodunda, giriş değerinin rakamlarının toplamının iki katına bölünebilir olup olmadığını belirleyen bir işlevi tanımlar. İşlev, System V AMD64 çağrı kuralına uygundur, böylece tıpkı bir C işlevimiş gibi hemen hemen her dilden çağrılabilir.

EDITest edilecek tamsayı olan arama kuralına göre, yazmaç üzerinden giriş olarak tek bir parametre alır . (Bunun, meydan okuma kurallarına uygun, pozitif bir tamsayı olduğu varsayılır ve CDQkullandığımız talimatın doğru çalışması için gereklidir .)

EAXArama sözleşmesine göre, sonucunu kayıt defterinde tekrar verir. Girdi değeri , rakamlarının toplamı ile bölünebiliyorsa , sonuç 0 olur, aksi takdirde sıfır değildir. (Temel olarak, tam olarak kural kurallarında verilen örnekte olduğu gibi, ters bir Boolean.)

C prototipi şöyle olurdu:

int DivisibleByDoubleSumOfDigits(int value);

Her bir talimatın amacını kısa bir açıklama ile açıklanmış olan asılsız montaj dili talimatları şunlardır:

; 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

İlk blokta, bazı kayıtların ilk başlangıçlarını yaparız:

• PUSH+ POPkomutları ESI10'a başlatmak için yavaş ama kısa bir yol olarak kullanılır . Bu gereklidir, çünkü DIVx86'daki komut bir kayıt operand'ı gerektirir. (Derhal 10 gibi bir değere bölünen bir form yoktur.)
• XORECXyazmacı temizlemek için kısa ve hızlı bir yol olarak kullanılır . Bu kayıt, gelecek döngünün içindeki "akümülatör" olarak görev yapacak.
• Son olarak, giriş değerinin bir kopyasından (from EDI) üretilir ve saklanır EAX, ki bu döngüden geçerken gizlenir.

Ardından, girilen değerdeki ilmekleri ve rakamları toplamaya başlarız. Bu, DIVişlecine EDX:EAXgöre bölen EAXve kalan kısmı içeri giren bölümü döndüren x86 komutuna dayanır EDX. Burada yapacağımız şey, giriş değerini 10'a bölmek, kalanı en sondaki basamak (akümülatör kayıt defterimize ekleyeceğimiz ECXrakam) ve bölüm kalan kalan rakamdır.

• CDQTalimat ayarı kısa yoludur EDXAslında 0'a oturum açma uzanır değeri EAXiçin EDX:EAXne, DIVtemettü olarak kullanır. Burada işaret genişletme CDQişlemine ihtiyacımız yok, çünkü giriş değeri işaretsiz, ancak XORtemizleme işleminin tersine EDX2 bayt olan 1 bayt.
• Sonra DIVide EDX:EAXtarafından ESI(10).
• Kalan ( EDX) aküye ( ) eklenir ECX.
• EAXRegister (bölüm) bu yüzden biz tüm basamakları bunu başardı ve biz yoluyla düşerse o 0'a eşit olup olmadığını görmek için test edilir. Değilse, toplayacağımız rakamların sayısı hala fazla olduğundan, döngünün tepesine geri dönüyoruz.

Son olarak, döngü bittikten sonra aşağıdakileri uygularız number % ((sum_of_digits)*2):

• LEATalimat çarpma kısa yolu olarak kullanılır ECX2'ye göre (eşit biçimde veya eklemek, ECX(bu durumda farklı bir kayıtta kendisine) ve sonucunu saklamak EAX).

  ^{(Ayrıca add ecx, ecx+ yapabilirdik xchg ecx, eax; ikisi de 3 bayttır, ancak LEAkomut daha hızlı ve daha tipiktir.)}

• Daha sonra CDQbölünmeye hazırlanmak için tekrar yaparız . Çünkü EAX(yani imzasız) pozitif olacaktır, bu sıfırlama etkisine sahiptir EDXhemen önce olduğu gibi.
• Bir sonraki bölüm, bu kez EDX:EAXgiriş değerine bölünerek bölünmüş durumda EDI. Bu, geri kalanı ile modulo eşdeğerdir EDX. (Bölüm de belirtildi EAX, ancak buna ihtiyacımız yok.)
• Son olarak, XCHG(değişim) içeriği EAXve EDX. Normalde MOVburada bir şeyler yaparsınız , ancak XCHGsadece 1 bayttır (yavaş da olsa). Çünkü EDXbölme işlemi içerir değeri eşit bölünebilen veya ise, bu 0 olacaktır, aksi takdirde sigara sıfır. Bu nedenle, RETurn'da EAX(sonuç), eğer giriş değeri, rakamlarının toplamı iki katına bölünebilirse veya sıfır değilse, 0 olur.

Umarım bu bir açıklama için yeterlidir.
Bu en kısa giriş değil, ama hey, neredeyse golf oynamayan dillerin hepsini geçiyor! :-)

Japt , 7 4 bayt

Bir dize olarak girdi alır. Çıkışlar 0için trueya büyük bir sayı 0için false, hangi diğer çözümlerden, geçerli gibi görünmektedir. Olmazsa, bilmeme izin ver, geri alırım.

%²¬x

Dene

açıklama

Dizenin örtük girişi U.
"390"

²

Uİki kez tekrarlayın .
"390390"

¬

Tek tek karakter dizisine bölün.
["3","9","0","3","9","0"]

x

Her karakteri otomatik olarak işlemdeki bir tam sayıya dönüştürerek toplayarak azaltın.
24

%

USonuçta bölüştürme, kalanı otomatik olarak Uişlemdeki bir tam sayıya çevirme. Sonuçta elde edilen tamsayıyı örtük olarak verir.
6 (=false)

C89, 55 53 bayt

^{(Steadybox'a teşekkürler!}

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

xTest edilecek değer olan tek bir giriş alır . Eğer 0 döndürür xiki katına basamak toplamı ya da başka şekilde sıfır olmayan bölünemeyen bir.

Çevrimiçi deneyin!

Ungolfed:

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

Gördüğünüz gibi, bu, C89’un gizli int kurallarından yararlanır. Genel değişkenler sve törtük olarak ints olarak bildirilir . (Ayrıca, 0 olarak başlatıldılar çünkü küreseldirler, ancak fonksiyonun birden çok kez çağrılabilir olmasını istiyorsak bundan yararlanamayız.)

Benzer şekilde, işlev, dolaylı olarak bir olan ftek bir parametre alır ve bir döndürür .x,intint

İşlev içindeki kod oldukça basittir, ancak forsözdizimine yabancıysanız , döngü oldukça garip görünecektir. Temel olarak, forC'deki bir döngü başlığı üç bölümden oluşur:

for (initialization; loop condition; increment)

"Başlatma" bölümünde, küresel değişkenlerimizi başlattık. Bu, döngü girilmeden önce bir kez çalışacaktır.

"Döngü koşulu" bölümünde, döngünün hangi koşulda devam etmesi gerektiğini belirledik. Bu çok açık olmalı.

"Artış" bölümünde, temelde rasgele bir kod koyduk, çünkü bu her döngünün sonunda çalışacaktır.

Döngünün daha büyük amacı, giriş değerindeki her bir basamağı tekrarlayarak yinelemektir s. Son olarak, döngü bittikten sonra siki katına çıkar ve xeşit bölünebilir olup olmadığını görmek için modulo alınır . (Buradaki mantığın daha iyi, daha ayrıntılı bir açıklaması, bunun dayandığı diğer cevabımda bulunabilir .)

İnsan tarafından okunabilen versiyon:

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

Brachylog , 8 bayt

ẹ+×₂;I×?

Çevrimiçi deneyin!

açıklama

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

Piton 2 , 34 , 32 bayt

@Rod sayesinde -2 bayt

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

Çevrimiçi deneyin!

Mathematica, 26 bayt

(2Tr@IntegerDigits@#)∣#&

Neden ∣çarpımdan daha yüksek önceliğe sahip olduğuna dair hiçbir ipucu yok ...

PHP , 41 bayt

bölünebilir ise sıfır, aksi takdirde pozitif tam sayı yazar.

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

Çevrimiçi deneyin!

Excel, 63 bayt

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

Sayıların toplanması, uzun bittir.

Perl 6 , 19 bayt

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

Çevrimiçi deneyin!

Kabuğu , 9 8 bayt

Leo'ya 1 byte kaydettiğin için teşekkürler.

Ṡ¦ȯ*2ṁis

Çevrimiçi deneyin!

açıklama

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

1 baytlık golf attığı için Zgarb'a teşekkürler

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

Çevrimiçi deneyin!

Bir dize olarak girdi alır; bölünebilir ve sıfır değilse, 0 döndürür.

Python 3, 35 bayt

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

TI-BASIC, 27 26 21 bayt

-5 @Oki sayesinde

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

Bu, TI-BASIC’te tamsayı rakamları toplamanın kısa bir yolu olmadığı gerçeğiyle daha zor hale getirildi . İade 0için Trueve farklı bir numara False.

Açıklama:

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

VR.Mvd&+2*c%

Çevrimiçi deneyin!

Gerçek için 0, falsey için başka herhangi bir sayı.

açıklama

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 bayt

vUì x*2

İade 1için true, 0içinfalse

Çevrimiçi deneyin!

açıklama

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 Bayt

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

kullanım

f 80

Çevrimiçi deneyin!

Java , 66 bayt

Olivier sayesinde -1 bayt

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

Ungolfed ve açıklama:

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 bayt

0, gerçeği, sıfır olmayan, sahtekarlığı gösterir.

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

açıklama

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

Ohm , 5 bayt

D}Σd¥

Çevrimiçi deneyin!

tcl, 45

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

gösteri

Haskell , 35 34 bayt

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

Çevrimiçi deneyin!

Gerçek durumda '0', geri kalanı aksi takdirde döner.

Haskell , nimi'den noktasuz baskı, 34 bayt

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

Çevrimiçi deneyin!

PHP, 44 bayt

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

Bu şekilde koş:

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

açıklama

Toplamı hesaplamak için rakamların üzerinde tekrar eder, daha sonra çoğu cevap gibi modulü verir.

Java (OpenJDK 8) , 55 53 bayt

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

Çevrimiçi deneyin!

Bir geri dönüş değeri 0truthy anlamına gelir, başka bir şey sahte demektir.

Okx'in cevabındaki yorumum dalgalanmadığı için, onu sildim ve bu cevap olarak gönderdim, biraz daha golf oynadım.

Doğru bir şekilde bana gösteren @ KrzysztofCichocki ve @Likonik sayesinde daha fazla golf oynamayı seviyorum.

Mini-Flak, 296 292 bayt

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

Çevrimiçi deneyin!

TIO bağlantısı benden daha fazla yorum içerdiğinden okunması kısmen kolaydır.

Truthy / Falsey: İkinci sayı üçüncü sayıya eşitse Truthy (bölünebilir), aksi takdirde sahte. Yani hem gerçek hem de sahte küme sonsuzdur, ancak buna izin verilmesi gerektiğini düşünüyorum. Eğer değilse +10 bayt.

Not: Önde gelen / izleyen yeni satırlara / boşluklara girmede izin verilmez.