Biorąc pod uwagę dodatnią liczbę całkowitą jako dane wejściowe, Twoim zadaniem jest wyprowadzenie prawdziwej wartości, jeśli liczba jest podzielna przez dwukrotność sumy jej cyfr, a w przeciwnym razie wartość fałszowania ( OEIS A134516 ). Innymi słowy:

(sum_of_digits)*2 | number

• Zamiast wartości prawda / fałsz dla przypadków prawda i fałsz, możesz zamiast tego podać dowolny skończony zestaw wartości dla przypadku prawda / fałsz i uzupełnić je o inne wartości. W prostym przykładzie możesz użyć 0dla prawdziwej wielkości liter i wszystkich innych liczb dla fałszywej wielkości liter (lub odwrotnie, jeśli chcesz).

• Obowiązują standardowe reguły wejścia i wyjścia. Obowiązują również domyślne luki.

• Dane wejściowe można przyjmować jako liczbę całkowitą lub jako ciąg znaków reprezentujący tę liczbę całkowitą.

• To jest golf-golf , stąd wygrywa najkrótszy kod w bajtach!

• Jestem nowy w PPCG, więc chciałbym, abyś opublikował wyjaśnienie, jeśli to możliwe.

Przypadki testowe

Wejście - Wyjście - (Przyczyna)

80 - Prawda - (16 podziałów 80)
100 - Prawda - (2 części 100)
60 - Prawda - (12 podziałów 60)
18 - Prawda - (18 podziałów 18)
12 - Prawda - (6 podziałów 12)

4 - Falsy - (8 nie dzieli 4)
8 - Falsy - (16 nie dzieli 8)
16 - Falsy - (14 nie dzieli 16)
21 - Falsy - (6 nie dzieli 21)
78 - Falsy - (30 nie dzieli 78)
110 - Falsy - (4 nie oznacza 110)
111 - Falsy - (6 nie dzieli 111)
390 - Falsy - (24 nie dzieli 390)

Neim , 3 bajty

𝐬ᚫ𝕞

Wyjaśnienie:

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

Wypróbuj online!

Wersja szczegółowa

JavaScript (ES6), 31 29 27 bajtów

Pobiera dane wejściowe jako ciąg. Zwraca zero dla prawdy i niezerowe dla fałszu.

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

Skomentował

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

Przypadki testowe

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 bajtów

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

Wersja pełna / sformatowana:

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 bajtów

-11 bajtów i naprawiono błąd w kodzie dzięki @MartinEnder

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

Wypróbuj online!

Drukuje 1, jeśli dzieli, 0 w przeciwnym razie

Wyjaśnienie (mam nadzieję, że mam rację)

$
$_¶$_

Dołącza całe dane wejściowe oraz nowy wiersz i dane wejściowe ponownie

.+$|.
$*

Konwertuje każde dopasowanie do unarnego (albo cały drugi wiersz, który jest oryginalnym wejściem, albo każda cyfra w pierwszym wierszu)

^(.+)¶\1+$

Sprawdź, czy pierwszy wiersz (suma podwójnej cyfry) jest dzielnikiem drugiego wiersza

MATL , 7 bajtów

tV!UsE\

Wyprowadza, 0jeśli podzielne, dodatnia liczba całkowita w przeciwnym razie. W szczególności, reszta jest dzielona przez dwukrotność sumy jej cyfr.

Wypróbuj online!

Wyjaśnienie

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 bajtów

-1 bajt dzięki Okx

SO·Ö

Wypróbuj online!

Możesz także usunąć ostatnie Ö, aby uzyskać 0 za prawda i coś innego za fałsz, w wyniku czego powstały tylko 3 bajty, ale dla mnie to po prostu nie pasuje do definicji.

Wyjaśnienie

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

Kod maszynowy x86-64, 24 bajty

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

Powyższy kod definiuje funkcję w 64-bitowym kodzie maszynowym x86, który określa, czy wartość wejściowa jest podzielna przez dwukrotność sumy jej cyfr. Funkcja jest zgodna z konwencją wywoływania AMD64 w Systemie V, dzięki czemu można ją wywoływać z praktycznie dowolnego języka, tak jakby była funkcją C.

Pobiera pojedynczy parametr jako dane wejściowe przez EDIrejestr, zgodnie z konwencją wywoływania, która jest liczbą całkowitą do przetestowania. (Zakłada się, że jest to dodatnia liczba całkowita, zgodna z regułami wyzwania i jest wymagana do prawidłowego działania CDQinstrukcji, których używamy).

EAXPonownie zwraca wynik do rejestru zgodnie z konwencją wywoływania. Wynik będzie wynosił 0, jeśli wartość wejściowa była podzielna przez sumę jej cyfr, a w przeciwnym razie niezerowa. (Zasadniczo odwrotna wartość logiczna, dokładnie taka jak w przykładzie podanym w regułach wyzwania).

Jego prototypem C będzie:

int DivisibleByDoubleSumOfDigits(int value);

Oto instrukcje języka asemblera bez oznakowania, opatrzone krótkim objaśnieniem celu każdej instrukcji:

; 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

W pierwszym bloku dokonujemy wstępnej inicjalizacji rejestrów:

• PUSH+ POPinstrukcje są używane jako powolna, ale krótka droga do inicjalizacji ESIdo 10. Jest to konieczne, ponieważ DIVinstrukcja na x86 wymaga operandu rejestru. (Nie ma formy, która dzieli bezpośrednią wartość, powiedzmy, 10).
• XORsłuży jako krótki i szybki sposób na wyczyszczenie ECXrejestru. Rejestr ten będzie służył jako „akumulator” wewnątrz nadchodzącej pętli.
• Na koniec EDItworzona jest kopia wartości wejściowej (z ) i zapisywana w niej EAX, która zostanie przechwycona podczas przechodzenia przez pętlę.

Następnie zaczynamy zapętlać i sumować cyfry w wartości wejściowej. Jest to oparte na DIVinstrukcji x86 , która dzieli EDX:EAXprzez operand i zwraca iloraz do, EAXa resztę do EDX. Tutaj podzielimy wartość wejściową przez 10, tak że reszta to cyfra w ostatnim miejscu (którą dodamy do naszego rejestru akumulatorów ECX), a iloraz to pozostałe cyfry.

• CDQInstrukcja jest krótki sposób ustalania EDX0. To rzeczywiście podpisze-rozciąga wartość w EAXcelu EDX:EAX, który jest co DIVwykorzystuje jako dywidendy. W rzeczywistości nie potrzebujemy tutaj rozszerzenia znaku, ponieważ wartość wejściowa jest bez znaku, ale CDQwynosi 1 bajt, w przeciwieństwie XORdo kasowania EDX, czyli 2 bajty.
• Następnie DIVide EDX:EAXprzez ESI(10).
• Pozostała część ( EDX) jest dodawana do akumulatora ( ECX).
• EAXRejestr (iloraz) jest testowany, aby sprawdzić, czy jest równa 0. Jeśli tak, zrobiliśmy to przez wszystkie cyfry i upadamy wskroś. Jeśli nie, nadal mamy więcej cyfr do podsumowania, więc wracamy na początek pętli.

Wreszcie po zakończeniu pętli implementujemy number % ((sum_of_digits)*2):

• LEAInstrukcja służy jako krótki sposób pomnożyć ECXprzez 2 (lub równoważnie dodać ECXdo siebie) i zapisać wynik w innym rejestrze (w tym przypadku EAX).

  ^{(Moglibyśmy także zrobić add ecx, ecx+ xchg ecx, eax; oba mają 3 bajty, ale LEAinstrukcja jest szybsza i bardziej typowa).}

• Następnie robimy jeszcze CDQraz, aby przygotować się do podziału. Ponieważ EAXbędzie dodatni (tj. Niepodpisany), spowoduje to zerowanie EDX, tak jak poprzednio.
• Następnie jest dzielenie, tym razem dzielone EDX:EAXprzez wartość wejściową (w której znajduje się niezaburzona kopia EDI). Jest to równoważne modulo, z resztą w EDX. (Podany jest również iloraz EAX, ale nie jest nam potrzebny.)
• Wreszcie XCHG(wymieniamy) zawartość EAXi EDX. Normalnie zrobiłbyś MOVtutaj, ale XCHGma on tylko 1 bajt (choć wolniej). Ponieważ EDXzawiera resztę po dzieleniu, będzie wynosić 0, jeśli w przeciwnym razie wartość będzie podzielna równo lub niezerowa. Kiedy więc RETurnujemy, EAX(wynik) wynosi 0, jeśli wartość wejściowa była podzielna przez dwukrotność sumy jej cyfr, lub w przeciwnym razie niezerowa.

Mam nadzieję, że to wystarczy do wyjaśnienia.
To nie jest najkrótszy wpis, ale hej, wygląda na to, że bije prawie wszystkie języki inne niż golf! :-)

Japt , 7 4 bajty

Pobiera dane wejściowe jako ciąg. Dane wyjściowe 0dla truelub liczba większa niż 0dla false, które z innych rozwiązań wydają się prawidłowe. Jeśli nie, daj mi znać, a wycofam się.

%²¬x

Sprawdź to

Wyjaśnienie

Domniemane wprowadzanie ciągu U.
"390"

²

Powtórz Udwa razy.
"390390"

¬

Podziel na tablicę pojedynczych znaków.
["3","9","0","3","9","0"]

x

Zmniejsz przez zsumowanie, automatycznie rzucając każdą postać na liczbę całkowitą w tym procesie.
24

%

Uzyskaj resztę dzielenia Uprzez wynik, również automatycznie rzutując Una liczbę całkowitą w tym procesie. Niejawnie wyprowadza wynikową liczbę całkowitą.
6 (=false)

C89, 55 53 bajtów

^{(Dzięki Steadybox!}

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

Wymaga pojedynczego wejścia x, które jest wartością do przetestowania. Zwraca 0, jeśli xjest równomiernie podzielne przez dwukrotność sumy jego cyfr, lub w przeciwnym razie niezerowe.

Wypróbuj online!

Nie golfowany:

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

Jak widać, wykorzystuje to zasady niejawne int C89. Zmienne globalne si tsą domyślnie zadeklarowane jako ints. (Są również domyślnie inicjowane na 0, ponieważ są globalne, ale nie możemy z tego skorzystać, jeśli chcemy, aby funkcja była wielokrotna).

Podobnie, funkcja fprzyjmuje pojedynczy parametr, x,który jest domyślnie an inti zwraca an int.

Kod wewnątrz funkcji jest dość prosty, chociaż forpętla będzie wyglądać okropnie dziwnie, jeśli nie znasz składni. Zasadniczo fornagłówek pętli w C zawiera trzy części:

for (initialization; loop condition; increment)

W sekcji „inicjalizacja” zainicjalizowaliśmy nasze zmienne globalne. Uruchomi się to raz, przed wejściem w pętlę.

W sekcji „Warunek pętli” określiliśmy, w jakim stanie pętla powinna być kontynuowana. To powinno być oczywiste.

W sekcji „przyrost” umieściliśmy w zasadzie dowolny kod, ponieważ będzie on uruchamiany na końcu każdej pętli.

Większym celem pętli jest iterowanie każdej cyfry wartości wejściowej, dodając je do s. W końcu, po zakończeniu pętli, sjest podwojony i pobierany modulo, xaby sprawdzić, czy jest on równo podzielny. (Lepsze, bardziej szczegółowe wyjaśnienie logiki tutaj można znaleźć w mojej drugiej odpowiedzi , na której ta jest oparta).

Wersja czytelna dla człowieka:

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

Brachylog , 8 bajtów

ẹ+×₂;I×?

Wypróbuj online!

Wyjaśnienie

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

Python 2 , 34 32 bajty

-2 bajty dzięki @Rod

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

Wypróbuj online!

Mathematica, 26 bajtów

(2Tr@IntegerDigits@#)∣#&

Nie ma pojęcia, dlaczego ∣ma wyższy priorytet niż mnożenie ...

PHP , 41 bajtów

wypisuje zero, jeśli jest podzielna, dodatnia liczba całkowita w przeciwnym razie.

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

Wypróbuj online!

Excel, 63 bajty

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

Sumowanie cyfr jest długim fragmentem.

Perl 6 , 19 bajtów

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

Wypróbuj online!

Łuska , 9 8 bajtów

Dzięki Leo za oszczędność 1 bajtu.

Ṡ¦ȯ*2ṁis

Wypróbuj online!

Wyjaśnienie

Ṡ¦ȯ         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 bajtów

Dzięki Zgarb za grę w golfa z 1 bajtu

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

Wypróbuj online!

Pobiera dane wejściowe jako ciąg; zwraca 0, jeśli w przeciwnym razie jest podzielna, a niezerowa.

Python 3, 35 bajtów

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

TI-BASIC, 27 26 21 bajtów

-5 dzięki @Oki

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

Utrudnia to fakt, że w TI-BASIC nie ma zwięzłego sposobu sumowania cyfr całkowitych . Powraca 0do Truei inny numer do False.

Wyjaśnienie:

: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 bajtów

VR.Mvd&+2*c%

Wypróbuj online!

Wyjście 0 dla prawdy, każda inna liczba dla falsey.

Wyjaśnienie

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 bajtów

vUì x*2

Zwraca 1za true, 0dlafalse

Wypróbuj online!

Wyjaśnienie

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 bajtów

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

Stosowanie

f 80

Wypróbuj online!

Java , 66 bajtów

-1 bajt dzięki Olivier

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

Nie golf i wyjaśnienia:

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 bajtów

0 oznacza prawdę, niezerowa oznacza fałsz.

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

Wyjaśnienie

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

Ohm , 5 bajtów

D}Σd¥

Wypróbuj online!

tcl, 45

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

próbny

Haskell , 35 34 bajtów

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

Wypróbuj online!

Zwraca „0” w prawdziwym przypadku, reszta w przeciwnym razie.

Haskell , edycja pointfree autorstwa nich, 34 bajty

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

Wypróbuj online!

PHP, 44 bajty

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

Uruchom tak:

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

Wyjaśnienie

Iteruje nad cyframi, aby obliczyć sumę, a następnie wysyła modulo jak większość odpowiedzi.

Java (OpenJDK 8) , 55 53 bajtów

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

Wypróbuj online!

0Zwracana wartość oznacza prawda, wszystko inne oznacza fałsz.

Ponieważ mój komentarz w odpowiedzi Okxa nie zafalował, usunąłem go i opublikowałem, ponieważ w tej odpowiedzi grałem jeszcze trochę.

Dalsza gra w golfa dzięki @KrzysztofCichocki i @Laikoni, którzy słusznie pokazali mi, że nie muszę odpowiadać na wartość prawda / fałsz, ale jakąkolwiek wartość, o ile opisuję wynik.

Mini-Flak, 296 292 bajtów

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

Wypróbuj online!

Link do TIO ma ode mnie więcej komentarzy, więc jest częściowo łatwiejszy do odczytania.

Truthy / Falsey: Prawda (podzielna), jeśli druga liczba jest równa trzeciej, fałsz w przeciwnym razie. Tak więc zarówno zbiór prawdy, jak i fałszu są nieskończone, ale przypuszczam, że należy na to pozwolić. +10 bajtów, jeśli tak nie jest.

Uwaga: Wstawianie / końcowe znaki nowej linii / białe znaki są niedozwolone.