Counting 'False' values at the ends of a list

Question

I have table like this:

t = {False, False, False, 4.5, 6.789, 1.23, 0.98, False, False}

and I want to know how many False values I have at the beginning and at the end of the table.

I made:

size = Length[t]
t = Cases[t,Except[False]];
size2 = Length[t]
diff = size - size2

But this counts number of all 'False' values inside the table. But I want to know how many is at the beginning and how many at the end (so i my example I have: 3 at the beginning and 2 at the end). How can I solve that?

Answer 1

Here is one way:

before= LengthWhile[t, Not]

(* 3  *)

after = LengthWhile[Reverse[t], Not]

(* 2  *)

Answer 2

z = Split[t];
Map[Length, {First[z], Last[z]}]

(* {3, 2} *)

Answer 3

list = {False, False, False, 4.5, 6.789, 1.23, 0.98, False, False};

Using SequenceCount (new in 10.1)

SequenceCount[list, #] & /@ {{False, _}, {_, False}}

{3, 2}

Answer 4

Using SequenceCases:

list = {False, False, False, 4.5, 6.789, 1.23, 0.98, False, False};

SequenceCases[list, s : {False ..} :> Length@s]

(*{3, 2}*)

Or using SequenceSplit and Select:

patt = {b : Longest[False ..]} :> {b};

Length /@ Select[SequenceSplit[list, patt], ! FreeQ[#, False] &]

(*{3, 2}*)

Answer 5

Since @eldo keeps up the wonderful work and @E. Chan-López is following along I am providing an answer the question.

t = {False, False, False, 4.5, 6.789, 1.23, 0.98, False, False};
foreldo[list_] := Module[{adjacency, result},
   adjacency = 
    SparseArray[
      list /. x_ /; x > 0 -> 0 /. x_ /; x < 0 -> 0 /. 
       x_ /; x == 0 -> 0]["AdjacencyLists"];
   result = Length /@ Split[adjacency, #2 == # + 1 &];
   Print[
    "The number of consecutive False elements are --- from start to \
end"];
   Return[result];
   ];

Then, we have

foreldo[t]

returning

Answer 6

Gives you the leading and trailing as a list:

LengthWhile[#, ! # &] & /@ {t, t // Reverse}

If you need to assign to symbols, e.g.,

{front, back}=LengthWhile[#, ! # &] & /@ {t, t // Reverse}

Edit: Just saw L.S.'s answer - same idea. As he notes, for huge lists reverse may not be the best way. I find the idiom somelist[[-1;;1;;-1]] a faster way, and depending on what you know about the structure of the data, other ways may be faster.

Answer 7

Here's a rules-based solution as well so that we have one of those too:

t /. {f : False ..., Except[False] .., l : False ...} :> {Length[{f}], Length[{l}]}

Answer 8

I came up with this and then noticed it is a variation on Anon's approach:

 # /. {___, x:Longest[False ...], __, y:Longest[False ...]} :> {Length[{x}], Length[{y}]} &

---

The same idea, with a named function:

f[list_] := Length[list /. {___, x : Longest[False ...], __} :> {x}]

Example:

 {f[t], f[Reverse[t]]}

{3, 2}