How to repeat the nonblank string?

Question

As the title, if I have a list:

{"", "", "", "2$70", ""}

I will expect:

{"", "", "", "2$70", "2$70"}

If I have

{"", "", "", "3$71", "", "2$72", ""}

then:

{"", "", "", "3$71", "3$71", "2$72", "2$72"}

And

{"", "", "", "3$71", "","", "2$72", ""}

should give

{"", "", "", "3$71", "3$71", "", "2$72", "2$72"}

This is my try:

{"", "", "", "2$70", ""} /. {p : Except["", String], ""} :> {p, p}

But I don't know why it doesn't work. Poor ability of pattern match. Can anybody give some advice?

most probably a duplicate but hard to find it. here is one way: Module[{last = "", f}, f[""] := last; f[x_] := last = x; f /@ # ] &@{"", "", "", "2$70", ""} — Kuba, Feb 11 '17 at 20:33
What you do expect as output for {"", "x", "y", "", "z", ""} ? — Mr.Wizard, Feb 11 '17 at 21:28

score 8 · Answer 1 · answered Feb 12 '17 at 00:52

8

In place modification of a list works well here:

fc[list_] := Module[{out=list},
    With[{empty = Pick[Range[2,Length@list], Rest@list,""]},
        out[[empty]]=out[[empty-1]]
    ];
    out
]

A comparison with Mr Wizard's fn:

data = RandomChoice[{"","","","a","b"}, 10^5];
r1 = fn[data]; //AbsoluteTiming
r2 = fc[data]; //AbsoluteTiming
r1 === r2

{0.049858,Null}

{0.01092,Null}

True

answered Feb 12 '17 at 00:52

Carl Woll

130,679
6
243
355

Now I feel silly yet again. +1 of course. :^) – Mr.Wizard Feb 12 '17 at 00:54
Added to my benchmark. – Mr.Wizard Feb 12 '17 at 00:58
haha i tried using a method i thought and i got 67 seconds on my tablet. That really shows how important is being able to write a clear and fast code – Alucard Feb 12 '17 at 11:49

Mr.Wizard · Accepted Answer · 2017-02-12T00:58:36.997

7

As I presently interpret the question

(Now with refinements after considering Chris Degnen's simultaneous answer)

fn[list_] :=
  Partition[list, 2, 1, -1, ""] // Cases[{p_, ""} | {_, p_} :> p]

Test:

 {"", "x", "y", "", "z", ""} // fn

{"", "x", "y", "y", "z", "z"}

Patterns

Since you seem only to be interested in a pattern-matching solution here is my proposal to avoid the extremely slow use of ReplaceRepeated while still using pattern-matching as the core of the operation.

fn2[list_] :=
  list // ReplacePart @ 
   ReplaceList[list, {a___, p_, "", ___} :> (2 + Length@{a} -> p)]

Recursive replacement

I just realized that this is a perfect time to use a self-referential replacement:

fn3[list_] :=
  list /. {a___, p_, "", b___} :> {a, p, p, ##& @@ fn3@{b}}

Benchmark

All three methods are much faster than kglr's foo (note the log-log scale).

Now with Carl Woll's fc, the fastest method yet. ( but no patterns ;-) )

Needs["GeneralUtilities`"]

$RecursionLimit = 1*^5;

BenchmarkPlot[{foo, fn, fn2, fn3, fc},
  RandomChoice[{"", "", "", "a", "b"}, #] &
]

edited Feb 12 '17 at 00:58

answered Feb 11 '17 at 21:15

Mr.Wizard

271,378
34
587
1,371

The pattern matching method is slower in generally. – yode Feb 11 '17 at 22:08
@yode Indeed it can be, but the main issue here is the use of a single-pass method versus //. which has to reprocess the entire list for every element to be duplicated. – Mr.Wizard Feb 11 '17 at 22:15
@yode Please see my update. – Mr.Wizard Feb 11 '17 at 22:38
Funny~the ReplaceList is a good lesson.Upvote! :) – yode Feb 11 '17 at 22:45
@yode I added a third and final method to this answer. If it is not enough to wrest the Accept from kglr's grasp I give up. – Mr.Wizard Feb 12 '17 at 00:16
1

Wow,I have to say that flash my eyes(the last method). – yode Feb 12 '17 at 02:08

kglr · Answer 3 · 2017-02-11T21:31:26.873

4

Update:

foo = # //. {a___, p : Except["", _String], Longest[b : "" ..],   c___} :>
   {a, p, p, ## & @@ ConstantArray["☺", Length[{b}] - 1], c} /. "☺" -> "" &;

{"", "", "", "3$71", "", "", "2$72", "", "", "", ""} // foo

{"", "", "", "3$71", "3$71", "", "2$72", "2$72", "", "", ""}

Previous post:

rule = {a___, p : Except["", _String], Longest["" ..],  b___} :> {a, p, p, b};

{"", "", "", "3$71", "", "", "2$72", "", "", "", ""} //. rule

{"", "", "", "3$71", "3$71", "2$72", "2$72"}

edited Feb 11 '17 at 21:31

answered Feb 11 '17 at 20:34

kglr

394,356
18
477
896

1

Thanks very much.But {"", "", "", "3$71", "", "", "2$72", ""} will give three "3$71".I just expect two here. – yode Feb 11 '17 at 20:39
@yode, fixed... – kglr Feb 11 '17 at 20:51
I'm sorry,I expect two "3$71" but not three. – yode Feb 11 '17 at 20:53
@yode, hope i finally got it. – kglr Feb 11 '17 at 21:04
1

{"", "", "", "3$71", "","", "2$72", ""} should give {"", "", "", "3$71", "3$71", "", "2$72", "2$72"}.I'm sorry,actually your code have given me enough information now. :) – yode Feb 11 '17 at 21:17
@yode This will have to scan the list multiple times which can be very slow. I would use Sequence instead; see my answer please. – Mr.Wizard Feb 11 '17 at 21:18
@yode No am I wrong, yet again. If I don't improve my reading comprehension I'm going to quit Stack Exchange. <:( – Mr.Wizard Feb 11 '17 at 21:25
@Mr.Wizard The culprit is my ability of presentation. :) – yode Feb 11 '17 at 21:50

score 4 · Answer 4 · edited Feb 11 '17 at 23:49

4

Borrowing kglr's pattern

x = {"", "", "1$71", "3$71", "", "", "2$72", "", "", "", ""};

Prepend[
 Map[Last, Partition[x, 2, 1] /. {p : Except[""], ""} :> {p, p}],
 First[x]]

{"", "", "1\$71", "3\$71", "3\$71", "", "2\$72", "2\$72", "", "", ""}

user might consider to use Apply rather than Map:

Last@@@(Partition[x, 2, 1] /. {p : Except[""], ""} :> {p, p})//Prepend[First@x]

edited Feb 11 '17 at 23:49

Ali Hashmi

8,950
4
22
42

answered Feb 11 '17 at 21:50

Chris Degnen

30,927
2
54
108

I was just posting a Partition method myself. +1 and I hope I don't step on any toes. – Mr.Wizard Feb 11 '17 at 21:51
No worries. :-) – Chris Degnen Feb 11 '17 at 21:56
@ChrisDegnen @Mr.Wizard what if you use Last@@@ .... instead of Map[Last ...] . I assume the former will be faster – Ali Hashmi Feb 11 '17 at 23:21
1

@AliHashmi I avoided Last entirely by hard-coding it into f[{_, x_}] := x. For this code I would use Part[. . ., All, 2] as that is usually fastest. – Mr.Wizard Feb 11 '17 at 23:23
1

@AliHashmi Since you care about refinements I realized that this code could be made shorter; see my updated answer. – Mr.Wizard Feb 11 '17 at 23:49
@Mr.Wizard i like how the post started and where it ended ! – Ali Hashmi Feb 12 '17 at 01:54

eldo · Answer 5 · 2024-01-12T06:46:31.983

3

Using SequenceReplace (new in 11.3)

f = SequenceReplace[{a : Except[""], ""} :> Sequence[a, a]] @ #&;
f @ {"", "", "", "270", ""}

{"", "", "", "270", "270"}

f @ {"", "", "", "371", "", "272", ""}

{"", "", "", "371", "371", "272", "272"}

f @ {"", "", "", "371", "", "", "272", ""}

{"", "", "", "371", "371", "", "272", "272"}

Addendum

As Syed commented a better solution would be

f = SequenceReplace[{a_String, ""} :> Sequence[a, a]] @ #&;
f @ {"", "", "", "270", ""}

{"", "", "", "270", "270"}

edited Jan 12 '24 at 06:46

answered Jan 12 '24 at 00:24

eldo

67,911
5
60
168

This works, albeit it is making redundant substitutions by not checking for empty strings: SequenceReplace[list, {a_String, ""} :> Sequence[a, a]] where list is your input. – Syed Jan 12 '24 at 06:39
Thanks, Syed, I updated my answer – eldo Jan 12 '24 at 06:47

score 1 · Answer 6 · answered Jan 12 '24 at 05:56

Using SequenceSplit:

sp[lst_] := SequenceSplit[lst, s : {Except[""], ""} :> s]
pos1 = Position[sp[l1], {a_String, _} /; DigitQ[a]];
Flatten@ReplacePart[sp[l1], Thread[pos1 -> Cases[sp[l1], {a_, _} :> {a, a}]]]
({"", "", "", "270", "270"})
pos2 = Position[sp[l2], {a_String, _} /; DigitQ[a]];
Flatten@ReplacePart[sp[l2], Thread[pos2 -> Cases[sp[l2], {a_, _} :> {a, a}]]]
({"", "", "", "371", "371", "272", "272"})
pos3 = Position[sp[l3], {a_String, _} /; DigitQ[a]];
Flatten@ReplacePart[sp[l3], Thread[pos3 -> Cases[sp[l3], {a_, _} :> {a, a}]]]
({"", "", "", "371", "371", "", "272", "272"})

How to repeat the nonblank string?

6 Answers6

Patterns

Recursive replacement

Benchmark

Linked