Calculer n% 12

27

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.
nbubis
la source
6
Vous souhaiterez peut-être définir les opérateurs pour les utilisateurs de langues autres que C / Java. Je comprends que l' +-*on additionne, soustrait, multiplie; ~&^|sont au niveau du bit NOT, AND, XOR, OR; et << >>sont des décalages de bits.
Level River St
@steveverrill - merci. Telle est bien l'intention.
nbubis
Puis-je utiliser for i in x:y:z, .dostuff?
Οurous
Puis-je définir une variable égale à une valeur à utiliser dans une expression?
xnor
4
la plupart des compilateurs optimiseront n % 12pour une multiplication et un changement comme dans le plaisir des pirates, donc c'est trivial, il suffit de sortir l'assemblage et de voir
phuclv

Réponses:

29

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

isaacg
la source
1
Aww shucks, tu m'as battu à cette approche! Je n'étais qu'à quelques instants de poster n - (((11 - n) & 0xC0000000) >> 28). Bien joué, je ne pense pas que ce soit possible en moins de quatre.
Runer112
1
@ Runner112 Ouais, j'espérais que personne ne me battrait comme je l'ai posté. Bravo pour le trouver par vous-même, cependant
isaacg
1
Awesome :) 4 est en effet un accomplissement.
nbubis
11

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
copie
la source
7

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

la source
1
Ce n'est pas valide car il utilise des pointeurs.
curiousdannii
@curiousdannii De quels pointeurs parlez-vous? Les flux stdinet stdout? Bien sûr, en interne, ce sont des pointeurs, mais nous pourrions aussi bien disqualifier Java car il utilise la Integerclasse en interne pour beaucoup de choses.
Cole Johnson
$ () N'est-il pas effectivement équivalent à un pointeur?
curiousdannii
@curiousdannii - la documentation awk indique qu'il s'agit de variables intégrées.
5

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;
R ..
la source
Comment ça marche?
nbubis
1
Sorta triche, puisque vous utilisez = 0 au lieu de & 0x0, ce qui devrait compter comme 2 opérations supplémentaires. Mais +1 pour la créativité :)
nbubis
4

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);
Tomas
la source
2
Agréable. Je pense cependant qu'il peut y avoir un problème, car les tableaux sont interdits. Vraiment sympa cependant.
AJMansfield
@AJMansfield On pourrait dire que cela n'a pas de tableaux mais des chaînes (oui, à bas niveau, les chaînes sont des tableaux d'octets). :)
seequ
1
@seequ On pourrait également affirmer que cela n'est pas valide en raison de son utilisation de la RAM (oui, à bas niveau, ram est techniquement un tableau indexé) ¯_ (ツ) _ / ¯
Stan Strum
2

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.

Level River St
la source
Bien joué!! Voyons maintenant si quelqu'un peut arriver à 4 ..
nbubis
2

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

Pinna_be
la source
1

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)

Willem
la source
J'aime la façon dont vous avez utilisé une fonction pour multiplier une seule fois. mais à mon humble avis, vous venez de renommer la multiplication en fonction m (,), ce qui signifie pour moi que vous l'avez utilisée deux fois.
Pinna_be
dépend de la façon dont les règles sont interprétées, mais vous avez un point valide
Willem
1

C - 6

(n - (((n * 0xAAAB) >> 19)) * 12 )
nbubis
la source
Cela devrait faire partie de la question ou simplement d'une autre réponse. Je suggère ce dernier.
Jwosty
@Jwosty - changé.
nbubis
0

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.

Οurous
la source
0

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.

Kyle Kanos
la source
Je ne suis pas sûr de l'opération au sol, mais je suis certain que la première multiplication fonctionne sur autre chose que des entiers 32 bits.
Runer112
@ Runer112: OP indique que l' entrée doit être de 32 bits et que les opérateurs sont tels qu'ils sont normalement définis avec des uints de 32 bits; il ne dit rien sur les valeurs non entières dans le code.
Kyle Kanos
À moins que je ne comprenne quelque chose, 0,08333 * x ne semble pas être une multiplication telle que définie sur les uints 32 bits, car 0,08333 n'est pas une uint 32 bits.
Runer112
1
"Peut utiliser un nombre arbitraire d'uints constants." - ie ne peut pas utiliser de flottants arbitraires.
nbubis
1
@nbubis: cette ligne ne place pas de restriction sur les flottants.
Kyle Kanos