Filter list with different list in it

Question

I have a list like:

   {{{4, 14}, 1}, {{4, 15}, 1}, {{4, 16}, 1}, {{4, 17}, 1}, 
    {{4, 18}, 1}, {{4, 14}, 3},  {4,15},      {{4, 16}, 2},{4,18}}

Now I want to filter this list. First I want to delete lists that have the form: {a,b} like {4,15} and {4,18}. So what remains is:

 {{{4, 14}, 1}, {{4, 15}, 1}, {{4, 16}, 1}, {{4, 17}, 1}, 
  {{4, 18}, 1}, {{4, 14} ,3}, {{4, 16}, 2}}

And now I want only the lists which are a minimum: For example now you have a list with:

{{4, 14}, 1} and {{4, 14}, 3}
{{4, 16}, 1} and {{4, 16}, 2}

I want that only {{4, 14}, 1} and {{4, 16}, 1} remain (minimum of the third number).

Finally remains:

{{{4, 14}, 1}, {{4, 15}, 1}, {{4, 16}, 1}, {{4, 17}, 1}, {{4, 18}, 1}

How can I easily do this??

Glenn, as you can see from the answers below there is ambiguity in your question. Do you want to return only elements of the form {{_, _}, min} where min is the global minimum across all lists, or rather elements where min is the smallest value within the set that share a common first part (e.g. {4, 14})? — Mr.Wizard, Commented Dec 16, 2012 at 23:08

VLC · Accepted Answer · 2012-12-16 17:56:56Z

6

Yet another way using Select and GatherBy:

list = {{{4, 14}, 1}, {{4, 15}, 1}, {{4, 16}, 1}, {{4, 17}, 
    1}, {{4, 18}, 1}, {{4, 14}, 3}, {4, 15}, {{4, 16}, 2}, {4, 18}};
x1 = Select[list, Length[#[[1]]] == 2 &];
x2 = GatherBy[x1, First];
(Sort[#] & /@ x2)[[All, 1]]

{{{4, 14}, 1}, {{4, 15}, 1}, {{4, 16}, 1}, {{4, 17}, 1}, {{4, 18}, 1}}

edited Dec 16, 2012 at 17:56

answered Dec 16, 2012 at 16:42

VLC

9,8781 gold badge32 silver badges60 bronze badges

$\begingroup$ You could use SortBy[#,Last] instead of Sort[#, #1[[2]] < #2[[2]] &] . Or, for this problem, just Sort since the first elements are all the same $\endgroup$
– Simon Woods
Commented Dec 16, 2012 at 17:31
$\begingroup$ @SimonWoods You're right, updated. $\endgroup$
– VLC
Commented Dec 16, 2012 at 17:58

Add a comment |

Nasser · Accepted Answer · 2012-12-16 16:32:06Z

5

another way

list = DeleteCases[list, {x_Integer, y_Integer}];
min = Min[list[[All, 2]]];
Extract[list, Position[list[[All, 2]], min] ]

Mathematica graphics

answered Dec 16, 2012 at 16:32

Nasser

151k12 gold badges162 silver badges376 bronze badges

$\begingroup$ You're assuming the minimum (third number) is just going to be one number, in this case 1, but it seems the different lists could have various minimum numbers. $\endgroup$
– Chris Degnen
Commented Dec 16, 2012 at 16:38

Add a comment |

Mr.Wizard · Accepted Answer · 2012-12-16 23:01:20Z

4

lst = {{{4, 14}, 1}, {{4, 15}, 1}, {{4, 16}, 1},
       {{4, 17}, 1}, {{4, 18}, 1}, {{4, 14}, 3}, {4, 15}, {{4, 16}, 2}, {4, 18}}

First /@ Sort /@ GatherBy[Cases[lst, {_List, _}], First]

{{{4, 14}, 1}, {{4, 15}, 1}, {{4, 16}, 1}, {{4, 17}, 1}, {{4, 18}, 1}}

Or with ~infix~:

First /@ Sort /@ lst ~Cases~ {_List, _} ~GatherBy~ First

answered Dec 16, 2012 at 23:01

Mr.Wizard

273k34 gold badges595 silver badges1.4k bronze badges

Add a comment |

Chris Degnen · Accepted Answer · 2012-12-16 16:28:29Z

2

Here's a fairly simple way of doing it:-

x = {{{4, 14}, 1}, {{4, 15}, 1}, {{4, 16}, 1}, {{4, 17}, 1},
     {{4, 18}, 1}, {{4, 14}, 3}, {4, 15}, {{4, 16}, 2}, {4, 18}};
x2 = Replace[x, {a_Integer, b_Integer} -> Null, {1}];
x3 = DeleteCases[x2, Null];
types = Union[x3[[All, 1]]];
First[Sort[Cases[x3, {#, _}]]] & /@ types

{{{4, 14}, 1}, {{4, 15}, 1}, {{4, 16}, 1}, {{4, 17}, 1}, {{4, 18}, 1}}

answered Dec 16, 2012 at 16:28

Chris Degnen

31.3k2 gold badges56 silver badges109 bronze badges

Add a comment |

image_doctor · Accepted Answer · 2012-12-16 23:04:21Z

2

An approach based on Cases:

lst = {{{4, 14}, 1}, {{4, 15}, 1}, {{4, 16}, 1},
   {{4, 17}, 1}, {{4, 18}, 1}, {{4, 14}, 3}, {4, 15}, {{4, 16}, 2}, {4, 18}}

Cases[list, {{_, _}, Min[list /. {{_, _}, x_} -> x]}]

{{{4, 14}, 1}, {{4, 15}, 1}, {{4, 16}, 1}, {{4, 17}, 1}, {{4, 18}, 1}}

answered Dec 16, 2012 at 23:04

image_doctor

10.3k23 silver badges41 bronze badges

Add a comment |

kglr · Accepted Answer · 2012-12-17 11:28:39Z

With

x = {{{4, 14}, 1}, {{4, 15}, 1}, {{4, 16}, 1}, {{4, 17}, 1}, 
  {{4, 18}, 1}, {{4, 14}, 3}, {4, 15}, {{4, 16}, 2}, {4, 18}};
x2 = {{{4, 15}, 1}, {{4, 16}, 1}, {{4, 17}, 1}, {{4, 18}, 1}, 
  {{4, 14}, 3}, {4, 15}, {{4, 16}, 2}, {4, 18}, {{4, 14}, 2}};

you can also use

 Union[Cases[x, {{ _, _ }, _}], SameTest -> (First@#1 == First@#2 &)]

or

 (* if the elements `{{a,b}, c}` are already sorted with respect to the the last entry:*)
 DeleteDuplicates[Cases[x, {{_, _}, _}], (#1[[1]] == #2[[1]] &)] 
 (* if not: *)
 DeleteDuplicates[SortBy[#, Last] &@Cases[x, {{_, _}, _}], (#1[[1]] == #2[[1]] &)]

to get:

(* {{{4, 14}, 1}, {{4, 15}, 1}, {{4, 16}, 1}, {{4, 17}, 1}, {{4, 18}, 1}} *)

Update: Further alternatives that preserve the ordering of the input list:

cleanUp2[x_] :=  With[{gthrd = GatherBy[Select[x, Depth[#] == 3 &], First]},
   Join @@ Pick[#, Last /@ #, Min @@ (Last /@ #)] & /@ gthrd];
cleanUp3[x_] := DeleteCases[x, Alternatives[{_Integer, _},
    {w : {_, _}, z_} /; z > Min @@ Last /@ Cases[x, {w, _}]]]; 
cleanUp4[x_] :=  Cases[x, {w : {_, _}, z_} /; z == Min @@ Last /@ Cases[x, {w, _}]];

Example:

 cleanUp3[x2]
 (* {{{4, 15}, 1}, {{4, 16}, 1}, {{4, 17}, 1}, {{4, 18}, 1}, {{4, 14}, 2}} *)

Syed · Accepted Answer · 2023-04-27 10:01:32Z

2

Using MinimalBy:

list = {{{4, 14}, 1}, {{4, 15}, 1}, {{4, 16}, 1}, {{4, 17}, 
   1}, {{4, 18}, 1}, {{4, 14}, 3}, {4, 15}, {{4, 16}, 2}, {4, 18}};

DeleteCases[list, {_?AtomQ, _?AtomQ}, {1}] // MinimalBy[Last]

{{{4, 14}, 1}, {{4, 15}, 1}, {{4, 16}, 1}, {{4, 17}, 1}, {{4, 18}, 1}}

answered Apr 27, 2023 at 10:01

Syed

59.5k5 gold badges40 silver badges95 bronze badges

Add a comment |

E. Chan-López · Accepted Answer · 2023-04-30 23:53:53Z

2

Using GroupBy and Select:

lst = {{{4, 14}, 1}, {{4, 15}, 1}, {{4, 16}, 1},
       {{4, 17}, 1}, {{4, 18}, 1}, {{4, 14}, 3}, {4, 15}, {{4, 16}, 2}, {4, 18}};

First@GroupBy[Select[lst, Length[Flatten@#] > 2 &], Last, Sort]

(* {{{4, 14}, 1}, {{4, 15}, 1}, {{4, 16}, 1}, {{4, 17}, 1}, {{4, 18}, 1}} *)

Edit: By @Syed's suggestion, another way:

Cases[list, {{__}, _}] // GroupBy[#, Min@Last][1] & (*Thanks, mate!*)

edited Apr 30, 2023 at 23:53

answered Apr 27, 2023 at 23:22

E. Chan-López

31.3k3 gold badges29 silver badges50 bronze badges

1

$\begingroup$ Try: ` Cases[list, {{__}, _}] // GroupBy[#, Min@Last][1] &` $\endgroup$
– Syed
Commented Apr 28, 2023 at 4:00

Add a comment |

eldo · Accepted Answer · 2024-04-18 23:37:23Z

2

list = 
 {{{4, 14}, 1}, {{4, 15}, 1}, {{4, 16}, 1}, {{4, 17}, 1}, 
  {{4, 18}, 1}, {{4, 14}, 3}, {4, 15}, {{4, 16}, 2}, {4, 18}};

KeyValueMap[List] @ GroupBy[Cases[list, {_List, _}], First -> Last, Min]

{{{4, 14}, 1}, {{4, 15}, 1}, {{4, 16}, 1}, {{4, 17}, 1}, {{4, 18}, 1}}

answered Apr 18 at 23:37

eldo

83.1k6 gold badges72 silver badges202 bronze badges

Add a comment |

Stack Exchange Network

Filter list with different list in it

9 Answers 9

Your Answer

Not the answer you're looking for? Browse other questions tagged
list-manipulation
functions
function-construction
functional-style
or ask your own question.

Hot Network Questions

Filter list with different list in it

9 Answers 9

Your Answer

Sign up or log in

Post as a guest

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

Related

Hot Network Questions

Not the answer you're looking for? Browse other questions tagged
list-manipulation
functions
function-construction
functional-style
or ask your own question.