Calculez nmodulo 12pour un entier 32 bits non signé.

Les règles:

• Doit fonctionner pour tous nentre 0 et 23. Autres numéros facultatifs.
• Ne doit utiliser l' un des opérateurs +-*, ~&^|ou <<, >>comme généralement défini sur 32 uints bits.
• Peut utiliser un nombre arbitraire d'uints constants.
• Ne peut utiliser aucune forme de pointeurs, y compris des tableaux ou des ifinstructions, y compris des éléments qui se compilent pour des instructions telles que des opérateurs ternaires ou des opérateurs "supérieurs à".

Le score:

• Les opérateurs + -et les opérateurs au niveau du bit ~ & ^ | << >>(NOT, AND, XOR, OR, décalage de bits) donnent un score de 1, *donne un score de 2.
• Le score total le plus bas gagne.

4

(La langue n'est pas pertinente)

n-((48&(11-n))>>2)

Courtiser! Je suis arrivé à 4.

11-n garantira que tous les bits de poids fort sont définis si et seulement si n> = 12.

48&(11-n) == si n> 11 puis 48 sinon 0

(48&(11-n))>>2 == si n> 11 puis 12 sinon 0

n-((48&(11-n))>>2) Est la réponse

4

Une solution avec une table de recherche (elle recherche i ^ (i % 12)):

i ^ (0x1d4c000 >> (i & 0xfc) & 30)

4

Voici une autre solution avec 4 opérations:

i - ((0xffff >> (i - 12)) & 12)

Il suppose que l'opérande de comptage des décalages de bits est implicitement pris mod 32, c'est x >> -1-à- dire est le même que x >> 31.

5

Une autre approche, à l'aide d'une table de recherche:

i - (16773120 >> i & 1) * 12

bash - 1

echo `seq 0 11` `seq 0 11` | awk '{print $(number+1)}'

par exemple

$ echo `seq 0 11` `seq 0 11` | awk '{print $(0+1)}'
0

$ echo `seq 0 11` `seq 0 11` | awk '{print $(11+1)}'
11

$ echo `seq 0 11` `seq 0 11` | awk '{print $(12+1)}'
0

$ echo `seq 0 11` `seq 0 11` | awk '{print $(23+1)}'
11

C, petit-boutien - 2

C'est probablement de la triche mais je pense que cela satisfait les règles ...

union {
    int i;
    struct {
        int a:4;
        int b:2;
        int c:10;
    } s;
    struct {
        int a:2;
        int b:14;
    } t;
} u;

u.i = 11-n;
u.s.a = 0;
u.s.c = 0;
result = n-u.t.b;

PHP - score 0

Je me demande comment est-il possible que personne ne soit venu avec ça avant moi !!!

$n = 18;
$s = str_repeat("a", $n);
$s2 = preg_replace('/aaaaaaaaaaaa/', '', $s);
echo strlen($s2);

C, score 5

Fonctionne jusqu'à 23, non garanti au-dessus.

( ((n+4)>>2)&4 ) + n & 15

((n+4)>>2)&4renvoie 4 pour n> = 12. Ajoutez-le à n et vous obtenez la bonne réponse dans les 4 bits les moins significatifs, puis tronquez les autres bits.

quelle que soit la langue: 5

ne va pas gagner, mais participer parce que c'est amusant et peut-être parce qu'il est plus facile de comprendre que les autres:

n - ((n+20)>>5)*12

cela équivaut à

n - (n>11)*12

c'est équivalent parce que lorsque vous ajoutez 20 à 12, vous obtenez 32, donc le 5ème bit devient 1. Ce n'est que lorsque n> 1 que 32 est le plus petit nombre où le 5ème bit devient 1.

notez également qu'il est facilement extensible pour une gamme plus élevée, comme vous pouvez le faire

n - ((n+20)>>5)*12 - ((n+41)>>5)*12

pour atteindre une plage jusqu'à 35

Python 2.x - 4

j=input();m=lambda a,b:a*b;a=(m(j,357913942)>>32);print j-m(12,a)

Est =un opérateur?

Dans ce cas, le score est de 6.

j-12*(j*357913942>>32)

La solution de BTW @steveverrill peut également être utilisée directement en Python.

Fonctionne pour la gamme 0 .. 23

Alors que se passe-t-il ? Multipliez par 357913942 et divisez par 2 ^ 32 (ou décalage à droite 32)

C - 6

(n - (((n * 0xAAAB) >> 19)) * 12 )

Cobra - 2 (ou 3)

def modulo12(n as uint32) as uint32
        for i in 11:n to int64:12,n-=12
        return n

Cela pourrait un peu déformer les règles, mais j'ai demandé et j'ai été autorisé à utiliser cela.

Il fonctionne également pour n'importe quel numéro.

Kona - 5

Peut être invalide car je ne sais pas si l'opérateur de plancher est autorisé, mais j'en ai deux *et un moins:

mod:{x-(_0.08333*x)*12}

Ce qui devrait fonctionner pour n'importe quel entier.