Replace zeros in a list with last nonzero value

Question

This question is closely related to the problem of zero crossings.

Suppose I have a list l = {-1, -1, 0, 1, 0, 0, -1, -1, 1, 1, 1, 0, 0, 0, -1}

and I want to replace the zeros with the previous nonzero value, like this:

{-1, -1, -1, 1, 1, 1, -1, -1, 1, 1, 1, 1, 1, 1, -1}

A rather clunky way to do this is with:

  f = TimeSeries[l /. 0 -> Missing[], 
MissingDataMethod -> {"Interpolation", InterpolationOrder -> 0}]

Then indeed f[-1 + Range@Length@l]gives the required result.

However, there must be a more elegant way to achieve same, with patterns.

Can anyone supply a suggestion?

$\begingroup$ What should happen when the first element is a zero? $\endgroup$
– Sjoerd Smit
Commented Sep 25, 2019 at 14:53 — Sjoerd Smit, Commented Sep 25, 2019 at 14:53

kglr · Accepted Answer · 2024-02-07 07:25:48Z

20

`SequenceReplace`

SequenceReplace[ p:{a_, 0..} :> Sequence @@ (p /. 0 -> a)] @ l

or

FixedPoint[SequenceReplace[{a_, 0} :> Sequence[a, a]], l]

`ReplaceRepeated`

An alternative way to use ReplaceRepeated with a single replacement rule:

l //. {a___, b_, 0, c___} :> {a, b, b, c}

Memoization

Memoize the last non-zero value (inspired by @WReach's answer):

f[x_] := (f[0] = x; x) 
f /@ l

`Split` + `ReplaceAll`

Split[l, #2 == 0 &] /. p : {a_, 0 ..} :> (p /. 0 -> a) // Flatten

`TimeSeries` + `MissingDataMethod`

Using the "Values" property with OP's f:

f["Values"]

edited Feb 7 at 7:25

answered Sep 25, 2019 at 12:18

kglr

399k18 gold badges486 silver badges920 bronze badges

1

$\begingroup$ One of the reasons I asked this question even though I had a working (although inelegant) solution was to see all the creative ways in which MMA experts are able to use the Wolfram language to solve a problem. Outstanding! $\endgroup$
– Jonathan Kinlay
Commented Sep 25, 2019 at 22:41
1

$\begingroup$ What sort of (Mathematica) black magic is this!? My +1 sir. $\endgroup$
– Hans Olo
Commented Sep 27, 2019 at 13:54

Add a comment |

mikado · Accepted Answer · 2019-09-26 19:06:26Z

17

Define a simple function, using FoldList

op = FoldList[If[#2 == 0, #1, #2] &];

l = {-1, -1, 0, 1, 0, 0, -1, -1, 1, 1, 1, 0, 0, 0, -1};

op@l
(* {-1, -1, -1, 1, 1, 1, -1, -1, 1, 1, 1, 1, 1, 1, -1} *)

answered Sep 26, 2019 at 19:06

mikado

16.8k2 gold badges20 silver badges54 bronze badges

$\begingroup$ This must be the fastest (and simplest) of the lot. The one I knew existed, but never reached. $\endgroup$
– Suba Thomas
Commented Sep 26, 2019 at 22:19

Add a comment |

High Performance Mark · Accepted Answer · 2019-09-25 12:19:29Z

8

Perhaps something like this will appeal

l //. {{a___, 1, 0, b___} -> {a, 1, 1, b}, {a___, -1, 0, b___} -> {a, -1, -1, b}}

answered Sep 25, 2019 at 12:19

High Performance Mark

1,5341 gold badge10 silver badges17 bronze badges

$\begingroup$ This is the kind of thing I was aiming for, but I couldn't find the right formulation. I find patterns such a challenge (although I do use them extensively). Anyway that you for a great solution. $\endgroup$
– Jonathan Kinlay
Commented Sep 25, 2019 at 22:35

Add a comment |

WReach · Accepted Answer · 2019-09-25 15:47:18Z

6

Given:

list = {-1, -1, 0, 1, 0, 0, -1, -1, 1, 1, 1, 0, 0, 0, -1}

Then:

Module[{prev = 0}, Replace[list, {0 :> prev, x_ :> (prev = x)}, {1}]]

(* {-1, -1, -1, 1, 1, 1, -1, -1, 1, 1, 1, 1, 1, 1, -1} *)

The initial value assigned by prev = 0 is only used for lists that start with a zero -- choose another value if desired.

answered Sep 25, 2019 at 15:47

WReach

69.2k4 gold badges164 silver badges270 bronze badges

Add a comment |

Suba Thomas · Accepted Answer · 2019-09-26 17:38:57Z

A few more...

l = {-1, -1, 0, 1, 0, 0, -1, -1, 1, 1, 1, 0, 0, 0, -1};

Do[If[l[[i]] == 0, l[[i]] = l[[i - 1]]], {i, 2, Length[l]}]

l

fn[l_] := Block[{l1 = l},
  Set[Part[l1, #[[2]]], Part[l1, #[[1]]]] & /@ SequencePosition[l, {_, 0}];
  l1
]

l = {-1, -1, 0, 1, 0, 0, -1, -1, 1, 1, 1, 0, 0, 0, -1};

FixedPoint[fn, l]

l = {-1, -1, 0, 1, 0, 0, -1, -1, 1, 1, 1, 0, 0, 0, -1};

Fold[{#1, If[#2 == 0, Last[#1], #2]} &, l[[1 ;; 1]], l[[2 ;; -1]]] //Flatten

E. Chan-López · Accepted Answer · 2024-02-07 04:37:25Z

4

list = {-1, -1, 0, 1, 0, 0, -1, -1, 1, 1, 1, 0, 0, 0, -1};

Using SplitBy, SequenceCases and a suggestion from Syed:

patts = {{0 ..}, {a : Except[0], b : 0 ..} :> Array[a &, Length@{b}]};

sp = SplitBy[#, {0 ..}] &@list;

Catenate[sp /. Rule @@@ Thread[SequenceCases[list, #] & /@ patts]]

(*{-1, -1, -1, 1, 1, 1, -1, -1, 1, 1, 1, 1, 1, 1, -1}*)

Or in a simpler way using SequenceReplace, as @Syed suggests:

patt = {a : Except[0], b : 0 ..} :> Splice@Array[a &, Length@{b} + 1];

SequenceReplace[list, patt]

(*{-1, -1, -1, 1, 1, 1, -1, -1, 1, 1, 1, 1, 1, 1, -1}*)

edited Feb 7 at 4:37

answered Feb 7 at 2:49

E. Chan-López

29.2k3 gold badges26 silver badges48 bronze badges

1

$\begingroup$ SequenceReplace[list, {a : Except[0], b : 0 ..} :> Sequence @@ ConstantArray[a, Length@{b} + 1]]. ReplacePart functionality is built into Sequence* functions. Flatten is not a good idea. Consider replacing the -1 in the second location with {a} and rerun the solutions. $\endgroup$
– Syed
Commented Feb 7 at 3:42
$\begingroup$ Thanks for your excellent observation, Syed! I think I'll pay more attention to SequenceReplace because I haven't used it much. See the update, please. :-) $\endgroup$
– E. Chan-López
Commented Feb 7 at 4:39

Add a comment |

eldo · Accepted Answer · 2024-02-07 00:13:35Z

3

list = {-1, -1, 0, 1, 0, 0, -1, -1, 1, 1, 1, 0, 0, 0, -1};

Using SequenceSplit (new in 11.3)

Flatten @ SequenceSplit[list, {a_, b : 0 ..} :> {a, Table[a, Length @ {b}]}]

{-1, -1, -1, 1, 1, 1, -1, -1, 1, 1, 1, 1, 1, 1, -1}

answered Feb 7 at 0:13

eldo

82.5k6 gold badges69 silver badges194 bronze badges

Add a comment |

eldo · Accepted Answer · 2024-06-02 00:10:54Z

3

list = {-1, -1, 0, 1, 0, 0, -1, -1, 1, 1, 1, 0, 0, 0, -1};

Using SequenceSplit with ReplaceAll

Flatten @ SequenceSplit[list, {a_, b : 0 ..} :> {a, {b} /. 0 :> a}]

answered Jun 2 at 0:10

eldo

82.5k6 gold badges69 silver badges194 bronze badges

Add a comment |

Vito Vanin · Accepted Answer · 2024-02-08 01:24:50Z

Looking for a mostly arithmetic solution, I found a function that replaces only the first zero:

f[list_] := list + Prepend[ Rest[1 - Unitize[list]] Most[list], 0]

Finding the number of repetitions requires patterns:

list = {-1, -1, 0, 1, 0, 0, -1, -1, 1, 1, 1, 0, 0, 0, -1};
numberIterations =  Max[ SequenceCases[list, {p : Repeated[0]} :> Length[{p}]]]
Nest[f, list, numberIterations]
(* {-1, -1, -1, 1, 1, 1, -1, -1, 1, 1, 1, 1, 1, 1, -1} *)

Works, but it didn't correspond to what I was looking for.

Stack Exchange Network

Replace zeros in a list with last nonzero value

9 Answers 9

`SequenceReplace`

`ReplaceRepeated`

Memoization

`Split` + `ReplaceAll`

`TimeSeries` + `MissingDataMethod`

Your Answer

Not the answer you're looking for? Browse other questions tagged
list-manipulation
replacement
pattern-matching
or ask your own question.

Linked

Hot Network Questions

9 Answers 9

Split + ReplaceAll

TimeSeries + MissingDataMethod

Your Answer

Sign up or log in

Post as a guest

Not the answer you're looking for? Browse other questions tagged list-manipulationreplacementpattern-matching or ask your own question.

Linked

Related

`Split` + `ReplaceAll`

`TimeSeries` + `MissingDataMethod`

Not the answer you're looking for? Browse other questions tagged
list-manipulation
replacement
pattern-matching
or ask your own question.