Seu desafio, se você aceitar, é criar uma função ou um programa que emita "sim" se um determinado número for divisível por 13 e em "não" se não for.

Regras:
- Você não tem permissão para usar o número 13 em qualquer lugar.
- Nenhum sinônimo de cop-out para 13 também (como usar 15-2).
- Pontos de bônus serão concedidos por não usar o módulo, bônus adicional por não usar a divisão.

Pontuação:
- Sua pontuação será o número de bytes no seu código (espaço em branco não incluído) multiplicado pelo seu bônus.
- Se você não usou o módulo, esse bônus é 0,90; se você não usou a divisão, esse bônus é 0,90.
- Se você também não usou, esse bônus é 0,80.
- Quanto menor a sua pontuação, melhor.

A entrada sempre será um número inteiro maior que 0 e menor que 2 ^ 32.
Sua saída deve ser um simples "sim" ou "não".

Esclarecimentos:
- O uso de algum método indireto para gerar o número 13 para uso é aceitável. Sinónimos aritméticos simples como (10 + 3) não são permitidos.
- A função ou programa deve literalmente emitir "yes" ou "no", pois se o número especificado é divisível por 13.
- Como sempre, soluções inteligentes são recomendadas, mas não necessárias.

Java (pontuação 60,8 59,2)

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

Pontuação: (76 - 2 espaços em branco) caracteres * 0,8 = 59,2

ASM - x86 de 16 bits no shell de comando do WinXP

executável - 55 bytes * 0,8 = 44

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

O número 13 nem aparece no arquivo .com montado.

Monte usando o 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

Pode ser um cop-out ter uma sequência de comprimento 13, mas aqui vai:

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

Ele funciona construindo uma sequência de n espaços (a escolha do delimitador é arbitrária, mas eu escolhi o espaço por razões óbvias) e separando substrings de 13 espaços até que você fique com uma sequência contendo n% 13 espaços.

GolfScript, 32 caracteres

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

Eu queria tentar algo diferente de todos os outros, então minha solução calcula a raiz digital base 14 do número, convertendo repetidamente o número em base 14 e somando os dígitos até que o resultado não fique menor. Isso é essencialmente o mesmo que calcular o restante módulo 13, exceto que o resultado estará no intervalo de 1 a 13 em vez de 0 a 12.

Como verificar se a raiz digital é igual a 13 seria difícil sem usar o próprio número 13 (ou alguma solução alternativa esfarrapada, como 12 + 1), o que realmente faço é incrementar o número de entrada em um antes do loop e diminuir o resultado posteriormente. Dessa forma, o resultado para números divisíveis por 13 será de fato zero, o que é muito mais fácil de verificar.

Aqui está uma versão comentada do programa:

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

Este programa vai realmente lidar com qualquer não-negativo inteiro entradas, desde GolfScript usa aritmética bignum. Obviamente, entradas extremamente grandes podem consumir tempo e / ou memória excessivos.

O código não usa módulos nem divisões diretamente, embora use o operador de conversão base do GolfScipt, que quase certamente faz alguma divisão e faz o restante internamente. Vou deixar para o GigaWatt decidir se isso me qualifica para o bônus ou não.

C, 68 * 0,8 = 54,4

Após 24 respostas, ninguém apresentou esse algoritmo óbvio ainda:

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

JavaScript (27.9)

Versão atual (31 caracteres * 0,90 de bônus = 27,9).

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

Demonstração: http://jsfiddle.net/9GQ9m/2/

Editar 1: Abandone o segundo bônus usando o módulo para diminuir consideravelmente a pontuação e evitar o forloop. Também elimine ~~e salve dois caracteres (obrigado @copy).

Versão mais antiga (48 caracteres * 0,80 de bônus = 38,4)

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

BrainFuck

Pontuação: 200 * 0.8 = 160

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

Lê de stdin. Provavelmente não é a solução mais inteligente, mas conseguir qualquer coisa que funcione no BF é bom. É bastante compacto.

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

Igual a 0xD (hex) ou 015(oct).

O valor ASCII de 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)

Por exemplo

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

dá

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

C, 54,4 == 68 * 0,8   80 * 0,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

Sim, é uma maneira chata de conseguir 13 anos.

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

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

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

⎕IOdeve ser definido como 0 para que isso funcione corretamente no Dyalog APL. Para gerar 13, pegamos o piso ( ⌊) do logaritmo natural ( ⍟) de 9 à potência de 6 ( 9*6). Depois disso, encontramos o MDC ( ∨) de nossa entrada ( ⎕) e 13 e testamos se isso é igual a 1. Isso é usado para indexar ([...] ) o vetor de respostas.

Se alguém quiser ser pedante sobre a menção de bytes na especificação de pontuação, a pontuação para a versão UTF-8 codificado desta é (29 - 1) × 0.8 = 22.4. :)

C, 88

Truque de 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 o shebang como um byte.

Estou um pouco atrasado para o jogo, mas pensei em compartilhar o algoritmo, pois nenhuma outra postagem até o momento o usou.

Isso funciona sob a observação de que se n é divisível por 13 , então ⌊ n / 10 ⌋ + n% 10 * 4 também é divisível por 13 . Os valores 13 , 26 e 39 alternam entre si. Todos os outros múltiplos de 13 eventualmente atingirão um desses valores em não mais que log ₁₀ n iterações.

Em outras bases

É certo que chopé um pouco de bobagem. Com uma representação base 10, é equivalente a divmod. Mas o algoritmo funciona bem em outras bases, por exemplo, base 4 ou 8.

Pseudo-código no estilo Python do algoritmo acima (base 10):

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

Na base 2:

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

Na base 4:

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

Na base 8:

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

etc. Qualquer base menor que 13 funciona igualmente bem.

Javascript: 59 * 0.8 = 47.2 (?)

violino :

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

Incluindo a melhoria de 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 espaços) * 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 bytes * .9

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

Nota: Meu primeiro programa Perl. Dificilmente digitado é bom para o golfe, eu acho.

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

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

EDIT1: ok removeu todas as dependências de funções externas, o acima funcionará desde que você coloque essa linha na 13ª linha do arquivo! :) Se __LINE__for aceitável ser substituído por say 0xd, pode salvar mais 5 caracteres (pontuação: 33,6)

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

Baseado no método cíclico inteligente de mxmul .

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

Exemplos:

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

JavaScript (108 menos 0 para espaço em branco) => 108, x 0,8 (sem módulo, sem divisão) = 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")

Este método usa o seguinte algoritmo: 1. Pegue o último dígito, multiplique por quatro, adicione-o ao restante do número truncado. 2. Repita a etapa 1 para 99 iterações ... 3. Teste-a mais uma vez usando a etapa 1, se o número resultante for o próprio, você encontrou um múltiplo de 13.

Atualização anterior, removida vare lógica reversa no alerta para remover mais caracteres usando condicional subtração-falso.

Tecnicamente, o resultado final é que você chegará a um número de dois dígitos como 13, 26 ou 39 que, quando executado na etapa 1 novamente, fornecerá 13, 26 ou 39, respectivamente. Portanto, o teste para a iteração 100 ser o mesmo confirmará a divisibilidade.

Cheddar, 20 bytes (não-competitivo)

A pontuação é 20 * 0,9 = 18

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

Uma resposta direta.

Lisp comum (71 bytes * 0,8) = 56,8

Recursão simples, realmente.

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

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

Maneira inteligente de usar eval

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

D 56 caracteres 0,80 bônus = 44,8

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

isso pode ter sido um problema com o uso de 1/13 e um duplo pode armazenar qualquer número de 32 bits exatamente

edit: isso funciona multiplicando por 1/13 e verificando a parte fracionária se for diferente de 0 (permitindo erros de arredondamento) ou, em outras palavras, verifica a parte fracionária de i / 13

Python 2.7

(20 - 1 espaço em branco) * 0,9 (sem divisão) = 17,1

print input()%015==0

sim / não em vez de verdadeiro / falso: 31 * 0,9 (sem divisão) = 27,9

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

tira proveito do python int para converter outras bases de strings em números inteiros de base 10. você pode ver nas duas versões que eles usam uma base diferente (mas com o mesmo comprimento de caractere)

edit: 1 char save na versão yes / no

edit2: outros 2 caracteres raspados!

edit3: obrigado novamente aos comentários! ainda mais caracteres cortados usando as representações octais internas do python ( 015== 13...) em vez da tradução base do 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"}

As quebras de linha foram adicionadas para maior clareza. Eu provavelmente poderia ter tornado essa resposta muito mais curta, mas acho que essa resposta representa uma maneira única de abordar o problema.

Python - pontuação 27.9

(31 caracteres * 0,90) - renuncia a algum bônus por código mais curto.

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

versão anterior: (47 caracteres * 0,80) - cópia completa da resposta Javascript do mellamokb, mas em Python.

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

versão anterior: (60 caracteres * 0,80)

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

versão anterior: (105 caracteres * 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]

Em Q:

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

Gramática linear direita - ∞ pontos

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

Então, dependendo de como você optar por 'executá-lo', ele exibirá 'yes' ou 'no'.

Não é uma entrada séria, apenas um pouco de diversão;)

Edição: Talvez eu deva explicar um pouco.

Uma gramática é um conjunto de regras (produções) que definem um idioma . Uma linguagem pode ser pensada como todas as seqüências possíveis formadas por um alfabeto, que estão em conformidade com as regras de sua gramática.

Aqui, o alfabeto é o conjunto de todos os dígitos decimais. As regras da gramática são que todas as seqüências de caracteres devem formar números decimais divisíveis por 13.

Podemos usar a gramática acima para testar se uma string pertence ao nosso idioma.

As regras da gramática contêm símbolos terminais (que são elementos no idioma), bem como símbolos não terminais que são substituídos recursivamente.

É mais fácil explicar o que está acontecendo com um exemplo:

Digamos, por exemplo, que a string que estamos testando seja 71955.

Sempre existe um símbolo de início (que não é terminal); no caso da gramática acima, é 'S'. Neste ponto, não lemos nenhum caractere da nossa string:

current pattern                    symbol read
S                                  ε

Agora, lemos o primeiro símbolo em nossa string que é '7', depois procuramos uma regra na gramática que possua qualquer um dos não terminais em nosso padrão atual no lado esquerdo do '->' e que tem o nosso símbolo no lado direito do '->'. Felizmente, existe um (S-> 7G), por isso substituímos os símbolos não terminais em nosso padrão atual pelo lado direito da nova regra:

current pattern                    symbol read
7G                                 7

Agora, temos o 'G' não terminal em nosso padrão, e o próximo símbolo a ser lido é '1'; portanto, procuramos uma regra em nossa gramática que começa com 'G-> 1 ". Descobrimos que existe um. (G-> 1F), substituímos o não terminal pelo RHS de nossa nova regra:

current pattern                    symbol read
71F                                1

Continue repetindo este processo:

Próxima regra: F-> 9D

current pattern                    symbol read
719D                               9

Próxima regra: D-> 5F

current pattern                    symbol read
7195F                              5

Próxima regra: F-> 5S

current pattern                    symbol read
71955S                             5

Neste ponto, não temos mais símbolos em nossa string, mas temos outro símbolo não terminal lá. Vemos pela primeira regra da gramática que podemos substituir 'S' pela string vazia (ε): S-> ε

Isso nos dá o padrão atual: 71955ε, que é equivalente a 71955.

Lemos todos os símbolos em nossa string e o padrão não contém símbolos não terminais. O que significa que a string pertence ao idioma e, portanto, 71955 é de fato divisível por 13.

Ou seja, o objetivo é ter pattern = string. Se você tiver algum símbolo não terminal, depois de ler todos os símbolos da sua string, ela não pertence ao idioma. Da mesma forma, se você ainda tiver mais símbolos em sua sequência para ler, mas não houver regras na gramática que permitam avançar, a sequência não pertence ao idioma.