Ваша задача, если вы решите принять ее, - создать функцию или программу, которая выдает «да», если данное число делится на 13, и выдает «нет», если это не так.

Правила:
- Вы не можете использовать номер 13 в любом месте.
- Никаких синонимов для 13 тоже нет (как при использовании 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 - 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 использует арифметику bignum. Конечно, очень большие входы могут потреблять чрезмерное время и / или память.

В коде не используются ни модули, ни деление напрямую, хотя он использует базовый оператор преобразования GolfScipt, который почти наверняка выполняет некоторое деление и взятие остатков внутри. Я оставлю это на GigaWatt, чтобы решить, соответствует ли это мне бонусу или нет.

С 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

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

Читает со стандартного ввода. Вероятно, не самое умное решение, но получить все, что работает в BF, приятно. Это довольно компактно, хотя.

Скала (38 * 0,9 = 34,2)

Аналогично 0xD(hex) или 015(oct).

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

Например

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

дает

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

С 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 ( ∨) наших input ( ⎕) и 13, а затем проверяем, равно ли это 1. Это используется для индексации ( [...]) вектора ответов.

Если кто-то хочет быть педантичным в отношении упоминания байтов в спецификации оценки, оценка для зашифрованной версии UTF-8 такова (29 - 1) × 0.8 = 22.4. :)

С, 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 , в конечном счете достигнет одного из этих значений не более чем лог ₁₀ п итераций.

В других базах

По общему признанию, 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-программа. Полагаю, слабо набрано для гольфа.

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

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

EDIT1: хорошо, удалили все зависимости от внешних функций, вышеописанное будет работать до тех пор, пока вы поместите эту строку в 13-ю строку файла! :) Если __LINE__можно заменить на скажем, 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 меньше 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. Возьмите последнюю цифру, умножьте ее на четыре, добавьте к остальному усеченному числу. 2. Повторите шаг 1 для 99 итераций ... 3. Протестируйте его еще раз, используя шаг 1, если полученное число само по себе, вы нашли кратное 13.

Предыдущее обновление, удаление varи обратная логика в предупреждении для удаления большего числа символов с использованием условного вычитания-ложного.

Технически, конечный результат заключается в том, что вы в конечном итоге достигнете двузначного числа, такого как 13, 26 или 39, которое при повторном выполнении шага 1 даст 13, 26 или 39 соответственно. Таким образом, тестирование на итерацию 100, являющееся одним и тем же, подтвердит делимость.

Чеддер, 20 байтов (неконкурентный)

Оценка 20 * 0,9 = 18

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

Простой ответ.

Common Lisp (71 байт * 0,8) = 56,8

Простая рекурсия, правда.

(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))))

Рубин ( 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, и двойной может хранить любое 32-битное число точно

редактировать: это работает путем умножения на 1/13 и проверки дробной части, если она отличается от 0 (с учетом ошибок округления), или другими словами, она проверяет дробную часть i / 13

Python 2.7

(20 - 1 пробел) * 0,9 (без деления) = 17,1

print input()%015==0

да / нет вместо истина / ложь: 31 * 0,9 (без деления) = 27,9

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

использует преимущества Python intдля преобразования других баз из строк в целые 10. вы можете видеть, что в обеих версиях используется разная (но одинаковая длина символов)

редактировать: 1 символ сохранить в да / нет версии

edit2: еще 2 символа побрился!

edit3: еще раз спасибо за комментарии! еще больше символов сбрасывается с помощью встроенных восьмеричных представлений python ( 015== 13...) вместо базового перевода 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"}

Для ясности добавлены разрывы строк. Возможно, я мог бы сделать этот ответ намного короче, но я чувствую, что этот ответ представляет собой уникальный способ решения проблемы.

Питон - оценка 27,9

(31 символ * 0,90) - отказывается от бонуса за более короткий код.

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

более старая версия: (47 символов * 0,80) - полный ответ на Javascript от mellamokb, но на языке 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

Правая линейная грамматика - ∞ баллов

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.

Т.е. цель состоит в том, чтобы pattern = string. Если у вас остались какие-либо нетерминальные символы, после прочтения всех символов в вашей строке строка не принадлежит языку. Аналогично, если в вашей строке еще есть символы для чтения, но в грамматике нет правил, позволяющих вам двигаться вперед, тогда строка не принадлежит языку.