Numéros popcount magiques


25

Il existe un célèbre algorithme délicat pour compter le nombre de bits définis dans un entier non signé 32 bits:

int popcount(unsigned x) {
   x = (x & 0x55555555) + ((x >> 1) & 0x55555555);
   x = (x & 0x33333333) + ((x >> 2) & 0x33333333);
   x = (x & 0x0F0F0F0F) + ((x >> 4) & 0x0F0F0F0F);
   x = (x & 0x00FF00FF) + ((x >> 8) & 0x00FF00FF);
   x = (x & 0x0000FFFF) + ((x >>16) & 0x0000FFFF);
   return x;
}

Je ne l'expliquerai pas ici. Mais imaginez un code similaire pour les entiers 512 bits! Les constantes hexadécimales seraient énormes et formeraient un joli motif. Votre tâche consiste simplement à imprimer cette sortie exacte :

0x55555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555
0x33333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333
0x0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f
0x00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff
0x0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff
0x00000000ffffffff00000000ffffffff00000000ffffffff00000000ffffffff00000000ffffffff00000000ffffffff00000000ffffffff00000000ffffffff
0x0000000000000000ffffffffffffffff0000000000000000ffffffffffffffff0000000000000000ffffffffffffffff0000000000000000ffffffffffffffff
0x00000000000000000000000000000000ffffffffffffffffffffffffffffffff00000000000000000000000000000000ffffffffffffffffffffffffffffffff
0x0000000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff

Pas d'espaces de fin, s'il vous plaît - bien qu'une seule nouvelle ligne de fin soit facultative.

Il s'agit de , donc la réponse la plus courte (en octets) l'emporte.


Sommes-nous autorisés à prendre des entrées (comme dans quelque chose comme 0x0x0x0x0x0x0x0x0x)?
ouflak

@ouflak No. ———
Lynn

Réponses:


3

05AB1E , 26 22 21 octets

05AB1E utilise l' encodage CP-1252 .

9F„0x0NÍo×9ooNoo>÷hJ,

Essayez-le en ligne!

Explication

9F                      # for N in [0 ... 8]
  „0x                   # push the string "0x"
     0NÍo×              # push 2**(N-2) zeroes
          9oo           # 2**2**9
                 ÷      # //
             Noo>       # (2**2**N+1)
                  h     # converted to base-16
                   J    # join everything to string
                    ,   # print with a newline

Autres versions qui pourraient être améliorées

9F9ooNoo>÷h¾6o×J7o£R…0xÿ,
9F9ooNoo>÷h0žy×ìR7o£R…0xÿ,
9FX0No×1No×JCh7o×1K7o£…0xÿ,
8ÝovX0y×1y×JCh7o×1K7o£…0xÿ,
9F1NoÅ0D>)˜JCh1K7o×7o£…0xÿ,

21

Python 2, 52 49 46 octets

Le kième nombre est donné par 2**512/(2**2**k + 1). C'est pour un nombre de 512 bits, il est donc trivial d'étendre le motif à différentes largeurs.

l=2;exec"print'0x%0128x'%(2**512/-~l);l*=l;"*9

3 octets enregistrés grâce à Dennis.
3 octets enregistrés grâce à xnor.


2
Les avantages des entiers de précision arbitraire ...
ETHproductions

Agréable. Cela économise quelques octets.
Dennis

Plus court pour garder la quadrature:l=2;exec"print'0x%0128x'%(2**512/-~l);l*=l;"*9
xnor

1
Cela me fait chaud au cœur de voir Python en tête du vote :)
Tobias Kienzler

4
@TuukkaX J'ai juste beaucoup d'expérience avec les hacks twiddling. J'ai beaucoup utilisé Wolfram Alpha pour simplifier les sommes et autres. Mais au fond , je fait le modèle 01010101, 00010001, 00000001, puis multiplié par ceux 1, 11, 1111pour obtenir les schémas binaires corrects. Par exemple, 01010101vous pouvez obtenir la formule pour une certaine largeur w en faisant sum 2^(2*k) for k = 0, w/2 - 1et en découvrant qu'elle est (2**w - 1)/3.
orlp

7

PHP, 111 110 108 octets

Un octet enregistré grâce à @ user59178.

<?=($p=str_pad)("0x",130,5).$p($s="\n0x",131,3);for($x=1;$x<65;$x*=2)echo($p($s,131,$p(0,$x,0).$p(f,$x,f)));

Quel est le modèle pour 1024 bits? :RÉ


1
Vous pouvez enregistrer un octet en utilisant $x<65plutôt que $i++<7. Cette fois, je l'ai testé et tout.
user59178

6

Rétine , 43 octets

:`
0x128$*5
:`5
3
;{:`33
0f
0(f+)(0+)
0$2$1

Essayez-le en ligne!

Explication

Cela fait beaucoup usage de l' :option généralement sous-utilisée qui vous permet d'imprimer des résultats intermédiaires, car il est beaucoup plus court de modifier une seule ligne que de créer la sortie entière.

:`
0x128$*5

Ceci remplace l'entrée vide par 0xsuivie de 128 5s et l'imprime pour générer la première ligne.

:`5
3

Celui-ci remplace le 5s par 3s pour générer la deuxième ligne et l'imprime également.

;{:`33
0f

Il s'agit de la dernière ligne à boîtier spécial et elle se transforme tous les deux 3s en 0fpour générer la troisième ligne. Cela démarre également une boucle à travers les deux dernières étapes ( {). Cependant, cette étape ne fera rien après la première itération, sauf imprimer l'état actuel. Le ;supprime la sortie à la toute fin du programme pour éviter de dupliquer la dernière ligne.

0(f+)(0+)
0$2$1

Cette substitution transforme maintenant chaque ligne en la suivante, en échangeant toutes les autres paires de fs et de 0s. La condition "toutes les autres paires" est appliquée en faisant correspondre un zéro devant le f, ce qui rend impossible la correspondance des paires consécutives car les correspondances ne peuvent pas se chevaucher.


6

Vim, 32 octets

i5<CR>3<Esc>qqYpVrf$<C-V>{yPG1vr0q6@q<C-V>{I0x<Esc>

Je n'ai qu'à écrire manuellement le premier 5et 3, et la macro s'occupe du reste, "doubler le nombre de bits" à chaque exécution. L'ordre des étapes dans la macro est un peu bizarre (faire une nouvelle fligne, copie bloc par bloc, réutiliser la taille du bloc visuel pour mettre 0s dans la fligne), mais c'est la variante la plus rapide que j'ai trouvée.


5

Pyth, 26 octets

V9%"0x%0128x"/^2 512h^2^2N

Port de ma réponse Python.


5

J, 46 34 octets

Je travaille sur le golf, mais ce bébé aime rester à 46 octets ... Plus maintenant! -12 octets grâce aux miles!

'0x',"1'5','3','0f'(128$#)"{~2^i.7

Essayez-le en ligne! :RÉ

Résultat

   '0x',"1'5','3','0f'(128$#)"{~2^i.7
0x55555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555
0x33333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333
0x0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f
0x00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff00ff
0x0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff0000ffff
0x00000000ffffffff00000000ffffffff00000000ffffffff00000000ffffffff00000000ffffffff00000000ffffffff00000000ffffffff00000000ffffffff
0x0000000000000000ffffffffffffffff0000000000000000ffffffffffffffff0000000000000000ffffffffffffffff0000000000000000ffffffffffffffff
0x00000000000000000000000000000000ffffffffffffffffffffffffffffffff00000000000000000000000000000000ffffffffffffffffffffffffffffffff
0x0000000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff

Pour cette réponse, j'avais besoin (idéalement) d'un verbe avec rang 0 1afin de l'utiliser dans la u"vdéfinition du rang; cependant, des milles ont observé que 0 _c'était suffisant pour la tâche à accomplir.

┌──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┐
│= │< │<.│<:│> │>.│>:│+ │+.│+:│* │*.│*:│_ 0 0│_ 0 0│0 0 0│0 0 0│0 0 0│0 0 0│0 0 0│0 0 0│0 0 0│0 0 0│0 0 0│0 0 0│0 0 0│
├──┼──┼──┼──┼──┼──┼──┼──┼──┼──┼──┼──┼──┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
│- │-.│-:│% │%.│%:│^ │^.│$ │$.│$:│~.│~:│0 0 0│0 _ _│0 _ _│0 0 0│2 _ 2│0 0 0│0 0 0│0 0 0│_ 1 _│_ _ _│_ _ _│_ 0 0│_ 0 0│
├──┼──┼──┼──┼──┼──┼──┼──┼──┼──┼──┼──┼──┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
│| │|.│, │,.│,:│; │;:│# │#.│#:│! │/:│\:│0 0 0│_ 1 _│_ _ _│_ _ _│_ _ _│_ _ _│1 _ _│_ 1 _│1 1 1│_ 1 0│0 0 0│_ _ _│_ _ _│
├──┼──┼──┼──┼──┼──┼──┼──┼──┼──┼──┼──┼──┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
│[ │[:│] │{ │{.│{:│}.│}:│".│":│? │?.│a │_ _ _│_ _ _│_ _ _│1 0 _│_ 1 _│_ 0 0│_ 1 _│_ 0 0│1 _ _│_ 1 _│0 0 0│_ 0 0│_ _ _│
├──┼──┼──┼──┼──┼──┼──┼──┼──┼──┼──┼──┼──┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
│A │A.│b │C │C.│d │D │e │e.│E │E.│f │H │_ _ _│1 0 _│_ _ _│_ _ _│1 1 _│_ _ _│_ _ _│_ _ _│_ _ _│_ _ _│0 _ _│_ _ _│_ _ _│
├──┼──┼──┼──┼──┼──┼──┼──┼──┼──┼──┼──┼──┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
│i │i.│i:│I │I.│j │j.│L │L.│M │o │o.│p │_ _ _│1 _ _│0 _ _│_ _ _│1 _ _│_ _ _│0 0 0│_ _ _│_ 0 0│_ _ _│_ _ _│0 0 0│_ _ _│
├──┼──┼──┼──┼──┼──┼──┼──┼──┼──┼──┼──┼──┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┼─────┤
│p.│p:│q │q:│r │r.│s │s:│S │t │T │u:│x:│1 1 0│0 _ _│_ _ _│0 0 0│_ _ _│0 0 0│_ _ _│_ _ _│_ _ _│_ _ _│_ _ _│_ _ _│_ _ _│
└──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┘

Vous voyez ici un tas de représentations de chaînes de verbes avec leurs rangs respectifs. Ceci est le script que j'ai utilisé pour le générer.


Un verbe avec rang 0 _est très bien ici. Vous pouvez le raccourcir à 34 octets avec'0x',"1'5','3','0f'(128$#)"{~2^i.7
miles

@miles Huh. Je pensais avoir essayé ça ... cool! et j'ai oublié la fonction de remplissage automatique de J, merci encore!
Conor O'Brien

4

En fait , 25 octets

9r`╙╙u9╙╙\#"0x%0128x"%`Mi

Essayez-le en ligne!

Cette solution utilise le fait que f(n) = 2**512//(2**2**n + 1)(où //est la division au sol) pour calculer les valeurs.

Explication:

9r`╙╙u9╙╙\#"0x%0128x"%`Mi
9r`╙╙u9╙╙\#"0x%0128x"%`M   for n in range(1, 10):
      9╙╙\                   2**2**9//
   ╙╙u                                (2**2**n + 1)
          #"0x%0128x"%       pad with zeroes to 128 digits, prefix with "0x"
                        i  flatten and implicitly print

4

JavaScript (Firefox 30+), 139 113 112 92 83 80 octets

_=>[for(x of"970123456")(f=y=>y--?f(y)+(x>6?x-4:y>>x&1&&'f'):'0x')(128)].join`
`

Enfin, frappez le sweet spot récursif :-) Utilise une compréhension de chaîne pratique pour économiser 3 octets sur .map:

_=>[..."970123456"].map(x=>(f=y=>y--?f(y)+(x>6?x-4:y>>x&1&&'f'):'0x')(128)).join`
`

.replace est également de 83 octets:

_=>"970123456".replace(/./g,x=>(f=y=>y--?f(y)+(x>6?x-4:y>>x&1&&'f'):'0x')(128)+`
`)

Si une nouvelle ligne de tête était autorisée, ce serait également 80 octets:

_=>"970123456".replace(/./g,x=>(f=y=>y--?f(y)+(x>6?x-4:y>>x&1&&'f'):`
0x`)(128))


3

Bubblegum , 65 octets

00000000: c5cb 4501 0441 1043 d17b d4fc 254b d110  ..E..A.C.{..%K..
00000010: f7cb 9761 9e7a 8d45 e451 4ce4 564c 04d7  ...a.z.E.QL.VL..
00000020: 2e11 b02b 8f08 80df aa5e 11fe fc77 762c  ...+.....^...wv,
00000030: 428b 5b8e ae8b 30c1 13b6 ce8b b091 377a  B.[...0.......7z
00000040: 01                                       .

Réponse Bubblegum obligatoire.


3

Haskell, 84 72 octets

Portage de @ orlp's answer:

import Text.Printf
mapM(\n->printf"0x%0128x\n"$div(2^2^9)$2^2^n+1)[0..8]

Alternatives de 94 octets sans la puissance de Text.Printf:

import Data.List
mapM(putStrLn.("0x"++))$transpose$("53"++).reverse<$>sequence(["0f"]<*[1..7])

r=[0..127]
mapM(putStrLn.("0x"++))$('5'<$r):('3'<$r):[["0f"!!mod(div x(2^y))2|x<-r]|y<-[0..6]]

@nimi whoops, doit avoir été chargé Control.Monaddans le REPL. Fixé.
Angs

3

PowerShell v2 +, 68 octets

5,3|%{"0x"+"$_"*128}
($a=1)..7|%{"0x"+('0'*$a+'f'*$a)*(128/($a*=2))}

PowerShell n'a pas d'entiers de précision arbitraire sans utiliser d' [bigint]appels, et ceux-ci ne peuvent pas être facilement convertis en hexadécimal, donc nous traitons plutôt cela comme un défi basé sur des chaînes.

La première ligne gère la répétition 5et 3en faisant simplement une multiplication de chaîne sur les 128caractères et en clouant un 0xsur le devant.

La ligne suivante passe de $a=1à 7, chaque itération produisant une autre chaîne. Encore une fois , nous avons le 0xcloués sur l'avant, et nous faisons la multiplication des cordes au milieu pour construire le nombre approprié de 0et fconcaténés, et puis en faisant la multiplication de chaîne de ce sur le nombre de caractères. Notez que nous utilisons $aici une variable , et non le compteur de boucles $_, donc nous pouvons correctement mettre à l'échelle (sinon nous aurions besoin de boucler comme 1,2,4,8,16,32,64|%{...}, ce qui est plus long).

Les chaînes résultantes sont laissées sur le pipeline, et la sortie via implicite Write-Outputse produit à la fin du programme, avec une nouvelle ligne entre les éléments.


3

V , 43 octets

64i0fòYpÓ¨¨0«©¨f«©©û2}/²²³³òdd{3ÄÒ5jÒ3Îi0x

Essayez-le en ligne!

Cela utilise l'un des regex compressés les plus longs dont j'ai jamais eu besoin dans une réponse V. Voici la version la plus lisible, où j'ai ajouté un octet pour les expressions rationnelles lisibles et changé le caractère d'échappement non imprimable en<esc>

64i0f<esc>òYpÓö((0+)(f+)){2}/²²³³òdd{3ÄÒ5jÒ3Îi0x

Explication (en utilisant la version lisible):

64i0f<esc>                                          " Insert 64 "0f"s and escape to normal mode
          ò                      ò                  " Recursively:
           Yp                                       "   Duplicate this line
             Ó                                      "   Substitute:
              ö                                     "     (Optionally Turn the readable version on)
               ((0+)(f+))                           "     One or more '0's followed by one or more 'f's
                         {2}                        "     Repeated twice
                            /                       "   With:
                             ²²                     "     The second capture group twice (the '0's)
                               ³³                   "     Followed by the third capture group twice (the 'f's)
                                                    "   Once the search is not found, the loop will break
                                  dd                " Delete a line (because we have one too many)
                                    {               " Move to the first line
                                     3Ä             " Make three copies of this line
                                       Ò5           " Replace the first one with '5's
                                         jÒ3        " Move down a line and replace the second with '3's
                                            Î       " On every line:
                                             i0x    "   Insert a '0x'

3

JavaScript (ES6), 74 72 70 octets

Inclut la nouvelle ligne de fin facultative.

f=(i=1152)=>i--?f(i)+(i&127?'':`
0x`)+('53'[y=i>>7]||i&1<<y-2&&'f'):''


2

Pyth - 31 30 octets

Pour obtenir un motif, sauf pour le 3et 5le, il réduit cumulativement, en doublant à chaque fois les morceaux.

jm+"0x".[dd128+`3+`5.u.iNN6"0f

Essayez-le en ligne ici .


2

Lot, 216 octets

@echo off
set s=5
call:c
set s=3
call:c
set a=0
set b=f
for /l %%i in (1,1,7)do call:l %%i
exit/b
:l
set s=%a%%b%
:c
for /l %%j in (0%1,1,6)do call set s=%%s%%%%s%%
echo 0x%s%
set a=%a%%a%
set b=%b%%b%

2

Vim 72 octets

i0x128a5Ypll128r3o0x64a0fa0Ypqqffdt0fft0p@qq@qqwYp@qq@w@w@w@w:%s/0$

TryItOnline!

Non imprimables:

i0x^[128a5^[Ypll128r3o0x^[64a0f^[a0^[Ypqqffdt0fft0p@qq@qqwYp@qq@w@w@w@w:%s/0$

Les 4 @ws à la fin me dérangent, mais parce que je comptais sur le @qpour échouer à la fin d'une ligne, il échoue également le @w. Je pourrais essayer d'exécuter q 32 fois et voir si cela gâche les lignes suivantes.


2

C, 146 octets

#define F for(i=0;++i<129;)s[i+1]=
#define P ;puts(s);
i,j;f(){char s[131]={'0','x'};F'5'P F'3'P for(j=1;(j*=2)<129;){F(i-1)%j<j/2?'0':'f'P}}

Non golfé:

#define F for(i=0;++i<129;)s[i+1]=
#define P ;puts(s);
i,j;f(){
  char s[131]={'0','x'};
  F'5'P
  F'3'P
  for(j=1;(j*=2)<129;){
    F(i-1)%j<j/2?'0':'f'P 
  }
}


2

brainfuck , 211 octets

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

Essayez-le en ligne!


1
197 octets via différentes vérifications de boucle. Je suis sûr que le xgénérateur peut être déplacé hors de la boucle maintenant
Jo King



1

C #, 168 octets

()={string R="",o="0",f="f";for(int i=0,j;i<9;i++){R+="0x";if(i>2){o+=o;f+=f;}for(j=0;j<128;){R+=i<1?"5":i<2?"3":o+f;j+=i>1?(int)Math.Pow(2,i-1):1;}R+="\n";}return R;};

1

Stax , 19 octets

⌡hÅék╝94"ºé♪╛#V┐5í╒

Exécuter et déboguer

Déballé, non golfé et commenté, il ressemble à ceci.

512r        [0..511]
{:Brm       convert each to bits and reverse each
M           transpose matrix, filling missing elements in rectangle with zero
m           map over each element of array, using the rest of the program.  outputs implicitly.
  4/        split bits into groups of 4
  {:b|Hm    convert each 4-bit binary number to single digit hex string
  .0xp      print "0x" without newline

Exécutez celui-ci


1

/// , 193 octets

/*/\/\///X/
0x*F/5555*G/FFFF*T/3333*U/TTTT*o/0f0f*1/oooo*t/00ff*2/tttt*g/0000*h/ffff*4/ghgh*6/gghh*7/gggg*8/hhhh*9/7788/0xGGGGGGGGXUUUUUUUUX11111111X22222222X44444444X66666666X78787878X99X77988

Essayez-le en ligne!

En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.