주어진 숫자를 13으로 나눌 수 있으면 "예"를 출력하고 그렇지 않으면 "아니오"를 출력하는 함수 또는 프로그램을 작성하는 것이 문제입니다.

규칙 :
-어디에서나 13 번을 사용할 수 없습니다.
-13에 대한 cop-out 동의어가 없습니다 (예 : 15-2 사용).
-계수를 사용하지 않으면 보너스 포인트가 부여되고, 나누기를 사용하지 않으면 추가 보너스가 제공됩니다.

득점 :
-점수는 코드의 바이트 수 (공백은 포함 되지 않음 )에 보너스를 곱한 값입니다.
-계수를 사용하지 않았다면, 그 보너스는 0.90입니다; 나누기를 사용하지 않은 경우 해당 보너스는 0.90입니다.
-어느 쪽도 사용하지 않았다면, 그 보너스는 0.80입니다.
-점수가 낮을수록 좋습니다.

입력은 항상 0보다 크고 2 ^ 32보다 작은 정수입니다.
출력은 간단한 "예"또는 "아니오"여야합니다.

설명 :
-몇 번의 로터리 방법을 사용하여 숫자 13을 사용할 수 있습니다. (10 + 3)과 같은 간단한 산술 동의어는 허용되지 않습니다.
- 주어진 숫자가 13으로 나눌 수있는 경우, 함수 또는 프로그램은 문자 그대로 "예"또는 "아니오"를 출력 해야합니다
.-언제나처럼 영리한 솔루션이 권장되지만 필수는 아닙니다.

자바 (점수 60.8 59.2)

void t(int n){System.out.print(Math.cos(.483321946706122*n)>.9?"yes":"no");}

점수 : (76-2 개의 공백) 문자 * 0.8 = 59.2

ASM-WinXP 명령 셸의 16 비트 x86

실행 파일-55 바이트 * 0.8 = 44

소스-288 자 * 0.8 = 230.4

숫자 13은 조립 된 .com 파일에도 나타나지 않습니다.

A86을 사용하여 조립하십시오.

    mov si,82h
    xor ax,ax
    xor cx,cx
a:  imul cx,10
    add cx,ax
    lodsb
    sub al,48
    jnc a
    inc cx
h:  mov dl,a and 255
c:  loop g
    sub dl,a and 255
    jz e
    mov dl,4
e:  add dl,k and 255
    mov dh,1
    mov ah,9
    int 21h
    ret
g:  inc dl
    cmp dl,c and 255
    jne c
    jmp h
k:  db 'yes$no$'

파이썬 3.x : 54 * 0.8 = 43.2

길이 13의 문자열을 갖는 것은 cop-out 일 수 있지만 여기서는 다음과 같습니다.

print('no' if any((' ' * int(input())).split('             ')) else 'yes')

그것은 n 개의 공백 문자열을 생성하고 (구분 기호의 선택은 임의적이지만 명백한 이유로 공간을 선택했습니다), n % 13 공백을 포함하는 문자열이 남을 때까지 13 공백 하위 문자열을 분리합니다.

GolfScript, 32 자

~){.14base{+}*.@<}do('no''yes'if

나는 다른 사람들과 다른 것을 시도하고 싶었으므로 솔루션은 기본 14를 계산합니다. 은 숫자를 기본 14 로 반복 변환 하고 결과가 더 이상 작아지지 않을 때까지 숫자를 합산하여 숫자 디지털 근 을 . 이것은 결과가 0에서 12가 아닌 1에서 13의 범위에 있다는 것을 제외하고 나머지 모듈로 13을 계산하는 것과 본질적으로 동일합니다.

숫자 13 자체 (또는 12 + 1과 같은 일부 문제 해결 방법)를 사용하지 않고 디지털 루트가 13인지 여부를 확인하는 것이 어려울 수 있으므로 실제로 수행하는 작업은 루프 전에 입력 번호를 1 씩 늘리고 나중에 결과를 줄입니다. 이렇게하면 13으로 나눌 수있는 숫자의 결과가 실제로 0이되어 훨씬 쉽게 확인할 수 있습니다.

주석이 달린 프로그램 버전은 다음과 같습니다.

~              # evaluate the input, turning it from a string to a number
)              # increment by one
{              # start of do-loop 
    .          # make a copy of the previous number, so we can tell when we're done
    14 base    # convert the number to base 14
    { + } *    # sum the digits
    . @ <      # check if the new number is less than the previous number...
} do           # ...and repeat the loop if so
(              # decrement the result by one
'no' 'yes' if  # output 'no' if the result is non-zero, 'yes' if it's zero

이 프로그램은 실제로 처리합니다 GolfScript는 bignum 산술을 사용하므로이 음이 아닌 정수 입력을 합니다 . 물론, 매우 큰 입력은 과도한 시간 및 / 또는 메모리를 소비 할 수 있습니다.

이 코드는 모듈러스 또는 나눗셈을 직접 사용하지 않지만 GolfScipt의 기본 변환 연산자를 사용하지만 거의 확실하게 일부 나눗셈과 나머지를 내부적으로 수행합니다. GigaWatt가 이것이 보너스의 자격 여부를 결정하도록 남겨 두겠습니다.

C, 68 * 0.8 = 54.4

24 답변 후, 아무도이 명백한 알고리즘을 찾지 못했습니다.

f(x){puts("no\0yes"+3*((x*330382100LL>>32)-(~-x*330382100LL>>32)));}

자바 스크립트 (27.9)

현재 버전 (31 자 * 0.90 보너스 = 27.9).

alert(prompt()*2%26?'no':'yes')

데모 : http://jsfiddle.net/9GQ9m/2/

편집 1 : 점수를 상당히 낮추고 for루프를 피하기 위해 모듈러스를 사용하여 두 번째 보너스를 잊어 버립니다 . 또한 ~~두 글자를 제거 하고 저장하십시오 (감사합니다 @copy).

이전 버전 (48 자 * 0.80 보너스 = 38.4)

for(n=~~prompt()*2;n-=26>0;);alert(n?'no':'yes')​

BrainFuck

점수 : 200 * 0.8 = 160

>++++++[>++++++++<-]>>,[<[-<+>>-<]<[->+<]>>>[->++++++++++<]>[-<+>]<<[->+<],]++++
+++++++++>[>+<-<-[>>>]>>[[-<<+>>]>>>]<<<<]>[<<<[-<++>]<++++++++++++++.+.>]<<[[-<
++++++<++++++++>>]<-----.<---.>------.>]

stdin에서 읽습니다. 아마도 가장 영리한 솔루션은 아니지만 BF에서 작동하는 것을 얻는 것이 좋습니다. 그래도 꽤 컴팩트합니다.

스칼라 (38 * 0.9 = 34.2)

0xD(16 진수) 와 비슷 하거나015 (oct) .

ASCII 값 CR은 13입니다.

def t(n:Int)=if(n%'\r'==0)"yes"else"no"

하스켈, 28 * 0.8 = 22.4

f x|gcd 26x>2="yes"|1<3="no"

파이썬 :

f=lambda n:1==pow(8,n,79)

예 :

[i for i in range(100) if f(i)]

준다

[0, 13, 26, 39, 52, 65, 78, 91]

C, 54.4 == 68 * .8   80 * .8

char*f(c){char*s=" yes\0\rno";while(c&&*s++);return c>0?f(c-*s):++s;}

ECMAScript 6, 25 × 0.9 = 22.5

예, 13을 얻는 지루한 방법입니다.

n => n % '             '.length ? 'no' : 'yes'

APL ((21-1) × 0.8 = 16)

'yes' 'no'[1=⎕∨⌊⍟9*6]

⎕IODyalog APL에서 제대로 작동하려면 0으로 설정해야합니다. 13을 생성하기 위해 9 ⌊의 자연 로그 ( ⍟)의 바닥 ( ) 을 6의 거듭 제곱 ( 9*6)으로 가져갑니다. 그런 다음 ∨입력 ( ⎕)과 13 의 GCD ( )를 찾은 다음 1과 같은지 테스트합니다.[...] 답의 벡터 .

스코어링 스펙에서 바이트 에 대한 언급을하려는 사람이라면 UTF-8로 인코딩 된 버전의 스코어는 (29 - 1) × 0.8 = 22.4입니다. :)

C, 88

피보나치 트릭.

f(n){return n<2?n:f(n-1)+f(n-2);}main(x){printf("%s",x%f(7)?"No":"Yes",scanf("%d",&x));}

펄-44 × 0.8 = 35.2

#!perl -p
map$_+=4*chop,($_)x10;$_=chop^$_*3?'no':yes

shebang을 1 바이트로 계산합니다.

나는 게임에 조금 늦었지만이 시점의 다른 게시물이 그것을 사용하지 않았기 때문에 알고리즘을 공유 할 것이라고 생각했습니다.

그 경우 관측에서이 작업 n은 로 나누어 13 이어서, ⌊ N / 10 ⌋ + N % 10 * 4는 또한로 나누어 13 . 값 13 , 26 및 39는 스스로 순환합니다. 다른 모든 배수 (13)는 결국보다는 더 이상 이러한 값 중 하나에 도달 할 것 로그 ₁₀ n 반복합니다.

다른 기지에서

물론 chop 약간의 cop-out입니다. 밑이 10 인 표현에서는divmod . 그러나이 알고리즘은 다른 기본 (예 : 기본 4 또는 8)에서 잘 작동합니다.

위 알고리즘의 파이썬 스타일 의사 코드 (기본 10) :

def div13(n):
    while n > 40:
        q, r = n // 10, n % 10
        n = q + 4*r
    return n in [13, 26, 39]

베이스 2 :

def div13(n):
    while n > 40:
        q, r = n >> 1, n & 1
        n = q + 7*r
    return n in [13, 26, 39]

베이스 4 :

def div13(n):
    while n > 40:
        q, r = n >> 2, n & 3
        n = q + 10*r
    return n in [13, 26, 39]

베이스 8 :

def div13(n):
    while n > 40:
        q, r = n >> 3, n & 7
        n = q + 5*r
    return n in [13, 26, 39]

13보다 작은 모든베이스는 똑같이 잘 작동합니다.

자바 스크립트 : 59 * 0.8 = 47.2 (?)

바이올린 :

function r(n){
  for(c=0;n>c;n-=12,c++);
  return n==c?'yes':'no';
}

mellamokb의 개선 사항 포함 (57 * 0.8 = 45.6) :

function r(n){
  for(c=0;n>c;n-=12,c++);
  return n-c?'no':'yes'
}

펄 : (51-4 공백) * 0.9 = 42.3

say+<>%(scalar reverse int 40*atan2 1,1)?'no':'yes'

40 * atan2 (1,1)-> 31.41592 (PI * 10)

펄 (19.8)

21 바이트 * .9

say2*<>%26?"no":"yes"

참고 : 나의 첫번째 Perl 프로그램. 약한 타이핑은 골프에 좋다고 생각합니다.

C (K & R) : 47 * 0.8 = 37.6

f(i){for(;i>0;i-=__LINE__);puts(i?"no":"yes");}

EDIT1 : 외부 함수에 대한 모든 종속성을 제거했습니다. 위 줄을 파일의 13 번째 줄에 넣으면 위의 작업이 수행됩니다! :) __LINE__say로 대체해도 괜찮다 면 0xd5자를 더 저장할 수 있습니다 (점수 : 33.6).

J-22.4 ^{= 28 * 0.8}

mxmul의 영리한 순환 방법을 기반으로 합니다.

f=:<:{('yes',~12 3$'no ')$~]

예 :

   f 13
yes
   f 23
no
   f 13*513
yes
   f 123456789
no

JavaScript (공백의 경우 108 미만 0) => 108, x 0.8 (모듈러스 없음, 나눗셈 없음) = 86.4

b=b=>{a=z,a=a+"";return+a.slice(0,-1)+4*+a.slice(-1)};z=prompt();for(i=99;i--;)z=b();alert(b()-z?"no":"yes")

이 방법은 다음 알고리즘을 사용합니다. 1. 마지막 숫자를 취하고 4를 곱한 후 잘린 숫자의 나머지에 더합니다. 2. 99 번의 반복에 대해 1 단계를 반복하십시오 ... 3. 1 단계를 사용하여 1 번 더 테스트하십시오. 결과 수가 그 자체라면 13의 배수를 찾았습니다.

var빼기 거짓 조건부를 사용하여 더 많은 문자를 제거하라는 경고에서 이전 업데이트, 제거 및 역 논리

기술적으로 최종 결과는 13, 26 또는 39와 같은 두 자리 숫자에 도달하여 1 단계를 다시 실행할 때 각각 13, 26 또는 39를 제공한다는 것입니다. 따라서 반복 100에 대한 테스트가 동일한 지 여부를 확인합니다.

체다, 20 바이트 (비경쟁)

점수는 20 * 0.9 = 18입니다

n->n*2%26?'no':'yes'

간단한 답변.

공통 리스프 (71 바이트 * 0.8) = 56.8

간단한 재귀입니다.

(defun w(x)(if(> x 14)(w(- x 13))(if(> 14 x 12)(print'yes)(print'no))))

언 골프 드 :

(defun w (x)
  (if (> x 14)
      (w (- x 13))
      (if (> 14 x 12)
          (print 'yes)
          (print 'no))))

루비 ( 50 48 * 0.9 = 43.2)

똑똑한 사용 방법 eval

eval x="p gets.to_i*3%x.length == 0? 'yes':'no'"

D 56 자 .80 보너스 = 44.8

bool d(double i){
    return modf(i*0,0769230769,i)<1e-3;
}

이것은 1/13을 사용하여 cop-out되었을 수 있으며 double은 32 비트 숫자를 정확하게 저장할 수 있습니다

편집 : 이것은 1/13을 곱하고 분수 부분이 0과 다르면 (반올림 오류 허용) 또는 다른 말로하면 i / 13의 분수 부분을 확인하여 작동합니다

파이썬 2.7

(20-1 공백) * 0.9 (나눗셈 없음) = 17.1

print input()%015==0

참 / 거짓 대신 예 / 아니요 : 31 * 0.9 (나눗셈 없음) = 27.9

print'yneos'[input()%015!=0::2]

파이썬을 이용합니다 int 하여 다른 염기를 문자열에서 기본 10 정수로 변환합니다. 두 버전에서 서로 다른 문자 길이를 사용하는 것을 알 수 있습니다.

편집 : 예 / 아니오 버전에서 1 문자 저장

edit2 : 또 다른 2 개의 문자가 면도되었습니다!

edit3 : 의견 감사합니다! int의 기본 번역 대신 파이썬의 내장 8 진 표현 ( 015== 13...) 을 사용하여 더 많은 문자가 면도되었습니다.

펄, 95 * 0.8 = 76

$_=<>;
while($_>0){
$q=7*chop;
$d=3*($m=chop$q);
chop$d;
$_-=$d+$m}
if($_){print"no"}
else{print"yes"}

명확성을 위해 줄 바꿈이 추가되었습니다. 이 답변을 훨씬 짧게 만들 수도 있었지만이 답변은 문제에 접근하는 독특한 방법을 나타냅니다.

파이썬-27.9 점

(31 자 * 0.90) -더 짧은 코드에 대한 보너스가 없습니다.

print'yneos'[2*input()%26>0::2]

이전 버전 : (47 자 * 0.80)-mellamokb의 Javascript 답변을 완전히 제거했지만 Python.

n=2*input()
while n>0:n-=26
print'yneos'[n<0::2]

이전 버전 : (60 자 * 0.80)

n=input()
while n>12:
 for _ in'x'*12+'!':n-=1
print'yneos'[n>0::2]

이전 버전 : (105 자 * 0.80)

n=abs(input())
while n>12:n=abs(sum(int(x)*y for x,y in zip(`n`[::-1],n*(1,-3,-4,-1,3,4))))
print'yneos'[n>0::2]

Q에서 :

d:{$[0=x mod "I"$((string 6h$"q")[1 2]);`yes;`no]}
50*.9=45

오른쪽 선형 문법-∞ points

S->ε
S->1A
S->0S
S->9I
S->3C
S->5E
S->4D
S->2B
S->7G
S->6F
S->8H
F->3K
K->0F
A->2L
K->1G
A->5B
A->0J
B->7A
J->5A
G->6K
G->8S
H->9K
F->5S
K->2H
I->6E
I->5D
J->4S
D->8I
B->6S
K->9B
F->6A
G->9A
K->6L
K->4J
C->1E
L->8K
E->5C
B->4K
C->0D
J->2K
D->2C
A->9F
J->7C
C->6J
C->8L
E->0K
L->0C
B->9C
E->2S
L->6I
I->0L
J->0I
B->2I
I->3B
H->1C
I->7F
C->4H
F->1I
G->4I
I->0G
C->3G
F->8C
D->0A
E->3A
I->9H
A->7D
C->2F
H->7I
A->8E
F->9D
E->8F
A->6C
D->6G
G->0E
D->5F
E->9G
H->2D
D->7H
H->3E
I->2A
K->3I
C->9S
C->7K
E->4B
D->1B
L->1D
J->9E
I->1S
E->1L
J->8D
D->9J
L->2E
J->3L
B->5L
B->8B
L->7J
L->9L
G->1F
A->4A
K->5K
B->3J
H->6H
E->7E
J->1J
D->4E
G->2G
J->6B
D->3D
E->6D
H->4F
I->4C
C->5I
F->0H
H->5G
K->7S
G->3H
L->5H
H->8J
A->3S
H->0B
B->1H
G->7L
K->8A
F->2J
F->7B
L->4G
F->4L
A->1K
B->0G
G->5J
L->3F

그런 다음 '실행'을 선택한 방법에 따라 '예'또는 '아니오'가 출력됩니다.

진지한 입장이 아니라 단지 재미;)

편집 : 아마도 조금 설명해야합니다.

문법 정의하는 규칙 (제작)의 집합입니다 언어 . 언어는 문법 규칙에 맞는 알파벳으로 구성된 가능한 모든 문자열로 생각할 수 있습니다.

여기서 알파벳은 모든 십진수의 집합입니다. 문법 규칙은 모든 문자열이 13으로 나눌 수있는 십진 정수를 형성해야한다는 것입니다.

위의 문법을 사용하여 문자열이 언어에 속하는지 테스트 할 수 있습니다.

문법 규칙에는 재귀 적으로 대체되는 비단 자 기호뿐만 아니라 터미널 기호 (언어의 요소)가 포함됩니다.

예제로 무슨 일이 일어나고 있는지 설명하는 것이 더 쉽습니다.

예를 들어 테스트하는 문자열이 71955라고 가정 해 봅시다.

항상 시작 기호 (비 터미널)가 있으며 위의 문법의 경우 'S'입니다. 이 시점에서 우리는 문자열에서 어떤 문자도 읽지 않았습니다 :

current pattern                    symbol read
S                                  ε

이제 문자열에서 '7'인 첫 번째 기호를 읽은 다음 문법에서 '->'의 왼쪽에 현재 패턴의 비 터미널이있는 규칙을 찾습니다. '->'의 오른쪽에 기호가 있습니다. 운 좋게도 하나 (S-> 7G)가 있으므로 현재 패턴의 비 터미널 기호를 새 규칙의 오른쪽으로 바꿉니다.

current pattern                    symbol read
7G                                 7

이제 패턴에 비 터미널 'G'가 있으며 다음으로 읽을 기호는 '1'이므로 문법에서 'G-> 1'로 시작하는 규칙을 찾습니다. (G-> 1F) 비 터미널을 새로운 규칙의 RHS로 대체합니다.

current pattern                    symbol read
71F                                1

이 과정을 계속 반복하십시오.

다음 규칙 : F-> 9D

current pattern                    symbol read
719D                               9

다음 규칙 : D-> 5F

current pattern                    symbol read
7195F                              5

다음 규칙 : F-> 5S

current pattern                    symbol read
71955S                             5

이 시점에서 우리는 더 이상 문자열에 기호가 없지만 거기에 다른 비 터미널 기호가 있습니다. 문법의 첫 번째 규칙에서 'S'를 빈 문자열 (ε)로 바꿀 수 있음을 알 수 있습니다. S-> ε

그렇게하면 현재 후두둑 : 71955ε이 71955에 해당합니다.

문자열의 모든 기호를 읽었으며 패턴에는 비 터미널 기호가 없습니다. 이는 문자열이 언어에 속하므로 71955는 실제로 13으로 나눌 수 있음을 의미합니다.

즉, 목표는 패턴 = 문자열을 갖는 것입니다. 터미널이 아닌 기호가 남아있는 경우 문자열의 모든 기호를 읽은 후에는 문자열이 언어에 속하지 않습니다. 마찬가지로, 문자열에 읽을 기호가 더 있지만 문법에 규칙이 없으면 문자열이 언어에 속하지 않습니다.