Якщо ви вирішите прийняти це, ваше завдання - створити функцію або програму, яка виводить "так", якщо задане число ділиться на 13, а виходить "ні", якщо його немає.

Правила:
- Вам заборонено використовувати номер 13 ніде.
- Немає жодних синонімів для викидання для 13 (наприклад, використання 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 - 16 біт x86 на командній оболонці WinXP

виконуваний файл - 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, було б складно без використання самого числа 13 (або якогось кульгавого вирішення типу 12 + 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 використовує арифметику бінуму. Звичайно, надзвичайно великі входи можуть вимагати зайвого часу та / або пам'яті.

Код не використовує ні модулів, ні поділ безпосередньо, хоча він використовує базовий оператор перетворення GolfScipt, який майже напевно виконує деякий поділ і залишки, що приймаються всередині. Я залишу це на GigaWatt, щоб вирішити, кваліфікує мене це за бонус чи ні.

C, 68 * 0,8 = 54,4

Після 24 відповідей ніхто не придумав цього очевидного алгоритму:

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

JavaScript (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(hex) або015 (oct).

Значення ASCIICR становить 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]

⎕IOдля правильної роботи в програмі Dyalog APL слід встановити 0. Щоб генерувати 13, беремо підлогу ( ⌊) природного логарифму ( ⍟) 9 до потужності 6 ( 9*6). Після цього ми знаходимо GCD ( ∨) нашого введення ( ⎕) та 13, а потім перевіряємо, чи дорівнює це 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));}

Perl - 44 × 0,8 = 35,2

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

Порахувавши шебанг як один байт.

Я трохи запізнююся на гру, але я подумав, що поділюсь алгоритмом, оскільки жоден інший пост до цього часу не використовував його.

Це працює під спостереженням, що якщо n ділиться на 13 , то ⌊ n / 10 ⌋ + n% 10 * 4 також ділиться на 13 . Значення 13 , 26 і 39 циклично перетворюються на себе. Усі інші кратні 13 з часом досягнуть одного з цих значень не більше ніж log ₁₀ n ітерацій .

В інших базах

Справді, chopце трохи коп. З базовим представництвом 10 це еквівалентно divmod. Але алгоритм добре працює в інших базах, наприклад, в базі 4 або 8.

Псевдо-код стилю Python у наведеному вище алгоритмі (база 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 працює однаково добре.

Javascript: 59 * 0,8 = 47,2 (?)

загадка :

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

У тому числі покращення меламокба (57 * 0,8 = 45,6):

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

Perl: (51-4 пробіли) * 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 байт * .9

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

Примітка: Моя перша програма Perl коли-небудь. Слабо набраний хороший для гольфу я здогадуюсь.

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

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

EDIT1: добре видалено всі залежності від зовнішніх функцій, вищезгадане буде працювати до тих пір, поки ви поставите цей рядок у 13-му рядку файлу! :) Якщо __LINE__нормально замінити слово say, 0xdтоді можна зберегти ще 5 символів (оцінка: 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 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.