如果您选择接受它，那么您面临的挑战是创建一个函数或程序，如果给定数字可被13整除，则输出“是”，否则将输出“否”。

规则：
-不允许在任何地方使用数字13。
-也没有针对13的cop-out同义词（例如使用15-2）。
-如果不使用模数，将获得奖励积分，如果不使用除法，则将获得额外奖励。

评分：
-您的分数将是代码中的字节数（不包括空格）乘以您的奖金。
-如果您不使用模数，则该奖励为0.90；如果您不使用除法，则该奖金为0.90。
-如果您都不使用，则该奖励为0.80。
-分数越低越好。

输入将始终是大于0且小于2 ^ 32的整数。
您的输出应该是简单的“是”或“否”。

澄清：
-可以采用一些绕行方法来生成数字13。不允许使用简单的算术同义词，例如（10 + 3）。
- 如果给定的数字可被13整除，则函数或程序必须按字面输出 “是”或“否”。-
与往常一样，建议（但不是必须）明智的解决方案。

Java（得分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$'

Python 3.x：54 * 0.8 = 43.2

长度为13的字符串可能很适合，但在这里行得通：

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

它的工作方式是构建一个由n个空格组成的字符串（定界符的选择是任意的，但出于显而易见的原因，我选择了空格），然后拆分13个空格的子字符串，直到剩下包含n％13个空格的字符串为止。

GolfScript，32个字符

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

我想尝试与众不同的方法，因此我的解决方案通过将数字重复转换为以14为基数来计算数字的以14为底的数字根并求和直到结果不再变小。这与计算余数模13基本相同，除了结果将在1到13而不是0到12的范围内。

由于不使用数字13本身（或某些类似12 + 1的la脚解决方法）很难检查数字根是否等于13，因此我实际要做的是在循环之前将输入数字加1，然后再减少结果。这样，被13整除的数字的结果实际上将为零，这很容易检查。

这是程序的注释版本：

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

JavaScript (27.9)

Current version (31 characters * 0.90 bonus = 27.9).

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

Demo: http://jsfiddle.net/9GQ9m/2/

Edit 1: Forgo second bonus by using modulus to lower score considerably and avoid for loop. Also eliminate ~~ and save two chars (thanks @copy).

Older version (48 characters * 0.80 bonus = 38.4)

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

BrainFuck

Score: 200 * 0.8 = 160

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

Reads froms stdin. Probably not the most clever solution, but getting anything that works in BF is nice. It's quite compact though.

Scala (38 * 0.9 = 34.2)

Similar to 0xD(hex) or 015(oct).

ASCII value of CR is 13.

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

Haskell, 28 * 0.8 = 22.4

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

Python:

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

E.g.

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

gives

[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

Yeah, it's a boring way of getting 13.

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

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

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

⎕IO should be set to 0 for this to work properly in Dyalog APL. To generate 13, we take the floor (⌊) of the natural logarithm (⍟) of 9 to the power of 6 (9*6). After that, we find the GCD (∨) of our input (⎕) and 13, and we then test if that equals 1. This is used to index ([...]) the vector of answers.

If anyone wants to be pedantic about the mention of bytes in the scoring specification, the score for the UTF-8 encoded version of this is (29 - 1) × 0.8 = 22.4. :)

C, 88

Fibonacci trick.

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

Perl - 44 × 0.8 = 35.2

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

Counting the shebang as one byte.

I'm a bit late to the game, but I thought I'd share the algorithm, as no other posts to this point have used it.

This works under the observation that if n is divisible by 13, then ⌊n/10⌋+n%10*4 is also divisible by 13. The values 13, 26 and 39 cycle onto themselves. All other multiples of 13 will eventually reach one of these values in no more than log₁₀ n iterations.

In Other Bases

Admittedly, chop is a bit of a cop-out. With a base 10 representation, it's equivalent to divmod. But the algorithm works prefectly well in other bases, for example base 4, or 8.

Python style pseudo-code of the above algorithm (base 10):

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

In base 2:

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

In base 4:

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

In base 8:

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

etc. Any base smaller than 13 works equally well.

Javascript: 59*0.8 = 47.2 (?)

fiddle:

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

Including mellamokb's improvement (57*0.8 = 45.6):

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

Perl: (51-4 spaces)*0.9 = 42.3

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

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

Perl (19.8)

21 bytes * .9

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

note: My first Perl program ever. Weakly typed is good for golf i guess.

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

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

EDIT1: okay removed all dependencies on external functions, the above will work as long as you put this line on the 13th line of the file! :) If __LINE__ is okay to be replaced by say 0xd then can save a further 5 characters (score: 33.6)

J - 22.4 ^{= 28 * 0.8}

Based on mxmul's clever cyclic method.

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

Examples:

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

JavaScript (108 less 0 for whitespace) => 108, x 0.8 (no modulus, no division) = 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")

This method uses the following algorithm: 1. Take the last digit, multiply it by four, add it to the rest of the truncated number. 2. Repeat step 1 for 99 iterations... 3. Test it one more time using step 1, if the resulting number is itself, you've found a multiple of 13.

Previous update, removed var, and reversed logic at the alert to remove more chars by using subtraction-false conditional.

Technically, the end result is that you'll eventually reach a two digit number like 13, 26, or 39 which when run through step 1 again will give 13, 26, or 39 respectively. So testing for iteration 100 being the same will confirm the divisibility.

Cheddar, 20 bytes (noncompeting)

Score is 20 * 0.9 = 18

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

A straightforward answer.

Common Lisp (71 bytes * 0.8) = 56.8

Simple recursion, really.

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

Ungolfed:

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

Ruby (50 48 * 0.9 = 43.2)

Smart way to use eval

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

D 56 chars .80 bonus = 44.8

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

this might have been a cop-out with using 1/13 and a double can store any 32 bit number exactly

edit: this works by multiplying with 1/13 and checking the fractional part if it's different from 0 (allowing for rounding errors) or in other words it check the fractional part of i/13

Python 2.7

(20 - 1 whitespace) * 0.9 (no division) = 17.1

print input()%015==0

yes/no instead of true/false: 31 * 0.9 (no division) = 27.9

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

takes advantage of python's int to convert other bases from strings into base 10 integers. you can see in both versions they use a different (yet same character length) base

edit: 1 char save in yes/no version

edit2: another 2 chars shaved!

edit3: thanks again to comments! even more characters shaved off by using python's builtin octal representations (015 == 13...) instead of int's base translation

Perl, 95 * 0.8 = 76

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

The line breaks were added for clarity. I could have probably made this answer a lot shorter, but I feel that this answer represents a unique way of approaching the problem.

Python - score 27.9

(31 characters * 0.90) -- forgoes some bonus for shorter code.

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

older version: (47 characters * 0.80) -- complete rip-off of mellamokb's Javascript answer, but in Python.

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

older version: (60 characters * 0.80)

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

older version: (105 characters * 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]

In Q:

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

Right Linear Grammar - ∞ 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

Then depending on how you choose to 'run' it, it will output 'yes' or 'no'.

Not a serious entry, just some fun ;)

EDIT: Perhaps I should explain a bit.

A grammar is a set of rules (productions) which define a language. A language can be thought of as all of the possible strings formed by an alphabet, that conform to the rules of it's grammar.

Here the alphabet is the set of all decimal digits. The grammar's rules are that all strings must form decimal integers that are divisible by 13.

We can use the grammar above to test whether a string belongs to our language.

The rules of the grammar contain terminal symbols (which are elements in the language) as well as non-terminal symbols which are replaced recursively.

It's easier to explain what's going on with an example:

Lets say for example that the string we are testing is 71955.

There is always a start symbol (which is non-terminal), in the case of the grammar above this is 'S'. At this point we have not read any characters from our string:

current pattern                    symbol read
S                                  ε

Now, we read the first symbol in our string which is '7', then we look for a rule in the grammar which has any of the non-terminals in our current pattern in the left hand side of the '->' and that has our symbol in the right hand side of the '->'. Luckily there is one (S->7G), so we replace the non-terminal symbols in our current pattern with the right hand side of the new rule:

current pattern                    symbol read
7G                                 7

Now we have the non-terminal 'G' in our pattern, and the next symbol to be read is '1', So we look for a rule in our grammar that begins with 'G->1". We find there is one (G->1F), so we replace the non terminal with the RHS of our new rule:

current pattern                    symbol read
71F                                1

Keep repeating this process:

Next rule: F->9D

current pattern                    symbol read
719D                               9

Next rule: D->5F

current pattern                    symbol read
7195F                              5

Next rule: F->5S

current pattern                    symbol read
71955S                             5

At this point we have no more symbols in our string, but we have another non-terminal symbol in there. We see from the first rule in the grammar that we can replace 'S' with the empty string (ε): S->ε

Doing so gives us the current patter: 71955ε which is the equivalent to 71955.

We have read all of the symbols in our string, and the pattern contains no non-terminal symbols. Which means that the string belongs to the language and therefore 71955 is in fact divisible by 13.

I.e. the goal is to have pattern = string. If you are left with any non-terminal symbols, after reading all of the symbols in your string, the string doesnt belong to the language. Likewise, if you still have more symbols in your string to read, but there are no rules in the grammar allowing you to go forward, then the string does not belong to the language.