Votre défi, si vous l'acceptez, est de créer une fonction ou un programme qui génère "oui" si un nombre donné est divisible par 13 et génère "non" s'il ne l'est pas.

Règles:
- Vous n'êtes pas autorisé à utiliser le numéro 13 n'importe où.
- Aucun synonyme de sortie pour 13 non plus (comme l'utilisation de 15-2).
- Des points bonus seront attribués pour ne pas utiliser le module, un bonus supplémentaire pour ne pas utiliser la division.

Scoring:
- Votre score sera le nombre d'octets dans votre code (espaces non inclus) multiplié par votre bonus.
- Si vous n'avez pas utilisé de module, ce bonus est de 0,90; si vous n'avez pas utilisé la division, ce bonus est de 0,90.
- Si vous n'avez pas utilisé non plus, ce bonus est de 0,80.
- Plus votre score est bas, mieux c'est.

L'entrée sera toujours un entier supérieur à 0 et inférieur à 2 ^ 32.
Votre sortie doit être un simple «oui» ou «non».

Clarifications:
- L'utilisation d'une méthode détournée pour générer le chiffre 13 à utiliser est acceptable. Les synonymes arithmétiques simples comme (10 + 3) ne sont pas autorisés.
- La fonction ou le programme doit littéralement afficher "oui" ou "non" car si le nombre donné est divisible par 13.
- Comme toujours, des solutions intelligentes sont recommandées, mais pas obligatoires.

Java (score 60,8 59,2)

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

Score: (76 - 2 espaces blancs) caractères * 0,8 = 59,2

ASM - 16 bits x86 sur le shell de commande WinXP

exécutable - 55 octets * 0,8 = 44

source - 288 caractères * 0,8 = 230,4

Le nombre 13 n'apparaît même pas dans le fichier .com assemblé.

Assemblez en utilisant 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

Ce peut être un cop-out d'avoir une chaîne de longueur 13, mais ici ça va:

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

Cela fonctionne en construisant une chaîne de n espaces (le choix du délimiteur est arbitraire, mais j'ai choisi l'espace pour des raisons évidentes), et en séparant les sous-chaînes de 13 espaces jusqu'à ce que vous vous retrouvez avec une chaîne contenant n% 13 espaces.

GolfScript, 32 caractères

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

Je voulais essayer quelque chose de différent de tout le monde, donc ma solution calcule la racine numérique de base 14 du nombre, en convertissant à plusieurs reprises le nombre en base 14 et en additionnant les chiffres jusqu'à ce que le résultat ne diminue plus. C'est essentiellement la même chose que le calcul du module 13 restant, sauf que le résultat sera compris entre 1 et 13 au lieu de 0 à 12.

Étant donné qu'il serait difficile de vérifier si la racine numérique est égale à 13 sans utiliser le nombre 13 lui-même (ou une solution de rechange boiteuse comme 12 + 1), ce que je fais en fait, c'est que j'incrémente le nombre d'entrée de un avant la boucle et décrémente le résultat par la suite. De cette façon, le résultat pour les nombres divisibles par 13 sera en fait zéro, ce qui est beaucoup plus facile à vérifier.

Voici une version commentée du programme:

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

Ce programme gérera en fait toutes les entrées entières non négatives, puisque GolfScript utilise l'arithmétique bignum. Bien entendu, des entrées extrêmement volumineuses peuvent consommer trop de temps et / ou de mémoire.

Le code n'utilise ni module ni division directement, bien qu'il utilise l'opérateur de conversion de base de GolfScipt, qui effectue presque certainement une division et une prise de reste en interne. Je laisse le soin à GigaWatt de décider si cela me donne droit ou non au bonus.

C, 68 * 0,8 = 54,4

Après 24 réponses, personne n'a encore trouvé cet algorithme évident:

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

JavaScript (27,9)

Version actuelle (31 caractères * 0,90 bonus = 27,9).

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

Démo: http://jsfiddle.net/9GQ9m/2/

Édition 1: renoncez au deuxième bonus en utilisant le module pour réduire considérablement le score et éviter la forboucle. Éliminez ~~et enregistrez également deux caractères (merci @copy).

Version plus ancienne (48 caractères * 0,80 bonus = 38,4)

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

BrainFuck

Score: 200 * 0,8 = 160

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

Lit à partir de stdin. Ce n'est probablement pas la solution la plus intelligente, mais obtenir tout ce qui fonctionne en BF est bien. C'est assez compact cependant.

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

Similaire à 0xD(hex) ou 015(oct).

La valeur ASCII de CRest 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)

Par exemple

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

donne

[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

Oui, c'est une façon ennuyeuse d'avoir 13 ans.

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

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

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

⎕IOdoit être défini sur 0 pour que cela fonctionne correctement dans Dyalog APL. Pour générer 13, nous prenons le plancher ( ⌊) du logarithme naturel ( ⍟) de 9 à la puissance de 6 ( 9*6). Après cela, nous trouvons le GCD ( ∨) de notre entrée ( ⎕) et 13, et nous testons ensuite si cela est égal à 1. Ceci est utilisé pour indexer ( [...]) le vecteur de réponses.

Si quelqu'un veut être pédant sur la mention d' octets dans la spécification de notation, le score de la version codée UTF-8 est (29 - 1) × 0.8 = 22.4. :)

C, 88

Truc 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

Compter le shebang comme un octet.

Je suis un peu en retard dans le jeu, mais je pensais partager l'algorithme, car aucun autre message à ce stade ne l'a utilisé.

Cela fonctionne sous l'observation que si n est divisible par 13 , alors ⌊ n / 10 ⌋ + n% 10 * 4 est également divisible par 13 . Les valeurs 13 , 26 et 39 se succèdent. Tous les autres multiples de 13 atteindront finalement l'une de ces valeurs en pas plus de log ₁₀ n itérations.

Dans d'autres bases

Certes, chopc'est un peu une dérobade. Avec une représentation en base 10, c'est équivalent à divmod. Mais l'algorithme fonctionne parfaitement bien dans d'autres bases, par exemple la base 4 ou 8.

Pseudo-code de style Python de l'algorithme ci-dessus (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 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 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 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. Toute base inférieure à 13 fonctionne aussi bien.

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

violon :

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

Y compris l'amélioration 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 espaces) * 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 octets * .9

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

note: Mon tout premier programme Perl. Faiblement tapé est bon pour le golf, je suppose.

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

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

EDIT1: bien supprimé toutes les dépendances sur les fonctions externes, ce qui précède fonctionnera tant que vous mettez cette ligne sur la 13e ligne du fichier! :) Si __LINE__est correct d'être remplacé par dire 0xdalors peut enregistrer 5 autres caractères (score: 33,6)

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

Basé sur la méthode cyclique intelligente de mxmul .

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

Exemples:

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

JavaScript (108 moins 0 pour les espaces blancs) => 108, x 0,8 (pas de module, pas de division) = 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")

Cette méthode utilise l'algorithme suivant: 1. Prenez le dernier chiffre, multipliez-le par quatre, ajoutez-le au reste du nombre tronqué. 2. Répétez l'étape 1 pour 99 itérations ... 3. Testez-le une fois de plus en utilisant l'étape 1, si le nombre résultant est lui-même, vous en avez trouvé un multiple de 13.

Mise à jour précédente, suppression varet logique inversée à l'alerte pour supprimer plus de caractères en utilisant la soustraction-faux conditionnel.

Techniquement, le résultat final est que vous atteindrez finalement un nombre à deux chiffres comme 13, 26 ou 39 qui, lors de l'exécution de l'étape 1, donnera respectivement 13, 26 ou 39. Donc, tester la même itération 100 confirmera la divisibilité.

Cheddar, 20 octets (non compétitif)

Le score est de 20 * 0,9 = 18

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

Une réponse simple.

Lisp commun (71 octets * 0,8) = 56,8

Récursivité simple, vraiment.

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

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

Une façon intelligente d'utiliser eval

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

D 56 caractères 0,80 bonus = 44,8

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

cela aurait pu être une sortie avec l'utilisation de 1/13 et un double peut stocker n'importe quel nombre 32 bits exactement

edit: cela fonctionne en multipliant par 1/13 et en vérifiant la partie fractionnaire si elle est différente de 0 (en tenant compte des erreurs d'arrondi) ou en d'autres termes, il vérifie la partie fractionnaire de i / 13

Python 2.7

(20-1 espace blanc) * 0,9 (sans division) = 17,1

print input()%015==0

oui / non au lieu de vrai / faux: 31 * 0,9 (pas de division) = 27,9

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

tire parti de python intpour convertir d'autres bases de chaînes en entiers de base 10. vous pouvez voir dans les deux versions qu'ils utilisent une base différente (mais la même longueur de caractère)

modifier: 1 caractère enregistrer dans la version oui / non

edit2: 2 autres caractères rasés!

edit3: merci encore aux commentaires! encore plus de caractères rasés en utilisant les représentations octales intégrées de python ( 015== 13...) au lieu de la traduction de base 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"}

Les sauts de ligne ont été ajoutés pour plus de clarté. J'aurais probablement pu rendre cette réponse beaucoup plus courte, mais je pense que cette réponse représente une façon unique d'aborder le problème.

Python - score 27,9

(31 caractères * 0,90) - renonce à certains bonus pour un code plus court.

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

ancienne version: (47 caractères * 0,80) - arnaque complète de la réponse Javascript de mellamokb, mais en Python.

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

ancienne version: (60 caractères * 0,80)

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

ancienne version: (105 caractères * 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

Grammaire linéaire droite - ∞ points

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

Ensuite, selon la façon dont vous choisissez de «l'exécuter», il affichera «oui» ou «non».

Pas une entrée sérieuse, juste du plaisir;)

EDIT: Je devrais peut - être expliquer un peu.

UNE grammaire est un ensemble de règles (productions) qui définissent une langue . Une langue peut être considérée comme l'ensemble des chaînes possibles formées par un alphabet, qui sont conformes aux règles de sa grammaire.

Ici, l'alphabet est l'ensemble de tous les chiffres décimaux. Les règles de la grammaire sont que toutes les chaînes doivent former des entiers décimaux divisibles par 13.

Nous pouvons utiliser la grammaire ci-dessus pour tester si une chaîne appartient à notre langue.

Les règles de la grammaire contiennent des symboles terminaux (qui sont des éléments du langage) ainsi que des symboles non terminaux qui sont remplacés récursivement.

Il est plus facile d'expliquer ce qui se passe avec un exemple:

Disons par exemple que la chaîne que nous testons est 71955.

Il y a toujours un symbole de début (qui n'est pas terminal), dans le cas de la grammaire ci-dessus, c'est «S». À ce stade, nous n'avons lu aucun caractère de notre chaîne:

current pattern                    symbol read
S                                  ε

Maintenant, nous lisons le premier symbole de notre chaîne qui est «7», puis nous recherchons une règle dans la grammaire qui a l'un des non-terminaux de notre modèle actuel dans le côté gauche du «->» et que a notre symbole dans le côté droit du '->'. Heureusement, il y en a un (S-> 7G), nous remplaçons donc les symboles non terminaux dans notre modèle actuel par le côté droit de la nouvelle règle:

current pattern                    symbol read
7G                                 7

Maintenant, nous avons le «G» non terminal dans notre modèle, et le prochain symbole à lire est «1». Nous recherchons donc une règle dans notre grammaire qui commence par «G-> 1». Nous en trouvons un (G-> 1F), nous remplaçons donc le non terminal par le RHS de notre nouvelle règle:

current pattern                    symbol read
71F                                1

Continuez à répéter ce processus:

Règle suivante: F-> 9D

current pattern                    symbol read
719D                               9

Règle suivante: D-> 5F

current pattern                    symbol read
7195F                              5

Règle suivante: F-> 5S

current pattern                    symbol read
71955S                             5

À ce stade, nous n'avons plus de symboles dans notre chaîne, mais nous avons un autre symbole non terminal là-dedans. Nous voyons à partir de la première règle de la grammaire que nous pouvons remplacer 'S' par la chaîne vide (ε): S-> ε

Cela nous donne le bagout actuel: 71955ε qui est l'équivalent de 71955.

Nous avons lu tous les symboles de notre chaîne et le modèle ne contient aucun symbole non terminal. Ce qui signifie que la chaîne appartient à la langue et donc 71955 est en fait divisible par 13.

C'est-à-dire que le but est d'avoir pattern = string. Si vous vous retrouvez avec des symboles non terminaux, après avoir lu tous les symboles de votre chaîne, la chaîne n'appartient pas à la langue. De même, si vous avez encore plus de symboles à lire dans votre chaîne, mais qu'il n'y a pas de règles dans la grammaire vous permettant d'avancer, alors la chaîne n'appartient pas à la langue.