La tua sfida, se scegli di accettarlo, è quella di creare una funzione o un programma che produca "sì" se un dato numero è divisibile per 13 e produca "no" se non lo è.

Regole:
- Non puoi usare il numero 13 ovunque.
- Nessun sinonimi cop-out per 13 (come usare 15 - 2).
- Saranno assegnati punti bonus per non usare il modulo, bonus aggiuntivo per non usare la divisione.

Punteggio:
- Il tuo punteggio sarà il numero di byte nel tuo codice (spazi bianchi non inclusi) moltiplicato per il tuo bonus.
- Se non hai utilizzato il modulo, quel bonus è 0,90; se non hai usato la divisione, quel bonus è 0,90.
- Se non hai usato nessuno dei due, quel bonus è 0.80.
- Più basso è il tuo punteggio, meglio è.

L'input sarà sempre un numero intero maggiore di 0 e inferiore a 2 ^ 32.
L'output dovrebbe essere un semplice "sì" o "no".

Chiarimenti:
- È accettabile l'uso di un metodo rotatorio per generare il numero 13 per l'uso. Non sono consentiti semplici sinonimi aritmetici come (10 + 3).
- La funzione o il programma deve letteralmente produrre "sì" o "no" per se il dato numero è divisibile per 13.
- Come sempre, si consigliano soluzioni intelligenti, ma non necessarie.

Java (punteggio 60,8 59,2)

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

Punteggio: (76 - 2 spazi bianchi) * 0,8 = 59,2

ASM - 16 bit x86 sulla shell dei comandi di WinXP

eseguibile - 55 byte * 0,8 = 44

fonte - 288 caratteri * 0,8 = 230,4

Il numero 13 non appare nemmeno nel file .com assemblato.

Assemblare usando 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

Potrebbe essere un cop-out per avere una stringa di lunghezza 13, ma qui va:

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

Funziona costruendo una stringa di n spazi (la scelta del delimitatore è arbitraria, ma ho scelto lo spazio per ovvi motivi), e suddividendo sottostringhe di 13 spazi fino a quando non ti rimane una stringa contenente n% 13 spazi.

GolfScript, 32 caratteri

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

Volevo provare qualcosa di diverso da tutti gli altri, quindi la mia soluzione calcola la radice digitale di base 14 del numero, convertendo ripetutamente il numero in base 14 e sommando le cifre fino a quando il risultato non diventa più piccolo. Questo è essenzialmente lo stesso del calcolo del resto del modulo 13, tranne per il fatto che il risultato sarà compreso tra 1 e 13 anziché tra 0 e 12.

Dal momento che verificare se la radice digitale è uguale a 13 sarebbe difficile senza utilizzare il numero 13 stesso (o qualche soluzione approssimativa come 12 + 1), quello che effettivamente faccio è aumentare il numero di input di uno prima del ciclo e decrementare il risultato in seguito. In questo modo, il risultato per i numeri divisibili per 13 sarà in realtà zero, il che è molto più facile da verificare.

Ecco una versione commentata del programma:

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

Questo programma gestirà effettivamente qualsiasi input intero non negativo, poiché GolfScript utilizza l'aritmetica del bignum. Naturalmente, input estremamente grandi possono richiedere tempo e / o memoria eccessivi.

Il codice non utilizza direttamente i moduli o le divisioni, sebbene utilizzi l'operatore di conversione di base di GolfScipt, che quasi certamente esegue alcune divisioni e acquisizioni interne. Lascerò che GigaWatt decida se questo mi qualifica per il bonus o meno.

C, 68 * 0,8 = 54,4

Dopo 24 risposte, nessuno ha ancora trovato questo ovvio algoritmo:

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

JavaScript (27.9)

Versione corrente (31 caratteri * 0,90 bonus = 27,9).

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

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

Modifica 1: rinuncia al secondo bonus usando il modulo per ridurre considerevolmente il punteggio ed evitare il forloop. Elimina ~~e salva anche due caratteri (grazie @copy).

Versione precedente (48 caratteri * 0,80 bonus = 38,4)

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

BrainFuck

Punteggio: 200 * 0,8 = 160

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

Legge dallo stdin. Probabilmente non è la soluzione più intelligente, ma ottenere qualcosa che funzioni in BF è bello. È abbastanza compatto però.

Scala (38 * 0.9 = 34.2)

Simile a 0xD(hex) o 015(oct).

Il valore ASCII di 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"

Pitone:

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

Per esempio

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

dà

[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

Sì, è un modo noioso di ottenere 13.

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

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

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

⎕IOdovrebbe essere impostato su 0 affinché funzioni correttamente in Dyalog APL. Per generare 13, prendiamo il floor ( ⌊) del logaritmo naturale ( ⍟) di 9 alla potenza di 6 ( 9*6). Successivamente, troviamo il GCD ( ∨) del nostro input ( ⎕) e 13, e quindi testiamo se è uguale a 1. Questo è usato per indicizzare ( [...]) il vettore di risposte.

Se qualcuno vuole essere pedante riguardo alla menzione dei byte nella specifica del punteggio, il punteggio per la versione codificata UTF-8 di questo è (29 - 1) × 0.8 = 22.4. :)

C, 88

Trucco di 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

Contando lo shebang come un byte.

Sono un po 'in ritardo nel gioco, ma ho pensato di condividere l'algoritmo, dato che nessun altro post a questo punto lo ha usato.

Questo funziona sotto l'osservazione che se n è divisibile per 13 , allora ⌊ n / 10 ⌋ + n% 10 * 4 è anche divisibile per 13 . I valori 13 , 26 e 39 scorrono su se stessi. Tutti gli altri multipli di 13 alla fine di raggiungere uno di questi valori in non più di log ₁₀ n iterazioni.

In altre basi

Certo, chopè un po 'un cop-out. Con una rappresentazione di base 10, è equivalente a divmod. Ma l'algoritmo funziona perfettamente in altre basi, ad esempio base 4 o 8.

Pseudo-codice in stile Python dell'algoritmo sopra (base 10):

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

Nella base 2:

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

Nella base 4:

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

In base 8:

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

ecc. Qualsiasi base inferiore a 13 funziona ugualmente bene.

Javascript: 59 * 0.8 = 47.2 (?)

violino :

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

Compreso il miglioramento di 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 spazi) * 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"

nota: il mio primo programma Perl di sempre. Immagino che sia debolmente scritto è buono per il golf.

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

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

EDIT1: va bene rimosso tutte le dipendenze da funzioni esterne, quanto sopra funzionerà fintanto che metterai questa linea sulla 13a riga del file! :) Se __LINE__va bene essere sostituito da dire, 0xdallora può salvare altri 5 caratteri (punteggio: 33,6)

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

Basato sul metodo ciclico intelligente di mxmul .

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

Esempi:

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

JavaScript (108 in meno 0 per gli spazi bianchi) => 108, x 0,8 (nessun modulo, nessuna divisione) = 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")

Questo metodo utilizza il seguente algoritmo: 1. Prendi l'ultima cifra, moltiplicala per quattro, aggiungila al resto del numero troncato. 2. Ripeti il ​​passaggio 1 per 99 iterazioni ... 3. Provalo ancora una volta utilizzando il passaggio 1, se il numero risultante è esso stesso, hai trovato un multiplo di 13.

Aggiornamento precedente, rimozione vare logica invertita nell'avviso per rimuovere più caratteri mediante sottrazione-falso condizionale.

Tecnicamente, il risultato finale è che alla fine raggiungerai un numero di due cifre come 13, 26 o 39 che, se eseguito di nuovo attraverso il passaggio 1, darà rispettivamente 13, 26 o 39. Quindi testare l'iterazione 100 allo stesso confermerà la divisibilità.

Cheddar, 20 byte (non competitivo)

Il punteggio è 20 * 0,9 = 18

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

Una risposta semplice.

Lisp comune (71 byte * 0,8) = 56,8

Ricorsione semplice, davvero.

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

Rubino ( 50 48 * 0.9 = 43.2)

Modo intelligente di usare eval

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

D 56 caratteri .80 bonus = 44.8

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

questo potrebbe essere stato un cop-out con l'utilizzo di 1/13 e un doppio può memorizzare esattamente qualsiasi numero a 32 bit

modifica: funziona moltiplicando per 1/13 e controllando la parte frazionaria se è diversa da 0 (consentendo errori di arrotondamento) o in altre parole controlla la parte frazionaria di i / 13

Python 2.7

(20-1 spazi bianchi) * 0.9 (nessuna divisione) = 17.1

print input()%015==0

sì / no invece di vero / falso: 31 * 0.9 (nessuna divisione) = 27.9

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

sfrutta i python intper convertire altre basi dalle stringhe in numeri interi di base 10. puoi vedere in entrambe le versioni che usano una base diversa (ma con la stessa lunghezza di caratteri)

modifica: 1 carattere salva nella versione sì / no

edit2: altri 2 caratteri rasati!

edit3: grazie ancora ai commenti! ancora più personaggi rasati usando le rappresentazioni ottali incorporate di python ( 015== 13...) invece della traduzione base di 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"}

Le interruzioni di riga sono state aggiunte per maggiore chiarezza. Probabilmente avrei potuto rendere questa risposta molto più breve, ma ritengo che questa risposta rappresenti un modo unico di affrontare il problema.

Python - punteggio 27.9

(31 caratteri * 0,90) - rinuncia ad alcuni bonus per il codice più breve.

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

versione precedente: (47 caratteri * 0,80) - completa fregatura della risposta Javascript di mellamokb, ma in Python.

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

versione precedente: (60 caratteri * 0.80)

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

versione precedente: (105 caratteri * 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]

In Q:

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

Right Linear Grammar - ∞ punti

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

Quindi, a seconda di come si sceglie di "eseguirlo", verrà emesso "sì" o "no".

Non una voce seria, solo un po 'di divertimento;)

EDIT: forse dovrei spiegare un po '.

Una grammatica è un insieme di regole (produzioni) che definiscono una lingua . Una lingua può essere pensata come tutte le possibili stringhe formate da un alfabeto, conformi alle regole della sua grammatica.

Qui l'alfabeto è l'insieme di tutte le cifre decimali. Le regole della grammatica prevedono che tutte le stringhe debbano formare numeri decimali divisibili per 13.

Possiamo usare la grammatica sopra per verificare se una stringa appartiene alla nostra lingua.

Le regole della grammatica contengono simboli terminali (che sono elementi nella lingua) e simboli non terminali che vengono sostituiti in modo ricorsivo.

È più facile spiegare cosa sta succedendo con un esempio:

Diciamo ad esempio che la stringa che stiamo testando è 71955.

C'è sempre un simbolo iniziale (che non è terminale), nel caso della grammatica sopra questa è 'S'. A questo punto non abbiamo letto alcun carattere della nostra stringa:

current pattern                    symbol read
S                                  ε

Ora leggiamo il primo simbolo nella nostra stringa che è '7', quindi cerchiamo una regola nella grammatica che abbia uno dei non terminali nel nostro modello corrente nella parte sinistra del '->' e che ha il nostro simbolo nella parte destra di '->'. Fortunatamente ce n'è uno (S-> 7G), quindi sostituiamo i simboli non terminali nel nostro modello corrente con il lato destro della nuova regola:

current pattern                    symbol read
7G                                 7

Ora abbiamo la 'G' non terminale nel nostro modello e il prossimo simbolo da leggere è '1', quindi cerchiamo una regola nella nostra grammatica che inizi con 'G-> 1 ". Scopriamo che ce n'è uno (G-> 1F), quindi sostituiamo il non terminale con l'RHS della nostra nuova regola:

current pattern                    symbol read
71F                                1

Continua a ripetere questo processo:

Regola successiva: F-> 9D

current pattern                    symbol read
719D                               9

Regola successiva: D-> 5F

current pattern                    symbol read
7195F                              5

Regola successiva: F-> 5S

current pattern                    symbol read
71955S                             5

A questo punto non abbiamo più simboli nella nostra stringa, ma abbiamo un altro simbolo non terminale all'interno. Dalla prima regola della grammatica vediamo che possiamo sostituire 'S' con la stringa vuota (ε): S-> ε

In questo modo ci dà l'attuale scalpiccio: 71955ε che è l'equivalente di 71955.

Abbiamo letto tutti i simboli nella nostra stringa e il modello non contiene simboli non terminali. Ciò significa che la stringa appartiene alla lingua e quindi 71955 è in realtà divisibile per 13.

Cioè l'obiettivo è avere pattern = string. Se ti rimangono simboli non terminali, dopo aver letto tutti i simboli nella tua stringa, la stringa non appartiene alla lingua. Allo stesso modo, se hai ancora più simboli nella tua stringa da leggere, ma non ci sono regole nella grammatica che ti permettono di andare avanti, allora la stringa non appartiene alla lingua.