Twoim wyzwaniem, jeśli zdecydujesz się je zaakceptować, jest stworzenie funkcji lub programu, który wyświetli „tak”, jeśli daną liczbę można podzielić przez 13, i wyśle ​​„nie”, jeśli nie jest.

Zasady:
- Nie wolno nigdzie używać numeru 13.
- Brak wyodrębniających się synonimów dla 13 (tak jak przy użyciu 15 - 2).
- Punkty premiowe będą przyznawane za niestosowanie modułu, dodatkowy bonus za niestosowanie podziału.

Punktacja:
- Twój wynik będzie liczbą bajtów w kodzie ( nie zawiera białych znaków ) pomnożoną przez premię.
- Jeśli nie użyłeś modułu, premia wynosi 0,90; jeśli nie użyłeś podziału, premia wynosi 0,90.
- Jeśli nie używałeś żadnego z nich, bonus wynosi 0,80.
- Im niższy wynik, tym lepiej.

Wejście będzie zawsze liczbą całkowitą większą niż 0 i mniejszą niż 2 ^ 32.
Twój wynik powinien być prostym „tak” lub „nie”.

Wyjaśnienia:
- Użycie jakiejś ronda do generowania liczby 13 do użytku jest dopuszczalne. Proste synonimy arytmetyczne, takie jak (10 + 3) są niedozwolone.
- Funkcja lub program musi dosłownie wypisać „tak” lub „nie”, ponieważ jeśli podaną liczbę można podzielić przez 13.
- Jak zawsze, sprytne rozwiązania są zalecane, ale nie wymagane.

Java (wynik 60,8 59,2)

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

Wynik: (76 - 2 białe znaki) znaki * 0,8 = 59,2

ASM - 16 bitów x86 w powłoce poleceń WinXP

wykonywalny - 55 bajtów * 0,8 = 44

źródło - 288 znaków * 0,8 = 230,4

Liczba 13 nawet nie pojawia się w złożonym pliku .com.

Złóż za pomocą 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

Może to być wydzierżawiony ciąg o długości 13, ale oto on:

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

Działa poprzez budowanie ciągu n spacji (wybór separatora jest arbitralny, ale wybrałem spację z oczywistych powodów) i dzielenie 13-spacji podciągów, dopóki nie zostanie ci ciąg zawierający n% 13 spacji.

GolfScript, 32 znaki

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

Chciałem wypróbować coś innego niż wszyscy, więc moje rozwiązanie oblicza cyfrowy pierwiastek z liczby 14, wielokrotnie konwertując liczbę na bazę 14 i sumując cyfry, aż wynik nie będzie już mniejszy. Jest to w zasadzie to samo, co obliczanie pozostałego modułu 13, z tym wyjątkiem, że wynik będzie w zakresie od 1 do 13 zamiast od 0 do 12.

Ponieważ sprawdzenie, czy cyfrowy pierwiastek jest równy 13, byłoby trudne bez użycia samej liczby 13 (lub jakiegoś kiepskiego obejścia, takiego jak 12 + 1), tak naprawdę zwiększam liczbę wejściową o jeden przed pętlą, a następnie zmniejszam wynik. W ten sposób wynik liczb podzielnych przez 13 będzie wynosił zero, co jest znacznie łatwiejsze do sprawdzenia.

Oto skomentowana wersja programu:

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

Ten program faktycznie obsłuży wszelkie nieujemne liczby całkowite, ponieważ GolfScript używa arytmetyki bignum. Oczywiście, bardzo duże dane wejściowe mogą pochłaniać nadmierny czas i / lub pamięć.

Kod nie korzysta bezpośrednio z modułów ani dzielenia, chociaż korzysta z podstawowego operatora konwersji GolfScipt, który prawie na pewno dokonuje podziału i odbiera resztę wewnętrznie. Zostawię GigaWatt decyzję, czy kwalifikuje mnie to do premii, czy nie.

C 68 * 0,8 = 54,4

Po 24 odpowiedziach nikt jeszcze nie wymyślił tego oczywistego algorytmu:

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

JavaScript (27,9)

Aktualna wersja (31 znaków * 0,90 bonus = 27,9).

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

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

Edycja 1: Zrezygnuj z drugiej premii, używając modułu, aby znacznie obniżyć wynik i uniknąć forpętli. Wyeliminuj ~~i zapisz dwa znaki (dzięki @copy).

Starsza wersja (48 znaków * 0,80 bonus = 38,4)

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

BrainFuck

Wynik: 200 * 0,8 = 160

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

Czyta froms stdin. Prawdopodobnie nie jest to najsprytniejsze rozwiązanie, ale fajnie jest dostać wszystko, co działa w BF. Jest jednak dość kompaktowy.

Scala (38 * 0,9 = 34,2)

Podobne do 0xD(hex) lub 015(oct).

Wartość ASCIICR wynosi 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"

Pyton:

f=lambda n:1==pow(8,n,79)

Na przykład

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

daje

[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

Tak, to nudny sposób na zdobycie 13 lat.

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

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

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

⎕IOpowinien być ustawiony na 0, aby działał poprawnie w Dyalog APL. Aby wygenerować 13, bierzemy podłogę ( ⌊) logarytmu naturalnego ( ⍟) 9 do potęgi 6 ( 9*6). Następnie znajdujemy GCD ( ∨) naszych danych wejściowych ( ⎕) i 13, a następnie sprawdzamy, czy jest to równe 1. Służy do indeksowania ( [...]) wektora odpowiedzi.

Jeśli ktoś chce być pedantyczny, jeśli chodzi o wzmiankę o bajtach w specyfikacji oceniania, wynik dla wersji kodowanej w UTF-8 to (29 - 1) × 0.8 = 22.4. :)

C, 88

Sztuczka Fibonacciego.

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

Licząc shebang jako jeden bajt.

Jestem trochę spóźniony do gry, ale pomyślałem, że podzielę się algorytmem, ponieważ żadne inne posty do tej pory go nie używały.

Działa to pod obserwacją, że jeśli n jest podzielne przez 13 , to ⌊ n / 10 ⌋ + n% 10 * 4 jest również podzielne przez 13 . Wartości 13 , 26 i 39 przełączają się na siebie. Wszystkie inne wielokrotności 13 w końcu dotrzeć do jednego z tych wartości w czasie nie dłuższym niż log ₁₀ n iteracji.

W innych bazach

Trzeba przyznać, że chopto trochę kłótnia. Przy podstawowej reprezentacji 10 jest to odpowiednik divmod. Ale algorytm działa doskonale dobrze w innych bazach, na przykład w bazie 4 lub 8.

Pseudokod powyższego algorytmu w stylu Python (podstawa 10):

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

W bazie 2:

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

W bazie 4:

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

W bazie 8:

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

itd. Każda baza mniejsza niż 13 działa równie dobrze.

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

skrzypce :

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

Łącznie z poprawą 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 spacji) * 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 bajtów * .9

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

Uwaga: Mój pierwszy program w Perlu. Słabo wpisane jest dobre do golfa.

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

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

EDYCJA 1: OK usunąłem wszystkie zależności od funkcji zewnętrznych, powyższe będzie działać tak długo, jak umieścisz ten wiersz w 13 wierszu pliku! :) Jeśli __LINE__można zastąpić słowem say, 0xdmożna zapisać kolejne 5 znaków (wynik: 33,6)

J - 22,4 ^{= 28 * 0,8}

Na podstawie mxmul na mądry cyklicznej metodzie .

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

Przykłady:

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

JavaScript (108 minus 0 dla białych znaków) => 108, x 0,8 (bez modułu, bez podziału) = 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")

Ta metoda wykorzystuje następujący algorytm: 1. Weź ostatnią cyfrę, pomnóż ją przez cztery, dodaj ją do reszty obciętej liczby. 2. Powtórz krok 1 dla 99 iteracji ... 3. Przetestuj go jeszcze raz, wykonując krok 1, jeśli wynikowa liczba jest sama, znalazłeś wielokrotność 13.

Poprzednia aktualizacja, usunięta vari odwrócona logika w alercie, aby usunąć więcej znaków przy użyciu warunku odejmowania-fałszywego.

Technicznie wynik końcowy jest taki, że w końcu osiągniesz dwucyfrową liczbę, taką jak 13, 26 lub 39, która po przejściu przez krok 1 ponownie da odpowiednio 13, 26 lub 39. Zatem sprawdzenie, czy iteracja 100 jest taka sama, potwierdzi podzielność.

Cheddar, 20 bajtów (niekonkurencyjny)

Wynik to 20 * 0,9 = 18

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

Prosta odpowiedź.

Common Lisp (71 bajtów * 0,8) = 56,8

Prosta rekurencja, naprawdę.

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

Nie golfowany:

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

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

Inteligentny sposób użycia eval

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

D 56 znaków .80 bonus = 44,8

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

mogło to być wyłudzanie przy użyciu 1/13, a podwójne może dokładnie przechowywać dowolną liczbę 32-bitową

edycja: działa to przez pomnożenie przez 1/13 i sprawdzenie części ułamkowej, jeśli jest różna od 0 (dopuszczając błędy zaokrąglania) lub innymi słowy sprawdza część ułamkową i / 13

Python 2.7

(20-1 biała spacja) * 0,9 (bez podziału) = 17,1

print input()%015==0

tak / nie zamiast true / false: 31 * 0,9 (bez podziału) = 27,9

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

korzysta z Pythona int do konwersji innych zasad z ciągów znaków na liczby całkowite 10. widać w obu wersjach, że używają innej podstawy (jednakowej długości znaków)

edycja: 1 znak zapisz w wersji tak / nie

edit2: ogolono kolejne 2 znaki!

edit3: jeszcze raz dziękuję za komentarze! jeszcze więcej znaków golono za pomocą wbudowanych reprezentacji ósemkowych Pythona ( 015== 13...) zamiast podstawowego tłumaczenia 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"}

Podziały linii zostały dodane dla jasności. Prawdopodobnie mogłem skrócić tę odpowiedź, ale uważam, że ta odpowiedź stanowi wyjątkowy sposób podejścia do problemu.

Python - wynik 27,9

(31 znaków * 0,90) - rezygnuje z premii za krótszy kod.

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

starsza wersja: (47 znaków * 0,80) - całkowite zdzieranie odpowiedzi Javascript w mellamokb, ale w Pythonie.

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

starsza wersja: (60 znaków * 0,80)

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

starsza wersja: (105 znaków * 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]

W Q:

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

Gramatyka liniowa prawa - ∞ punktów

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

Następnie, w zależności od tego, w jaki sposób go „uruchomisz”, wyświetli „tak” lub „nie”.

Nie jest to poważny wpis, tylko trochę zabawy;)

EDYCJA: Może powinienem trochę wyjaśnić.

Gramatyka jest zbiorem reguł (produkcji), które określają język . Język można traktować jako wszystkie możliwe ciągi utworzone przez alfabet, które odpowiadają regułom jego gramatyki.

Tutaj alfabet jest zbiorem wszystkich cyfr dziesiętnych. Zasady gramatyki mówią, że wszystkie ciągi muszą tworzyć dziesiętne liczby całkowite, które można podzielić przez 13.

Możemy użyć powyższej gramatyki, aby sprawdzić, czy łańcuch należy do naszego języka.

Reguły gramatyki zawierają symbole końcowe (które są elementami w języku), a także symbole nieterminalne, które są zastępowane rekurencyjnie.

Łatwiej jest wyjaśnić, co się dzieje na przykładzie:

Powiedzmy na przykład, że testowany przez nas ciąg to 71955.

Zawsze występuje symbol początkowy (który nie jest końcowy), w przypadku gramatyki powyżej jest to „S”. W tym momencie nie odczytaliśmy żadnych znaków z naszego ciągu:

current pattern                    symbol read
S                                  ε

Teraz czytamy pierwszy symbol w naszym ciągu, który jest „7”, a następnie szukamy reguły w gramatyce, która ma dowolny z nieterminali w naszym bieżącym wzorze po lewej stronie „->” i że ma nasz symbol po prawej stronie „->”. Na szczęście jest jeden (S-> 7G), więc zastępujemy nieterminalne symbole w naszym obecnym wzorze prawą stroną nowej reguły:

current pattern                    symbol read
7G                                 7

Teraz mamy wzorzec nieterminalny „G”, a następnym symbolem do odczytania jest „1”, więc szukamy reguły w naszej gramatyce, która zaczyna się od „G-> 1”. (G-> 1F), więc zastępujemy terminale RHS naszej nowej reguły:

current pattern                    symbol read
71F                                1

Powtarzaj ten proces:

Następna zasada: F-> 9D

current pattern                    symbol read
719D                               9

Następna zasada: D-> 5F

current pattern                    symbol read
7195F                              5

Następna zasada: F-> 5S

current pattern                    symbol read
71955S                             5

W tym momencie nie mamy już żadnych symboli w naszym ciągu, ale mamy tam inny symbol nieterminalny. Widzimy z pierwszej reguły gramatyki, że możemy zastąpić „S” pustym ciągiem (ε): S-> ε

W ten sposób otrzymujemy aktualny wzór: 71955ε, co odpowiada 71955.

Przeczytaliśmy wszystkie symbole w naszym ciągu, a wzorzec nie zawiera żadnych symboli nieterminalnych. Co oznacza, że ​​ciąg należy do języka, a zatem 71955 jest w rzeczywistości podzielny przez 13.

Tj. Celem jest mieć wzór = ciąg. Jeśli masz jakieś nieterminalne symbole, po przeczytaniu wszystkich symboli w łańcuchu, łańcuch nie należy do języka. Podobnie, jeśli nadal masz więcej symboli do przeczytania, ale w gramatyce nie ma żadnych reguł, które pozwolą ci iść naprzód, to łańcuch nie należy do języka.