text:
List all multiplicative partitions of n
Given a positive number n, output all distinct multiplicative partitions of n in any convenient format.
A multiplicative partition of n is a set of integers, all greater than one, such that their product is n. For example, 20 has the following distinct multiplicative partitions:
2 * 2 * 5
2 * 10
4 * 5
20

Order does not matter, so 2 * 2 * 5 is the same partition as 2 * 5 * 2.

Examples:
1 -> {}
2 -> {2}
4 -> {2, 2}, {4}
20 -> {2, 2, 5}, {2, 10}, {4, 5}, {20}
84 -> {2, 2, 3, 7}, {2, 2, 21}, {2, 14, 3}, {2, 6, 7}, {2, 42}, {4, 3, 7}, {28, 3}, {4, 21}, {6, 14}, {12, 7}, {84}

Related OEIS sequence.

Related

Brachylog, 16 bytes
>~l:{1<}a.*?,.=o

This is a function (not a full program) which takes a positive number as input and generates all multiplicative partitions of it. (I also avoided using any prime factorization builtins in this solution, mostly because I wasn't sure they'd help; I might try a more builtin-heavy solution too at some point.)
Try it online! (Extra code has been added around the function here to make it into a full program; if you provide the function shown above to TIO directly, it will run the function but not print its output anywhere, which is kind-of useless as a demonstration.)
This program really disappoints me, because much of it is working around bugs in the Brachylog interpreter and deficiencies in its specification, rather than actually solving the problem; but the interpreter is what it is. (Even with the program like this, the interpreter uses much more memory than it logically should, and crashes due to memory exhaustion, but luckily on small problems it manages to produce the desired output first.) In a hypothetical "perfect version of Brachylog" you could just write ~*.o.:{>1}a,, which would be 4 bytes shorter, but I needed to add extra constraints to help the interpreter out a bit. (I don't really like Brachylog much, and would rather stick to Prolog, but it needed similar hints to make the program work and they're much longer to write. So Brachylog it is.)
Explanation:
As usual, a Brachylog program is a set of constraints; by default, the first constraint constrains the input against an unknown (which I'll call A), the second constraint constrains A against a second unknown B, and so on until we reach the output. Some characters, such as {}, can change this general flow, so I use a different set of letters (e.g. X/Y) to represent unknowns in nested predicates.
>       A is smaller than the input
~l      B has length A
  1<    X is 1, Y is larger
:{1<}a  For each element X of B, it corresponds to an element Y of C
.       C, the output, and D are all identical
*       E is the product of D's elements
?       E, the input, and F are all identical
,       There's no constraint between F and G
.       G, the output, and H are all identical
=       H and I are identical, and need to be evaluated early
o       The output can be produced by sorting I

It's still unclear how the program works, so let's try simplifying the constraints a bit. C, D, G, H, and I are all the same (and equal to the output). E and F are also the same (and equal to the input). So our constraints boil down to this:

A is the length of B and of the output, and is smaller than the input.
B consists of all 1s, and isn't particularly useful (it's part of the program simply because in the existing Brachylog interpreter, :{1<}a needs its left argument to have a constrained length, or else the interpreter goes into an infinite loop).
The output consists entirely of numbers greater than 1 (i.e. greater than the corresponding element of B).
The product of the elements of the output is equal to the input.
The output is unchanged by sorting it (i.e. is in sorted order).

Incidentally, I didn't explicitly specify that all the elements of the output are integers, something which might seem to be required; however, Brachylog's constraint solver can't handle non-integers, so it'll conveniently produce only the solutions that involve integers.
Clearly, "the length of the output is smaller than the input" is going to be true whenever the output is a multiplicative partition of the input (because 2x > x for all nonnegative x, i.e. positive 2x). So we can disregard that constraint; it's only there to give the Brachylog interpreter a working strategy for evaluating the program. The other constraints (that the output is sorted, that its product is the input, and that its elements are all greater than 1) are the definition of a multiplicative partition, and therefore this function is basically just a direct implementation of the question.

Brachylog 1, 14 bytes
:{$pp~c:*ao}fd

Try it online!
Brachylog 2, 11 10 bytes, language postdates challenge
{ḋp~c×ᵐo}ᵘ

Try it online!
Maltysen answered this question in 17 bytes of Pyth, so I came up with a 16-byte Brachylog solution that worked by translating the specification of the question to Brachylog. While I was doing that, Dennis wrote a 15-byte Jelly solution. So I had to go down to 14 bytes. This is a function that takes the input as an argument, and returns a list of all partitions (rather than a generator, as with my other solution).
Some time after I wrote this answer, Dennis and I managed to cooperatively get the Jelly solution down to 11 bytes. It turns out there's a new version of Brachylog out, with a terser syntax; it postdates the challenge, so doesn't actually count, but it could manage the 11-byte total too pretty much as soon as it released; later revisions of the language (inspired by other challenges) can go as low as 10, as seen here. The two programs are identical, with the only difference being the syntax.
Unlike my other solution, which didn't make much use of "golfing primitives" but rather stated the problem directly, this one ignores pretty much all the power of Brachylog constraints and does its best Jelly impression instead, writing a chain of constraints for which the left argument is already known (and thus the constraints simply act like Jelly monads rather than full-blown constraints). It therefore uses the same algorithm as @Maltysen's Pyth solution, which is probably the easiest way to solve this using typical golfing primitives. (Interestingly, the "just state the problem" solution in my other answer would be shorter if not for bugs/deficiencies in the Brachylog interpreter, despite its lack of use of golfing primitives. Some day I need to write an "improved Brachylog" in order to get a good solution for this kind of problem; as golfing languages go, Brachylog is actually really verbose.)
The program consists of a generator, and a wrapper around it. First, here's an explanation of the generator:
$pp~c:*ao  ḋp~c×ᵐo
$p         ḋ        Prime factor decomposition of the input
  p         p       Generate all permutations
   ~c        ~c     Generate all inverse concatenations (i.e. partitions)
     :*a       ×ᵐ   Take the product of each list element in each partition
        o        o  Sort each partition

This almost solves the problem, but we end up generating many of the partitions many times each. So we need a wrapper to deduplicate the solutions:
:{…}fd
:{…}f     Convert generator to list
     d    Remove duplicate elements

{…}ᵘ      Convert generator to list of unique elements

Why not edit your exsting answer?

@Downgoat: The two answers use entirely different approaches; the algorithms are different, the language features that are used are mostly independent, and the like. It wouldn't make sense to replace the older one with the newer one (and I might well have posted the new one even if it were longer). This meta post suggests that posting separate answers is preferable in this sort of situation.

I don't know if you know this but you can retrieve the output by setting the argument on TIO to be a variable (i.e. an uppercase letter). For example.

Mathematica, 61 bytes
±1={{}}
±n_:=Union@@(Sort/@Append[n/#]/@±#&/@Most@Divisors@n)

Defines a (recursive) unary operator ± which returns the list of partitions.

Doesn't mathematica not require the semicolon at the end?

@Pavel no, the semicolon just suppresses output in the interactive notebook. Thanks for pointing this out, btw, I accidentally left a semicolon at the end.

Pyth - 17 bytes
Takes all permutations of the prime factorization, then partitions each one and then products all the partitions, then only retains distinct partitions.
{mS-*Md1s./M.p+1P

Test Suite.

Python 2, 70 bytes
f=lambda n,k=2,l=[]:n/k and(n%k<1)*f(n/k,k,l+[k])+f(n,k+1,l)or 1/n*[l]

Outputs a list of sorted lists. For example f(20) is [[2, 2, 5], [2, 10], [4, 5], [20]].

As Python's built-in integer type has no limits, floating point is not an acceptable solution as inaccuracies will break the answer for too large inputs.

@orlp Ok, back to Python 2 then.

TL;DR I think 998 is not a too large input ;-) IMO a real cool code, more like latency O(n) and comparing to the Python 2 competitor might be more O(n^4) style - while f(998) might blow memory or hardware could die within run time of est. 80 days with the other algorithm, this one here converges after approx. 7 milli secs on my machine to yield the result [[2, 499], [998]]. IMO the problem could be more that for N > 998 the RecursionError: maximum recursion depth exceeded in comparison stops the above Python 3 code ... happy golfing :-)

@Dilettant Not sure if O(n^4) is even enough for my Python2 submission :D Considering the test case 998, my code will run 9 times, and calculate (n+r-1)! / r! / (n-1)! amount of tuples each time, where r is growing linearly from 2, and n is 9 - 2. But hey, at least you don't have to tweak the recursion limit...

@TuukkaX Caveat: I did not analyze the code, just skimmed over and compared the development of run times among the two candidates for some N up to 41 then thought I just commit the comment ;-)  stacks and recursion often meat easy, but then call for how deep type questions in unpleasant situations ... hope I coined it fuzzy enough for the amount of research that went in.

Jelly, 14 13 11 bytes
Ḋx³ŒPQP=¥Ðf

Try it online!
I was fairly sure @Dennis's Jelly solution could be improved. Unfortunately, I didn't manage to beat the Brachylog record, but I did manage to tie it. Update: With @Dennis' help, it's improved now; I guess Jelly takes back the crown.
This program is incredibly inefficient, having O(2n2) performance (which is why the test case above shows it for input 4). It completes quickly on 4, very slowly on 5, and may not be practically possible to run for larger numbers.
Interestingly, the Brachylog was improved by going from a solution that described the problem (which Brachylog is good at) to a solution that used an algorithm based on factorising the input (which Jelly is good at); meanwhile, the Jelly solution was improved by moving away from its strengths, and going back to a solution that just describes the problem.
Explanation:
Ḋx³ŒPQP=¥Ðf
Ḋ              List of integers from 2 to the input (apparently undocumented)
 x³            Make a number of copies of each that's equal to the input
   ŒP          Take all (possibly noncontiguous) subsequences of that list (!)
     Q         Remove duplicates
         Ðf    Filter, keeping elements where:
      P=         their product is equal to {the original input, by default}
        ¥      Parse preceding two links as a unit

Because the output of Ḋx is sorted, each subsequence must also be sorted, and thus we don't have to sort them individually. So the "the same output in different orders is a duplicate" part of the problem, and the "all values in the output are > 1" part of the problem, get solved by the generation. Apart from that, what we're basically doing here is "find all lists for which P=³", which we do (in an incredibly inefficient way) by generating all the lists in question and then filtering out the incorrect ones.
(Clearly, someone needs to go invent a hybrid of Jelly and Brachylog, plus a really good constraint solver, so that we could write something along the lines of {P=³}~ plus some deduplication code, and solve the program in a much shorter length. That might be some distance away, though.)

Please, someone find a character of savings here. I'd love a "byte war" in which the entries keep on getting one byte shorter every time. There's enough bytes wasted on structural parts of the program here that it seems like this might be improvable.

Heh, I was just about to post something strikingly similar. (Should refresh more often.) 2r can become Ḋ, and P=³$$ can become P=¥.

P=¥ doesn't work when I try it in the interpreter, although I'm not entirely sure why (logically, it should work, and it was one of the things I tried while writing the post; I just tried it again to make sure, it definitely doesn't do what I'd expected). Ḋ does, though, so I guess there's our one-byte saving :-)

Didn't pay attention to another detail. You'd have to replace µ with ¹ as well, as µ makes the repeated range the new left argument.

Oh, of course. So now we're down to 11, with much fewer characters, which is making me feel much better. (I used ³ rather than ¹ just for the variety.)

You. Beat. Dennis.

JavaScript (ES6), 74 67 bytes

f=(n,m=2,a=[])=>n>1?m>n?[]:f(n,m+1,a).concat(f(n/m,m,[...a,m])):[a]

for (var i = 1; i < 31; i++) console.log(JSON.stringify(f(i)));

Directly solves the problem recursively: for each integer m from 2 to n, we take each of the partitions of n / m with a minimum element of m (to avoid duplicate partitions) and append m. (For any m that does not divide n, this gives the empty array, as no arrangement of integers multiplies to a decimal.) We define a base case of the empty array for 1 so as to avoid infinite recursion.

Jelly, 9 bytes
ḊœċRẎP=¥Ƈ

Try it online!
This is fairly slow, timing out for \$n \ge 13\$ on TIO
How it works
ḊœċRẎP=¥Ƈ - Main link. Takes n on the left
Ḋ         - Dequeue; Yield [2, 3, ..., n]
   R      - Range; Yield [1, 2, 3, ..., n]
 œċ       - For each 1 ≤ k ≤ n, yield the combinations with replacement
             of length k, choosing from [2, 3, 4, ..., n]
    Ẏ     - Tighten these into a single list of lists
       ¥Ƈ - Keep those lists for which the following is true:
     P    -   The product...
      =   -   ...equals n

Python2, 198 191 172 180 bytes
from itertools import*
n=input()
for i in range(2,len(bin(n))):
 for P in combinations_with_replacement(range(2,n),i):
  if reduce(lambda a,b:a*b,P)==n:print(P)
print[(n,),()][n<2]

A full program. This could be improved a lot, so suggestions are deeply welcome!

@FlipTack saved 9 bytes!
@orlp saved 19 bytes!

Outputs from the range 1 to 31 (inclusive):
(1,)
(2,)
(3,)
(2, 2), (4,)
(5,)
(2, 3), (6,)
(7,)
(2, 4), (2, 2, 2), (8,)
(3, 3), (9,)
(2, 5), (10,)
(11,)
(2, 6), (3, 4), (2, 2, 3), (12,)
(13,)
(2, 7), (14,)
(3, 5), (15,)
(2, 8), (4, 4), (2, 2, 4), (2, 2, 2, 2), (16,)
(17,)
(2, 9), (3, 6), (2, 3, 3), (18,)
(19,)
(2, 10), (4, 5), (2, 2, 5), (20,)
(3, 7), (21,)
(2, 11), (22,)
(23,)
(2, 12), (3, 8), (4, 6), (2, 2, 6), (2, 3, 4), (2, 2, 2, 3), (24,)
(5, 5), (25,)
(2, 13), (26,)
(3, 9), (3, 3, 3), (27,)
(2, 14), (4, 7), (2, 2, 7), (28,)
(29,)
(2, 15), (3, 10), (5, 6), (2, 3, 5), (30,)
(31,)

Does this even work? There is test case 4 -> {2, 2}, {4} in question, I don't see such output in your log.

@Borsunho As I roller the old version back, I forgot to add +1 to int(math.log(n,2)), which caused that. +2 bytes and it will work. Thanks!

You haven't imported math but are using math.log.

@orlp I have...? On the third line.

@TuukkaX Excuse, me, I only looked at the topmost lines for imports, as they're almost always there... That being said, len(bin(n))-2 is shorter than int(math.log(n,2)).

@orlp May I print the divisor itself plainly? I'd rather do print n than print(n,). And I won't need +1 if I do len(bin(n))-2, so thanks!

The challenge seems to require that the output for 1 is () and not (1).

@MartinEnder So it seems. The resulting fix depends on whether I can output a plain number for sets of the length 1 --> 1 instead of (1). Does the meta say something about the default setting for this? I will however go with the bending fix (for now at least).

Jelly, 15 bytes
ÆfŒ!ŒṖ€;/P€€Ṣ€Q

Try it online!

This answer is rich!

Clojure, 91 bytes
(defn f[n](conj(set(for[i(range 2 n):when(=(mod n i)0)j(f(/ n i))](sort(flatten[i j]))))n))

Example runs:
(map f [20 84])
(#{20 (2 2 5) (4 5) (2 10)} #{(7 12) (2 2 3 7) (2 3 14) (2 2 21) (2 6 7) (6 14) (3 4 7) (3 28) (4 21) (2 42) 84})

The value itself is returned as a single number (not a list), others come out as lists. The n at the end could be replaced by [n] to make it a sequence as well, or (list n) to make it a list.

Wolfram Language (Mathematica), 58 56 52 47 bytes
#0[#/i,##2,i]~Do~{i,2,#>1||Print@{##2};Min@##}&

Try it online!
Prints the partitions.

J, 35 bytes
([:~.]<@/:~@(*//.)"$~#\#:i.@!@#)@q:

Based on the solution to a time-constrained factorization challenge.
This version is much more inefficient and runs in factorial time based on the number of prime factors. Creates partitions by generating factoradic numbers.
Try it online! (Don't try large values online!)
Explanation
([:~.]<@/:~@(*//.)"$~#\#:i.@!@#)@q:  Input: integer n
                                 q:  Prime factorization
(                              )@    Operate on them
                              #        Length
                            !@         Factorial
                         i.@           Range [0, i)
                     #\                Range [1, i]
                       #:              Mixed based conversion - Creates factoradic values
     ]                                 Get factors
            (    )"$~                  For each factoradic value
               /.                        Partition the factors based on equal
                                         digits in the factoradic value
             */                          Get the product of each block
        /:~@                             Sort it
      <@                                 Box it
 [:~.                                  Deduplicate

D, 95 bytes
void g(int n,int[]r){for(int i=r[0];i*i<=n;i++)(n%i)?0:g(n/i,i~r);r.back=n;r.writeln;}g(n,[2]);

Just a recursive solution. In g(n,r), r is the partition so far, and n is the value still left to break into factors. To get each unordered partition only once, we sort the factors in r in non-increasing order. The last element of r starts at 2 as the least possible factor, and gets overwritten by n in each copy just before each output operation.
For n = 60, the output is as follows:
[3, 2, 2, 5]
[2, 2, 15]
[3, 2, 10]
[5, 2, 6]
[2, 30]
[4, 3, 5]
[3, 20]
[4, 15]
[5, 12]
[6, 10]
[60]

Try it online!

Use the templates, Gassa, use the templates: void g(T)(T n,T[]r){for(T i=r[0];i*i<=n;i++)n%i0:r;r.back=n;r.writeln;}g(n,[2])

Anyways, this isn't even a valid answer, as you need to import std.stdio and std.range, input 1 should print nothing, not [1].

D, 109 bytes
import std.stdio;void g(T)(T n,T[]r=[2]){if(n-1){for(T i=r[0];i*i<=n;i++)n%i?0:g(n/i,i~r);r[$-1]=n;r.write;}}

Try it online!


text:
Every prime bit must alternate
A program is bit primed if bits in prime positions must alternate between zero and one, starting with one.
For example, this is a template for a bit primed program with [0..47] bits.
..10.1.0 ...1.0.. .1.0...1 .....0.1 .....0.. .1.0...1
01234567 89012345 67890123 45678901 23456789 01234567

Create a bit primed program that takes as input a string and checks if the string is bit primed. The string will be in ASCII and it will be a maximum of 1000 chars.
Rules

For the purposes of this challenge, the bit string for ABCD is
01000001 01000010 01000011 01000100

This is code-golf, so the shortest answer in bytes wins.

@EasterlyIrk Modifying challenge

@EasterlyIrk little endian is trivial

Could you clarify what Big Endian refers to here? Do you mean the string itself, the individual bytes, or both?

@EasterlyIrk your code's "bits" are ordered in big endian when we tell if it's bit primed

@Dennis it is done

your code's "bits" are ordered in big endian That doesn't make any sense and you haven't answered my question.

@Dennis for every bit, if n is it's location and n is prime; bit will be 1 if the last was 0, 0 if the last was 1, 1 if n is 2. It matters the order of the individual bits.

c'mon, I asked in chat before posting and in sandbox for 7 days

I understand what you mean by alternating, just not how the bits are ordered. Please show us by example what bit string corresponds to the byte string "ABCD". That should clear everything up.

@Dennis options, please

Let us continue this discussion in chat.

Related.

@EasterlyIrk Completeness.

@EasterlyIrk see edit

@EasterlyIrk It was there before because the challenge objective was different, now it's unnecessary. [tag:status-completed]

@Alkali Only the 7 bit ASCII standard. String is null-terminated if your language requires it.

I've spent several hours trying to come up with a JavaScript solution, but fitting a function name of more than 3 characters in is terrible. Either way, a few testcases for bit-prime strings would be nice.

@RomanCzyborra I don't care if you're proving a point, please don't make a massive comment of mostly nonsense characters. Next please say something like "Here is a counterexample @ Wheat Wizard: ".

I propose this Python3 program to generate such strings: http://pastebin.com/5iXPx2su

You should probably make it so that if the program does not consist of only ASCII, then it should support input of whatever code page it's encoded in.

To see a set of allowed characters for each position in your code: Python program.

Mathematica, 5432 bytes
f[gQqGCStZu2yl3mIEL5mBpO43ulpBaJP4g2sCvYht09xS9XvYv2XK7aZ6P2yh47J2y2Z8s42u91aKQT8dDQ7NZQFDShTWXW7ldVB8IorrV2Fu6ItvMF2y285nz52GizM3X1q0t3F7KMa@Print[29RshFOc0Zh3HKaau;i=0;1Kv6jpY40n3fmIl0YYfiskcIZaATpT76lc6ph3FhR1INU2ptKd8SJ8GXC54akjX4s08vjnaliCS5AQcSh56YS8hQ3xe2xtCV36Gn6lTDAg1tX3cz6G1tn2NB5NLk9Nx4O7Ygfmf3fAs6mnD3PjIzFw2FAK5Qj6i4wW0Gq0RSo7K6aV93L8N75ioRr6oZlCBRzeq3fiQI71KXLADrcO9sJVh24vMZr84plVXqzo52bmuRO6v6LoP47mggmS00gFtCXnwr64YntzbVjNpiyxQMDLXJnd1vUeUvvy0P6CodeGolfib1psOCu9iMxiT2oGesnIoDrqnKHqExqxgh30kFJRwJJk6LvY4M3ZCkKn43oFERtHe7d5qO7AvaF9T4o9T4Cf97MN1anz4TEPlR7FjoqQXaBVV57a5NfSZW97EFeIVn8LsqHjCgg72Vl6usW8L3RWlIo05Lfd8u7jUD0B8SP1fWymaP7kwYNLCg5OUQtLk479hUsE8bJungHwanMinm1xV9naf97dMqobj6jVAM1EzvXguLOal4OXO6DBFtmhHNwzx6u47fVRy7f;AllTrue[XF2uhxta8qS5K0ZeL9pmX3Zhrqn4IHD2hNTdEb9rsQw8raVJvbgSP1uk9OByu;Pick[l=(2EOFI4khaVxpn5d01z8kaARZNiz1oNZkcniL0sD13Sfqrapri0sq9AV12Wh9F1NtYjwbvHtM73G;Join@@(XX9giynmc3Y6ZScD3SIq0QdKvDHh30p3JAlYizir8xzW4d1AfMEIGKom1Hn3m4oGmSZACY012g1a1YRGaFY6YvI5zuzoseFjEDOn002W0qTCFdsmFMO0Wq05jPvEotODJ688d1Ef2iknRra301eEwXtCYAigA294p3Rn1i6dFvhOuIm9Omn1q6w9l4hY3skRZ4Yqc5IAEE0Ncv1eBg3PlT36YUzEEYhK3ekb5EXhrQEjkpJ3kQxL5m1sxu14N971gI8owjVUNyqzPXZ1YrTJ1i6lydT51gFZZzR9e1HPCG2fPzdY96udYT8m7TWZ6L3RnIzapDbrHJU86K4cLk280pmI0VQna8n5F9TsXzUSLkPY6defMJL7z4nPnSLTMFTtO5tYZ48bA723cK4GEM8Vx1oCSuhdn0OKl13tcKo1fenOJO39E5wIHFk35dButjorAWq8bGDteoHS1xt93x71gRJybCd4ruGl9kdZpwml4c8DRO3RlJAOF7nNwcjGzcLDeBS0VW6gOxGjO6LWEk6FgXEMzEmDHbVp0orIRb7jxeTY6QL0ReWS5E1iuqq0mU1ylo5uFjVuHUDobcBxKbajLjzuMuol57II7YxJrT72A0F0mHxP2EMwFtd6vha5DGtLonviT8osn3RVk7fJeY9pv1Dtxoz56Wd1kUcdL5N5PWPhJA118QlaQbPVQCxxbYXNQzi1PSatEcMIlJ3peMac6FOo6EvhpcIEmKJFCMxsO45dEYmoFf0EB3PTEhIVjX3wCvDvuK5FRrFwkB7CUOhSTlGEG61g8wblwOz9Ws3cu7L9LFDMPFn9rInZg1fq57GvB4VEAGQ02eIz6FbiDCK856Ou4uw2QwpDw8po190u7iQFhz9r74bz3exo2cokT1x059vpuKlnlS8iqc8CArq43qahewU4Kstn3gJKHbplFZrZbiX36tGoS5wY80RiosSf981WS8sGJabtcANl9ckq0nz4JS8y4150SVepw07KE2z7TvkyjA0ZBzIo7nxcrn7E2nGiCcsAT8Fv6mArN4b5v9fYWdZqA8a7gabW0ha8pykl63brXwLF3GJDAL0W376IvWk8IKYD7zTdnLCszD4Za8P7b4ExMeseyRXnuv1asg7sjRul9zQP3WryaMPCyB67gCDpt5n5AuSgC9nr7tEzWQCbBI2XFa5ogOgVdF3mkshjAU6sNuSxksnQdx0f1ZxS93Ioq3422Q1zB3BjML7i6NMF0yzxEiVTN2ENDUtK7V9uXrH1rva7TsXx9v9QE5sLf5gsP38LPUh5ZrDxXhfcCjtGDb9r1c00R9gM1xMjTj4cMEWJlXSfkeSM3yU52ZKsUDCq3fDqDE0plp96k8Ra9M84tz5uJ5mNXM8GxuXSS97c9sXXlFB0CaG4n0EP8lbyuUhOLaKUY9EelL68qSq5zlJFTIZf5u7SDEKFSkGU7ml97Gd7gtZ2NBq4hxOTR4uHZaS4ALmvN8o93fipy088oWKynoJSFjIkkZOw3mbSnHnfexKyYpp2Rv4SW3r3kPQ7UonY3Sm;IntegerDigits[3LpjdCIvIK7J5Cn3YbY9D3c6GuzGa8pUJ5O14ruPrrPcbXqb7z7qA8Q4hrTsWvSBbIIReq7mnIW5lakuMkPMgqg9Zt18pqfjOVQs6ZuYGp5NNds0rX65melVZKRlNCHaGskSIsl3QeApWc0rf8yT12zKI8SFm3SEgcxF4KfE8yHtcLJy8B3Pz06vOy78rg6Y6zSWnInE2pLBj6tYBspKs6YXNL8D6C4P2Y7EcozkoR6aKx2zs0Zfo6lryRqnGds6kg22M472LCJIZ470XGPAkH3QLA7zuST81EjwyqVvFR2p9AEtKiEJc14TVWXFZvsyMuic76ZoQox6B5p295GJVU0SyU5xvtb0CCKTnIvFdPzFFbwMocknxFpoBDbLqFGsaxg7J71Ls3vBkgnlN1Rc5w4PDNTCGQC2RCk1A2L43s3bnkgMAsUNYhGeJDAcNfWUNswuo7A97RYEJEcZRgGQ0upJHX77PZLzJr09HM6HNs1EuDPBslPTEHG4M4wIvx4Vf4rVwXvG3G8i8pORtYJUMzEaYz7X9zsRNAOZ3gXqnRYC5l3qUe28NlHMuiaRuywS1NkaF89bOxLxv4nyHZ9ueHf49L2Co0UqOtzFPs99pwjSDreIyQxioa6CMR9Ht17T9N7GMD7aWaxeBSK48J2pVn04yoQTB0BJMnm9e343KBUw6742VFgTajnRVv16LXtn0jpuOCWFVM2N4CGMzgCBdQZROOl2S4CE6AecPJOaVLWg5Z1GSqeXQmHwB9AjgxRdakpTrvAad0Wb5OLkZXQIKqFxQ7R8wBd79t8L4X9pwj4SJTVKFm1LDn5qeaOw54aJRFqQ0z5GvOd1Xt24TjH7y676nR42CMY91PoBcV2FyRdv8vmjQ8932IHn5LU3up9ZxbqrXPednbFmi6vyLODt8KlhM7ELfYp223GWMrTHVu34nKgdiM5Vlq1bWTaMq2mbM5AcQB52zXgy7pSVvlXdrLqdFwGrFRDrQ03DXm0r9ZbRitrU2tEzVmE9og9AKeAq7pZb68ypniGn5VVBM3mUMZjAACaVmgn5uZS0xsQcE84rblzkK1DAIa2yQ6ixAkGdlezfe6o94B3SJIgjujkBb876db31RXQVSX7aCLWm9DXr1ie7hc2U1M3y3Y3LK4eFbzM69Bg6B5TWVmY6AfBJsC8iYpfICgCpCNDUgGx53EzoWhatALongProgramuqO6XCaRvMePL0QFjx8ojo8IHbEIwbbat4DtRF4vTgRC0wQFzzSyrx2XoajV2DX70042W3x1o99Y4ms9dHATupNeeA57BtUU6rJ2li2i9mQHb1EftkNG5fnSSxWORLqdxw1uki88bxwf2sb7e1Sv4DHEA81ixwR74lT7k2FQ8qvL8ZyPN1iLn1NbpgOFXKAXOioKpoW2OHX6RNDRrL0rOBuLLugIiPg3SJ4n7kr0Ozm5N6nrGNNY5XlVIzE3i7Fqw96cGL8L7bNJBr3AIBaK5Il7RuIQT1nsFPJS810Ery0N9Hi5k96xn90UI80Joqg5DF7QRCWJF314159265358979323846dTVFQxiECjT5nYFX6Uw47fS3lhiEApOtuy1ghNiQbJzpjm67LKaxiEq8bAEXDQeEneLlixqi8AlYgan30RVlWJz2WEykIYH5LMcykwgPGNXOrPBzy63MCS3TB71I9yYar9eMqGRc4sz30GzU19v3rNohnMX5iaPSlkVPQB7kY2qpWaHe4gDjkOi69vErtRXON0Xqo6mvr1a8Ce980LT3X9jreKoDX5q33lSVxjlYBBlDYrRzNIWqrZr1YYkupuZM0wn9q8P9W86iTGf5GR705WWj5OKUjE6f1Z7Ro3P838mqrqYImc3qMV8wbnQ8Ogz8Fkxscc7F7lq06q0DkpUK7BK5mxBe046QrtyiuEYj999qFdo4nA9Exfw9xvi77WofVQ31tTBu3HZJsB3ypyZp3Omn2I7gsOQm89nXrDXOXalI4N1nvGRARtExOo5tN3WIlVVkrKeyvrDOQpT2rEIgsnDoTiy2jRZig0RmPA2718281828459045235w5f9780gQetd63mnIF4sg4tkhx0g2lR9ZNn70ZUZNzkxvIYfO4jnMPtcM7a1ek8f2rp0znURrnA8VB1Ak0uY3AmK9DoEHcJmodGNGliF7L5LVP7ABzPfKKMCdtAu6zZgW0XsPPs4WYy9jlkG25973qp678lKmN0LAdOaHT72lFrr9frau1402jqCHZqIy4qcRYyeCOrD0IkqZT9izDv59Z3b9fdkyoo5sO8AWFGerJ9vVT5m5mSzd8bWZZ7dss4XYHk3UORyLi1gpbKlT1QZbypPx0eF18TA6wuban93JZmfOngzx2kTNoRXa911ififrUt56nIuRtY324NPpvt7Rixl4X2YZzbOLm4L5kew9fv1BZvZQOPtLuQ7If368aUQnpV04D7TAkb1qbQbOKmkOVPgA7d0LMtlYwZbNRI97KiRHtsqGbNf70mvGj2lj1QF3Uv0sW1e7YliNp1w5M8lyHGpVVW7uBdyqKqXzGkqSa9DW527qbPHZPM1nCN;ToCharacterCode@#,wm;2,Yr3TLDuNJKQ2NHCv9;8])),hmPvHeg3R2mw02;Array[yruQ95uaGFdJu1;PrimeQ,Tr[GjbUXt;0l+1],Xxt;0]],8La1ktK9xi3XXf;#==(UISzsyNOrrXj0eSRMrbIzDOVjfKK0IazH6JdZQY7lzBolXGwU98mJjINCzp7pROIx1rwaTo1JdOSyw6Lw3KVXu85AxiKM7Q2EsvUEQaq8rMhAwdsgWYO21aAVLwuoz5Uz8NnASPJmW4f04z1kgUrAfMjZ0VAFaM2405222oU3y0yc5nxVmKd7AcA5gwCa3labMkKF7lMq5o8prUSy1AVTxNH7E46LVYWjxyw6Q6YRzNPSRJJWtjhVGt8tMkj;i=1-i)&]]Df]&

Takes a string as an input. Prints True or False. This works because Mathematica ignores undefined variables/functions. Because this code is so long, I stuck some easter eggs in there. :)
I'm sure this can be golfed more...
Explanation
Without all the gibberish (99 bytes):
AllTrue[Pick[l=Join@@IntegerDigits[ToCharacterCode@#,2,8],Array[PrimeQ,Tr[0l+1],i=0]],#==(i=1-i)&]&

ToCharacterCode@#

Convert the input into character codes.
IntegerDigits[ToCharacterCode@#,2,8]

Convert the character codes into binary numbers, length 8.
l=Join@@IntegerDigits[ToCharacterCode@#,2,8]

Flatten the result and store that in l. This generates the bit list of the input.

Tr[0l+1]

A short way to find the length of l.
Array[PrimeQ,Tr[0l+1],i=0]

Set i to 0. Create a list from 0 to (length l) - 1. Map primality test onto that list. In this list, only the prime positions are True.

Pick[l=Join@@...,Array[...]]

From the first argument (bit list), select ones whose corresponding element of the second argument (list whose prime positions are True) is True.
AllTrue[Pick[...],#==(i=1-i)&]

Check whether the resulting list is alternating 1 and 0, starting with 1. (each element is compared to i, and i alternates between 1 and 0 (i=1-i) each iteration).
Testing
f[gQqGCStZu2yl3mIEL5mBpO43ulpBaJP4g2sCvYht09xS9XvYv2XK7aZ6P2yh47J2y2Z8s42u91aKQT8dDQ7NZQFDShTWXW7ldVB8IorrV2Fu6ItvMF2y285nz52GizM3X1q0t3F7KMa@Print[29RshFOc0Zh3HKaau;i=0;1Kv6jpY40n3fmIl0YYfiskcIZaATpT76lc6ph3FhR1INU2ptKd8SJ8GXC54akjX4s08vjnaliCS5AQcSh56YS8hQ3xe2xtCV36Gn6lTDAg1tX3cz6G1tn2NB5NLk9Nx4O7Ygfmf3fAs6mnD3PjIzFw2FAK5Qj6i4wW0Gq0RSo7K6aV93L8N75ioRr6oZlCBRzeq3fiQI71KXLADrcO9sJVh24vMZr84plVXqzo52bmuRO6v6LoP47mggmS00gFtCXnwr64YntzbVjNpiyxQMDLXJnd1vUeUvvy0P6CodeGolfib1psOCu9iMxiT2oGesnIoDrqnKHqExqxgh30kFJRwJJk6LvY4M3ZCkKn43oFERtHe7d5qO7AvaF9T4o9T4Cf97MN1anz4TEPlR7FjoqQXaBVV57a5NfSZW97EFeIVn8LsqHjCgg72Vl6usW8L3RWlIo05Lfd8u7jUD0B8SP1fWymaP7kwYNLCg5OUQtLk479hUsE8bJungHwanMinm1xV9naf97dMqobj6jVAM1EzvXguLOal4OXO6DBFtmhHNwzx6u47fVRy7f;AllTrue[XF2uhxta8qS5K0ZeL9pmX3Zhrqn4IHD2hNTdEb9rsQw8raVJvbgSP1uk9OByu;Pick[l=(2EOFI4khaVxpn5d01z8kaARZNiz1oNZkcniL0sD13Sfqrapri0sq9AV12Wh9F1NtYjwbvHtM73G;Join@@(XX9giynmc3Y6ZScD3SIq0QdKvDHh30p3JAlYizir8xzW4d1AfMEIGKom1Hn3m4oGmSZACY012g1a1YRGaFY6YvI5zuzoseFjEDOn002W0qTCFdsmFMO0Wq05jPvEotODJ688d1Ef2iknRra301eEwXtCYAigA294p3Rn1i6dFvhOuIm9Omn1q6w9l4hY3skRZ4Yqc5IAEE0Ncv1eBg3PlT36YUzEEYhK3ekb5EXhrQEjkpJ3kQxL5m1sxu14N971gI8owjVUNyqzPXZ1YrTJ1i6lydT51gFZZzR9e1HPCG2fPzdY96udYT8m7TWZ6L3RnIzapDbrHJU86K4cLk280pmI0VQna8n5F9TsXzUSLkPY6defMJL7z4nPnSLTMFTtO5tYZ48bA723cK4GEM8Vx1oCSuhdn0OKl13tcKo1fenOJO39E5wIHFk35dButjorAWq8bGDteoHS1xt93x71gRJybCd4ruGl9kdZpwml4c8DRO3RlJAOF7nNwcjGzcLDeBS0VW6gOxGjO6LWEk6FgXEMzEmDHbVp0orIRb7jxeTY6QL0ReWS5E1iuqq0mU1ylo5uFjVuHUDobcBxKbajLjzuMuol57II7YxJrT72A0F0mHxP2EMwFtd6vha5DGtLonviT8osn3RVk7fJeY9pv1Dtxoz56Wd1kUcdL5N5PWPhJA118QlaQbPVQCxxbYXNQzi1PSatEcMIlJ3peMac6FOo6EvhpcIEmKJFCMxsO45dEYmoFf0EB3PTEhIVjX3wCvDvuK5FRrFwkB7CUOhSTlGEG61g8wblwOz9Ws3cu7L9LFDMPFn9rInZg1fq57GvB4VEAGQ02eIz6FbiDCK856Ou4uw2QwpDw8po190u7iQFhz9r74bz3exo2cokT1x059vpuKlnlS8iqc8CArq43qahewU4Kstn3gJKHbplFZrZbiX36tGoS5wY80RiosSf981WS8sGJabtcANl9ckq0nz4JS8y4150SVepw07KE2z7TvkyjA0ZBzIo7nxcrn7E2nGiCcsAT8Fv6mArN4b5v9fYWdZqA8a7gabW0ha8pykl63brXwLF3GJDAL0W376IvWk8IKYD7zTdnLCszD4Za8P7b4ExMeseyRXnuv1asg7sjRul9zQP3WryaMPCyB67gCDpt5n5AuSgC9nr7tEzWQCbBI2XFa5ogOgVdF3mkshjAU6sNuSxksnQdx0f1ZxS93Ioq3422Q1zB3BjML7i6NMF0yzxEiVTN2ENDUtK7V9uXrH1rva7TsXx9v9QE5sLf5gsP38LPUh5ZrDxXhfcCjtGDb9r1c00R9gM1xMjTj4cMEWJlXSfkeSM3yU52ZKsUDCq3fDqDE0plp96k8Ra9M84tz5uJ5mNXM8GxuXSS97c9sXXlFB0CaG4n0EP8lbyuUhOLaKUY9EelL68qSq5zlJFTIZf5u7SDEKFSkGU7ml97Gd7gtZ2NBq4hxOTR4uHZaS4ALmvN8o93fipy088oWKynoJSFjIkkZOw3mbSnHnfexKyYpp2Rv4SW3r3kPQ7UonY3Sm;IntegerDigits[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;ToCharacterCode@#,wm;2,Yr3TLDuNJKQ2NHCv9;8])),hmPvHeg3R2mw02;Array[yruQ95uaGFdJu1;PrimeQ,Tr[GjbUXt;0l+1],Xxt;0]],8La1ktK9xi3XXf;#==(UISzsyNOrrXj0eSRMrbIzDOVjfKK0IazH6JdZQY7lzBolXGwU98mJjINCzp7pROIx1rwaTo1JdOSyw6Lw3KVXu85AxiKM7Q2EsvUEQaq8rMhAwdsgWYO21aAVLwuoz5Uz8NnASPJmW4f04z1kgUrAfMjZ0VAFaM2405222oU3y0yc5nxVmKd7AcA5gwCa3labMkKF7lMq5o8prUSy1AVTxNH7E46LVYWjxyw6Q6YRzNPSRJJWtjhVGt8tMkj;i=1-i)&]]Df]&["f[gQqGCStZu2yl3mIEL5mBpO43ulpBaJP4g2sCvYht09xS9XvYv2XK7aZ6P2yh47J2y2Z8s42u91aKQT8dDQ7NZQFDShTWXW7ldVB8IorrV2Fu6ItvMF2y285nz52GizM3X1q0t3F7KMa@Print[29RshFOc0Zh3HKaau;i=0;1Kv6jpY40n3fmIl0YYfiskcIZaATpT76lc6ph3FhR1INU2ptKd8SJ8GXC54akjX4s08vjnaliCS5AQcSh56YS8hQ3xe2xtCV36Gn6lTDAg1tX3cz6G1tn2NB5NLk9Nx4O7Ygfmf3fAs6mnD3PjIzFw2FAK5Qj6i4wW0Gq0RSo7K6aV93L8N75ioRr6oZlCBRzeq3fiQI71KXLADrcO9sJVh24vMZr84plVXqzo52bmuRO6v6LoP47mggmS00gFtCXnwr64YntzbVjNpiyxQMDLXJnd1vUeUvvy0P6CodeGolfib1psOCu9iMxiT2oGesnIoDrqnKHqExqxgh30kFJRwJJk6LvY4M3ZCkKn43oFERtHe7d5qO7AvaF9T4o9T4Cf97MN1anz4TEPlR7FjoqQXaBVV57a5NfSZW97EFeIVn8LsqHjCgg72Vl6usW8L3RWlIo05Lfd8u7jUD0B8SP1fWymaP7kwYNLCg5OUQtLk479hUsE8bJungHwanMinm1xV9naf97dMqobj6jVAM1EzvXguLOal4OXO6DBFtmhHNwzx6u47fVRy7f;AllTrue[XF2uhxta8qS5K0ZeL9pmX3Zhrqn4IHD2hNTdEb9rsQw8raVJvbgSP1uk9OByu;Pick[l=(2EOFI4khaVxpn5d01z8kaARZNiz1oNZkcniL0sD13Sfqrapri0sq9AV12Wh9F1NtYjwbvHtM73G;Join@@(XX9giynmc3Y6ZScD3SIq0QdKvDHh30p3JAlYizir8xzW4d1AfMEIGKom1Hn3m4oGmSZACY012g1a1YRGaFY6YvI5zuzoseFjEDOn002W0qTCFdsmFMO0Wq05jPvEotODJ688d1Ef2iknRra301eEwXtCYAigA294p3Rn1i6dFvhOuIm9Omn1q6w9l4hY3skRZ4Yqc5IAEE0Ncv1eBg3PlT36YUzEEYhK3ekb5EXhrQEjkpJ3kQxL5m1sxu14N971gI8owjVUNyqzPXZ1YrTJ1i6lydT51gFZZzR9e1HPCG2fPzdY96udYT8m7TWZ6L3RnIzapDbrHJU86K4cLk280pmI0VQna8n5F9TsXzUSLkPY6defMJL7z4nPnSLTMFTtO5tYZ48bA723cK4GEM8Vx1oCSuhdn0OKl13tcKo1fenOJO39E5wIHFk35dButjorAWq8bGDteoHS1xt93x71gRJybCd4ruGl9kdZpwml4c8DRO3RlJAOF7nNwcjGzcLDeBS0VW6gOxGjO6LWEk6FgXEMzEmDHbVp0orIRb7jxeTY6QL0ReWS5E1iuqq0mU1ylo5uFjVuHUDobcBxKbajLjzuMuol57II7YxJrT72A0F0mHxP2EMwFtd6vha5DGtLonviT8osn3RVk7fJeY9pv1Dtxoz56Wd1kUcdL5N5PWPhJA118QlaQbPVQCxxbYXNQzi1PSatEcMIlJ3peMac6FOo6EvhpcIEmKJFCMxsO45dEYmoFf0EB3PTEhIVjX3wCvDvuK5FRrFwkB7CUOhSTlGEG61g8wblwOz9Ws3cu7L9LFDMPFn9rInZg1fq57GvB4VEAGQ02eIz6FbiDCK856Ou4uw2QwpDw8po190u7iQFhz9r74bz3exo2cokT1x059vpuKlnlS8iqc8CArq43qahewU4Kstn3gJKHbplFZrZbiX36tGoS5wY80RiosSf981WS8sGJabtcANl9ckq0nz4JS8y4150SVepw07KE2z7TvkyjA0ZBzIo7nxcrn7E2nGiCcsAT8Fv6mArN4b5v9fYWdZqA8a7gabW0ha8pykl63brXwLF3GJDAL0W376IvWk8IKYD7zTdnLCszD4Za8P7b4ExMeseyRXnuv1asg7sjRul9zQP3WryaMPCyB67gCDpt5n5AuSgC9nr7tEzWQCbBI2XFa5ogOgVdF3mkshjAU6sNuSxksnQdx0f1ZxS93Ioq3422Q1zB3BjML7i6NMF0yzxEiVTN2ENDUtK7V9uXrH1rva7TsXx9v9QE5sLf5gsP38LPUh5ZrDxXhfcCjtGDb9r1c00R9gM1xMjTj4cMEWJlXSfkeSM3yU52ZKsUDCq3fDqDE0plp96k8Ra9M84tz5uJ5mNXM8GxuXSS97c9sXXlFB0CaG4n0EP8lbyuUhOLaKUY9EelL68qSq5zlJFTIZf5u7SDEKFSkGU7ml97Gd7gtZ2NBq4hxOTR4uHZaS4ALmvN8o93fipy088oWKynoJSFjIkkZOw3mbSnHnfexKyYpp2Rv4SW3r3kPQ7UonY3Sm;IntegerDigits[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;ToCharacterCode@#,wm;2,Yr3TLDuNJKQ2NHCv9;8])),hmPvHeg3R2mw02;Array[yruQ95uaGFdJu1;PrimeQ,Tr[GjbUXt;0l+1],Xxt;0]],8La1ktK9xi3XXf;#==(UISzsyNOrrXj0eSRMrbIzDOVjfKK0IazH6JdZQY7lzBolXGwU98mJjINCzp7pROIx1rwaTo1JdOSyw6Lw3KVXu85AxiKM7Q2EsvUEQaq8rMhAwdsgWYO21aAVLwuoz5Uz8NnASPJmW4f04z1kgUrAfMjZ0VAFaM2405222oU3y0yc5nxVmKd7AcA5gwCa3labMkKF7lMq5o8prUSy1AVTxNH7E46LVYWjxyw6Q6YRzNPSRJJWtjhVGt8tMkj;i=1-i)&]]Df]&"]

True

Feeding the program to itself does print True.
f[gQqGCStZu2yl3mIEL5mBpO43ulpBaJP4g2sCvYht09xS9XvYv2XK7aZ6P2yh47J2y2Z8s42u91aKQT8dDQ7NZQFDShTWXW7ldVB8IorrV2Fu6ItvMF2y285nz52GizM3X1q0t3F7KMa@Print[29RshFOc0Zh3HKaau;i=0;1Kv6jpY40n3fmIl0YYfiskcIZaATpT76lc6ph3FhR1INU2ptKd8SJ8GXC54akjX4s08vjnaliCS5AQcSh56YS8hQ3xe2xtCV36Gn6lTDAg1tX3cz6G1tn2NB5NLk9Nx4O7Ygfmf3fAs6mnD3PjIzFw2FAK5Qj6i4wW0Gq0RSo7K6aV93L8N75ioRr6oZlCBRzeq3fiQI71KXLADrcO9sJVh24vMZr84plVXqzo52bmuRO6v6LoP47mggmS00gFtCXnwr64YntzbVjNpiyxQMDLXJnd1vUeUvvy0P6CodeGolfib1psOCu9iMxiT2oGesnIoDrqnKHqExqxgh30kFJRwJJk6LvY4M3ZCkKn43oFERtHe7d5qO7AvaF9T4o9T4Cf97MN1anz4TEPlR7FjoqQXaBVV57a5NfSZW97EFeIVn8LsqHjCgg72Vl6usW8L3RWlIo05Lfd8u7jUD0B8SP1fWymaP7kwYNLCg5OUQtLk479hUsE8bJungHwanMinm1xV9naf97dMqobj6jVAM1EzvXguLOal4OXO6DBFtmhHNwzx6u47fVRy7f;AllTrue[XF2uhxta8qS5K0ZeL9pmX3Zhrqn4IHD2hNTdEb9rsQw8raVJvbgSP1uk9OByu;Pick[l=(2EOFI4khaVxpn5d01z8kaARZNiz1oNZkcniL0sD13Sfqrapri0sq9AV12Wh9F1NtYjwbvHtM73G;Join@@(XX9giynmc3Y6ZScD3SIq0QdKvDHh30p3JAlYizir8xzW4d1AfMEIGKom1Hn3m4oGmSZACY012g1a1YRGaFY6YvI5zuzoseFjEDOn002W0qTCFdsmFMO0Wq05jPvEotODJ688d1Ef2iknRra301eEwXtCYAigA294p3Rn1i6dFvhOuIm9Omn1q6w9l4hY3skRZ4Yqc5IAEE0Ncv1eBg3PlT36YUzEEYhK3ekb5EXhrQEjkpJ3kQxL5m1sxu14N971gI8owjVUNyqzPXZ1YrTJ1i6lydT51gFZZzR9e1HPCG2fPzdY96udYT8m7TWZ6L3RnIzapDbrHJU86K4cLk280pmI0VQna8n5F9TsXzUSLkPY6defMJL7z4nPnSLTMFTtO5tYZ48bA723cK4GEM8Vx1oCSuhdn0OKl13tcKo1fenOJO39E5wIHFk35dButjorAWq8bGDteoHS1xt93x71gRJybCd4ruGl9kdZpwml4c8DRO3RlJAOF7nNwcjGzcLDeBS0VW6gOxGjO6LWEk6FgXEMzEmDHbVp0orIRb7jxeTY6QL0ReWS5E1iuqq0mU1ylo5uFjVuHUDobcBxKbajLjzuMuol57II7YxJrT72A0F0mHxP2EMwFtd6vha5DGtLonviT8osn3RVk7fJeY9pv1Dtxoz56Wd1kUcdL5N5PWPhJA118QlaQbPVQCxxbYXNQzi1PSatEcMIlJ3peMac6FOo6EvhpcIEmKJFCMxsO45dEYmoFf0EB3PTEhIVjX3wCvDvuK5FRrFwkB7CUOhSTlGEG61g8wblwOz9Ws3cu7L9LFDMPFn9rInZg1fq57GvB4VEAGQ02eIz6FbiDCK856Ou4uw2QwpDw8po190u7iQFhz9r74bz3exo2cokT1x059vpuKlnlS8iqc8CArq43qahewU4Kstn3gJKHbplFZrZbiX36tGoS5wY80RiosSf981WS8sGJabtcANl9ckq0nz4JS8y4150SVepw07KE2z7TvkyjA0ZBzIo7nxcrn7E2nGiCcsAT8Fv6mArN4b5v9fYWdZqA8a7gabW0ha8pykl63brXwLF3GJDAL0W376IvWk8IKYD7zTdnLCszD4Za8P7b4ExMeseyRXnuv1asg7sjRul9zQP3WryaMPCyB67gCDpt5n5AuSgC9nr7tEzWQCbBI2XFa5ogOgVdF3mkshjAU6sNuSxksnQdx0f1ZxS93Ioq3422Q1zB3BjML7i6NMF0yzxEiVTN2ENDUtK7V9uXrH1rva7TsXx9v9QE5sLf5gsP38LPUh5ZrDxXhfcCjtGDb9r1c00R9gM1xMjTj4cMEWJlXSfkeSM3yU52ZKsUDCq3fDqDE0plp96k8Ra9M84tz5uJ5mNXM8GxuXSS97c9sXXlFB0CaG4n0EP8lbyuUhOLaKUY9EelL68qSq5zlJFTIZf5u7SDEKFSkGU7ml97Gd7gtZ2NBq4hxOTR4uHZaS4ALmvN8o93fipy088oWKynoJSFjIkkZOw3mbSnHnfexKyYpp2Rv4SW3r3kPQ7UonY3Sm;IntegerDigits[3LpjdCIvIK7J5Cn3YbY9D3c6GuzGa8pUJ5O14ruPrrPcbXqb7z7qA8Q4hrTsWvSBbIIReq7mnIW5lakuMkPMgqg9Zt18pqfjOVQs6ZuYGp5NNds0rX65melVZKRlNCHaGskSIsl3QeApWc0rf8yT12zKI8SFm3SEgcxF4KfE8yHtcLJy8B3Pz06vOy78rg6Y6zSWnInE2pLBj6tYBspKs6YXNL8D6C4P2Y7EcozkoR6aKx2zs0Zfo6lryRqnGds6kg22M472LCJIZ470XGPAkH3QLA7zuST81EjwyqVvFR2p9AEtKiEJc14TVWXFZvsyMuic76ZoQox6B5p295GJVU0SyU5xvtb0CCKTnIvFdPzFFbwMocknxFpoBDbLqFGsaxg7J71Ls3vBkgnlN1Rc5w4PDNTCGQC2RCk1A2L43s3bnkgMAsUNYhGeJDAcNfWUNswuo7A97RYEJEcZRgGQ0upJHX77PZLzJr09HM6HNs1EuDPBslPTEHG4M4wIvx4Vf4rVwXvG3G8i8pORtYJUMzEaYz7X9zsRNAOZ3gXqnRYC5l3qUe28NlHMuiaRuywS1NkaF89bOxLxv4nyHZ9ueHf49L2Co0UqOtzFPs99pwjSDreIyQxioa6CMR9Ht17T9N7GMD7aWaxeBSK48J2pVn04yoQTB0BJMnm9e343KBUw6742VFgTajnRVv16LXtn0jpuOCWFVM2N4CGMzgCBdQZROOl2S4CE6AecPJOaVLWg5Z1GSqeXQmHwB9AjgxRdakpTrvAad0Wb5OLkZXQIKqFxQ7R8wBd79t8L4X9pwj4SJTVKFm1LDn5qeaOw54aJRFqQ0z5GvOd1Xt24TjH7y676nR42CMY91PoBcV2FyRdv8vmjQ8932IHn5LU3up9ZxbqrXPednbFmi6vyLODt8KlhM7ELfYp223GWMrTHVu34nKgdiM5Vlq1bWTaMq2mbM5AcQB52zXgy7pSVvlXdrLqdFwGrFRDrQ03DXm0r9ZbRitrU2tEzVmE9og9AKeAq7pZb68ypniGn5VVBM3mUMZjAACaVmgn5uZS0xsQcE84rblzkK1DAIa2yQ6ixAkGdlezfe6o94B3SJIgjujkBb876db31RXQVSX7aCLWm9DXr1ie7hc2U1M3y3Y3LK4eFbzM69Bg6B5TWVmY6AfBJsC8iYpfICgCpCNDUgGx53EzoWhatALongProgramuqO6XCaRvMePL0QFjx8ojo8IHbEIwbbat4DtRF4vTgRC0wQFzzSyrx2XoajV2DX70042W3x1o99Y4ms9dHATupNeeA57BtUU6rJ2li2i9mQHb1EftkNG5fnSSxWORLqdxw1uki88bxwf2sb7e1Sv4DHEA81ixwR74lT7k2FQ8qvL8ZyPN1iLn1NbpgOFXKAXOioKpoW2OHX6RNDRrL0rOBuLLugIiPg3SJ4n7kr0Ozm5N6nrGNNY5XlVIzE3i7Fqw96cGL8L7bNJBr3AIBaK5Il7RuIQT1nsFPJS810Ery0N9Hi5k96xn90UI80Joqg5DF7QRCWJF314159265358979323846dTVFQxiECjT5nYFX6Uw47fS3lhiEApOtuy1ghNiQbJzpjm67LKaxiEq8bAEXDQeEneLlixqi8AlYgan30RVlWJz2WEykIYH5LMcykwgPGNXOrPBzy63MCS3TB71I9yYar9eMqGRc4sz30GzU19v3rNohnMX5iaPSlkVPQB7kY2qpWaHe4gDjkOi69vErtRXON0Xqo6mvr1a8Ce980LT3X9jreKoDX5q33lSVxjlYBBlDYrRzNIWqrZr1YYkupuZM0wn9q8P9W86iTGf5GR705WWj5OKUjE6f1Z7Ro3P838mqrqYImc3qMV8wbnQ8Ogz8Fkxscc7F7lq06q0DkpUK7BK5mxBe046QrtyiuEYj999qFdo4nA9Exfw9xvi77WofVQ31tTBu3HZJsB3ypyZp3Omn2I7gsOQm89nXrDXOXalI4N1nvGRARtExOo5tN3WIlVVkrKeyvrDOQpT2rEIgsnDoTiy2jRZig0RmPA2718281828459045235w5f9780gQetd63mnIF4sg4tkhx0g2lR9ZNn70ZUZNzkxvIYfO4jnMPtcM7a1ek8f2rp0znURrnA8VB1Ak0uY3AmK9DoEHcJmodGNGliF7L5LVP7ABzPfKKMCdtAu6zZgW0XsPPs4WYy9jlkG25973qp678lKmN0LAdOaHT72lFrr9frau1402jqCHZqIy4qcRYyeCOrD0IkqZT9izDv59Z3b9fdkyoo5sO8AWFGerJ9vVT5m5mSzd8bWZZ7dss4XYHk3UORyLi1gpbKlT1QZbypPx0eF18TA6wuban93JZmfOngzx2kTNoRXa911ififrUt56nIuRtY324NPpvt7Rixl4X2YZzbOLm4L5kew9fv1BZvZQOPtLuQ7If368aUQnpV04D7TAkb1qbQbOKmkOVPgA7d0LMtlYwZbNRI97KiRHtsqGbNf70mvGj2lj1QF3Uv0sW1e7YliNp1w5M8lyHGpVVW7uBdyqKqXzGkqSa9DW527qbPHZPM1nCN;ToCharacterCode@#,wm;2,Yr3TLDuNJKQ2NHCv9;8])),hmPvHeg3R2mw02;Array[yruQ95uaGFdJu1;PrimeQ,Tr[GjbUXt;0l+1],Xxt;0]],8La1ktK9xi3XXf;#==(UISzsyNOrrXj0eSRMrbIzDOVjfKK0IazH6JdZQY7lzBolXGwU98mJjINCzp7pROIx1rwaTo1JdOSyw6Lw3KVXu85AxiKM7Q2EsvUEQaq8rMhAwdsgWYO21aAVLwuoz5Uz8NnASPJmW4f04z1kgUrAfMjZ0VAFaM2405222oU3y0yc5nxVmKd7AcA5gwCa3labMkKF7lMq5o8prUSy1AVTxNH7E46LVYWjxyw6Q6YRzNPSRJJWtjhVGt8tMkj;i=1-i)&]]Df]&["$;A;;A;;>@??A/??/@>?/;;?>??>;@@/@"]

True

Checking "$;A;;A;;>@??A/??/@>?/;;?>??>;@@/@" -- True.
f[gQqGCStZu2yl3mIEL5mBpO43ulpBaJP4g2sCvYht09xS9XvYv2XK7aZ6P2yh47J2y2Z8s42u91aKQT8dDQ7NZQFDShTWXW7ldVB8IorrV2Fu6ItvMF2y285nz52GizM3X1q0t3F7KMa@Print[29RshFOc0Zh3HKaau;i=0;1Kv6jpY40n3fmIl0YYfiskcIZaATpT76lc6ph3FhR1INU2ptKd8SJ8GXC54akjX4s08vjnaliCS5AQcSh56YS8hQ3xe2xtCV36Gn6lTDAg1tX3cz6G1tn2NB5NLk9Nx4O7Ygfmf3fAs6mnD3PjIzFw2FAK5Qj6i4wW0Gq0RSo7K6aV93L8N75ioRr6oZlCBRzeq3fiQI71KXLADrcO9sJVh24vMZr84plVXqzo52bmuRO6v6LoP47mggmS00gFtCXnwr64YntzbVjNpiyxQMDLXJnd1vUeUvvy0P6CodeGolfib1psOCu9iMxiT2oGesnIoDrqnKHqExqxgh30kFJRwJJk6LvY4M3ZCkKn43oFERtHe7d5qO7AvaF9T4o9T4Cf97MN1anz4TEPlR7FjoqQXaBVV57a5NfSZW97EFeIVn8LsqHjCgg72Vl6usW8L3RWlIo05Lfd8u7jUD0B8SP1fWymaP7kwYNLCg5OUQtLk479hUsE8bJungHwanMinm1xV9naf97dMqobj6jVAM1EzvXguLOal4OXO6DBFtmhHNwzx6u47fVRy7f;AllTrue[XF2uhxta8qS5K0ZeL9pmX3Zhrqn4IHD2hNTdEb9rsQw8raVJvbgSP1uk9OByu;Pick[l=(2EOFI4khaVxpn5d01z8kaARZNiz1oNZkcniL0sD13Sfqrapri0sq9AV12Wh9F1NtYjwbvHtM73G;Join@@(XX9giynmc3Y6ZScD3SIq0QdKvDHh30p3JAlYizir8xzW4d1AfMEIGKom1Hn3m4oGmSZACY012g1a1YRGaFY6YvI5zuzoseFjEDOn002W0qTCFdsmFMO0Wq05jPvEotODJ688d1Ef2iknRra301eEwXtCYAigA294p3Rn1i6dFvhOuIm9Omn1q6w9l4hY3skRZ4Yqc5IAEE0Ncv1eBg3PlT36YUzEEYhK3ekb5EXhrQEjkpJ3kQxL5m1sxu14N971gI8owjVUNyqzPXZ1YrTJ1i6lydT51gFZZzR9e1HPCG2fPzdY96udYT8m7TWZ6L3RnIzapDbrHJU86K4cLk280pmI0VQna8n5F9TsXzUSLkPY6defMJL7z4nPnSLTMFTtO5tYZ48bA723cK4GEM8Vx1oCSuhdn0OKl13tcKo1fenOJO39E5wIHFk35dButjorAWq8bGDteoHS1xt93x71gRJybCd4ruGl9kdZpwml4c8DRO3RlJAOF7nNwcjGzcLDeBS0VW6gOxGjO6LWEk6FgXEMzEmDHbVp0orIRb7jxeTY6QL0ReWS5E1iuqq0mU1ylo5uFjVuHUDobcBxKbajLjzuMuol57II7YxJrT72A0F0mHxP2EMwFtd6vha5DGtLonviT8osn3RVk7fJeY9pv1Dtxoz56Wd1kUcdL5N5PWPhJA118QlaQbPVQCxxbYXNQzi1PSatEcMIlJ3peMac6FOo6EvhpcIEmKJFCMxsO45dEYmoFf0EB3PTEhIVjX3wCvDvuK5FRrFwkB7CUOhSTlGEG61g8wblwOz9Ws3cu7L9LFDMPFn9rInZg1fq57GvB4VEAGQ02eIz6FbiDCK856Ou4uw2QwpDw8po190u7iQFhz9r74bz3exo2cokT1x059vpuKlnlS8iqc8CArq43qahewU4Kstn3gJKHbplFZrZbiX36tGoS5wY80RiosSf981WS8sGJabtcANl9ckq0nz4JS8y4150SVepw07KE2z7TvkyjA0ZBzIo7nxcrn7E2nGiCcsAT8Fv6mArN4b5v9fYWdZqA8a7gabW0ha8pykl63brXwLF3GJDAL0W376IvWk8IKYD7zTdnLCszD4Za8P7b4ExMeseyRXnuv1asg7sjRul9zQP3WryaMPCyB67gCDpt5n5AuSgC9nr7tEzWQCbBI2XFa5ogOgVdF3mkshjAU6sNuSxksnQdx0f1ZxS93Ioq3422Q1zB3BjML7i6NMF0yzxEiVTN2ENDUtK7V9uXrH1rva7TsXx9v9QE5sLf5gsP38LPUh5ZrDxXhfcCjtGDb9r1c00R9gM1xMjTj4cMEWJlXSfkeSM3yU52ZKsUDCq3fDqDE0plp96k8Ra9M84tz5uJ5mNXM8GxuXSS97c9sXXlFB0CaG4n0EP8lbyuUhOLaKUY9EelL68qSq5zlJFTIZf5u7SDEKFSkGU7ml97Gd7gtZ2NBq4hxOTR4uHZaS4ALmvN8o93fipy088oWKynoJSFjIkkZOw3mbSnHnfexKyYpp2Rv4SW3r3kPQ7UonY3Sm;IntegerDigits[3LpjdCIvIK7J5Cn3YbY9D3c6GuzGa8pUJ5O14ruPrrPcbXqb7z7qA8Q4hrTsWvSBbIIReq7mnIW5lakuMkPMgqg9Zt18pqfjOVQs6ZuYGp5NNds0rX65melVZKRlNCHaGskSIsl3QeApWc0rf8yT12zKI8SFm3SEgcxF4KfE8yHtcLJy8B3Pz06vOy78rg6Y6zSWnInE2pLBj6tYBspKs6YXNL8D6C4P2Y7EcozkoR6aKx2zs0Zfo6lryRqnGds6kg22M472LCJIZ470XGPAkH3QLA7zuST81EjwyqVvFR2p9AEtKiEJc14TVWXFZvsyMuic76ZoQox6B5p295GJVU0SyU5xvtb0CCKTnIvFdPzFFbwMocknxFpoBDbLqFGsaxg7J71Ls3vBkgnlN1Rc5w4PDNTCGQC2RCk1A2L43s3bnkgMAsUNYhGeJDAcNfWUNswuo7A97RYEJEcZRgGQ0upJHX77PZLzJr09HM6HNs1EuDPBslPTEHG4M4wIvx4Vf4rVwXvG3G8i8pORtYJUMzEaYz7X9zsRNAOZ3gXqnRYC5l3qUe28NlHMuiaRuywS1NkaF89bOxLxv4nyHZ9ueHf49L2Co0UqOtzFPs99pwjSDreIyQxioa6CMR9Ht17T9N7GMD7aWaxeBSK48J2pVn04yoQTB0BJMnm9e343KBUw6742VFgTajnRVv16LXtn0jpuOCWFVM2N4CGMzgCBdQZROOl2S4CE6AecPJOaVLWg5Z1GSqeXQmHwB9AjgxRdakpTrvAad0Wb5OLkZXQIKqFxQ7R8wBd79t8L4X9pwj4SJTVKFm1LDn5qeaOw54aJRFqQ0z5GvOd1Xt24TjH7y676nR42CMY91PoBcV2FyRdv8vmjQ8932IHn5LU3up9ZxbqrXPednbFmi6vyLODt8KlhM7ELfYp223GWMrTHVu34nKgdiM5Vlq1bWTaMq2mbM5AcQB52zXgy7pSVvlXdrLqdFwGrFRDrQ03DXm0r9ZbRitrU2tEzVmE9og9AKeAq7pZb68ypniGn5VVBM3mUMZjAACaVmgn5uZS0xsQcE84rblzkK1DAIa2yQ6ixAkGdlezfe6o94B3SJIgjujkBb876db31RXQVSX7aCLWm9DXr1ie7hc2U1M3y3Y3LK4eFbzM69Bg6B5TWVmY6AfBJsC8iYpfICgCpCNDUgGx53EzoWhatALongProgramuqO6XCaRvMePL0QFjx8ojo8IHbEIwbbat4DtRF4vTgRC0wQFzzSyrx2XoajV2DX70042W3x1o99Y4ms9dHATupNeeA57BtUU6rJ2li2i9mQHb1EftkNG5fnSSxWORLqdxw1uki88bxwf2sb7e1Sv4DHEA81ixwR74lT7k2FQ8qvL8ZyPN1iLn1NbpgOFXKAXOioKpoW2OHX6RNDRrL0rOBuLLugIiPg3SJ4n7kr0Ozm5N6nrGNNY5XlVIzE3i7Fqw96cGL8L7bNJBr3AIBaK5Il7RuIQT1nsFPJS810Ery0N9Hi5k96xn90UI80Joqg5DF7QRCWJF314159265358979323846dTVFQxiECjT5nYFX6Uw47fS3lhiEApOtuy1ghNiQbJzpjm67LKaxiEq8bAEXDQeEneLlixqi8AlYgan30RVlWJz2WEykIYH5LMcykwgPGNXOrPBzy63MCS3TB71I9yYar9eMqGRc4sz30GzU19v3rNohnMX5iaPSlkVPQB7kY2qpWaHe4gDjkOi69vErtRXON0Xqo6mvr1a8Ce980LT3X9jreKoDX5q33lSVxjlYBBlDYrRzNIWqrZr1YYkupuZM0wn9q8P9W86iTGf5GR705WWj5OKUjE6f1Z7Ro3P838mqrqYImc3qMV8wbnQ8Ogz8Fkxscc7F7lq06q0DkpUK7BK5mxBe046QrtyiuEYj999qFdo4nA9Exfw9xvi77WofVQ31tTBu3HZJsB3ypyZp3Omn2I7gsOQm89nXrDXOXalI4N1nvGRARtExOo5tN3WIlVVkrKeyvrDOQpT2rEIgsnDoTiy2jRZig0RmPA2718281828459045235w5f9780gQetd63mnIF4sg4tkhx0g2lR9ZNn70ZUZNzkxvIYfO4jnMPtcM7a1ek8f2rp0znURrnA8VB1Ak0uY3AmK9DoEHcJmodGNGliF7L5LVP7ABzPfKKMCdtAu6zZgW0XsPPs4WYy9jlkG25973qp678lKmN0LAdOaHT72lFrr9frau1402jqCHZqIy4qcRYyeCOrD0IkqZT9izDv59Z3b9fdkyoo5sO8AWFGerJ9vVT5m5mSzd8bWZZ7dss4XYHk3UORyLi1gpbKlT1QZbypPx0eF18TA6wuban93JZmfOngzx2kTNoRXa911ififrUt56nIuRtY324NPpvt7Rixl4X2YZzbOLm4L5kew9fv1BZvZQOPtLuQ7If368aUQnpV04D7TAkb1qbQbOKmkOVPgA7d0LMtlYwZbNRI97KiRHtsqGbNf70mvGj2lj1QF3Uv0sW1e7YliNp1w5M8lyHGpVVW7uBdyqKqXzGkqSa9DW527qbPHZPM1nCN;ToCharacterCode@#,wm;2,Yr3TLDuNJKQ2NHCv9;8])),hmPvHeg3R2mw02;Array[yruQ95uaGFdJu1;PrimeQ,Tr[GjbUXt;0l+1],Xxt;0]],8La1ktK9xi3XXf;#==(UISzsyNOrrXj0eSRMrbIzDOVjfKK0IazH6JdZQY7lzBolXGwU98mJjINCzp7pROIx1rwaTo1JdOSyw6Lw3KVXu85AxiKM7Q2EsvUEQaq8rMhAwdsgWYO21aAVLwuoz5Uz8NnASPJmW4f04z1kgUrAfMjZ0VAFaM2405222oU3y0yc5nxVmKd7AcA5gwCa3labMkKF7lMq5o8prUSy1AVTxNH7E46LVYWjxyw6Q6YRzNPSRJJWtjhVGt8tMkj;i=1-i)&]]Df]&["ABC"]

False

Checking ABC -- False
Check for characters that work
Catch[Block[
   {p, j = 1, i = 0, c = Characters@#, l, k = #2 - 1, max = 100000},
   p = AssociationMap[(i = 1 - i) &, Prime~Array~max];
   l = Length@c;
   While[k < max/8,
    Which[j > l,
       Throw[k - l + 1],
       MatchQ[IntegerDigits[ToCharacterCode[c[[j]]][[1]], 2, 8], #],
       j++,
       j > 1,
       k -= j - 1; j = 1
       ] &@Array[Lookup[p, #, _] &, 8, 8 k];
    k++
    ]; $Failed]] &

I wrote a simple code that checked where certain characters could be inserted (e.g. the first place to put Print[ while keeping the code bit-primed is position 141, 1-indexed).
The first argument is the string in interest and the second argument is the starting position (also 1-indexed).
I used this code to find out where to put meaningful code and then filled the rest of the code with gibberish, but choosing characters that keep the code bit-primed; simple with Prime and Partition (and RandomChoice)

Why the downvotes? This is a perfectly good answer, just very long...

@ev3commander my original answer was not a bit-primed program.

@JungHwanMin I see my problem now; I was one-indexing the first byte. With the first byte zero-indexed, the first bit of any byte is always on an even index.

WhatALongProgram

source: Stack Exchange

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/

sort: votes


text:
A 2D Traffic Jam
The Biham-Middleton-Levine traffic model is a self-organizing cellular automaton that models simplified traffic.

It consists of a number of cars represented by points on a lattice with a random starting position, where each car may be one of two types: those that only move downwards (shown as blue in this article), and those that only move towards the right (shown as red in this article). The two types of cars take turns to move. During each turn, all the cars for the corresponding type advance by one step if they are not blocked by another car.

Your task is to visualize this model as an animation. Here are some good demonstrations.

Input
A floating point number between 0 and 1 representing density, and two integers representing the displayed grid height and width. Assume inputs are valid, and parameters to a function or reading from user input are both fine.
Example: 0.38 144 89 (corresponds to image above)
Output
A grid, at least 80x80, that displays the animation of this model running. At the start, cars are randomly placed on the grid until the grid reaches the input density, with half red and half blue (that is density times total number of grid squares, rounded however you like). The density must be this value, which means you cannot fill each cell with density as a probability. For each step, one type of car either moves downwards or right, wrapping around if they go past the edge. The type of car that moves alternates each step. To make the animation viewable, there must be at least 10 ms between each step.
Rules

The cars can be any color or symbol as long as they are distinguishable from each other and the background, and each car type is the same color or symbol.
Console and graphical output are both allowed. For console output, any printable symbol is fine, but output must be as a grid of characters.
Please specify what kind of output you've produced if you don't have a screenshot or gif.
The simulation must run forever.

The output is a bit complex, so if you have any questions, please comment.

Any restrictions on how slowly or quickly the animation must run?

Perhaps it's worth specifying that the type of car that moves alternates each step.

@xnor I was thinking at least 5 or 10 ms per loop, but I'm not really sure if that would be difficult to measure.

@GregMartin It says that in the quote, but I'll edit it anyway

Can we assume that the dimensions are coprime, like in the linked animation?

How does the density work? if density is 0.38, are 38% of the pixels filled, or is the board 38% red car and 38% blue car?

@ais523 no, they could be not coprime

@JungHwanMin 38% of pixels filled. There's some gray area for rounding, but please be reasonable.

Is it okay if the dimensions are switched (width <-> height)

Does the density mean that the density has to be that value, or just that each pixel has a probability d to be filled? Also, do we have to assign the color of the cars randomly or not? If randomly, again is it ok if they just have a 50-50 chance of being either colour?

Is it acceptable if the cars move up instead of down?

If the density is 1, should it just be gridlocked?

@carusocomputing that is what the linked example does.

@LuisMendo waiting for a 40 byte MATL answer.

@JarkoDubbeldam The density has to be that value. They have a 50-50 chance of being each color. However I answered late so answers may be different. Cars can move up or left.

Mathematica, 237 228 203 198 181 bytes
(b=RandomSample@ArrayReshape[Table[{0,i=2},##/2],{1##2},1]~Partition~#2;Dynamic@Colorize[i=-i;b=CellularAutomaton[{193973693,{3,{a=0{,,},{3,9,1},a}},{1,1}},b];If[i>0,b,2-b]])&

The output is a dynamic Image. The background is light green, and the cars are black or magenta, depending on their direction.
Explanation
b=RandomSample@ArrayReshape[Table[{i=1,2},##/2],{1##2},1]~Partition~#2

Create the initial board:
Table[{0,i=2},##/2]

Set i to 2. Create a List of {0, 2}, whose length is floor(density * width * height / 2) (divided by two because {0, 2} is length-2).
ArrayReshape[ ... ,{1##2},1]

Reshape the resulting 2-D List (2 x something) into 1-D List (length = width * height). Pad 1 if there aren't enough values.
RandomSample@ ...

(Pseudo-)randomly sort the result.
... ~Partition~#2

Partition that result into length (width).
b= ...

Store that in b.

Dynamic@Colorize[i=-i;b=CellularAutomaton[{193973693,{3,{a=0{,,},{3,9,1},a}},{1,1}},b];If[i>0,b,2-b]]

Create a Dynamic Image:
i=-i;

Flip the sign of i.
b=CellularAutomaton[{193973693,{3,{a=0{,,},{3,9,1},a}},{1,1}},b]

Apply the cellular automaton with rule 193973693 and neighbor weights {{0, 0, 0}, {3, 9, 1}, {0, 0, 0}} to b transposed. Set b equal to that.
If[i>0,b,2-b]

If i is positive, leave b alone. If not, transpose the b (2- is there because I golfed the CellularAutomaton a bit). Essentially, this transposes b every other iteration (to undo the transposition)
Colorize[ ... ]

Convert the array into a colorful Image.
Dynamic@ ...

Make the expression Dynamic. i.e. the above functions are run repeatedly.
Output
Here's a sample output (inputs: 0.35, 192, 108) for 2000 frames (magnified 2x).
https://i.imgur.com/zmSyRut.mp4

Huh, using the built-in is longer than not using it?!

R, 350 338 293 291 273 268 264 bytes
function(d,x,y){f=function(w){v=length(w);for(j in which(w>0&!w[c(2:v,1)]))w[c(j,j%%v+1)]=0:1;w};m=matrix(sample(c(rep(1,q<-floor(d*y*x/2)),rep(-1,q),rep(0,x*y-2*q))),x);p=animation::ani.pause;o=image;a=apply;repeat{o(m<-t(a(m,1,f)));p();o(m<--1*a(-1*m,2,f));p()}}

Ungolfed:
function(d,x,y){
  q=floor(d*y*x/2)

  m=matrix(sample(c(rep(1,q),rep(-1,q),rep(0,x*y-2*q))),x)

  f=function(w){
    v=length(w)
    for(j in which(w>0&!w[c(2:v,1)])){
      w[c(j,j%%v+1)]=0:1
    }
    w
  }

  library(animation)
  repeat{
    m=t(apply(m,1,f))
    image(m)
    m=-1*apply(-1*t(m),2,f))
    ani.pause()
    image(m)
    ani.pause()
  }
}

Function that takes 3 arguments: d as density, and dimensions x,y. q is the number of cars in each colour. m is the matrix with cars, which is initially filled by taking a random sort of the number of cars and empty spaces. Cars are either 1 or -1, empty space is 0.
f is a function that moves the cars one row, looking at cars coded as 1. It checks if the car can move by checking for 1s followed by 0. We use apply to run f on every row or column, depending on which cars.
f handles the moving of the 1 cars, to move the -1 cars, we transpose the matrix, chaninging the direction of movement, multiplying the matrix by -1, so the -1 cars become 1 cars, and v.v. and the resulting matrix is transformed again.
This uses image to create the plot, using 3 default colours for the three values. Uses the animation package to handle the animations using the default options, which is 1 fps.
0.38, 144, 89:

0.2, 144, 89:

0.53, 144, 89:

Your animation looks really cool - what density did you use? Seems like the whole thing got jammed pretty quickly with a lot of empty space

@qwr that actually was something that was bothering me. In my program the whole thing jams at lower densities than in the example you linked. I can't remember the exact parameters used for the plot though, but it could very well be the 0.38 144 89 from the example.

Playing around with square grids I got a density of 0.35 to jam https://www.jasondavies.com/bml/#0.35/100/100 but it is almost always one thick 45deg line instead of thin diagonal lines. Since your lines look more vertical I think something with the two types of cars is off

I see the problem now. Cara can only advance if they are not blocked by another car. So in the Wikipedia examples all moving cars have a space in front of them them. But in your animation the cars move as a line. Interesting.

Ah, that would do it.

I think I am not the only submission that has this flaw. I'll try to fix it, but maybe it would be good to specify this in the challenge.

Dyalog APL, 190 108 115 112 bytes

Solution
S←{⍉⍣⍺⊢d[⍺]↑d[⍺]↓⍉↑(⍺⊃'(↓+) ' '(→+) ')⎕R' \1'↓(,⍨,⊢)⍉⍣⍺⍉⎕←⍵⊣⎕DL÷4}
{1S 0S⍵}⍣≡' ↓→'[d⍴{⍵[?⍨⍴⍵]}c↑1 2⍴⍨⌊⎕×c←×/d←⎕]

TryAPL online (slightly modified because of online restrictions):

Set ⎕IO←0, define the function S, and then define and display a random 38% 14×29 grid, G.
Make one move down.
Make one move to the right.
Go to step 2.

Animation of previous algorithm, which did not guarantee density.

Explanation
S←{ define the direct function S (explained here from right to left):
 ÷4 reciprocal of 4 (0.25)
 ⎕DL wait that many seconds (returns actual elapsed time)
 ⍵⊣ discard that in favour of ⍵ (the right argument; the grid)
 ⎕← output that
 ⍉ transpose
 ⍉⍣⍺ transpose back again if ⍺ (the left argument; 0=down, 1=right)
 ( apply the function train (explained here from left to right):
  ,⍨ the argument appended to itself
  , appended to
  ⊢ itself
 )
 ↓ split matrix into list of lists
 ( search regex (explained here from left to right):
  ⍺⊃ pick one of the following two based on ⍺ (0=down/first, 1=right/second)
  '(↓+) ' '(→+) ' down and left arrow sequences followed by a space
 )⎕R' \1' replace with a space followed by the found sequence
 ↑ mix list of lists into matrix
 ⍉ transpose
 d[⍺]↓ drop "height" rows if ⍺ (left argument) is 0 (down) or "width" rows if ⍺ is 1 (right)
 d[⍺]↑ then take that many rows
 ⊢ pass through (serves as separator)
 ⍉⍣⍺ transpose if ⍺ (the left argument; 0=down, 1=right)
}

' ↓→'[ index the string with (explained here from right to left):
 ⎕ numeric input (dimensions)
 d← assign that to d
 ×/ multiply the dimensions (finds count of cells)
 c← assign that to c
 ⎕× multiply that with numeric input (the density)
 ⌊ round down
 1 2⍴⍨ cyclically repeat one and two until that length
 c↑ extend that until length c, padding with zeros
 d⍴ use d (the dimensions) to reshape
 { apply this anonymous function to that (explained here from left to right):
  ⍵[ the right argument (the list of zeros, ones, and twos) indexed by
   ?⍨ the shuffled indices up to
   ⍴⍵ the length of the argument
  ]
 }
]
{ apply the following anonymous function (explained from right to left):
 0S⍵ apply S with 0 (down) as left argument and the grid as right argument
 1S with that as right argument, apply S with 1 (right) as left argument
}⍣≡ until two successive iterations are identical (a traffic jam)
Notes

Requires ⎕IO←0, which is default on many systems.
Prompts for (height,width), and then for density.
Does not use any built-in automaton.
Does use built-in regex support.
Stops if there is a traffic jam (no car can move).
Outputs character matrices where → represents cars moving right, ↓ represents cars moving down, and spaces are empty roads.
As above, it outputs to the session at 4 Hz, but frequency can be adjusted by changing ÷4; e.g ÷3 is 3 Hz and .3 is ³⁄₁₀ Hz.
It is easier to see what is going on if executing ]Box on -s=max -f=on first.
The required distribution is now guaranteed, and the two types of cars occur in exactly 50-50, save for rounding.

Your initial board generation does not guarantee a board that has the input density. I guess it's OP's choice whether to allow that or not.

Oh, @JarkoDubbeldam asked that already.

@JungHwanMin How so? Let the density be d. Every position gets a value between 0 and 1. If between 0 and ᵈ⁄₂ it becomes a ↓,. If between ᵈ⁄₂ and d it becomes a →. If between d and 1 it stays empty.

Well, an extreme case would be: every position somehow gets the value 0 (because they're (pseudo)-randomly generated (pseudo)-independently; very improbable but possible). Then your board is full of ↓s.

@JungHwanMin Ah, I see what you mean.

Also, your solution is 190 bytes, 108 characters, in UTF-8. (or is it 108 bytes? If so, what encoding did you use?)

@JungHwanMin Notice the link "bytes"...

@JungHwanMin Distribution is now guaranteed.

Java (624 Bytes + 18 Bytes for Java.awt.* = 642 Bytes)
static void k(double b,final int c,final int d){final int[][]a=new int[c+1][d+1];int i=0,j;for(;i<c;i++){for(j=0;j<d;j++){a[i][j]=Math.random()<b?Math.random()<0.5?1:2:0;}}Frame e=new Frame(){public void paint(Graphics g){setVisible(1>0);int i=0,j;for(;i<c;i++){for(j=0;j<d;j++){g.setColor(a[i][j]==2?Color.BLUE:a[i][j]==1?Color.RED:Color.WHITE);g.drawLine(i,j,i,j);}}for(i=c-1;i>=0;i--){for(j=d-1;j>=0;j--){if(a[i][j]==1&&a[i][(j+1)%d]==0){a[i][(j+1)%d]=1;a[i][j]=0;}else if(a[i][j]>1&&a[(i+1)%c][j]==0){a[(i+1)%c][j]=2;a[i][j]=0;}}}}};e.show();while(1>0){e.setSize(c,d+i++%2);try{Thread.sleep(400L);}catch(Exception f){}}}

Ungolfed:
static void k(double b,final int c,final int d){
        final int[][]a=new int[c+1][d+1];
        int i=0,j;
        for(;i<c;i++) {
            for(j=0;j<d;j++) {
                a[i][j]=Math.random()<b?Math.random()<0.5?1:2:0;
            }
        }

        Frame e=new Frame(){
            public void paint(Graphics g){
                setVisible(1>0);
                int i=0,j;
                for(;i<c;i++) {
                    for(j=0;j<d;j++) {
                        g.setColor(a[i][j]==2?Color.BLUE:a[i][j]==1?Color.RED:Color.WHITE);
                        g.drawLine(i,j,i,j);
                    }
                }
                for(i=c-1;i>=0;i--) {
                    for(j=d-1;j>=0;j--) {
                        if(a[i][j]==1&&a[i][(j+1)%d]==0){
                            a[i][(j+1)%d]=1;a[i][j]=0;
                        }else if(a[i][j]>1&&a[(i+1)%c][j]==0){
                            a[(i+1)%c][j]=2;a[i][j]=0;
                        }
                    }
                }
            }
        };
        e.show();
        while(1>0){e.setSize(c,d+i++%2);try{Thread.sleep(400L);}catch(Exception f){}}
    }

Picture:

Not familiar with java, but are red, blue and white the shortest names for colours you can use? (maybe grey is an option, saving one byte vs white)

The screenshot appears to show the same problem as what I described here http://codegolf.stackexchange.com/questions/104742/a-2d-traffic-jam/104775?noredirect=1#comment255146_104775

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/


text:
Line up the Diagonals of a Grid of Text
Given a rectangular grid of text, line up the diagonals that go from the upper-left to the bottom-right into columns such that the lowest-rightmost characters of all diagonals are on a level. Use spaces for indentation.
For example, if the input grid of text is
abcd
1234
WXYZ

then you'd line up the diagonals W, 1X, a2Y, b3z, c4, and d in columns giving this output:
  ab
 123c
WXYZ4d

Note that the lowest-rightmost characters of all diagonals, WXYZ4d, are at the same level.
Details

The input grid of text will be at minimum 1×1 in size and all lines will be the same length.
You may take the input grid as a multiline string or as a list of single line strings.
The input grid will only contains printable ASCII characters (includes space).
The output may optionally have one trailing newline but there should be no other empty lines.
The lines of the output may optionally have trailing spaces but should not have unnecessary leading spaces.

Other Examples
Empty lines separate examples. Each input is directly followed by its output.
123
456
789

  1
 452
78963

123.?!
456??!
789!!!

  123.
 456???
789!!!!!

**@
@

 **
@  @

/\/\
\/ /
/ /\
\/\/

   /
  \/\
 / / /
\/\/\/\

12
34
56
78
90

 7531
908642

Code

Code

G
O
L
F

FLOG

~

~

Scoring
The shortest code in bytes wins.

Related. Related tip.

Can the input be a 2D char array (a matrix of chars)?

Can the first column of the input contain spaces?

@LuisMendo That sounds ok.

@KritixiLithos Yes, it might.

Output as a single string or is a list/array ok?

J, 12 bytes
|./.&.|:&.|.

Defines an anonymous verb.
Try it online!
Explanation
|./.&.|:&.|.
|.            Reversed
  /.          anti-diagonals
    &.        under
      |:      transpose
        &.    under
          |.  reversal

In J, u &. v (read: u under v) means "v, then u, then inverse of v".
Reversal and transpose are self-inverses, so the program really means "reverse, transpose, extract reversed anti-diagonals, transpose, reverse".
With example input:
abcd
1234
WXYZ

Reverse:
WXYZ
1234
abcd

Transpose:
W1a
X2b
Y3c
Z4d

Extract reversed anti-diagonals (and pad with spaces):
W
X1
Y2a
Z3b
4c
d

Transpose:
WXYZ4d
 123c
  ab

Reverse:
  ab
 123c
WXYZ4d

Excellent demonstration of the power of adverbs

I woke up and remembered those were actually conjunctions.

JavaScript, 116 101 bytes

f=(s,r='$&',l='',z=s.replace(/.$|\n?(?!.*\n)..+/gm,x=>(l=x+l,'')))=>l?f(z,r+' ')+l.replace(/\n?/,r):l

G.onclick=()=>O.textContent=f(I.value);
<textarea id=I style=height:100px>/\/\
\/ /
/ /\
\/\/</textarea><button id=G>Go</button>

I just wanted to use this regex pattern /.$|\n?(?!.*\n)..+/gm idea. (https://regex101.com/r/mjMz9i/2)
JavaScript regex flavour is disappointing, I had to use (?!.*\n) because it doesn't have \Z implemented, and somehow I didn't get to use \0.

15 bytes off thanks @Neil.

I just love this approach, but you can use . instead of [^] since you only need to skip non-newline characters to find a newline, which saves 2 bytes.

I don't think the ^ is necessary in the final regex, because any \n is already at the beginning of the string anyway, so that saves another byte.

I've come up a way to golf the '$&'+' '.repeat(n). Basically that expression is just $& but with a space added each call, which is trivial to implement recursively - replace n=0 with r='$&' and f(z,n+1) with f(z,r+' ') and then r is the desired replacement string. If I've counted correctly that saves 12 bytes.

@Neil. That's awesome!!, thank you

CJam, 29 bytes
qN/{)\z}h]2/{~W%+}%eeSf.*W%N*

Try it online!
Explanation
Instead of extracting the diagonals, we peel off layers from the end, alternating left and right. Consider the following input:
GFDB
EEDB
CCCB
AAAA

If we write out the diagonals as required by the challenge, we get:
   G
  EEF
 CCCDD
AAAABBB

Note that this is simply (from bottom to top), the bottom-most row, concatenated with the right-most column. This definition also works if the input is rectangular.
{      e# Run this loop while there are still lines left in the input.
  )    e#   Pull off the bottom-most row.
  \    e#   Swap with the remaining rows.
  z    e#   Transpose the grid so that the next iteration pulls off the last
       e#   column instead. However, it should be noted that transposing
       e#   effectively reverses the column, so the second half of each output
       e#   line will be the wrong way around. We'll fix that later.
}h     e# When the loop is done, we'll have all the individual layers on the
       e# stack from bottom to top, alternating between horizontal and vertical
       e# layers. There will be an empty string on top.
]      e# Wrap all those strings in a list.
2/     e# Split into pairs. There may or may not be a trailing single-element
       e# list with the empty string.
{      e# Map this block over each pair...
  ~    e#   Dump the pair on the stack.
  W%   e#   Reverse the second element.
  +    e#   Append to first element.
       e#   If there was a trailing single-element list, this will simply
       e#   add the empty string to the previous pair, which just removes
       e#   the empty string.
}%
ee     e# Enumerate the list, which pairs each string (now containing both halves)
       e# of an output line from bottom to top) with its index.
Sf.*   e# Turn those indices X into strings of X spaces, to get the correct
       e# indentation.
W%     e# Reverse the list of strings so the longest line ends up on the bottom.

Careful, that ] will wrap the entire stack! I think functions should work regardless of the stack contents beneath the input, and you seem to agree ^^

@Lynn whoops, forgot that I was using ] when I changed it to a function.

I think you could do [{)\z}h] and keep it a function, for 27 bytes.

Jelly, 11 or 10 bytes
ZŒDṙLUz⁶ṚUY

Try it online!
A fairly different algorithm from my other solution; this one uses a builtin to get at the diagonals, rather than doing things manually.
Explanation:
ZŒDṙLUz⁶ṚUY
Z           transpose
 ŒD         diagonals, main diagonal first
    L       number of lines in the original array
   ṙ        rotate list (i.e. placing the short diagonal first)
     U      reverse inside lines
      z⁶    transpose, padding with spaces
        ṚU  rotate matrix 180 degrees
          Y (possibly unnecessary) join on newlines

The diagonals come out in possibly the worst possible orientation (requiring repeated transpositions, reversals, and rotations), and in the wrong order (Jelly outputs the main diagonal first, so we have to move some diagonals from the end to the start to get them in order). However, this still comes out shorter than my other Jelly solution.

Jelly, 15 or 14 bytes
L’⁶x;\Ṛ;"µZUZṚY

Try it online!
This is an algorithm that doesn't use Jelly's built-in for diagonals. Doing that might make it shorter; I might well try that next.
Here's how the algorithm works. Let's start with this input:
["abc",
 "def",
 "ghi"]

We start off with L’⁶x;\. L’ gives us the length of the input minus 1 (in this case, 2). Then ⁶x gives us a string of spaces of that length ("  " in this case); and ;\ gives us the cumulative results when concatenating it (a triangle of spaces). We then reverse the triangle and concatenate it to the left side of the original (;" concatenates corresponding elements of lists, µ forcibly causes a break in the parsing and thus uses the original input as the second list by default), giving us this:
["  abc",
 " def",
 "ghi"]

This is almost the solution we want, but we need to move the elements downwards to be flush with the last string. That's a matter of transposing (Z), reversing inside each line (U), transposing again (Z), and reversing the lines (Ṛ):
["  abc",
 " def",
 "ghi"]

transpose
["  g",
 " dh",
 "aei",
 "bf",
 "c"]

reverse within rows
["g  ",
 "hd ",
 "iea",
 "fb",
 "c"]

transpose
["ghifc",
 " deb",
 "  a"]

reverse the rows
["  a",
 " deb",
 "ghifc"]

Finally, Y joins on newlines. It's unclear to me whether or not this is required to comply with the specification (which allows input as a list of strings, but doesn't say the same about output), so the exact byte count depends on whether it's included or omitted.

Pyth, 16 bytes
j_.t_M.Tm+*;l=tQ

Big Pyth:
join-on-newline
reverse transpose-and-fill-with-spaces reverse func-map transpose-justified
map
  plus
    times innermost-var
      length assign tail input
    implicit-innermost-var
  implicit-input

Since people say golfing languages are hard to read, I've designed Big Pyth, which is both easily readable and easily translatable to Pyth. The linked file translates an input stream of Big Pyth to Pyth. Each whitespace-separated Big Pyth token corresponds to a Pyth token, either a character or a . followed by a character. The exceptions are the implicit tokens, which are implicit in the Pyth code.
I want to see how good an explanatory format Big Pyth is, so I'm not going to give any other explanation. Ask me if you want something explained, however.

Vyxal, 5 bytes
Þ√Ṙṅ§

Try it Online!
Header converts it into a single character matrix which is a valid input form.

JavaScript (ES6), 140 bytes
a=>[...Array(m=(h=a.length)<(w=a[0].length)?h:w)].map((_,i)=>[...Array(h+w-1)].map((_,j)=>(a[x=i+h-m-(++j>w&&j-w)]||``)[x+j-h]||` `).join``)

Takes input and output as arrays of strings. Also accepts a two-dimensional character array input, and save 7 bytes if a two-dimensional character array output is acceptable. Explanation: The height of the result m is the minimum of the height h and width w of the original array, while the width is simply one less than the sum of the height and width of the original array. The source row for the characters on the main portion of the result come directly from the appropriate row of the original array, counting up from the bottom, while on the extra portion of the result the source row moves up one row for each additional column. The source column for both halves of the result turns out to be equal to the destination column moved one column left for each source row above the bottom.

Octave, 57 bytes
@(A){B=spdiags(A),C=B>0,D='  '(C+1),D(sort(C))=B(C),D}{5}

Python 3, 247 bytes
def a(s):
 s=s.split('\n')
 for i,l in enumerate(s):r=len(s)-i-1;s[i]=' '*r+l+' '*(len(s)-r-1)
 print(*[''.join(i) for i in list(zip(*[''.join(a).rstrip([::-1].ljust(min(len(s),len(s[0])))for a in zip(*[list(i)for i in s])]))[::-1]],sep='\n')`

Useless whitespace at join(i) for.

Python 2, 150 bytes
def f(l):w=len(l[0]);h=len(l);J=''.join;R=range;print'\n'.join(map(J,zip(*['%%-%ds'%h%J(l[h+~i][j-i]for i in R(h)if-w<i-j<1)for j in R(h-~w)]))[::-1])

Takes input as list of strings.

Clojure, 194 bytes
Implemented the hard way by grouping characters to G and then generating lines.
#(let[n(count %)m(count(% 0))G(group-by first(for[i(range n)j(range m)][(min(- n i)(- m j))((% i)j)]))](apply str(flatten(for[k(reverse(sort(keys G)))][(repeat(dec k)" ")(map last(G k))"\n"]))))

Takes input as a vec of vecs like [[\a \b \c \d] [\1 \2 \3 \4] [\W \X \Y \Z]]. Example:
(def f #( ... ))
(print (str "\n" (f (mapv vec(re-seq #".+" "abcd\n1234\nWXYZ")))))

  ab
 c123
d4WXYZ


text:
It's factors all the way down!
This challenge is inspired by this fantastic animated diagram (thanks to flawr for posting it in chat).
Given an input n, draw all of its prime factors as nested polygons of dots, as specified.
For example, given the number 357 = 17x7x3, you arrange 3 dots in a triangle, 7 versions of those triangles in a heptagon, and 17 versions of those heptagons in a 17-gon. In short, nested polygons going from the largest prime factor on the outside to the smallest on the inside. For 357, your answer should look a little like this (with or without color):

Every polygon of every prime >= 3 should not be rotated around the diagram.
The only exception is the prime 2, specifically for odd powers of 2. As you can see in the example for 376 = 47x2x2x2 below, the 8s rotate and are not single lines of 2s, but are vertical stacks for 4s in a square. Even powers of 2, arranged in squares, do not need to be rotated in this way.

In fact, 448 = 7x2x2x2x2x2x2 has a diagram that looks like a heptagon of 64s, and 64 is arranged into a square of squares of squares, but without rotation.

Two more examples are 440 = 11x5x2x2x2 and 432 = 3x3x3x2x2x2x2. We see that 440 with an odd power of 2, has rotated 8s, but 432 with an even power of 2 does not rotate its 16s.

And finally, here is a minimal example, 10 = 5x2, without color that I mocked up with Python and its turtle module.

The challenge

Given an input n where 1 <= n <= 10000, output an image of its nested factor polygons.
Rules are:

The image is made up of nested polygons of dots, from a polygon with (the largest prime factor) sides on the outside to the smallest prime factor on the inside.
For the factor 2, the powers of 2 should stack as a line, then a squares, then a line of squares, and so on. Even powers of 2 should not be rotated. Odd powers of 2 should be rotated around their respective polygons, and they should be stacked vertically before rotation.

You may orient the image however you like (though I prefer up), but every nested polygon should be facing the same direction as any other polygon with the sole exception of odd powers of 2.
You have two options for image size and dot size:

The image size is static and the dot size decreases as n increases (as in the animation).
The dot size is static and the image size grows as n increases.

The first three layers of polygons should be distinguishable from neighboring polygons (i.e. not touching), but considering the size of the images at and around n=10000, it's okay if the layers after start to touch. I'd prefer it if they didn't, but it may be unavoidable to fit on an image that is uploadable to Stack Exchange.
Color is optional.
The shape of the dots is up to you. If squares are better for your language, use those.
No bonuses, but I would like to see someone animate and color the diagrams like in the original post.

Thanks to Conor O'Brien, EasterlyIrk, Martin Ender, Kritixi Lithos, Mego, DJ McMayhem, and El'endia Starman for their help in writing this question.
This code golf, so shortest code wins. Good luck and good golfing!

Python 3.5, 331 309 308 306 304 bytes
It took quite a bit of messing with the spacing of the polygons (and the specification, too, to be honest) to get this answer to work, but I finally did it and hopefully other answers can start coming in.
Edit: -2 bytes thanks to FlipTack. -8 bytes from removing a section of code that I forgot to remove earlier. -12 bytes from golfing the last function. -1 byte from changing the circumference of the drawings from size=2500 to size=2e3, which also allows the drawings to better fit on screens (diameter ~= 795.77 down to diameter ~= 636.62). -2 bytes from fixing a bug. -2 bytes from restructuring how I build a.
Golfing suggestions welcome. Trinket for testing and images to follow shortly.
from math import*
from turtle import*
ht();pu()
def g(n):
 i=1;a=[]
 while n%4<1:a+=4,;n//=4
 while n>1:
  i+=1
  while n%i<1:a+=i,;n//=i
 return f(a,2e3)
def f(a,s,x=0,y=0,t=0):
 if a:
  *c,b=a;s/=b
  for i in range(b):u=2*pi*i/b+t*(b<3)+pi/4*(b==4);f(c,s,x+s*sin(u),y+s*cos(u),u)
 else:goto(x,y);dot(4)

Here's g(448), which now fits on my 1366x768 screen.

Ungolfing
import math
import turtle

turtle.hideturtle()     # don't display the turtle itself)
turtle.penup()          # don't draw lines, just dots later on

def g(n):
    i = 1
    a = []
    while n % 4 == 0:   # get 4's into the list first,
        a = a + [4]     # so that the fractal will be easier to structure
        n = n // 4
    while n > 1:        # now get all of the other factors (including any stray 2's)
        i += 1
        while n % i == 0:
            a = a + [i]
            n = n // i
    return f(a, 2000)   # 2000 is the circumference of the circle
                        # on which we draw the polygons
def f(a, s, x=0, y=0, t=0):
    if a:
        c = a[-1]       # the size of the current outermost polygon
        b = a[:-1]      # the rest of the factors for recursion
        s = s/b         # the current circumference / the number of polygons at this layer
        for i in range(b):
            u = 2*math.pi*i/b   # angle around the circle
            if b == 2:          # if b == 2, add the previous angle to rotate the structure
                u += t
            if b == 4:          # if b == 4, add 45 degrees to keep the squares upright
                u += math.pi/4
            dx = s * math.sin(u)    # our coordinate changes for this polygon
            dy = s * math.cos(u)
            f(c, s, x+dx, y+dy, u)  # call the function again
                                    # on a new circle with new starting coordinates
    else:                   # when we run out of factors,
        turtle.goto(x,y)    # go to each coordinate
        turtle.dot(4)       # and draw a dot

is n = n //= i supposed to be n//= i ?

@Bobas_Pett Nah, you're looking at the ungolfing/explanation, and that's supposed to say n = n // i. I'll go fix it and add to the explanation while I'm at it.