Zorluk, kabul etmeyi seçmeniz durumunda, verilen bir sayı 13 ile bölünebiliyorsa "evet", bir değilse "hayır" veren bir işlev veya program oluşturmaktır.

Kurallar:
- 13 numarayı hiçbir yerde kullanamazsınız.
- 13 'ün hiçbiri için eşanlamlı yok (15 - 2 gibi).
- Modül kullanmamaya bonus puan, bölme kullanmamaya ek bonus verilir.

Puanlama:
- Puanınız, kodunuzdaki (boşluk içermeyen ) kodunuzdaki bayt sayısı ile bonusunuzla çarpılır.
- Modül kullanmadıysanız, bu bonus 0.90'dır; Eğer bölümü kullanmadıysanız, bu bonus 0.90.
- İkisini de kullanmadıysan, bu bonus 0.80.
- Puanınız ne kadar düşükse, o kadar iyi.

Giriş her zaman 0'dan büyük ve 2 ^ 32'den küçük bir tam sayı olur.
Çıktınız basit bir "evet" veya "hayır" olmalıdır.

Açıklamalar:
- Kullanım için 13 sayısını oluşturmak için bazı dolambaçlı bir yöntem kullanılması kabul edilebilir. (10 + 3) gibi basit aritmetik eş anlamlılara izin verilmez.
- İşlev veya program , verilen numara 13 ile bölünebiliyorsa, kelimenin tam anlamıyla "evet" veya "hayır" vermelidir .
- Her zaman olduğu gibi, akıllı çözümler önerilir, ancak gerekli değildir.

Java (puan 60,8 59,2)

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

Puan: (76 - 2 boşluk) karakter * 0.8 = 59.2

ASM - WinXP komut kabuğunda 16 bit x86

çalıştırılabilir - 55 bayt * 0.8 = 44

kaynak - 288 karakter * 0.8 = 230.4

13 sayısı birleşik .com dosyasında bile görünmüyor.

A86 kullanarak birleştirin.

    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 uzunluğunda bir dizgiye sahip olmak bir kaçık olabilir, ama işte burada:

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

Bir n boşluğu dizisi oluşturarak çalışır (sınırlayıcı seçimi isteğe bağlıdır, ancak bariz nedenlerden dolayı alanı seçtim) ve siz% n boşluk içeren bir dize bırakıncaya kadar 13 boşluklu alt dizgileri bölüp ayırın.

GolfScript, 32 karakter

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

Herkesten farklı bir şey denemek istedim, bu yüzden çözümüm , sayıyı tekrar baz 14'e dönüştürerek sayının 14 tabanının dijital kökünü hesaplar ve sonuç daha küçük hale gelinceye kadar rakamları toplar. Bu, esas olarak, kalan modulo 13'ü hesaplamakla aynıdır, ancak sonuç, 0 ila 12 yerine 1 ila 13 aralığında olacaktır.

Dijital kökün 13'e eşit olup olmadığını kontrol etmek, 13 sayısını (veya 12 + 1 gibi bazı geçici çözümler) kullanmadan zor olacağından, aslında yaptığım şey giriş numarasını döngüden önce birer birer arttırıp sonucu düşürmek. Bu şekilde, 13'e bölünebilen sayıların sonucu aslında sıfır olacaktır, bu da kontrol edilmesi daha kolaydır.

İşte programın yorumlanmış bir sürümü:

~              # 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 aritmetiği kullandığından, bu program aslında herhangi bir negatif olmayan tamsayı girişini işleyecektir. Elbette, aşırı büyük girişler aşırı zaman ve / veya hafıza tüketebilir.

Kod, doğrudan modulos veya bölme kullanmaz, GolfScipt 'in temel dönüştürme operatörünü kullanır, bu da neredeyse kesinlikle bazı bölümler ve kalanları dahili olarak alır. Bunun beni ikramiye için uygun olup olmadığına karar vermesini GigaWatt'a bırakacağım.

C, 68 * 0.8 = 54,4

24 cevaptan sonra, henüz kimse bu açık algoritmayı bulamadı:

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

JavaScript (27.9)

Mevcut sürüm (31 karakter * 0.90 bonus = 27.9).

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

Gösteri: http://jsfiddle.net/9GQ9m/2/

Düzenleme 1: Puanı önemli ölçüde düşürmek ve fordöngüden kaçınmak için modülü kullanarak ikinci bonusdan vazgeç . Ayrıca, ~~iki karakteri ortadan kaldırın ve kaydedin (teşekkürler @copy).

Daha eski sürüm (48 karakter * 0.80 bonus = 38.4)

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

brainfuck

Puan: 200 * 0,8 = 160

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

Stdin'den okur. Muhtemelen en zekice çözüm değil, ama BF'de işe yarayan her şeyi almak güzel. Yine de oldukça kompakt.

Scala (38 * 0.9 = 34.2)

Benzer 0xD(heks) ya da 015(w).

ASCII değeri CR13'tür.

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)

Örneğin

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

verir

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

C, 54.4 == 68 * .880   * .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

Evet, 13 almanın sıkıcı bir yolu.

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

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

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

⎕IOBunun Dyalog APL'de düzgün çalışması için 0'a ayarlanması gerekir. 13 üretmek için 9'un ⌊doğal logaritmasının ( ⍟) tabanını ( ) 6 ( 9*6) gücüne alıyoruz . Ondan sonra, ∨girdilerimizin ( ⎕) ve 13'ünün GCD'sini ( ) bulduk ve sonra bunun 1'e eşit olup olmadığını test ettik. Bu, [...]cevap vektörünün indekslenmesinde ( ) kullanılır .

Eğer herhangi biri puanlama şartnamesindeki baytların belirtilmesi konusunda bilgi sahibi olmak istiyorsa, bunun UTF-8 kodlanmış versiyonunun puanı (29 - 1) × 0.8 = 22.4. :)

C, 88

Fibonacci numarası.

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

Shebang'ı bir bayt olarak sayıyorum.

Oyuna biraz geç kaldım, ancak algoritmayı paylaşacağımı düşündüm, çünkü bu noktadaki diğer yazılar kullanılmadı.

Eğer gözlem altında Bu çalışmalar , n bölünemeyen 13 daha sonra, ⌊ N / 10 ⌋ + n% 10 * 4 de bölünemeyen 13 . 13 , 26 ve 39 değerleri kendi üzerlerine döner. 13'ün diğer tüm katları nihayetinde log ₁₀ n tekrarlamadan daha fazla olmayan bir sürede bu değerlerden birine ulaşacaktır .

Diğer Bazlarda

Kuşkusuz, chopbir kopuş biraz. 10 taban temsili ile eşdeğerdir divmod. Fakat algoritma, temel olarak diğer bazlarda, örneğin baz 4 veya 8'de iyi çalışır.

Yukarıdaki algoritmanın Python tarzı sözde kodu (temel 10):

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

Baza 2'de:

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

Dördüncü 4'te:

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

8 numaralı bölümde:

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

13 yaşından küçük tüm tabanlar eşit derecede iyi çalışır.

Javascript: 59 * 0.8 = 47.2 (?)

keman :

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

Mellamokb'un iyileştirilmesi dahil (57 * 0,8 = 45,6):

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

Perl: (51-4 boşluk) * 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 bayt * .9

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

not: Şimdiye kadarki ilk Perl programım. Zayıf yazdığınız golf için sanırım iyidir.

C (K&R) içinde: 47 * 0.8 = 37.6

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

EDIT1: Tamam, harici fonksiyonlara olan bütün bağımlılıkları kaldırdı, yukarıdakiler bu satırı dosyanın 13. satırına koyduğunuz sürece çalışacak! :) __LINE__Söylemeyle değiştirilmesi 0xdtamamsa, 5 karakter daha kaydedebilirsiniz (puan: 33.6)

J - 22.4 ^{= 28 * 0.8}

Göre mxmul en akıllı siklik yöntem .

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

Örnekler:

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

JavaScript (boşluk için 108 daha az 0) => 108, x 0.8 (modül yok, bölme yok) = 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")

Bu yöntem aşağıdaki algoritmayı kullanır: 1. Son basamağı al, dörtle çarp, kesilmiş sayının kalanına ekle. 2. 99 yineleme için 1. adımı tekrarlayın ... 3. Sonuçtaki sayı kendisiyse, 13'ün bir katını bulduysanız, adım 1'i kullanarak bir kez daha test edin.

varYanlış-koşullu çıkarma kullanarak daha fazla karakter çıkarmak için önceki güncelleme, kaldırılmış ve ters çevrilmiş mantık.

Teknik olarak, sonuçta sonuçta, 13, 26 veya 39 gibi iki basamaklı bir sayıya ulaşacak olursunuz; bu adım 1 ile tekrar tekrar sırasıyla 13, 26 veya 39 değerini verir. Dolayısıyla, yineleme 100'ün aynı olması için testler bölünebilirliği onaylayacaktır.

Çedar, 20 bayt (yarışmayan)

Puan, 20 * 0,9 = 18'dir

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

Basit bir cevap.

Ortak Lisp (71 bayt * 0.8) = 56.8

Basit özyineleme, gerçekten.

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

Yakut ( 50 48 * 0,9 = 43,2)

Kullanmanın akıllı yolu eval

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

D 56 karakter .80 bonus = 44.8

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

Bu 1/13 kullanarak bir koparma olabilir ve bir çift tam olarak herhangi bir 32 bit sayısını saklayabilir

düzenleme: Bu 1/13 ile çarparak ve kesirli kısmı 0'dan farklıysa (yuvarlama hatalarına izin veriyorsa) veya başka bir deyişle i / 13'ün kesirli bölümünü kontrol ederek çalışır

Python 2.7

(20 - 1 boşluk) * 0.9 (bölme yok) = 17.1

print input()%015==0

doğru / yanlış yerine evet / hayır: 31 * 0.9 (bölme yok) = 27.9

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

pitonun avantaj alır inttabanına 10 tamsayılar içine dizeleri diğer üsleri dönüştürmek için. Her iki versiyonda da görebildiğiniz gibi farklı (ama aynı karakter uzunluğunda) bir taban kullanıyorlar.

düzenleme: 1 char kaydet evet / hayır sürüm

edit2: başka 2 karakter traş!

edit3: yorumlarınız için tekrar teşekkürler! int 'in temel çevirisi yerine python'un yerleşik sekizlik gösterimlerini ( 015== 13...) kullanarak daha da fazla karakter traş oldu

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

Netlik için satır sonları eklendi. Muhtemelen bu cevabı çok daha kısaltabilirdim, ama bu cevabın soruna yaklaşmanın eşsiz bir yolunu temsil ettiğini hissediyorum.

Python - puan 27.9

(31 karakter * 0.90) - kısa kod için bir miktar bonus harcar.

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

eski versiyon: (47 karakter * 0.80) - mellamokb'un Javascript cevabının tamamıyla sökülmesi, ancak Python'da.

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

daha eski sürüm: (60 karakter * 0.80)

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

daha eski sürüm: (105 karakter * 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'da:

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

Sağ Doğrusal Dilbilgisi - ∞ puanları

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

Daha sonra, nasıl 'çalıştırmayı' seçtiğinize bağlı olarak, 'evet' veya 'hayır' şeklinde çıkacaktır.

Ciddi bir giriş değil, sadece biraz eğlenceli;)

EDIT: Belki biraz açıklamalıyım.

Bir dil bilgisi bir tanımlayan kurallar (üretimler) 'in bir grubu olduğu bir dil . Bir dil, bir alfabenin oluşturduğu, dilbilgisinin kurallarına uyan, olası tüm karakter dizileri olarak düşünülebilir.

Burada alfabe tüm ondalık basamakların kümesidir. Dilbilgisi kuralları, tüm dizelerin 13'e bölünebilen ondalık tamsayıları oluşturması gerektiğidir.

Bir dize dilimize ait olup olmadığını test etmek için yukarıdaki dilbilgisini kullanabiliriz.

Dilbilgisi kuralları, tekrarlayan bir şekilde değiştirilen terminal olmayan sembollerin yanı sıra (dilde bulunan öğeler) terminal sembollerini içerir.

Neler olduğunu bir örnekle açıklamak daha kolay:

Örneğin, test ettiğimiz dizenin 71955 olduğunu söyleyelim.

Her zaman bir başlangıç ​​simgesi vardır (terminal olmayan), bunun üstündeki gramer durumunda 'S' olur. Bu noktada dizgimizden hiçbir karakter okumadık:

current pattern                    symbol read
S                                  ε

Şimdi, dizgemizde '7' olan ilk sembolü okuduk, daha sonra şu anki düzenimizde '->' 'in sol tarafında bulunan terminal olmayanlardan herhangi birini içeren bir gramer kuralı arıyoruz. sembolümüz '->' in sağ tarafındadır. Neyse ki bir tane var (S-> 7G), bu yüzden şu anki düzenimizdeki terminal olmayan sembolleri yeni kuralın sağ tarafıyla değiştiriyoruz:

current pattern                    symbol read
7G                                 7

Şimdi modelimizde terminal olmayan 'G' var ve okunacak bir sonraki sembol '1'. Dilbilgimizde 'G-> 1' ile başlayan bir kural arıyoruz. (G-> 1F), bu yüzden terminal dışı terminali yeni kuralımızın RHS'si ile değiştiririz:

current pattern                    symbol read
71F                                1

Bu işlemi tekrarlamaya devam et:

Sonraki kural: F-> 9D

current pattern                    symbol read
719D                               9

Sonraki kural: D-> 5F

current pattern                    symbol read
7195F                              5

Sonraki kural: F-> 5S

current pattern                    symbol read
71955S                             5

Bu noktada ipimizde daha fazla sembol yoktur, fakat orada başka bir terminal olmayan sembol daha vardır. Dilbilgisindeki ilk kuraldan 'S'yi boş dize ile değiştirebileceğimizi görüyoruz (ε): S-> ε

Bunu yapmak bize şu anki bilgiyi verir: 71955ε, 71955'e eşdeğerdir.

İpimizdeki tüm sembolleri okuduk ve desende terminal olmayan semboller yok. Bu, dize dile ait demektir ve bu nedenle 71955 aslında 13 ile bölünebilir durumdadır.

Yani amaç, pattern = string'e sahip olmaktır. Herhangi bir terminal dışı sembolle kalırsanız, dizginizdeki tüm sembolleri okuduktan sonra, dize ait değildir. Benzer şekilde, hala okumak için dizenizde daha fazla sembol varsa, ancak dilbilgisinde ilerlemenizi sağlayan kurallar yoksa, dize dile ait değildir.