Tantangan Anda, jika Anda memilih untuk menerimanya, adalah membuat fungsi atau program yang menghasilkan "ya" jika angka yang diberikan dapat dibagi dengan 13 dan menghasilkan "tidak" jika tidak.

Aturan:
- Anda tidak diizinkan menggunakan nomor 13 di mana pun.
- Tidak ada sinonim cop-out untuk 13 (seperti menggunakan 15 - 2).
- Poin bonus akan diberikan untuk tidak menggunakan modulus, bonus tambahan untuk tidak menggunakan divisi.

Scoring:
- skor Anda akan menjadi jumlah byte dalam kode Anda (spasi tidak termasuk) dikalikan dengan bonus Anda.
- Jika Anda tidak menggunakan modulus, bonus itu adalah 0,90; jika Anda tidak menggunakan pembagian, bonus itu adalah 0,90.
- Jika Anda tidak menggunakan keduanya, bonus itu adalah 0,80.
- Semakin rendah skor Anda, semakin baik.

Input akan selalu berupa bilangan bulat lebih besar dari 0 dan kurang dari 2 ^ 32.
Output Anda harus berupa "ya" atau "tidak" yang sederhana.

Klarifikasi:
- Menggunakan beberapa metode bundaran untuk menghasilkan angka 13 untuk digunakan dapat diterima. Sinonim aritmatika sederhana seperti (10 + 3) tidak diizinkan.
- Fungsi atau program harus benar - benar menampilkan "ya" atau "tidak" karena jika angka yang diberikan dapat dibagi dengan 13.
- Seperti biasa, solusi cerdas disarankan, tetapi tidak diperlukan.

Jawa (skor 60,8 59.2)

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

Nilai: (76 - 2 spasi putih) karakter * 0.8 = 59.2

ASM - 16 bit x86 pada shell perintah WinXP

dieksekusi - 55 byte * 0.8 = 44

sumber - 288 karakter * 0.8 = 230.4

Angka 13 bahkan tidak muncul di file com. Com.

Merakit menggunakan 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

Mungkin merupakan solusi untuk memiliki string dengan panjang 13, tetapi ini dia:

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

Ia bekerja dengan membangun string n spasi (pilihan pembatas adalah arbitrer, tapi saya memilih ruang karena alasan yang jelas), dan memisahkan substring 13-ruang sampai Anda tersisa dengan string yang berisi n% 13 spasi.

GolfScript, 32 karakter

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

Saya ingin mencoba sesuatu yang berbeda dari orang lain, jadi solusi saya menghitung basis 14 akar digital nomor itu, dengan berulang kali mengubah angka menjadi basis 14 dan menjumlahkan digit sampai hasilnya tidak lagi menjadi lebih kecil. Ini pada dasarnya sama dengan menghitung sisa modulo 13, kecuali bahwa hasilnya akan berada dalam kisaran 1 hingga 13 bukannya 0 hingga 12.

Karena memeriksa apakah root digital sama dengan 13 akan sulit tanpa menggunakan angka 13 itu sendiri (atau beberapa solusi lumpuh seperti 12 + 1), apa yang sebenarnya saya lakukan adalah saya menambah nomor input dengan satu sebelum loop dan mengurangi hasilnya setelah itu. Dengan begitu, hasil untuk angka yang dapat habis oleh 13 akan menjadi nol, yang jauh lebih mudah untuk diperiksa.

Berikut versi program yang dikomentari:

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

Program ini benar-benar akan menangani setiap non-negatif bilangan bulat masukan, karena GolfScript menggunakan aritmatika bignum. Tentu saja, input yang sangat besar dapat menghabiskan waktu dan / atau memori yang berlebihan.

Kode tidak menggunakan modulos atau divisi secara langsung, meskipun menggunakan operator konversi basis GolfScipt, yang hampir pasti melakukan beberapa divisi dan sisanya mengambil internal. Saya akan menyerahkannya kepada GigaWatt untuk memutuskan apakah ini memenuhi syarat saya untuk bonus atau tidak.

C, 68 * 0,8 = 54,4

Setelah 24 jawaban, belum ada yang menemukan algoritma yang jelas ini:

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

JavaScript (27.9)

Versi saat ini (31 karakter * 0,90 bonus = 27,9).

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

Demo: http://jsfiddle.net/9GQ9m/2/

Sunting 1: Lupa bonus kedua dengan menggunakan modulus untuk menurunkan skor jauh dan menghindari forloop. Juga hilangkan ~~dan simpan dua karakter (terima kasih @copy).

Versi lebih lama (48 karakter * 0,80 bonus = 38,4)

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

BrainFuck

Nilai: 200 * 0,8 = 160

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

Membaca dari stdin. Mungkin bukan solusi yang paling pintar, tetapi mendapatkan apa pun yang bekerja di BF itu bagus. Ini cukup kompak.

Scala (38 * 0.9 = 34.2)

Mirip dengan 0xD(hex) atau 015(Oktober).

Nilai ASCIICR adalah 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)

Misalnya

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

memberi

[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;}

ECMASkrip 6, 25 × 0,9 = 22,5

Ya, itu cara yang membosankan untuk mendapatkan 13.

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

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

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

⎕IOharus ditetapkan ke 0 agar ini berfungsi dengan baik di Dyalog APL. Untuk menghasilkan 13, kita mengambil lantai ( ⌊) dari logaritma natural ( ⍟) dari 9 ke kekuatan 6 ( 9*6). Setelah itu, kami menemukan GCD ( ∨) dari input kami ( ⎕) dan 13, dan kami kemudian menguji apakah itu sama dengan 1. Ini digunakan untuk mengindeks ( [...]) vektor jawaban.

Jika ada yang ingin bertele-tele tentang penyebutan byte dalam spesifikasi penilaian, skor untuk versi yang disandikan UTF-8 ini adalah (29 - 1) × 0.8 = 22.4. :)

C, 88

Trik 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

Menghitung shebang sebagai satu byte.

Saya agak terlambat ke permainan, tapi saya pikir saya akan membagikan algoritme, karena tidak ada tulisan lain sampai saat ini yang menggunakannya.

Ini bekerja di bawah pengamatan bahwa jika n habis dibagi 13 , maka ⌊ n / 10 ⌋ + n% 10 * 4 juga habis dibagi 13 . Nilai-nilai 13 , 26 dan 39 siklus ke diri mereka sendiri. Semua kelipatan lain dari 13 pada akhirnya akan mencapai salah satu dari nilai-nilai ini dalam tidak lebih dari iterasi log ₁₀ dan .

Di Pangkalan Lain

Diakui, chopsedikit keluar dari masalah. Dengan representasi basis 10, itu setara dengan divmod. Tetapi algoritma bekerja dengan baik di basis lain, misalnya basis 4, atau 8.

Kode pseudo gaya python dari algoritma di atas (basis 10):

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

Di basis 2:

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

Di basis 4:

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

Di base 8:

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

dll. Setiap pangkalan yang lebih kecil dari 13 berfungsi sama baiknya.

Javascript: 59 * 0.8 = 47.2 (?)

biola :

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

Termasuk peningkatan 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 spasi) * 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"

Catatan: Program Perl pertama saya. Ketikan yang lemah bagus untuk golf.

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

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

EDIT1: oke menghapus semua dependensi pada fungsi eksternal, di atas akan berfungsi selama Anda meletakkan baris ini pada baris ke 13 file! :) Jika __LINE__boleh digantikan oleh say 0xdmaka dapat menyimpan 5 karakter lebih lanjut (skor: 33.6)

J - 22.4 ^{= 28 * 0.8}

Berdasarkan metode siklik pintar mxmul .

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

Contoh:

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

JavaScript (108 kurang 0 untuk spasi putih) => 108, x 0,8 (tanpa modulus, tanpa pembagian) = 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")

Metode ini menggunakan algoritma berikut: 1. Ambil digit terakhir, kalikan dengan empat, tambahkan ke sisa angka terpotong. 2. Ulangi langkah 1 untuk 99 iterasi ... 3. Uji sekali lagi menggunakan langkah 1, jika nomor yang dihasilkan itu sendiri, Anda telah menemukan kelipatan 13.

Pembaruan sebelumnya, dihapus var, dan logika terbalik pada peringatan untuk menghapus lebih banyak karakter dengan menggunakan pengurangan-salah bersyarat.

Secara teknis, hasil akhirnya adalah bahwa Anda pada akhirnya akan mencapai angka dua digit seperti 13, 26, atau 39 yang bila dijalankan melalui langkah 1 lagi akan memberikan 13, 26, atau 39 masing-masing. Jadi pengujian untuk iterasi 100 yang sama akan mengkonfirmasi pembagian itu.

Cheddar, 20 byte (tidak bersaing)

Skor 20 * 0,9 = 18

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

Jawaban langsung.

Gangguan Umum (71 byte * 0.8) = 56.8

Rekursi sederhana, sungguh.

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

Tidak Disatukan:

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

Ruby ( 50 48 * 0.9 = 43.2)

Cara cerdas untuk digunakan 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;
}

ini mungkin merupakan cop-out dengan menggunakan 1/13 dan ganda dapat menyimpan angka 32 bit dengan tepat

sunting: ini bekerja dengan mengalikan 1/13 dan memeriksa bagian fraksional jika berbeda dari 0 (memungkinkan untuk kesalahan pembulatan) atau dengan kata lain memeriksa bagian fraksional dari i / 13

Python 2.7

(20 - 1 spasi putih) * 0.9 (tidak ada pembagian) = 17.1

print input()%015==0

ya / tidak, bukan benar / salah: 31 * 0,9 (tidak ada pembagian) = 27,9

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

mengambil keuntungan dari python intuntuk mengkonversi pangkalan lain dari string menjadi basis 10 integer. Anda dapat melihat di kedua versi mereka menggunakan basis yang berbeda (panjang karakter yang sama)

sunting: 1 simpan char di versi ya / tidak

edit2: 2 karakter lagi dicukur!

sunting3: terima kasih lagi untuk komentar! bahkan lebih banyak karakter dicukur dengan menggunakan representasi oktal bawaan python ( 015== 13...) alih-alih terjemahan basis 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"}

Jeda baris ditambahkan untuk kejelasan. Saya mungkin bisa membuat jawaban ini jauh lebih pendek, tetapi saya merasa bahwa jawaban ini mewakili cara unik untuk mendekati masalah.

Python - skor 27,9

(31 karakter * 0,90) - lupa beberapa bonus untuk kode yang lebih pendek.

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

versi yang lebih lama: (47 karakter * 0,80) - lengkap jawaban Javascript mellamokb, tetapi dengan Python.

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

versi yang lebih lama: (60 karakter * 0.80)

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

versi yang lebih lama: (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]

Dalam Q:

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

Tata Bahasa Linear Kanan - ∞ poin

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

Kemudian tergantung pada bagaimana Anda memilih untuk 'menjalankannya, itu akan menampilkan' ya 'atau' tidak '.

Bukan entri serius, hanya bersenang-senang;)

EDIT: Mungkin saya harus menjelaskan sedikit.

Sebuah tata bahasa adalah seperangkat aturan (produksi) yang mendefinisikan bahasa . Bahasa dapat dianggap sebagai semua string yang mungkin dibentuk oleh alfabet, yang sesuai dengan aturan tata bahasa itu.

Di sini alfabet adalah himpunan semua digit desimal. Aturan tata bahasanya adalah bahwa semua string harus membentuk bilangan bulat desimal yang dapat dibagi oleh 13.

Kita dapat menggunakan tata bahasa di atas untuk menguji apakah suatu string termasuk dalam bahasa kita.

Aturan tata bahasa mengandung simbol terminal (yang merupakan elemen dalam bahasa) serta simbol non-terminal yang diganti secara rekursif.

Lebih mudah untuk menjelaskan apa yang terjadi dengan sebuah contoh:

Katakanlah misalnya bahwa string yang kami uji adalah 71955.

Selalu ada simbol awal (yang bukan terminal), dalam kasus tata bahasa di atas ini adalah 'S'. Saat ini kami belum membaca karakter apa pun dari string kami:

current pattern                    symbol read
S                                  ε

Sekarang, kita membaca simbol pertama dalam string kita yaitu '7', kemudian kita mencari aturan dalam tata bahasa yang memiliki salah satu non-terminal dalam pola kita saat ini di sisi kiri '->' dan bahwa memiliki simbol kita di sisi kanan '->'. Untungnya ada satu (S-> 7G), jadi kami mengganti simbol non-terminal dalam pola kami saat ini dengan sisi kanan aturan baru:

current pattern                    symbol read
7G                                 7

Sekarang kita memiliki 'G' non-terminal dalam pola kita, dan simbol berikutnya untuk dibaca adalah '1', Jadi kita mencari aturan dalam tata bahasa kita yang dimulai dengan 'G-> 1 ". Kami menemukan ada satu (G-> 1F), jadi kami mengganti non terminal dengan RHS dari aturan baru kami:

current pattern                    symbol read
71F                                1

Terus ulangi proses ini:

Aturan selanjutnya: F-> 9D

current pattern                    symbol read
719D                               9

Aturan selanjutnya: D-> 5F

current pattern                    symbol read
7195F                              5

Aturan selanjutnya: F-> 5S

current pattern                    symbol read
71955S                             5

Pada titik ini kita tidak memiliki lagi simbol dalam string kita, tetapi kita memiliki simbol non-terminal lain di sana. Kita melihat dari aturan pertama dalam tata bahasa bahwa kita dapat mengganti 'S' dengan string kosong (ε): S-> ε

Melakukannya memberi kita derai saat ini: 71955ε yang setara dengan 71955.

Kami telah membaca semua simbol dalam string kami, dan polanya tidak mengandung simbol non-terminal. Yang berarti bahwa string milik bahasa dan oleh karena itu 71955 sebenarnya dapat dibagi oleh 13.

Yaitu tujuannya adalah untuk memiliki pola = string. Jika Anda dibiarkan dengan simbol non-terminal, setelah membaca semua simbol di string Anda, string tersebut tidak termasuk dalam bahasa. Demikian juga, jika Anda masih memiliki lebih banyak simbol dalam string untuk dibaca, tetapi tidak ada aturan dalam tata bahasa yang memungkinkan Anda untuk maju, maka string tersebut bukan milik bahasa.