입력 으로 양의 정수가 주어지면 숫자의 자릿수의 두 배로 숫자를 나눌 수있는 경우 진실한 값을 출력하고 그렇지 않으면 거짓 값을 출력하는 것 입니다 ( OEIS A134516 ). 다시 말해:

(sum_of_digits)*2 | number

• 참과 거짓의 경우 진실 / 거짓 값 대신 참 / 거짓의 경우 유한 값 집합을 지정하고 다른 값을 보완 할 수 있습니다. 간단한 예를 들어, 0실제 경우에 사용할 수 있고 다른 경우에는 모두 다른 경우에 사용할 수 있습니다 (원하는 경우 그 반대도 가능).

• 표준 입력 및 출력 규칙이 적용됩니다. 기본 허점도 적용됩니다.

• 입력을 정수 또는 해당 정수의 문자열 표현으로 사용할 수 있습니다.

• 이것은 code-golf 이므로 바이트 단위의 가장 짧은 코드가 이깁니다!

• PPCG를 처음 사용하므로 가능한 경우 설명을 게시하고 싶습니다.

테스트 사례

입력-출력-(이유)

80-Truthy-(16 나누기 80)
100-Truthy-(2 나누기 100)
60-Truthy-(12 나누기 60)
18-Truthy-(18 나누기 18)
12-Truthy-(6 나누기 12)

4-거짓-(8은 4를 나누지 않음)
8-거짓-(16은 8을 나누지 않음)
16-거짓-(14는 16을 나누지 않음)
21-거짓-(6은 21을 나누지 않음)
78-거짓-(30은 78을 나누지 않음)
110-거짓-(4는 110을하지 않았다)
111-거짓-(6은 111을 나누지 않음)
390-Falsy-(24는 390을 나누지 않음)

Neim , 3 바이트

𝐬ᚫ𝕞

설명:

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

온라인으로 사용해보십시오!

상세 버전

자바 스크립트 (ES6), 31 29 27 바이트

입력을 문자열로받습니다. 진실의 경우 0을, 거짓의 경우 0이 아닌 값을 반환합니다.

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 바이트

@MartinEnder 덕분에 -11 바이트 및 코드 오류 수정

$
$_¶$_
.+$|.
$*
^(.+)¶\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 바이트

Okx 덕분에 -1 바이트

SO·Ö

온라인으로 사용해보십시오!

마지막 Ö를 제거하여 진실성을 위해 0을 얻고 거짓을 위해 다른 것을 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이되고 , 그렇지 않으면 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명령어는 ESI10 으로 초기화하는 느리지 만 짧은 방법으로 DIV사용됩니다. x86 의 명령어에는 레지스터 피연산자 가 필요하기 때문에 필요합니다. (즉, 10의 즉각적인 가치로 나눌 수있는 형태는 없습니다.)
• XORECX레지스터 를 지우는 짧고 빠른 방법으로 사용됩니다 . 이 레지스터는 다음 루프 내에서 "누적 기"역할을합니다.
• 마지막으로 (from EDI) 입력 값의 사본 이 만들어지고 저장되며 EAX, 루프를 통과 할 때 클로버됩니다.

그런 다음 입력 값에서 숫자를 루핑하고 합산하기 시작합니다. 이것은 x86 DIV명령어를 기반으로 EDX:EAX하며 피연산자로 나누고 몫 EAX과 나머지를로 반환합니다 EDX. 여기서 우리는 입력 값을 10으로 나누고 나머지는 마지막 자리의 숫자 (누적 기 레지스터에 추가 할 것 ECX)이며 몫은 나머지 숫자입니다.

• CDQ명령 설정하는 간단한 방법입니다 EDX그것은 실제로 0으로 로그인 확장 의 값 EAX에 EDX:EAX무엇인가, DIV배당으로 사용합니다. 입력 값이 부호가 없기 때문에 실제로 부호 확장이 필요하지 않지만 clear CDQ을 사용 XOR하는 것과는 반대로 1 바이트이므로 EDX2 바이트가됩니다.
• 그런 다음 우리 는 (10)까지 DIV기다 립니다.EDX:EAXESI
• 나머지 ( EDX)는 누산기 ( ECX)에 추가됩니다 .
• EAX레지스터 (몫)을 따라서 우리는 모든 숫자를 통해 만든 우리 통해 떨어지는 경우가 0과 동일 있는지 검사한다. 그렇지 않은 경우, 더 많은 숫자를 합산 할 수 있으므로 루프의 상단으로 돌아갑니다.

마지막으로 루프가 완료되면 다음을 구현합니다 number % ((sum_of_digits)*2).

• 이 LEA명령어는 ECX2 를 곱 하거나 (또는 ​​이와 동일하게 추가 ECX) 결과를 다른 레지스터 (이 경우 EAX)에 저장 하는 짧은 방법으로 사용됩니다 .

  ^{(우리는 add ecx, ecx+를 수행 할 수도 있습니다 xchg ecx, eax. 둘 다 3 바이트이지만 LEA명령이 더 빠르고 일반적입니다.)}

• 그런 다음 CDQ다시 분할 준비를합니다. EAX양수 (즉, 부호없는) 이기 때문에 EDX이전과 마찬가지로 제로화 효과가 있습니다.
• 다음은 나누기입니다. 이번에 EDX:EAX는 입력 값 (비밀 화되지 않은 복사본이 여전히에 있음 EDI) 으로 나눕니다 . 이것은 모듈로와 동일하며 나머지는에 EDX있습니다. 몫도에 넣지 EAX만 필요하지는 않습니다.
• 마지막으로, 우리 XCHG(교환)의 내용 EAX과 EDX. 일반적으로 MOV여기에서 작업을 수행 하지만 XCHG1 바이트 (더 느리지 만)입니다. EDX나누기 후 나머지를 포함 하기 때문에 값이 균등하게 나눌 수 있으면 0이되고 그렇지 않으면 0이 아닙니다. 따라서, 우리가 RETurn 할 때 EAX, 입력 값이 그 자리의 합의 두 배로 나눌 수 있으면 (결과)는 0이거나 그렇지 않으면 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테스트 할 값인 단일 입력이 필요합니다 . x숫자의 합을 두 배로 균등하게 나눌 수 있으면 0을 , 그렇지 않으면 0이 아닌 값을 반환합니다.

온라인으로 사용해보십시오!

언 골프 드 :

/* 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,사용합니다.이 매개 변수 는 암시 적으로이며을 int반환합니다 int.

함수 내부의 코드는 매우 간단하지만 for구문에 익숙하지 않으면 루프가 이상하게 보일 것입니다. 기본적으로 forC 의 루프 헤더에는 세 부분이 있습니다.

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

Brachylog , 8 바이트

ẹ+×₂;I×?

온라인으로 사용해보십시오!

설명

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

파이썬 2 , 34 32 바이트

@Rod 덕분에 -2 바이트

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

온라인으로 사용해보십시오!

Mathematica, 26 바이트

(2Tr@IntegerDigits@#)∣#&

∣곱셈보다 우선 순위가 높은 이유 는 전혀 없습니다 .

PHP , 41 바이트

나눌 수 있으면 0을, 그렇지 않으면 양의 정수를 인쇄합니다.

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

온라인으로 사용해보십시오!

엑셀, 63 바이트

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

합산 숫자는 긴 비트입니다.

펄 6 , 19 바이트

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

온라인으로 사용해보십시오!

껍질 , 9 8 바이트

1 바이트를 절약 해 준 Leo에게 감사합니다.

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

하스켈 , 38 37 42 바이트

1 바이트의 골프를 벌인 Zgarb에게 감사

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

온라인으로 사용해보십시오!

입력을 문자열로받습니다. 나눌 수 있으면 0을, 그렇지 않으면 0이 아닌 값을 반환합니다.

파이썬 3, 35 바이트

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

TI-BASIC, 27 26 21 바이트

@Oki 덕분에 -5

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

TI-BASIC 에서 정수 자릿수를 합산하는 간결한 방법이 없다는 사실로 인해 까다로워집니다 . 에 대해를 반환 하고에 대해 다른 숫자를 반환 0합니다 .TrueFalse

설명:

: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

온라인으로 사용해보십시오!

자바 , 66 바이트

Olivier 덕분에 -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은 진실을 나타내고 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 ""] +]))]

데모

하스켈 , 35 34 바이트

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

온라인으로 사용해보십시오!

실제 경우에는 '0'을, 그렇지 않으면 나머지를 반환합니다.

Haskell , nimi의 포인트 프리 에디션, 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;'

설명

숫자를 반복하여 총계를 계산 한 다음 대부분의 답변과 같이 모듈로를 출력합니다.

자바 (OpenJDK 8) , 55 53 바이트

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

온라인으로 사용해보십시오!

반환 값은 0진실 을 의미하고 다른 것은 거짓을 의미합니다.

Okx의 답변에 대한 내 의견은 잔물결이 없었으므로 삭제 하고이 답변으로 게시하여 훨씬 더 골프를 쳤다.

@KrzysztofCichocki와 @Laikoni 덕분에 나에게 합당한 사실을 보여 주었으므로 진실 / 거짓 가치에 답할 필요는 없지만 결과를 설명하는 한 어떤 가치도 대답 할 필요가 없습니다.

미니-플락, 296 292 바이트

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

온라인으로 사용해보십시오!

TIO 링크에는 더 많은 의견이 있으므로 부분적으로 읽기가 더 쉽습니다.

Truthy / Falsey : 두 번째 숫자가 세 번째 숫자와 같으면 다른 것 (거짓)입니다. 따라서 진실과 허위 세트는 모두 무한하지만 나는 그것이 허용되어야한다고 생각합니다. 그렇지 않은 경우 +10 바이트

참고 : 선행 / 트레일 링 개행 / 공백은 입력에 허용되지 않습니다.