Es gibt einen berühmten kniffligen Algorithmus zum Zählen der Anzahl der gesetzten Bits in einer 32-Bit-Ganzzahl ohne Vorzeichen:

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;
}

Ich werde es hier nicht erklären. Stellen Sie sich einen ähnlichen Code für 512-Bit-Ganzzahlen vor! Die hexadezimalen Konstanten wären riesig und würden ein hübsches Muster bilden. Ihre Aufgabe ist es einfach, genau diese Ausgabe zu drucken :

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

Bitte keine abschließenden Leerzeichen - eine einzelne abschließende Zeile ist jedoch optional.

Das ist Code-Golf , also gewinnt die kürzeste Antwort (in Bytes).

05AB1E , 26 22 21 Bytes

05AB1E verwendet die CP-1252- Codierung.

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

Probieren Sie es online!

Erläuterung

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

Andere Versionen, die möglicherweise verbessert werden

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ÿ,

Python 2, 52 49 46 Bytes

Die k-te Zahl ist gegeben durch 2**512/(2**2**k + 1). Dies gilt für eine 512-Bit-Zahl, daher ist es trivial, das Muster auf verschiedene Breiten zu erweitern.

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

3 Bytes gespart dank Dennis.
3 Bytes gespart dank xnor.

PHP, 111 110 108 Bytes

Ein Byte gespart dank @ 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)));

Was ist das Muster für 1024 Bits? : D

Retina , 43 Bytes

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

Probieren Sie es online!

Erläuterung

Dies macht viel Gebrauch von der allgemein zu wenig genutzten :Option, mit der Sie Zwischenergebnisse drucken können, da es viel kürzer ist, eine einzelne Zeile zu ändern, als die gesamte Ausgabe aufzubauen.

:`
0x128$*5

Dies ersetzt die leere Eingabe durch 0xgefolgt von 128 5s und druckt sie aus, um die erste Zeile zu erzeugen.

:`5
3

Dieser ersetzt das 5s durch 3s, um die zweite Zeile zu erzeugen und druckt sie ebenfalls aus.

;{:`33
0f

Dies ist die letzte Sondergefasste Linie und es stellt sich alle zwei 3s in 0fdie dritte Zeile zu erzeugen. Dies startet auch eine Schleife durch die letzten beiden Stufen ( {). In dieser Phase wird jedoch nach der ersten Iteration nur der aktuelle Status gedruckt. Die ;Unterdrückt die Ausgabe am Ende des Programms zu vermeiden , dass die letzte Zeile duplizieren.

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

Diese Ersetzung transformiert nun jede Zeile in die nächste, indem jedes zweite Paar von fs und 0s ausgetauscht wird . Die Bedingung "Jedes zweite Paar" wird durch Abgleichen einer Null vor der erzwungen f, wodurch es unmöglich wird, aufeinanderfolgende Paare abzugleichen, da Übereinstimmungen nicht überlappen können.

Vim, 32 Bytes

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

Ich muss nur das erste 5und manuell schreiben 3, und das Makro erledigt den Rest und "verdoppelt die Bitanzahl" jedes Mal, wenn es ausgeführt wird. Die Reihenfolge der Schritte im Makro ist etwas seltsam (eine neue fZeile blockweise kopieren, die visuelle Blockgröße wiederverwenden, um 0s in die fZeile einzufügen), aber es ist die schnellste Variante, die ich gefunden habe.

Pyth, 26 Bytes

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

Port meiner Python-Antwort.

J, 46 34 Bytes

Ich arbeite daran, das Golf zu spielen, aber dieses Baby mag es, bei 46 Bytes zu bleiben ... Nicht mehr! -12 Bytes dank Meilen!

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

Probieren Sie es online! : D

Ergebnis

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

Für diese Antwort benötigte ich (idealerweise) ein Verb mit Rang 0 1, um es in der u"vDefinition von Rang zu verwenden; Meilen beobachteten jedoch, dass dies 0 _für die anstehende Aufgabe ausreichte.

┌──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┐
│= │< │<.│<:│> │>.│>:│+ │+.│+:│* │*.│*:│_ 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│_ _ _│_ _ _│_ _ _│_ _ _│_ _ _│_ _ _│_ _ _│
└──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┴─────┘

Hier sehen Sie eine Reihe von Zeichenfolgendarstellungen der Verben mit ihren jeweiligen Rängen. Dies ist das Skript, mit dem ich es generiert habe.

Eigentlich 25 Bytes

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

Probieren Sie es online!

Diese Lösung nutzt die Tatsache, dass f(n) = 2**512//(2**2**n + 1)(wo //ist Floored Division), um die Werte zu berechnen.

Erläuterung:

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

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

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

Endlich den rekursiven Sweet Spot erreichen :-) Verwendet ein handliches Dandy-String-Verständnis, um 3 Bytes zu sparen .map:

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

.replace ist auch 83 Bytes:

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

Wenn eine führende Zeile zulässig wäre, wären dies auch 80 Byte:

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

Python 2 , 60 Bytes

k=1
exec"print'0x%0128x'%int(256/k*('0'*k+'1'*k),2);k*=2;"*9

Probieren Sie es online!

Bubblegum , 65 Bytes

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                                       .

Obligatorische Bubblegum-Antwort.

Haskell, 84 72 Bytes

Portierung @ orlps Antwort:

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

94-Byte-Alternativen ohne die Leistung von 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]]

PowerShell v2 +, 68 Byte

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

In PowerShell gibt es keine Ganzzahlen mit willkürlicher Genauigkeit, ohne dass [bigint]Aufrufe verwendet werden. Diese können nicht einfach in Hexadezimalzahlen konvertiert werden. Wir behandeln dies stattdessen als eine auf Zeichenfolgen basierende Herausforderung.

Die erste Zeile behandelt das Wiederholen 5und 3durch einfaches Multiplizieren von 128Zeichen und Anheften von a 0xauf der Vorderseite.

Die nächste Zeile springt ab $a=1 bis 7, wobei jede Iteration eine andere Zeichenfolge ausgibt. Wieder haben wir 0xdas vorne angeheftet, und wir führen eine String-Multiplikation in der Mitte durch , um die entsprechende Anzahl von Zeichen zu konstruieren 0und miteinander zu fverknüpfen, und führen dann eine String-Multiplikation dieser Zeichen mit der entsprechenden Anzahl von Zeichen durch. Beachten Sie, dass wir hier eine Variable verwenden $aund nicht den Schleifenzähler $_, damit wir richtig skalieren können (andernfalls müssten wir eine Schleife wie1,2,4,8,16,32,64|%{...} , die länger ist).

Die resultierenden Zeichenfolgen Write-Outputverbleiben in der Pipeline und werden implizit nach Abschluss des Programms mit einer neuen Zeile zwischen den Elementen ausgegeben.

V , 43 Bytes

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

Probieren Sie es online!

Dies verwendet eine der längsten komprimierten regulären Ausdrücke, die ich je in einer V-Antwort benötigt habe. Hier ist die lesbarere Version, in der ich ein Byte für lesbare reguläre Ausdrücke hinzugefügt und das nicht druckbare Escape-Zeichen in geändert habe<esc>

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

Erklärung (unter Verwendung der lesbaren Version):

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'

JavaScript (ES6), 74 72 70 Byte

Beinhaltet den optionalen abschließenden Zeilenumbruch.

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

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

console.log(f())

Pyth - 31 30 Bytes

Um ein Muster zu erhalten, wird es mit Ausnahme des 3's und 5' s kumulativ reduziert, wobei jedes Mal die Stücke verdoppelt werden.

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

Probieren Sie es hier online aus .

Stapel, 216 Bytes

@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%

Vim 72 Bytes

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

TryItOnline!

Unbedruckbares:

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

Die 4 @ws am Ende nerven mich, aber weil ich mich darauf verlassen habe @q, dass das am Ende einer Zeile ausfällt, fällt auch das @w aus. Ich könnte versuchen, nur 32-mal q auszuführen und zu sehen, ob es die späteren Zeilen durcheinander bringt.

C 146 Bytes

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

Ungolfed:

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

Brainfuck , 211 Bytes

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

Probieren Sie es online!

GNU sed 4.2.2 , 77

s/^/0x5/
:
s/x5{,127}$/&5/
t
p
y/5/3/
p
s/33/0f/gp
:a
s/(f+)(0+f+)/\2\1/gp
ta

Probieren Sie es online aus.

Ruby , 66 60 45 Bytes

x=2;9.times{puts"0x%0128x"%(2**512/-~x);x*=x}

Probieren Sie es online!

Idee von Orlp gestohlen

C #, 168 Bytes

()={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;};

Stax , 19 Bytes

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

Führen Sie es aus und debuggen Sie es

Entpackt, ungolfed und kommentiert sieht es so aus.

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

Führen Sie dieses aus

/// , 193 Bytes

/*/\/\///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

Probieren Sie es online!