How to generate patterns by a list of integers

Question

I have a list of integers {3,4,2,2}.

This list will give patterns {x_,_,y_,y_,_,_,z_,z_,w_,w_,x_} and {0,0,0,1,1,1,1,0,0,1,1}.

Notice that I want to assign successive 0,1 with the same symbol.

How to make this?

*edit

Compare the patterns

{x_,_,y_,y_,_,_,z_,z_,w_,w_,x_}
{0, 0, 0,1, 1,1, 1,0,  0,1, 1 }
{1, _, 2,2, _,_, 3,3,  4,4, 1 }

Suppose I have symbols {x_,y_,z_,w_} (you may use {a_,b_,c_,d_,...}).

To transform lst={3,4,2,2} to {x_,_,y_,y_,_,_,z_,z_,w_,w_,x_}, begin with {x_,_,_,_,_,_,_,_,_,_,_}.

Then put y_ at positions lst[[1]] and lst[[1]]+1.

Then put z_ at positions lst[[1]]+lst[[2]] and lst[[1]]+lst[[2]]+1.

Then put w_ at positions lst[[1]]+lst[[2]]+lst[[3]] and lst[[1]]+lst[[2]]+lst[[3]]+1.

And finally put x_ at the last position.

Answer 1

Like others I cannot follow the {x_,_,y_,y_,_,_,z_,z_,w_,w_,x_} part but for the integer sequence this problem is related to: How to apply or map a list of functions to a list of data?

Any of those solutions should be adaptable but for this particular application I like TomD's method the best. It is both concise and very fast.

f[pat : {__Integer}, rep_List] /; Min[pat] > 0 :=
  Join @@ ConstantArray @@@ Partition[Riffle[pat, rep, {1, -1, 2}], 2]

f[{3, 4, 2, 2}, {0, 1}]

{0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1}

---

Here is one that is a bit shorter and faster still:

f2[p : {__Integer}, r_List] /; Min[p] > 0 :=
  Inner[ConstantArray, PadRight[r, Length @ p, r], p, Join]

f2[{3, 4, 2, 2}, {0, 1}]

{0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1}

---

In response to your updated question you could use this:

lst = {3, 4, 2, 2};

ReplacePart[
 ConstantArray[_, Tr@lst],
 Prepend[
  {{#}, {# + 1}} -> (Pattern[#, _] &@Unique[]) & /@ Accumulate@lst,
  {{1}, {-1}} -> x_
 ]
]

{x_, _, $1_, $1_, _, _, $2_, $2_, $3_, $3_, x_}

This generates as many Unique symbols as required to fill out the list.

I still think this is distinct from the integer sequence result and should be split to a separate question. I also echo m_goldberg's question: "How do you intend to use the pattern?" as there may be another approach.

Answer 2

One part of the question is easy -- constructing a sequence of ones and zeros according to a pattern given by a control list of integers:

binaryPattern[controlList : {_Integer ..}] := 
   Flatten@MapIndexed[
      If[EvenQ @@ #2, ConstantArray[1, #1], ConstantArray[0, #1]] &, controlList]

binaryPattern[{3, 4, 2, 2}]

{0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1}

binaryPattern[{1, 2, 3, 4}]

{0, 1, 1, 0, 0, 0, 1, 1, 1, 1}

About the other part, I haven't a clue of what the OP has in mind.

Edit

Slightly modifying the function Mr. Wizard defined in his comment to this answer, I present a function that produces sequences of digits from any base from two to ten. I confess I can think of no use case for this extended version.

nAryPattern[controlList : {__Integer}, base_Integer: 2] /; 11 > base > 1 := 
   Join @@ MapIndexed[ConstantArray[Mod[#2[[1]] - 1, base], #] & controlList]  

Table[nAryPattern[Range[5], base], {base, 2, 5}]

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