generating integer partitions

Question

Mathematica can generate integer partitions of an integer $N$. For example, IntegerPartitions[4] quickly gives

{{4}, {3, 1}, {2, 2}, {2, 1, 1}, {1, 1, 1, 1}}

This is nice, but I wish to generate a partition given as $[N_1,N_2,\ldots,]$ with $\sum_{i}i N_i=N$, where $N_i$ counts the number of $i$ in the partition. For example, in the above-mentioned example of $N=4$, we would have

{{0, 0, 0, 1}, {1, 0, 1, 0}, {0, 2, 0, 0}, {2, 1, 0, 0}, {4, 0, 0, 0}}

How could I generate this with Mathematica?

Answer 1

myIP[int_] := Block[{ip = IntegerPartitions[int], r},
  r = Range[1, int];
  Tally[Join[r, #]][[All, 2]] - 1 & /@ ip]

Answer 2

I needed to do this sometime ago while investigating Bell polynomial analogs. Normally, you'd do

FrobeniusSolve[Range[n], n]

but the fastest variation (and quite compact, too!) I found was

Outer[Count, IntegerPartitions[n], Range[n], 1]

---

A different approach

Some undocumented magic is needed for this approach; in particular, with the system setting "SparseArrayOptions" -> {"TreatRepeatedEntries" -> 1} that adds up entries in duplicate positions, we can write something like this:

SetSystemOptions["SparseArrayOptions" -> {"TreatRepeatedEntries" -> 1}];
cp[n_Integer?Positive] := SparseArray[Flatten[MapIndexed[
        Thread[Transpose[PadRight[{#2, #1}, Automatic, #2]] -> 1] &, 
        IntegerPartitions[n]]]]

This is slightly faster than my previous approach, but still slower than ciao's.

---

Finally, ciao's code can be optimized slightly, with a modest gain in speed:

myIP2[n_Integer?Positive] := Block[{r = Range[n], tmp},
      tmp = Tally[Join[r, #]] & /@ IntegerPartitions[n];
      tmp[[All, All, 2]] - 1]

Answer 3

Reverse@GroupTheory`Tools`IntegerPartitionCounts[4]

{{0, 0, 0, 1}, {1, 0, 1, 0}, {0, 2, 0, 0}, {2, 1, 0, 0}, {4, 0, 0, 0}}

GroupTheory`Tools`IntegerPartitionCounts[70] // Length // AbsoluteTiming

{2.48625, 4087968}

Answer 4

nCountPartitions[int_Integer?Positive] :=
 Module[{partitions = IntegerPartitions[int], selectList},
  selectList = Function[{i}, Select[# == i &]] /@ Range[int];
  Length /@ Through[selectList[#]] & /@ partitions
  ]

nCountPartitions[4]
(* {{0, 0, 0, 1}, {1, 0, 1, 0}, {0, 2, 0, 0}, {2, 1, 0, 0}, {4, 0, 0, 0}} *)

selectList is a list of Select functions, one for each possible integer.

Function[{i}, Select[# == i &]] /@ Range[4]
(* {Select[#1 == 1 &], Select[#1 == 2 &], Select[#1 == 3 &], Select[#1 == 4 &]} *)

Each partition is passed Through to this list of functions that select out their matches. The Length of these select list are then taken.