제 친구와 저는 AP 컴퓨터 과학 수업에서 실험실에서 일하고 있었고, 골프를 마친 후에도 여전히 반 수업을 무료로 제공했기 때문에 골프 문제 하나를 코딩하기로 결정했습니다. 질문은 다음과 같습니다.

숫자 n이 주어지면, n은 각 숫자로 나눌 수 있습니까?

예를 들어 128은이 테스트를 통과합니다. 1, 2, 8로 나눌 수 있습니다. 0이있는 숫자는 자동으로 숫자를 실격합니다. 원하는 경우 다른 언어를 사용하고 솔루션을 게시 할 수 있지만 클래스에서 사용하는 언어 인 컴팩트 한 프로그램을 Java로 작성하는 방법을 보는 것이 가장 중요합니다. 지금까지 우리 모두 51이 있습니다. 현재 코드는 다음과 같습니다.

public boolean dividesSelf(int n){for(int p=n;n%10>0;)n/=p%(n%10)>0?.1:10;return n<1;}
// 51 characters

// Breakdown:
// for(int p=n;         Saves one semicolon to put declaration into for loop
// n%10>0;)             Basic check-for-zero
// n/=                  Pretty simple, discarding one number off of n at a time
// p%(n%10)>0?          If p (the given value) is not divisible by n%10 (the current digit)...
// .1:10;               Divide by .1 (multiply by 10) so it fails the check next iteration. If it is divisible, divide by 10 to truncate the last digit
// return n<1           If the number was fully divisible, every digit would be truncated, and n would be 0. Else, there would still be non-zero digits.

요구 사항

메소드 서명은 원하는대로 될 수 있습니다. 함수 본문을 세십시오. 그러나 메소드가 부울 값을 리턴하고 하나의 숫자 매개 변수 (문자열이 아님) 만 전달하는지 확인하십시오 .

코드는 원래의 질문의 방향에 충실하기 위해이 모든 경우를 (통과 할 수 있어야합니다, 단지 부울 true와 false 값은 계산 언어 지원의 부울. 만약의 경우 귀하의 언어는 부울 변수를 가지고 있지 않은 경우에만 0으로 false를 나타내고 0이 아닌 정수 (바람직하게는 1 또는 -1)로 true를 나타낼 수 있습니다.

128 -> true
 12 -> true
120 -> false
122 -> true
 13 -> false
 32 -> false
 22 -> true
 42 -> false
212 -> true
213 -> false
162 -> true
204 -> false

또한 공백을 계산하지 않았으므로 공백이 프로그램 작업에 필수적이 아닌 한 자유롭게 수행하십시오 (Java의 줄 바꿈은 중요하지 않지만 사이 int와 공백 사이의 단일 공백은 중요하지 않습니다 x=1). !

펄 6, 13

sub golf($_) {
   $_%%.comb.all
}

암시 적 변수를 사용합니다 $_— $_ %% .comb.all와 같습니다 $_ %% all($_.comb). %%"분할 가능"연산자이며 comb추가 인수가 없으면 문자열의 문자 목록을 반환합니다. 예를 들어, 인수가 123이면 함수는

123 %% all(123.comb)

어느

123 %% all(1, 2, 3)

접합 자동 스레딩으로 만듭니다

all(123 %% 1, 123 %% 2, 123 %% 3)

어느

all(True, False, True)

부울 컨텍스트에서는 "all"접점이므로 모든 요소가 사실이 아니기 때문에 false입니다.

Bool함수 signature를 만들어서 반환 값을 강제하고 호출자로부터 정션을 숨길 수는 sub golf($_ --> Bool())있지만 함수 서명의 강제는 아직 Rakudo에서 작동하지 않습니다. 반환 값은 여전히 ​​정확히 true 또는 false이며 단지 True또는 아닙니다 False.

C # 및 System.Linq-26/40

규칙에 따라 메소드 선언 자체는 계산하지 않습니다.

bool dividesSelf(int i) { 
    return(i+"").All(d=>i%(d-48d)<1);
}

다시 한 번, C #은 Java를 고려할 때 탁월한 선택입니다 ... I kid, I kid!

불행히도,이 기능 (및 다른 답변의 많은 기능)은 부정적인 입력에 대한 올바른 결과를 생성하지 않습니다. 우리는 이것을 고칠 수는 있지만 솔루션은 많은 매력을 잃습니다 (길이가 46 자로 늘어남).

return(i+"").All(d=>d>48&&i%(d-48)==0||d==45);

편집 : 팀의 제안으로 한 캐릭터를 면도했습니다.

편집 : C # 6 에 표현 본문 멤버 를 도입 하면 return다음 을 잘라서 더 자세히 분석 할 수 있습니다 .

bool dividesSelf(int i) =>
    (i+"").All(d=>i%(d-48d)<1);

총 26 자 (제 의견으로는 =>중괄호보다 많으면 안됩니다). 음수를 처리하는 버전도 비슷하게 단축 될 수 있습니다.

APL ( 13 11)

{0∧.=⍵|⍨⍎¨⍕⍵}

설명:

• ⍎¨⍕⍵:의 문자열 표현에서 각 문자를 평가 ⍵
• ⍵|⍨: 각각의 모듈로를 찾아서 ⍵
• 0∧.=: 모든 것이 같은지 확인하십시오 0

테스트 케이스 :

      N,[.5] {0∧.=⍵|⍨⍎¨⍕⍵} ¨ N←128 12 120 122 13 32 22 42 212 213 162 204
128 12 120 122 13 32 22 42 212 213 162 204
  1  1   0   1  0  0  1  0   1   0   1   0

파이썬 2 : 43 자

f=lambda n:any(n%(int(d)or.3)for d in`n`)<1

숫자에 0이 아닌 나머지 숫자가 모듈로 있는지 여부를 확인하고 그 부정을 출력합니다. 0 자리 숫자는 이상하게 처리됩니다. 컴퓨팅 %0에서 오류가 발생하기 때문에의 숫자는 0로 대체됩니다 .3. 부동 소수점 부정확성으로 인해 항상 0이 아닌 결과를 나타내는 것 같습니다.

함수 본문은 32 자입니다.

펄-27 바이트

sub dividesSelf{
    $_=pop;s/./!$&||$_%$&/ger<1
}

지시에 따라 함수 서명을 계산하지 않습니다.

샘플 사용법 :

use Data::Dump qw(dump);
for $i (128, 12, 120, 122, 13, 32, 22, 42, 212, 213, 162, 204) {
  printf "%3d -> %s\n", $i, dump(dividesSelf $i);
}

샘플 출력 :

128 -> 1
 12 -> 1
120 -> ""
122 -> 1
 13 -> ""
 32 -> ""
 22 -> 1
 42 -> ""
212 -> 1
213 -> ""
162 -> 1
204 -> ""

문제 사양 해결 : "부울 true 및 false 값만 계산합니다. Truthy / falsey 값은 계산 되지 않습니다 ."

use Data::Dump qw(dump);
dump(1 == 1);
dump(0 == 1);

출력 :

1
""

'참'과 '거짓'으로 정의 1하고 "".

오자 :
브래드 길버트가 바르게 지적 , 펄을 정의 진정한 정수 둘 다 스칼라로 1하고 문자열 "1"동시에, 그리고 거짓을 정수 둘 다 스칼라로 0하고 문자열 ""동시에.

CJam, 11 10 바이트

{
    _Ab:df%:+!
}:F;

이름이 지정된 함수를 정의 F하고 스택에서 블록을 버립니다.

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

테스트 사례

$ cjam <(echo '{_Ab:df%:+!}:F;[128 12 120 122 13 32 22 42 212 213 162 204]{F}%p')
[1 1 0 1 0 0 1 0 1 0 1 0]

작동 원리

_      " Copy the integer on the stack.                                          ";
Ab     " Push the array of its digits in base 10.                                ";
:d     " Cast each digit to Double.                                              ";
f%     " Take the integer on the stack modulus each of its digits.               ";
:+     " Add the results.                                                        ";
!      " Push the logical NOT of the sum.                                        ";

자바 스크립트 ES6, 39 32 28 바이트

v=>[...""+v].every(x=>v%x<1)

덕분에 대체 할 제안에 대한 core1024 (""+v).split("")로 [...""+v]의 사용을 제안하기위한, 그리고 openorclose every기능.

대답은 현재 내 코드의 1 비트를 포함하지 않습니다 : O

이전 솔루션

v=>[...""+v].filter(x=>v%x|!+x)==""

==""[""]==""returns 이므로 배열이 비어 있는지 확인하는 올바른 방법은 아니지만 배열에 비어 true있지 않은 문자열이 포함되어 있으므로 여기에서 작동합니다.

나머지는 JavaScript에서 매우 일반적인 속기 유형 변환입니다.

Java 8, 46 바이트 (메소드 본문)

Jeroen Mostert 의 더블 트릭으로 변환 사용 .

public static boolean dividesSelf(int n) {
    return(""+n).chars().allMatch(x->n%(x-48d)<1);
}

Pyth, 12 바이트

!f|!vT%vzvTz

문자열의 문자를 0 ( !vT)으로 입력하거나 입력을 나누지 않도록 필터링 한 %vzvT다음 결과 목록의 논리가 아닌 논리를 취합니다.

여기에서 시도하십시오.

루비, 44 바이트 (기능 본문 : 37)

아마도 더 골프를 칠 가능성이 있습니다.

f=->n{n.to_s.chars.all?{|x|x>?0&&n%x.hex<1}}

입력 기능을 수행 f. 사용법 예 :

f[128] # => true
f[12]  # => true
f[120] # => false
...

파이썬 -59 50 49 47 바이트

f=lambda n:all(c>'0'and 0==n%int(c)for c in`n`)

더 빠른 방법이 있다고 확신합니다.

편집 -골프 팁 FryAmTheEggman에게 감사합니다.

편집 2 -FryAmTheEggman 은이 시점에서 이것을 쓸 수도 있습니다.

편집 3 -genexps가 무엇인지 몰랐다면 손을 들어보십시오. ...나만?

피스 11

!f%Q|vT.3`Q

이것은 @isaacg 와 @xnor의 답변을 결합 합니다. 의 값을 확인하여 입력에서 숫자를 필터링합니다 input % (eval(current_digit) or .3). 그런 다음 결과 문자열이 비어 있는지 확인합니다.

동일한 길이의 다른 변형을 발견했습니다.

!f%Q|T.3jQT
!f|!T%QTjQT

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

Bash + coreutils, 44 바이트

전체 기능 정의는 다음과 같습니다.

f()((`tr 0-9 \10<<<$1``sed "s/./||$1%&/g"<<<$1`))

일반적으로 쉘 함수가 단일 세트를 사용 {}하거나 ()함수 본문을 포함 하기 때문에 점수를 매기는 방법을 잘 모르겠습니다 . 여기에서 double (())을 사용 하여 함수 본문을 포함 할 수 있으며 여기에서 필요한 산술 확장이 발생합니다. 그래서 지금은 한 쌍의 괄호를 세고 있습니다. 이에 대한 자세한 논의는 환영합니다.

산출:

$ for i in 128 12 120 122 13 32 22 42 212 213 162 204; do f $i; printf "%d " $?; done
1 1 0 1 0 0 1 0 1 0 1 0 $
$

J-14 자

함수 본문은 다음에 나오는 부분 =:입니다. 전체 함수의 문자 수를 최소화하려면 15 자 */@(0=,.&.":|])입니다.

f=:0*/@:=,.&.":|]

,.&.":J에서 가장 작은 방법으로 숫자를 10 진수 목록으로 확장합니다. 문자열로 변환하고 숫자를 구분하고 각 숫자를 다시 숫자로 변환합니다. 해당 숫자 ,.&.":|]의 입력 번호 ( ]) 모듈로 ( |)를 가져옵니다 . 0*/@:=모든 결과가 0이면 true를, 그렇지 않으면 false를 반환합니다.

   f 162
1
   f every 204 212 213
0 1 0

자바 - 121 102 97 79 78 바이트

나는 이것이 나중에 혼란스럽게 될 것이라는 것을 알고 있습니다. 오 잘

boolean b(int a){int m=10,j,t=1;for(;m<a*10;m*=10){j=10*(a%m)/m;if(j==0||a%j>0)t=0;}return t>0;}

돌아 올게요

하스켈 -100 54 38

f x=all(\y->y>'0'&&x`mod`read[y]<1)$show x

아직도 배우고, 비평은 인정했다

CJam, 15 바이트

{_Abf{_g{%}*}:|!}

이것은 CJam의 기능에 가장 가까운 블록입니다. 나는 몸만 세고있다. 다음과 같이 사용할 수 있습니다.

128{_Abf{_g{%}*}:|!}~

또는 일련의 입력을 테스트하려면 다음을 수행하십시오.

[128 12 120 122 13 32 22 42 212 213 162 204]{{_Abf{_g{%}*}:|!}~}%

블록 은 결과를 나타 내기 위해 스택에 0(거짓) 또는 1(거친) 떠납니다. CJam에는 부울 형식이 없습니다.

여기에서 테스트하십시오.

설명:

_               "Duplicate input.";
 Ab             "Get base-10 digits.";
   f{      }    "This maps the block onto the list of digits, supplying the input each time.";
     _g         "Duplicate digit, get signum S (0 or 1).";
       { }*     "Repeat this block S times.";
        %       "Take input modulo digit.";
                "This leaves an array of zeroes for divisible digits, non-zeroes
                 for non-divisible digits, and non-zero junk for zeroes.";
            :|  "Fold OR onto this list. One could also sum the list with :+";
              ! "Logical NOT. Turns 0 into 1, and non-zero values into 0.";

대안, 또한 15 바이트

{:XAb{X\_X)?%},!}

설명

:X              "Store input in X.";
  Ab            "Get base-10 digits.";
    {       },  "Filter this list by the result of the block.";
     X\         "Push another copy of X, swap with digit.";
       _        "Duplicate digit.";
        X)      "Push X+1.";
          ?     "Select digit itself or X+1, depending on whether digit is 0 or not.";
           %    "Take modulo. X%(X+1) will always be nonzero for positive integers.";
              ! "Logical NOT. Turns an empty list into 1 and a non-empty list into 0.";

CJam, 15 바이트

{_Abf{_{%}1?}1b!}

{}CJam에서 가장 가까운 함수입니다. 함수의 본문을 세고 있습니다.

다음과 같이 사용하십시오.

128{_Abf{_{%}1?}1b!}~

1(숫자가 나눌 수있는 경우) 또는 0( 숫자가 숫자로 나눌 수없는 경우) 구하기 .

여기에서 온라인으로 사용해보십시오

설명

_Ab                "Copy the number and split it to its digits";
   f{      }       "For each digit, run this code block on the number";
     _{%}1?        "If the digit is 0, put 1, otherwise perform number modulus digit";
            1b     "We now have an array of modulus corresponding to each digit. Sum it up";
              !    "Negate the sum. If all digits were divisible, sum of modules will be"
                   "0, thus answer should be 1 and vice versa";

C89, 43 바이트

unsigned char d(int n, int c) {
        int a=n%10;return!n||a&&!(c%a)&&d(n/10,c);
}

C89에는 부울 유형이 없습니다. 그것이 효과가 있기를 바랍니다. 또한 두 번째 매개 변수를 사용하여 스택을 통해 원래 숫자의 사본을 전달했지만 정의는 무엇이든 가능합니다. 올바른 결과를 얻으려면 두 매개 변수 ( d(128, 128))에 대해 동일한 값으로 함수를 호출하면됩니다 .

편집 : 익명 사용자가 제안한 편집 제안 적용

함수 본문에서 C11-44 바이트

비재 귀적이며 부동 소수점 예외가없는 다른 C 버전.

bool digit_multiple(int i)
{
    for(int n=i;i%10&&n%(i%10)<1;i/=10);return!i;
}

이것은 C ++, Java 및 대부분의 다른 C 유사 언어에서도 작동합니다.

primo의 의견 개선을 포함하도록 편집되었습니다.

줄리아 32 25 23

숫자를 사용하여 개선

음수 문제 해결

selfDivides(x)=sum(x%digits(x).^1.)==0

오래된 방법

모든 나머지의 합이 0이면 모든 숫자가 나눕니다. 다른 숫자와 마찬가지로 음수에 문제가 있습니다.

selfDivides(x)=sum(x.%(Float64["$x"...]-48))==0

산출

[selfDivides(x) for x in [128,12,120,122,13,32,22,42,212,213,162,204]]
12-element Array{Any,1}:
  true
  true
 false
  true
 false
 false
  true
 false
  true
 false
  true
 false

개선 된 방법으로 BigInt도 처리

selfDivides(BigInt(11111111111111111111111111111111111111112))
true

하나

selfDivides(BigInt(11111111111111111111111111111111111111113))
false

때문에

BigInt(11111111111111111111111111111111111111113) %3
1

C / C ++, 58 바이트 (본문 44)

정의되지 않은 동작을 호출합니다 (주석 참조).

int d(int i){int j=i;while(i&&!(j%(i%10)))i/=10;return!i;}

true하고 false 있는 1, 0,하지만를 반환 서명 한 문자를 추가 부담 bool.

그리고 재미를 위해, 폼의 호출을 허용하면 더 작은 재귀 버전 r(128,128)

편집 : 이제 규칙에서 허용하지 않습니다.

int r(int i,int j){return!i||!(j%(i%10))&&r(i/10,j);}

R : 72 67 65

함수

f<-function(a)!(anyNA(a%%(d=as.double(strsplit(paste0(a),"")[[1]])))|sum(a%%d))

저축을위한 @AlexA와 @plannapus에게 감사합니다

시운전

i=c(128,12,120,122,13,32,22,42,212,213,162,204)
for(a in i){print(f(a))}
[1] TRUE
[1] TRUE
[1] FALSE
[1] TRUE
[1] FALSE
[1] FALSE
[1] TRUE
[1] FALSE
[1] TRUE
[1] FALSE
[1] TRUE
[1] FALSE

GNU Awk : 53 자

계산 된 부분 :

for(;++i<=split($1,a,//);)r=r||!a[i]||v%a[i];return!r

전체 기능 :

function self_divisible(v, i, r)
{
    for (; ++i <= split($1, a, //); )
        r = r || ! a[i] || v % a[i]

    return ! r
}

Awk에는 부울 값이 없으므로 1 tor true를, false를 0을 반환합니다.

자바 스크립트 (ES6) 30

하나의 숫자 매개 변수가있는 기능. JavaScript에서 0 % 0은 NaN이므로 %와 빼기를 사용하면 특별한 경우 '0'이 필요하지 않습니다.

저장된 1 문자 thx DocMax 편집

F=n=>[for(d of t=n+'')t-=n%d]&&t==n 

함수 서명을 세지 않는 것에 대한 규칙을 남용하는 재미, 4

Check=(n,t=n+'',q=[for(d of t)n-=t%d])=>t==n

FireFox / FireBug 콘솔에서 테스트

console.log([128, 12, 120, 122, 13, 32, 22, 42, 212, 213, 162, 204]
.map(x=>+x + ' -> ' + F(x)).join('\n'))

산출

128 -> true
12 -> true
120 -> false
122 -> true
13 -> false
32 -> false
22 -> true
42 -> false
212 -> true
213 -> false
162 -> true
204 -> false

PHP : 85 바이트 (본문 64 바이트)

이 함수가 작동하려면 단순히 문자열이나 숫자를 전달하십시오.

0 올바르게 거짓을 반환합니다.

코드:

function f($n,$i=0){for($n.='';$n[$i]&&$t=!($n%$n[$i++]););return$t&&$i==strlen($n);}

두 번째 매개 변수를 설정하지 마십시오!

자바 스크립트 : 76 바이트 (본문의 61 바이트)

이것은 이전 함수를 다시 쓴 것입니다.

두 버전간에 크게 변경되지 않았습니다.

코드는 다음과 같습니다.

function f(n){for(i=0,n+='';n[i]/1&&(t=!(n%n[i++])););return t&&i==n.length}

폴리 글롯 : Javascript + PHP 187 217 바이트 (76 상용구없는 84 바이트) :

내가 만든 이유는 무엇입니까?

이유 때문에 그리고 내가 할 수 있기 때문에!

PHP의 오류를 무시하십시오. 어쨌든 작동합니다!
더 이상 필요하지 않은이 문제는 3 바이트를 제거하여 수정되었습니다.

걸작은 다음과 같습니다.

if('\0'=="\0"){function strlen($s){return $s['length'];}}
function toString(){return'';}
function f($n){for($i=0,$n=$n.toString();$n[$i]/1&&($t=!($n%$n[$i++])););return $t&&$i==strlen($n);}

콘솔과 PHP 인터프리터에서이 코드를 실행할 수 있습니다!

구 버전:

if('\0'=="\0"){function strlen($s){return $s['length'];}}
function s($s){return('\0'=="\0")?$s+'':str_replace('','',$s);}
function f($n,$i){for($i=0,$n=s($n);$n[$i]/1&&($t=!($n%$n[$i++])););return $t&&$i==strlen($n);}

옥타브, 33 (기능 설정 포함 39)

숫자-행렬 변환 사용 :

f=@(a)sum(mod(a./(num2str(a)-48),1))==0

숫자를 행렬 X로 나누십시오. 여기서 X는 숫자를 문자열로 변환하고 48을 빼서 ASCII 값에서 숫자로 다시 이동합니다. 모듈로 1을 취하여 각 나눗셈의 소수 부분을 구하고 이들 모두가 0인지 확인합니다 (/ 0으로 인해 NaN 인 경우 합계는 NaN이되어 0이 아님).

www.octave-online.net을 사용한 샘플 입력 :

f=@(a)sum(mod(a./(num2str(a)-48),1))==0
for j=[128,12,120,122,13,32,22,42,212,213,162,204]
f(j)
end

산출:

ans =  1
ans =  1
ans = 0
ans =  1
ans = 0
ans = 0
ans =  1
ans = 0
ans =  1
ans = 0
ans =  1
ans = 0

MATLAB-39 자

function [b] = dividesSelf(i)
b=all(~mod(i,sscanf(num2str(i),'%1d')))
end

배쉬-117 자

f(){ [[ $1 =~ 0 ]]&& return 0 || r=;n=$1;for((i=0;i<${#n};i++));do r=$(($r+${n}%${n:$i:1}));done;return $(($r==0));}

테스트

for N in 128 12 120 122 13 32 22 42 212 213 162 204; do
  f $N
  echo "${N} ->  $?"
done

128 ->  1
12 ->  1
120 ->  0
122 ->  1
13 ->  0
32 ->  0
22 ->  1
42 ->  0
212 ->  1
213 ->  0
162 ->  1
204 ->  0

PHP- 74 71 64 자

골프 :

function t($n){while($n>1){if(!($b=$n%10)||($n%$b)){return 0;}$n/=10;}return 1;}

덜 골프 :

function t($n){
    while($n>1){
        if( !($b=$n%10) || ($n%$b) )
            { return 0; }
        $n/=10;
    }
    return 1;
}

시험 결과:

(암호)

$ans = array(128,12,120,122,13,32,22,42,212,213,162,204);
foreach($ans as $a)
{ echo "$a -> ".(t($a)?"True":"False").PHP_EOL; }

(산출)

128 -> True
12 -> True
120 -> False
122 -> True
13 -> False
32 -> True
22 -> True
42 -> True
212 -> True
213 -> True
162 -> False
204 -> False