Thách thức của bạn, nếu bạn chọn chấp nhận nó, là tạo một hàm hoặc một chương trình xuất ra "có" nếu một số đã cho chia hết cho 13 và xuất ra "không" nếu không.

Quy tắc:
- Bạn không được phép sử dụng số 13 ở bất cứ đâu.
- Không có từ đồng nghĩa cop-out cho 13 hoặc (như sử dụng 15 - 2).
- Điểm thưởng sẽ được trao cho việc không sử dụng mô-đun, tiền thưởng bổ sung cho việc không sử dụng phép chia.

Chấm điểm:
- Điểm của bạn sẽ là số byte trong mã của bạn ( không bao gồm khoảng trắng ) nhân với phần thưởng của bạn.
- Nếu bạn không sử dụng mô-đun, phần thưởng đó là 0,90; nếu bạn không sử dụng phép chia, phần thưởng đó là 0,90.
- Nếu bạn không sử dụng, phần thưởng đó là 0,80.
- Điểm của bạn càng thấp thì càng tốt.

Đầu vào sẽ luôn là một số nguyên lớn hơn 0 và nhỏ hơn 2 ^ 32.
Đầu ra của bạn phải là "có" hoặc "không" đơn giản.

Làm rõ:
- Sử dụng một số phương pháp đường vòng để tạo số 13 để sử dụng là chấp nhận được. Các từ đồng nghĩa số học đơn giản như (10 + 3) không được phép.
- Hàm hoặc chương trình phải xuất ra "có" hoặc "không" theo nghĩa đen nếu số đã cho chia hết cho 13.
- Như mọi khi, các giải pháp thông minh được khuyến nghị, nhưng không bắt buộc.

Java (điểm 60,8 59,2)

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

Điểm: (76 - 2 khoảng trắng) ký tự * 0.8 = 59.2

ASM - 16 bit x86 trên shell lệnh WinXP

thực thi - 55 byte * 0.8 = 44

nguồn - 288 ký tự * 0,8 = 230,4

Số 13 thậm chí không xuất hiện trong tệp .com đã lắp ráp.

Lắp ráp bằng 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$'

Con trăn 3.x: 54 * 0.8 = 43.2

Nó có thể là một bản sao để có một chuỗi dài 13, nhưng ở đây nó có:

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

Nó hoạt động bằng cách xây dựng một chuỗi n không gian (sự lựa chọn dấu phân cách là tùy ý, nhưng tôi đã chọn không gian vì lý do rõ ràng) và tách các chuỗi con 13 không gian cho đến khi bạn còn lại một chuỗi chứa n% 13 khoảng trắng.

GolfScript, 32 ký tự

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

Tôi muốn thử một cái gì đó khác với mọi người, vì vậy giải pháp của tôi tính toán gốc số 14 của số, bằng cách liên tục chuyển đổi số thành cơ sở 14 và tính tổng các chữ số cho đến khi kết quả không còn nhỏ hơn nữa. Điều này về cơ bản giống như tính toán modulo 13 còn lại, ngoại trừ kết quả sẽ nằm trong phạm vi từ 1 đến 13 thay vì 0 đến 12.

Vì việc kiểm tra xem gốc kỹ thuật số bằng 13 có khó không nếu không sử dụng chính số 13 (hoặc một số cách giải quyết khập khiễng như 12 + 1), điều tôi thực sự làm là tăng số đầu vào lên một trước vòng lặp và giảm kết quả sau đó. Theo cách đó, kết quả cho các số chia hết cho 13 trên thực tế sẽ bằng 0, dễ kiểm tra hơn nhiều.

Đây là một phiên bản bình luận của chương trình:

~              # 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

Chương trình này sẽ thực sự xử lý bất kỳ đầu vào số nguyên không âm nào, vì GolfScript sử dụng số học bignum. Tất nhiên, đầu vào cực lớn có thể tiêu tốn quá nhiều thời gian và / hoặc bộ nhớ.

Mã này không sử dụng trực tiếp mô đun hoặc phân chia, mặc dù nó sử dụng toán tử chuyển đổi cơ sở của GolfScipt, gần như chắc chắn thực hiện một số phân chia và phần còn lại trong nội bộ. Tôi sẽ để lại cho GigaWatt để quyết định xem điều này có đủ điều kiện cho tôi nhận tiền thưởng hay không.

C, 68 * 0,8 = 54,4

Sau 24 câu trả lời, vẫn chưa có ai nghĩ ra thuật toán rõ ràng này:

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

JavaScript (27.9)

Phiên bản hiện tại (31 ký tự * 0,90 tiền thưởng = 27,9).

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

Bản trình diễn: http://jsfiddle.net/9GQ9m/2/

Chỉnh sửa 1: Bỏ phần thưởng thứ hai bằng cách sử dụng mô-đun để giảm điểm đáng kể và tránh forvòng lặp. Cũng loại bỏ ~~và lưu hai ký tự (cảm ơn @copy).

Phiên bản cũ hơn (48 ký tự * 0,80 tiền thưởng = 38,4)

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

BrainFuck

Điểm: 200 * 0,8 = 160

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

Đọc từ stdin. Có lẽ không phải là giải pháp thông minh nhất, nhưng nhận được bất cứ điều gì hoạt động trong BF là tốt. Nó khá nhỏ gọn mặc dù.

Scala (38 * 0,9 = 34,2)

Tương tự như 0xD(hex) hoặc 015(oct).

Giá trị ASCIICR là 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"

Con trăn

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

Ví dụ

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

cho

[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

Vâng, đó là một cách nhàm chán để nhận được 13.

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

APL ((21 - 1) × 0,8 = 16)

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

⎕IOnên được đặt thành 0 để điều này hoạt động chính xác trong Dyalog APL. Để tạo 13, chúng ta lấy sàn ( ⌊) của logarit tự nhiên ( ⍟) là 9 thành lũy thừa 6 ( 9*6). Sau đó, chúng tôi tìm thấy GCD ( ∨) của đầu vào ( ⎕) và 13 của chúng tôi và sau đó chúng tôi kiểm tra xem nó có bằng 1. Điều này được sử dụng để lập chỉ mục ([...] ) vectơ của câu trả lời.

Nếu bất cứ ai muốn trở thành nhà mô phạm về việc đề cập đến byte trong đặc tả điểm, thì điểm cho phiên bản được mã hóa UTF-8 của điều này là (29 - 1) × 0.8 = 22.4. :)

C, 88

Thủ thuật Fibonacci.

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

Đếm shebang là một byte.

Tôi hơi trễ trò chơi, nhưng tôi nghĩ tôi sẽ chia sẻ thuật toán, vì không có bài viết nào khác cho đến thời điểm này đã sử dụng nó.

Điều này hoạt động theo quan sát rằng nếu n chia hết cho 13 , thì ⌊ n / 10 + n% 10 * 4 cũng chia hết cho 13 . Các giá trị 13 , 26 và 39 tự chu kỳ. Tất cả các bội số khác của 13 cuối cùng sẽ đạt được một trong các giá trị này không quá log ₁₀ n lần lặp.

Trong các căn cứ khác

Phải thừa nhận rằng, choplà một chút của một cảnh sát. Với đại diện cơ sở 10, nó tương đương với divmod. Nhưng thuật toán hoạt động hoàn hảo trong các cơ sở khác, ví dụ cơ sở 4 hoặc 8.

Mã giả kiểu Python của thuật toán trên (cơ sở 10):

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

Trong cơ sở 2:

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

Trong cơ sở 4:

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

Trong cơ sở 8:

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

vv Bất kỳ cơ sở nhỏ hơn 13 hoạt động tốt như nhau.

Javascript: 59 * 0.8 = 47.2 (?)

bí ẩn :

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

Bao gồm cải tiến của mellamokb (57 * 0.8 = 45.6):

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

Perl: (51-4 dấu cách) * 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 byte * .9

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

chú thích: chương trình Perl đầu tiên của tôi từ trước đến nay. Tôi đánh máy yếu là tốt cho golf tôi đoán.

trong C (K & R): 47 * 0,8 = 37,6

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

EDIT1: được loại bỏ tất cả các phụ thuộc vào các chức năng bên ngoài, ở trên sẽ hoạt động miễn là bạn đặt dòng này trên dòng thứ 13 của tệp! :) Nếu __LINE__được thay thế bằng cách nói 0xdthì có thể lưu thêm 5 ký tự (điểm: 33,6)

J - 22,4 ^{= 28 * 0,8}

Dựa trên phương pháp tuần hoàn thông minh của mxmul .

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

Ví dụ:

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

JavaScript (108 ít hơn 0 cho khoảng trắng) => 108, x 0,8 (không có mô đun, không phân chia) = 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")

Phương pháp này sử dụng thuật toán sau: 1. Lấy chữ số cuối cùng, nhân nó với bốn, thêm nó vào phần còn lại của số bị cắt. 2. Lặp lại bước 1 cho 99 lần lặp ... 3. Kiểm tra lại một lần nữa bằng bước 1, nếu số kết quả là chính nó, bạn đã tìm thấy bội số của 13.

Cập nhật trước đó, loại bỏ varvà đảo ngược logic tại cảnh báo để loại bỏ nhiều ký tự hơn bằng cách sử dụng điều kiện trừ-sai.

Về mặt kỹ thuật, kết quả cuối cùng là cuối cùng bạn sẽ đạt được một số có hai chữ số như 13, 26 hoặc 39 mà khi chạy qua bước 1 một lần nữa sẽ cho 13, 26 hoặc 39 tương ứng. Vì vậy, thử nghiệm cho lần lặp 100 giống nhau sẽ xác nhận tính phân chia.

Cheddar, 20 byte (không lọc)

Điểm là 20 * 0,9 = 18

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

Một câu trả lời thẳng thắn.

Lisp thường gặp (71 byte * 0,8) = 56,8

Đệ quy đơn giản, thực sự.

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

Ung dung:

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

Hồng ngọc ( 50 48 * 0,9 = 43,2)

Cách sử dụng thông minh eval

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

D 56 ký tự .80 tiền thưởng = 44,8

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

đây có thể là một khoản đồng thanh toán với việc sử dụng 1/13 và gấp đôi có thể lưu trữ chính xác bất kỳ số 32 bit nào

chỉnh sửa: điều này hoạt động bằng cách nhân với 1/13 và kiểm tra phần phân số nếu nó khác 0 (cho phép sai số làm tròn) hoặc nói cách khác, nó kiểm tra phần phân số của i / 13

Python 2.7

(20 - 1 khoảng trắng) * 0,9 (không phân chia) = 17,1

print input()%015==0

có / không thay vì đúng / sai: 31 * 0.9 (không chia) = 27.9

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

lợi dụng python intđể chuyển đổi các cơ sở khác từ chuỗi thành số nguyên cơ sở 10. bạn có thể thấy trong cả hai phiên bản họ sử dụng một cơ sở khác nhau (nhưng cùng độ dài ký tự)

chỉnh sửa: 1 char lưu trong có / không có phiên bản

chỉnh sửa2: 2 ký tự cạo khác!

chỉnh sửa 3: cảm ơn một lần nữa để bình luận! thậm chí nhiều nhân vật còn bị loại bỏ bằng cách sử dụng các biểu diễn bát phân dựng sẵn của python ( 015== 13...) thay vì bản dịch cơ sở của int

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"}

Các ngắt dòng đã được thêm vào cho rõ ràng. Tôi có thể đã có thể làm cho câu trả lời này ngắn hơn rất nhiều, nhưng tôi cảm thấy rằng câu trả lời này đại diện cho một cách tiếp cận vấn đề độc đáo.

Con trăn - điểm 27,9

(31 ký tự * 0,90) - bỏ qua một số phần thưởng cho mã ngắn hơn.

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

phiên bản cũ hơn: (47 ký tự * 0,80) - trích xuất hoàn toàn câu trả lời Javascript của mellamokb, nhưng bằng Python.

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

phiên bản cũ hơn: (60 ký tự * 0,80)

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

phiên bản cũ hơn: (105 ký tự * 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]

Trong Q:

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

Ngữ pháp tuyến tính phải - điểm

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

Sau đó, tùy thuộc vào cách bạn chọn 'chạy' nó, nó sẽ xuất ra 'có' hoặc 'không'.

Không phải là một mục nghiêm túc, chỉ là một số niềm vui;)

EDIT: Có lẽ tôi nên giải thích một chút.

Một ngữ pháp là một tập hợp các quy tắc (sản phẩm) xác định một ngôn ngữ . Một ngôn ngữ có thể được coi là tất cả các chuỗi có thể được hình thành bởi một bảng chữ cái, phù hợp với các quy tắc ngữ pháp của nó.

Ở đây bảng chữ cái là tập hợp của tất cả các chữ số thập phân. Các quy tắc của ngữ pháp là tất cả các chuỗi phải tạo thành các số nguyên thập phân chia hết cho 13.

Chúng ta có thể sử dụng ngữ pháp ở trên để kiểm tra xem một chuỗi có thuộc ngôn ngữ của chúng ta hay không.

Các quy tắc của ngữ pháp chứa các ký hiệu đầu cuối (là các thành phần trong ngôn ngữ) cũng như các ký hiệu không đầu cuối được thay thế theo cách đệ quy.

Thật dễ dàng để giải thích những gì đang xảy ra với một ví dụ:

Hãy nói ví dụ rằng chuỗi chúng tôi đang kiểm tra là 71955.

Luôn có một ký hiệu bắt đầu (không phải là thiết bị đầu cuối), trong trường hợp ngữ pháp ở trên đây là 'S'. Tại thời điểm này, chúng tôi chưa đọc bất kỳ ký tự nào trong chuỗi của chúng tôi:

current pattern                    symbol read
S                                  ε

Bây giờ, chúng tôi đọc ký hiệu đầu tiên trong chuỗi của chúng tôi là '7', sau đó chúng tôi tìm một quy tắc trong ngữ pháp có bất kỳ ký tự không nào trong mẫu hiện tại của chúng tôi ở phía bên trái của '->' và đó có biểu tượng của chúng tôi ở phía bên phải của '->'. May mắn thay, có một (S-> 7G), vì vậy chúng tôi thay thế các biểu tượng không đầu cuối trong mẫu hiện tại của chúng tôi bằng phía bên phải của quy tắc mới:

current pattern                    symbol read
7G                                 7

Bây giờ chúng ta có mẫu 'G' không phải đầu cuối trong mẫu của chúng tôi và ký hiệu tiếp theo được đọc là '1', vì vậy chúng tôi tìm một quy tắc trong ngữ pháp bắt đầu bằng 'G-> 1 ". Chúng tôi thấy có một (G-> 1F), vì vậy chúng tôi thay thế thiết bị đầu cuối không bằng RHS của quy tắc mới của chúng tôi:

current pattern                    symbol read
71F                                1

Tiếp tục lặp lại quá trình này:

Quy tắc tiếp theo: F-> 9D

current pattern                    symbol read
719D                               9

Quy tắc tiếp theo: D-> 5F

current pattern                    symbol read
7195F                              5

Quy tắc tiếp theo: F-> 5S

current pattern                    symbol read
71955S                             5

Tại thời điểm này, chúng ta không còn ký hiệu nào trong chuỗi, nhưng chúng ta có một ký hiệu không đầu cuối khác trong đó. Chúng ta thấy từ quy tắc đầu tiên trong ngữ pháp mà chúng ta có thể thay thế 'S' bằng chuỗi trống (ε): S->

Làm như vậy cung cấp cho chúng tôi mẫu hiện tại: 71955ε tương đương với 71955.

Chúng tôi đã đọc tất cả các ký hiệu trong chuỗi của chúng tôi và mẫu không chứa các ký hiệu không phải đầu cuối. Điều đó có nghĩa là chuỗi thuộc về ngôn ngữ và do đó 71955 trên thực tế chia hết cho 13.

Tức là mục tiêu là có mẫu = chuỗi. Nếu bạn còn lại với bất kỳ ký hiệu không đầu cuối nào, sau khi đọc tất cả các ký hiệu trong chuỗi của bạn, chuỗi không thuộc về ngôn ngữ. Tương tự, nếu bạn vẫn có nhiều ký hiệu trong chuỗi của mình để đọc, nhưng không có quy tắc nào trong ngữ pháp cho phép bạn đi tiếp, thì chuỗi đó không thuộc về ngôn ngữ.