あなたの挑戦は、あなたがそれを受け入れることを選択した場合、与えられた数が13で割り切れる場合に「はい」を出力し、そうでない場合に「いいえ」を出力する関数またはプログラムを作成することです。

ルール：
-番号13はどこでも使用できません。
-13のいずれかの警戒同義語はありません（15-2を使用するなど）。
-モジュラスを使用しない場合はボーナスポイント、除算を使用しない場合は追加のボーナスポイントが付与されます。

スコアリング：
-スコアは、コードのバイト数（空白は含まれません）にボーナスを掛けたものになります。
-モジュラスを使用しなかった場合、そのボーナスは0.90です。除算を使用しなかった場合、そのボーナスは0.90です。
-どちらも使用しなかった場合、そのボーナスは0.80です。
-スコアが低いほど良い。

入力は常に0より大きく2 ^ 32より小さい整数です。
出力は、単純な「はい」または「いいえ」でなければなりません。

明確化：
-使用のために数13を生成する何らかのラウンドアバウト方式を使用することは許容されます。（10 + 3）のような単純な算術同義語は使用できません。
- 指定された数値が13で割り切れる場合、関数またはプログラムは文字通り「yes」または「no」を出力する必要があります。-
いつものように、賢明な解決策が推奨されますが、必須ではありません。

Java（スコア60.8 59.2）

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

スコア：（76-2個の空白）chars * 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個のスペースの文字列を作成して（区切り文字の選択は任意ですが、明らかな理由でスペースを選択します）、n％13個のスペースを含む文字列が残るまで13スペースのサブストリングを分割します。

GolfScript、32文字

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

他の人とは違う何かを試してみたかったので、私のソリューションでは、数値を基数14に繰り返し変換し、結果が小さくなるまで数字を合計することにより、基数14のデジタルルートを計算します。これは、結果が0〜12ではなく1〜13の範囲になることを除いて、13を法とする剰余の計算と本質的に同じです。

デジタルルートが13に等しいかどうかを確認することは、番号13自体（または12 + 1のような不完全な回避策）なしでは難しいため、実際に行うのは、ループの前に入力番号を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）

現在のバージョン（31文字* 0.90ボーナス= 27.9）。

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

デモ：http : //jsfiddle.net/9GQ9m/2/

編集1：モジュラスを使用してスコアを大幅に下げ、forループを回避することで、2番目のボーナスを忘れる また~~、2つの文字を削除して保存します（ありがとうございます@copy）。

古いバージョン（48文字* 0.80ボーナス= 38.4）

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

BrainFuck

スコア：200 * 0.8 = 160

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

froms stdinを読み取ります。おそらく最も賢い解決策ではありませんが、BFで機能するものを入手するのは良いことです。しかし、それは非常にコンパクトです。

Scala（38 * 0.9 = 34.2）

0xD（hex）または015（oct）と同様。

ASCII値CRは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]

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）にします。その後∨、入力（⎕）および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));}

Perl-44×0.8 = 35.2

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

シバンを1バイトとしてカウントします。

私はゲームに少し遅れましたが、この点の他の投稿では使用していないので、アルゴリズムを共有すると思いました。

場合、その観察下で、この作品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';
}

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スペース）* 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__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マイナス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を使用してもう一度テストします。結果の数値がそれ自体である場合、13の倍数が見つかりました。

以前の更新、削除var、およびアラートのロジックを逆にして、減算-偽条件を使用してさらに文字を削除します。

技術的には、最終的には最終的に13、26、または39のような2桁の数字に到達し、手順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))))

ゴルフをしていない：

(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の使用による警戒であった可能性があり、doubleは任意の32ビット数を正確に格納できます

編集：これは1/13で乗算し、0と異なる場合（端数処理エラーを許容）小数部分をチェックするか、言い換えればi / 13の小数部分をチェックすることで機能します。

Python 2.7

（20-1個の空白）* 0.9（除算なし）= 17.1

print input()%015==0

true / falseの代わりにyes / no：31 * 0.9（除算なし）= 27.9

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

pythonを利用します intして、他の基数を文字列から基数10の整数に変換します。両方のバージョンで、異なる（まだ同じ文字長）ベースを使用していることがわかります

編集：はい/いいえバージョンで1文字保存

edit2：別の2文字を剃った！

edit3：コメントをありがとう！intのベース変換の代わりに、Pythonの組み込み8進表現（015== 13...）を使用して、さらに多くの文字を削り落としました

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

明確にするために改行が追加されました。おそらくこの答えをもっと短くすることもできたかもしれませんが、この答えは問題にアプローチするためのユニークな方法だと思います。

Python-スコア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

右線形文法-∞ポイント

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

次に、「実行」の選択方法に応じて、「はい」または「いいえ」が出力されます。

真面目なエントリーではなく、ちょっとした楽しみ;）

編集： おそらく私は少し説明する必要があります。

文法を定義するルール（プロダクション）の集合である言語。言語は、アルファベットによって形成され、文法の規則に準拠する可能性のあるすべての文字列と考えることができます。

ここで、アルファベットはすべての10進数のセットです。文法の規則では、すべての文字列は13で割り切れる10進整数を形成する必要があります。

上記の文法を使用して、文字列が言語に属しているかどうかをテストできます。

文法の規則には、終端記号（言語の要素）と再帰的に置換される非終端記号が含まれます。

例で何が起こっているかを説明するのは簡単です：

たとえば、テストする文字列が71955であるとしましょう。

常に開始記号（非終端記号）があります。上記の文法の場合、これは 'S'です。この時点では、文字列から文字を読み取っていません。

current pattern                    symbol read
S                                  ε

ここで、文字列の最初のシンボル「7」を読み取り、「->」の左側に現在のパターンの非終端記号を含む文法のルールを探します。 「->」の右側にシンボルがあります。幸いにも1つ（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で割り切れます。

すなわち、目標はパターン=文字列にすることです。非終端記号が残っている場合、文字列内のすべての記号を読み取った後、文字列は言語に属しません。同様に、文字列にまだ読み取るシンボルがまだあるが、文法に進むことができないルールがある場合、文字列は言語に属しません。