Su desafío, si elige aceptarlo, es crear una función o un programa que arroje "sí" si un número dado es divisible por 13 y arroje "no" si no lo es.

Reglas:
- No puedes usar el número 13 en ningún lado.
- Tampoco hay sinónimos de eliminación para 13 (como usar 15-2).
- Se otorgarán puntos de bonificación por no usar el módulo, bonificación adicional por no usar la división.

Puntaje:
- Su puntaje será el número de bytes en su código (espacio en blanco no incluido) multiplicado por su bono.
- Si no usaste el módulo, ese bono es 0.90; si no usaste división, ese bono es 0.90.
- Si tampoco usaste, ese bono es 0.80.
- Cuanto más bajo sea tu puntaje, mejor.

La entrada siempre será un número entero mayor que 0 y menor que 2 ^ 32.
Su salida debe ser un simple "sí" o "no".

Aclaraciones:
- Es aceptable usar algún método indirecto para generar el número 13 para su uso. Los sinónimos aritméticos simples como (10 + 3) no están permitidos.
- La función o el programa debe literalmente generar "sí" o "no" para si el número dado es divisible por 13.
- Como siempre, se recomiendan soluciones inteligentes, pero no son necesarias.

Java (puntaje 60.8 59.2)

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

Puntuación: (76 - 2 espacios en blanco) caracteres * 0.8 = 59.2

ASM: 16 bits x86 en el shell de comandos de WinXP

ejecutable - 55 bytes * 0.8 = 44

fuente - 288 caracteres * 0.8 = 230.4

El número 13 ni siquiera aparece en el archivo .com ensamblado.

Montar 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

Puede ser una evasión tener una cadena de longitud 13, pero aquí va:

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

Funciona construyendo una cadena de n espacios (la elección del delimitador es arbitraria, pero elegí el espacio por razones obvias) y separando las subcadenas de 13 espacios hasta que quede una cadena que contenga n% 13 espacios.

GolfScript, 32 caracteres

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

Quería probar algo diferente de los demás, por lo que mi solución calcula la raíz digital de base 14 del número, convirtiendo repetidamente el número en base 14 y sumando los dígitos hasta que el resultado ya no sea más pequeño. Esto es esencialmente lo mismo que calcular el resto del módulo 13, excepto que el resultado estará en el rango de 1 a 13 en lugar de 0 a 12.

Dado que verificar si la raíz digital es igual a 13 sería difícil sin usar el número 13 en sí (o alguna solución poco convincente como 12 + 1), lo que realmente hago es incrementar el número de entrada en uno antes del ciclo y disminuir el resultado después. De esa manera, el resultado para números divisibles por 13 será de hecho cero, lo cual es mucho más fácil de verificar.

Aquí hay una versión comentada del 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 realmente manejará cualquier entrada entera no negativa, ya que GolfScript usa aritmética bignum. Por supuesto, las entradas extremadamente grandes pueden consumir demasiado tiempo y / o memoria.

El código no utiliza módulos ni divisiones directamente, aunque sí utiliza el operador de conversión de base de GolfScipt, que casi con seguridad hace algunas divisiones y toma de residuos internamente. Dejaré que GigaWatt decida si esto me califica para el bono o no.

C, 68 * 0.8 = 54.4

Después de 24 respuestas, a nadie se le ocurrió este algoritmo obvio todavía:

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

JavaScript (27.9)

Versión actual (31 caracteres * 0.90 bonus = 27.9).

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

Demostración: http://jsfiddle.net/9GQ9m/2/

Edición 1: renunciar a la segunda bonificación mediante el uso de módulo para reducir la puntuación considerablemente y evitar el forbucle También elimine ~~y guarde dos caracteres (gracias @copy).

Versión anterior (48 caracteres * 0.80 bonus = 38.4)

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

BrainFuck

Puntuación: 200 * 0.8 = 160

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

Lee de stdin. Probablemente no sea la solución más inteligente, pero obtener algo que funcione en BF es bueno. Sin embargo, es bastante compacto.

Scala (38 * 0.9 = 34.2)

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

El valor ASCII de CRes 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"

Pitón:

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

P.ej

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

da

[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í, es una forma aburrida de obtener 13.

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

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

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

⎕IOdebe establecerse en 0 para que esto funcione correctamente en Dyalog APL. Para generar 13, tomamos el piso ( ⌊) del logaritmo natural ( ⍟) de 9 a la potencia de 6 ( 9*6). Después de eso, encontramos el MCD ( ∨) de nuestra entrada ( ⎕) y 13, y luego probamos si eso es igual a 1. Esto se usa para indexar ( [...]) el vector de respuestas.

Si alguien quiere ser pedante acerca de la mención de bytes en la especificación de puntuación, la puntuación para la versión codificada UTF-8 es (29 - 1) × 0.8 = 22.4. :)

C, 88

Truco 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 el shebang como un byte.

Llegué un poco tarde al juego, pero pensé en compartir el algoritmo, ya que ninguna otra publicación hasta el momento lo ha utilizado.

Esto funciona bajo la observación de que si n es divisible por 13 , entonces ⌊ n / 10 ⌋ + n% 10 * 4 también es divisible por 13 . Los valores 13 , 26 y 39 se ciclan sobre sí mismos. Todos los otros múltiplos de 13 , finalmente, llegará a uno de estos valores en no más de log ₁₀ n iteraciones.

En otras bases

Es cierto que chopes una especie de evasión. Con una representación de base 10, es equivalente a divmod. Pero el algoritmo funciona perfectamente bien en otras bases, por ejemplo, la base 4 u 8.

Seudocódigo de estilo Python del algoritmo anterior (base 10):

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

En la base 2:

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

En la base 4:

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

En la 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. Cualquier base menor de 13 funciona igual de bien.

Javascript: 59 * 0.8 = 47.2 (?)

violín :

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

Incluyendo la mejora 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 espacios) * 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: mi primer programa Perl. Débilmente escrito es bueno para el golf, supongo.

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

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

EDITAR1: está bien, eliminó todas las dependencias de las funciones externas, ¡lo anterior funcionará siempre que coloque esta línea en la línea 13 del archivo! :) Si __LINE__está bien ser reemplazado por decir, 0xdentonces puede guardar otros 5 caracteres (puntuación: 33.6)

J - 22.4 ^{= 28 * 0.8}

Residencia en el inteligente método cíclico de mxmul .

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

Ejemplos:

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

JavaScript (108 menos 0 para espacios en blanco) => 108, x 0.8 (sin módulo, sin división) = 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 utiliza el siguiente algoritmo: 1. Tome el último dígito, multiplíquelo por cuatro, agréguelo al resto del número truncado. 2. Repita el paso 1 para 99 iteraciones ... 3. Pruébelo una vez más usando el paso 1, si el número resultante es él mismo, ha encontrado un múltiplo de 13.

Actualización anterior, eliminada var lógica e inversa en la alerta para eliminar más caracteres mediante el uso de condicional de resta-falso.

Técnicamente, el resultado final es que eventualmente alcanzará un número de dos dígitos como 13, 26 o 39, que cuando se ejecute nuevamente en el paso 1 dará 13, 26 o 39 respectivamente. Entonces, probar que la iteración 100 sea la misma confirmará la divisibilidad.

Cheddar, 20 bytes (sin competencia)

El puntaje es 20 * 0.9 = 18

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

Una respuesta directa.

Lisp común (71 bytes * 0.8) = 56.8

Recurrencia simple, de verdad.

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

Sin golf:

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

Rubí ( 50 48 * 0.9 = 43.2)

Forma inteligente de usar eval

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

D 56 caracteres .80 bonus = 44.8

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

Esto podría haber sido una evasión con el uso de 1/13 y un doble puede almacenar cualquier número de 32 bits exactamente

editar: esto funciona multiplicando con 1/13 y verificando la parte fraccionaria si es diferente de 0 (permitiendo errores de redondeo) o, en otras palabras, verificando la parte fraccionaria de i / 13

Python 2.7

(20-1 espacio en blanco) * 0.9 (sin división) = 17.1

print input()%015==0

sí / no en lugar de verdadero / falso: 31 * 0.9 (sin división) = 27.9

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

aprovecha Python intpara convertir otras bases de cadenas en enteros de base 10. puedes ver en ambas versiones que usan una base diferente (pero con la misma longitud de caracteres)

editar: 1 char guardar en versión sí / no

edit2: ¡otros 2 caracteres afeitados!

edit3: gracias de nuevo a los comentarios! incluso más caracteres eliminados mediante el uso de representaciones octales incorporadas de Python ( 015== 13...) en lugar de la traducción base de 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"}

Los saltos de línea se agregaron para mayor claridad. Probablemente podría haber hecho esta respuesta mucho más corta, pero siento que esta respuesta representa una forma única de abordar el problema.

Python - puntaje 27.9

(31 caracteres * 0.90) : renuncia a alguna bonificación por código más corto.

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

versión anterior: (47 caracteres * 0.80) - estafa completa de la respuesta Javascript de mellamokb, pero en Python.

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

versión anterior: (60 caracteres * 0.80)

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

versión 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]

En Q:

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

Gramática lineal derecha - ∞ puntos

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

Luego, dependiendo de cómo elija 'ejecutarlo', generará 'sí' o 'no'.

No es una entrada seria, solo un poco de diversión;)

EDITAR: Tal vez debería explicar un poco.

Una gramática es un conjunto de reglas (producciones) que definen un lenguaje . Un lenguaje puede considerarse como todas las cadenas posibles formadas por un alfabeto, que se ajustan a las reglas de su gramática.

Aquí el alfabeto es el conjunto de todos los dígitos decimales. Las reglas de la gramática son que todas las cadenas deben formar enteros decimales que sean divisibles por 13.

Podemos usar la gramática anterior para probar si una cadena pertenece a nuestro idioma.

Las reglas de la gramática contienen símbolos terminales (que son elementos en el lenguaje), así como símbolos no terminales que se reemplazan recursivamente.

Es más fácil explicar lo que está sucediendo con un ejemplo:

Digamos, por ejemplo, que la cadena que estamos probando es 71955.

Siempre hay un símbolo de inicio (que no es terminal), en el caso de la gramática anterior es 'S'. En este punto no hemos leído ningún carácter de nuestra cadena:

current pattern                    symbol read
S                                  ε

Ahora, leemos el primer símbolo en nuestra cadena que es '7', luego buscamos una regla en la gramática que tenga cualquiera de los no terminales en nuestro patrón actual en el lado izquierdo del '->' y que tiene nuestro símbolo en el lado derecho de '->'. Afortunadamente, hay uno (S-> 7G), por lo que reemplazamos los símbolos no terminales en nuestro patrón actual con el lado derecho de la nueva regla:

current pattern                    symbol read
7G                                 7

Ahora tenemos la 'G' no terminal en nuestro patrón, y el siguiente símbolo a leer es '1', así que buscamos una regla en nuestra gramática que comience con 'G-> 1 ". Encontramos que hay una (G-> 1F), por lo que reemplazamos el no terminal con el RHS de nuestra nueva regla:

current pattern                    symbol read
71F                                1

Sigue repitiendo este proceso:

Siguiente regla: F-> 9D

current pattern                    symbol read
719D                               9

Siguiente regla: D-> 5F

current pattern                    symbol read
7195F                              5

Siguiente regla: F-> 5S

current pattern                    symbol read
71955S                             5

En este punto no tenemos más símbolos en nuestra cadena, pero tenemos otro símbolo no terminal allí. Vemos de la primera regla en la gramática que podemos reemplazar 'S' con la cadena vacía (ε): S-> ε

Hacerlo nos da el patrón actual: 71955ε, que es el equivalente a 71955.

Hemos leído todos los símbolos en nuestra cadena, y el patrón no contiene símbolos no terminales. Lo que significa que la cadena pertenece al idioma y, por lo tanto, 71955 es de hecho divisible por 13.

Es decir, el objetivo es tener patrón = cadena. Si le quedan símbolos no terminales, después de leer todos los símbolos en su cadena, la cadena no pertenece al idioma. Del mismo modo, si todavía tiene más símbolos en su cadena para leer, pero no hay reglas en la gramática que le permitan avanzar, entonces la cadena no pertenece al idioma.