Replace all symbols in a matrix with their numbered forms

Question

I have a matrix made mostly from "x" with a few 0's thrown in:

list = {{0, "x", "x", 0}, {0, "x", "x", "x"}, {0, "x", "x", 
   "x"}, {"x", "x", "x", "x"}, {"x", "x", "x", "x"}, {"x", "x", "x", 
   "x"}, {"x", "x", "x", "x"}, {"x", "x", "x", "x"}, {0, "x", "x", 
   "x"}}

I know that there are 31 "x"'s in the matrix, and I want to replace each of them with a numbered variable: x1, x2, and so on til x31 (without quotations). Here's the expected result:

(* {{0, x1, x2, 0}, {0, x3, x4, x5}, {0, x6, x7, x8}, {x9, x10, x11, 
  x12}, {x13, x14, x15, x16}, {x17, x18, x19, x20}, {x21, x22, x23, 
  x24}, {x25, x26, x27, x28}, {0, x29, x30, x31}} *)

Below is the list of the numbered variables that you may use:

numberedx = Table["x" <> ToString@i // Symbol, {i, Range@Count[list, "x", {2}]}]
(* {x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, 
x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, 
x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31} *)

I can't for the life of me figure out how to do this. My gut tells me that some procedural method is in order since each "x" is replaced by its numbered form, then the next "x" down the line is replaced by the next member in the list of numbered variables. Unfortunately I'm very uncomfortable with procedural programming. I also tried MapIndexed but the 0's are mapped as well. I'd really appreciate any help or insight.

Answer 1

ReplaceAll solution:

i = 1;
list /. "x" :> Symbol@StringJoin["x", ToString[i++]]

The same thing can be achieved with Map:

i = 1;
Map[If[# == "x", "x" <> ToString[i++] // Symbol, #] &, list, {2}]

They both give:

{{0, x1, x2, 0}, {0, x3, x4, x5}, {0, x6, x7, x8}, {x9, x10, x11, 
      x12}, {x13, x14, x15, x16}, {x17, x18, x19, x20}, {x21, x22, x23, 
      x24}, {x25, x26, x27, x28}, {0, x29, x30, x31}}

Answer 2

Pickett's answer should get the job done but I encourage you to use indexed objects:

Module[{i = 0},
  list /. s_String :> x[++i]
]

Answer 3

Another way:

Module[{i = 0, l = #, f}, 
   f[x_String] := Symbol[x <> ToString[++i]];
   f[x_] := x;
   Map[f, l, {2}]] &@list

{{0, x1, x2, 0}, {0, x3, x4, x5}, {0, x6, x7, x8}, {x9, x10, x11, x12},
 {x13, x14, x15, x16}, {x17, x18, x19, x20}, {x21, x22, x23, x24},
 {x25, x26, x27, x28}, {0, x29, x30, x31}}

Answer 4

Another way using ReplacePart:

pos = Position[list, "x"];

idx = ToString /@ Range[Length@pos];

numbdx = Symbol@*StringJoin @@@ Thread[{Array["x" &, Length@#], #}] &@idx;

ReplacePart[list, Thread[pos -> numbdx]]

(*{{0, x1, x2, 0}, {0, x3, x4, x5}, {0, x6, x7, x8}, {x9, x10, x11, x12}, 
   {x13, x14, x15, x16}, {x17, x18, x19, x20}, {x21, x22, x23, x24}, 
   {x25, x26, x27, x28}, {0, x29, x30, x31}}*)

Answer 5

I worked out a solution using Position and a Table of Set's i.e. "set x at this position to the numbered variable with the same index i". I really appreciate all of your answers, and hopefully I will get used to using ++i in the future.

Clear[replacex]
replacex[l_List] := Module[{lCopy = l, positionx, numberedx},
  positionx = Position[l, "x"]; 
  numberedx = Table[Symbol["x" <> ToString[i]], {i, Range[Count[l, "x", {2}]]}]; 
  Table[lCopy[[Sequence @@ positionx[[i]]]] = numberedx[[i]], {i, Length[numberedx]}];
  lCopy]

replacex[list]
(* {{0, x1, x2, 0}, {0, x3, x4, x5}, {0, x6, x7, x8}, {x9, x10, x11, 
  x12}, {x13, x14, x15, x16}, {x17, x18, x19, x20}, {x21, x22, x23, 
  x24}, {x25, x26, x27, x28}, {0, x29, x30, x31}} *)

---

I also found that these work to replace the second to last line in my module:

Function[i, lCopy[[Sequence @@ positionx[[i]]]] = numberedx[[i]]] /@ Range@Length[numberedx];
Set[lCopy[[Sequence @@ positionx[[#]]]], numberedx[[#]]] & /@ Range@Length[numberedx];

but not this

(lCopy[[Sequence @@ positionx[[#]]]] = numberedx[[#]] &) /@ Range@Length[numberedx];