AppleScript: Compare references in a list - list

How do I make this output true and not false:
{item 1 of {4}, item 1 of {5}} = {4, 5}
I know you can do this...
{4, 5} = {4, 5}
...but I need to do something more complex.
Is that possible?


It probably has to do with the binding of the = operator, e.g. it gets evaluated before the lhs and rhs expressions are evaluated.
For example, this is true:
set x to {item 1 of {4}, item 1 of {5}}
x = {4, 5}


nmok i got it
set c to {item 1 of {4}, item 1 of {5}}
c is equal to {4, 5}

Related

How to consolidate a list of coordinates into subgroup if they are close to each within 2 or less unit distance in x direction?

I have a list(a) of coordinates as follow.
list a = {{1 2} {5 6} {1 5} {5 8} {1 8}}
I would like the result to be broken into two lists, b and c. How do I do it in tcl?
list b = {{1 2} {1 5} {1 8}}
list c = {{5 6} {5 8}}

One way, which returns a list of lists you can break up into individual variables or do whatever else is needed:
#!/usr/bin/env tclsh
# Return a list of lists of coords. Each sublist is of coordinates with
# an x value $distance or less units away from each other.
# Each coordinate will only appear once in the result.
proc partition {coords {distance 2}} {
set groups {}
foreach coord $coords {
set found false
for {set n 0} {$n < [llength $groups]} {incr n} {
if {abs([lindex $groups $n 0 0] - [lindex $coord 0]) <= $distance} {
lset groups $n [linsert [lindex $groups $n] end $coord]
set found true
break
}
}
if {!$found} {
lappend groups [list $coord]
}
}
return $groups
}
set coords {{1 2} {5 6} {1 5} {5 8} {1 8}}
foreach group [partition $coords] {
puts $group
}
when run outputs
{1 2} {1 5} {1 8}
{5 6} {5 8}
Basically, for each element of the input list, see if its first number is <= 2 of an existing element of the output list of lists, and if so, add it to that sublist. If there are no matches, append a new sublist to the result.

Elixir: How to find ALL occurrences of a value from a list of tuples?

Find all occurrences of {1, _}; in other words, all first element values that are 1 from each tuple in the list.
Consider the following input:
[
{1, 0},
{2, 2},
{1, 1},
{11, 1},
{1, 3},
{1, 2},
{13, 1}
]
Expected Output:
[{1,0}, {1,1}, {1,3}, {1,2}]
I tried Enum.find(tl(input), fn x -> elem(x, 0) == elem(hd(input), 0) end), but I realized that Enum.find/2 only returns the first and only one element that matches the criteria or function, which is: {1,1}.
My goal is to find all tuples that contain {1, _}, where the first element must be 1 and the second element can be any value.

Here you can use a comprehension with pattern-matching:
result = for x = {1, _} <- list, do: x
Any x that doesn't match the pattern {1, _} will be filtered out.
See the documentation for for/1 for more information.
You could also use Enum.filter/2 together with the match?/2 macro to achieve the same result:
result = Enum.filter(list, fn x -> match?({1, _}, x) end)
Enum.find/2 is useful when you are looking for a single element, e.g. if you want to find the first entry matching your condition.

Removing elements that have consecutive dupes in Elixir list

I have a list of numbers in Elixir, and I want to remove the duplicates, but only for the consecutive dupes.
For the following input list: [1,1,2,2,1,1,1,1,3,3,2,2].
The result should be: [1,2,1,3,2].

Enum.dedup/1 does exactly what you want: it replaces consecutive duplicate elements with only one instance of it and returns the remaining elements in a list.
iex(1)> Enum.dedup([1, 1, 2, 2, 1, 1, 1, 1, 3, 3, 2, 2])
[1, 2, 1, 3, 2]
This works on all values that compare equal with ===, including maps:
iex(2)> Enum.dedup([%{a: 1}, %{a: 2}, %{a: 2}, %{a: 2}])
[%{a: 1}, %{a: 2}]

Check List for an Abstract Quality in Mathematica

I'm working with a list in Mathematica generated by the FactorList function that looks like
t = {{-1, 1}, {q, 1}, {P[41, 42], 1}, {P[41, 43], 1}, {P[42, 43], 1}}
I would like to search through this list, identify which elements in position [i][1] (where i is the position of the ith set in t) are of the form P[a,b] where a,b are integers.
Is there a way to test if an element conforms to the general form P[integer, integer] so that running this test on the value q, element t[[2][1]], would return False and running it on P[41,43] would return True?

For example:
Select[t, Head[#[[1]]] == P &]
returns
(* {{P[41, 42], 1}, {P[41, 43], 1}, {P[42, 43], 1}} *)
Or:
Cases[t, {P[_Integer, _Integer], _}]
returns the same

Show duplicates in Mathematica

In Mathematica I have a list:
x = {1,2,3,3,4,5,5,6}
How will I make a list with the duplicates? Like:
{3,5}
I have been looking at Lists as Sets, if there is something like Except[] for lists, so I could do:
unique = Union[x]
duplicates = MyExcept[x,unique]
(Of course, if the x would have more than two duplicates - say, {1,2,2,2,3,4,4}, there the output would be {2,2,4}, but additional Union[] would solve this.)
But there wasn't anything like that (if I did understand all the functions there well).
So, how to do that?

Lots of ways to do list extraction like this; here's the first thing that came to my mind:
Part[Select[Tally#x, Part[#, 2] > 1 &], All, 1]
Or, more readably in pieces:
Tally#x
Select[%, Part[#, 2] > 1 &]
Part[%, All, 1]
which gives, respectively,
{{1, 1}, {2, 1}, {3, 2}, {4, 1}, {5, 2}, {6, 1}}
{{3, 2}, {5, 2}}
{3, 5}
Perhaps you can think of a more efficient (in time or code space) way :)
By the way, if the list is unsorted then you need run Sort on it first before this will work.

Here's a way to do it in a single pass through the list:
collectDups[l_] := Block[{i}, i[n_]:= (i[n] = n; Unevaluated#Sequence[]); i /# l]
For example:
collectDups[{1, 1, 6, 1, 3, 4, 4, 5, 4, 4, 2, 2}] --> {1, 1, 4, 4, 4, 2}
If you want the list of unique duplicates -- {1, 4, 2} -- then wrap the above in DeleteDuplicates, which is another single pass through the list (Union is less efficient as it also sorts the result).
collectDups[l_] :=
DeleteDuplicates#Block[{i}, i[n_]:= (i[n] = n; Unevaluated#Sequence[]); i /# l]
Will Robertson's solution is probably better just because it's more straightforward, but I think if you wanted to eek out more speed, this should win. But if you cared about that, you wouldn't be programming in Mathematica! :)

Here are several faster variations of the Tally method.
f4 uses "tricks" given by Carl Woll and Oliver Ruebenkoenig on MathGroup.
f2 = Tally## /. {{_, 1} :> Sequence[], {a_, _} :> a} &;
f3 = Pick[#, Unitize[#2 - 1], 1] & ## Transpose#Tally## &;
f4 = # ~Extract~ SparseArray[Unitize[#2 - 1]]["NonzeroPositions"] & ## Transpose#Tally## &;
Speed comparison (f1 included for reference)
a = RandomInteger[100000, 25000];
f1 = Part[Select[Tally##, Part[#, 2] > 1 &], All, 1] &;
First#Timing#Do[##a, {50}] & /# {f1, f2, f3, f4, Tally}
SameQ ## (##a &) /# {f1, f2, f3, f4}
Out[]= {3.188, 1.296, 0.719, 0.375, 0.36}
Out[]= True
It is amazing to me that f4 has almost no overhead relative to a pure Tally!

Using a solution like dreeves, but only returning a single instance of each duplicated element, is a bit on the tricky side. One way of doing it is as follows:
collectDups1[l_] :=
Module[{i, j},
i[n_] := (i[n] := j[n]; Unevaluated#Sequence[]);
j[n_] := (j[n] = Unevaluated#Sequence[]; n);
i /# l];
This doesn't precisely match the output produced by Will Robertson's (IMO superior) solution, because elements will appear in the returned list in the order that it can be determined that they're duplicates. I'm not sure if it really can be done in a single pass, all the ways I can think of involve, in effect, at least two passes, although one might only be over the duplicated elements.

Here is a version of Robertson's answer that uses 100% "postfix notation" for function calls.
identifyDuplicates[list_List, test_:SameQ] :=
list //
Tally[#, test] & //
Select[#, #[[2]] > 1 &] & //
Map[#[[1]] &, #] &
Mathematica's // is similar to the dot for method calls in other languages. For instance, if this were written in C# / LINQ style, it would resemble
list.Tally(test).Where(x => x[2] > 1).Select(x => x[1])
Note that C#'s Where is like MMA's Select, and C#'s Select is like MMA's Map.
EDIT: added optional test function argument, defaulting to SameQ.
EDIT: here is a version that addresses my comment below & reports all the equivalents in a group given a projector function that produces a value such that elements of the list are considered equivalent if the value is equal. This essentially finds equivalence classes longer than a given size:
reportDuplicateClusters[list_List, projector_: (# &),
minimumClusterSize_: 2] :=
GatherBy[list, projector] //
Select[#, Length## >= minimumClusterSize &] &
Here is a sample that checks pairs of integers on their first elements, considering two pairs equivalent if their first elements are equal
reportDuplicateClusters[RandomInteger[10, {10, 2}], #[[1]] &]

This thread seems old, but I've had to solve this myself.
This is kind of crude, but does this do it?
Union[Select[Table[If[tt[[n]] == tt[[n + 1]], tt[[n]], ""], {n, Length[tt] - 1}], IntegerQ]]

Given a list A,
get the non-duplicate values in B
B = DeleteDuplicates[A]
get the duplicate values in C
C = Complement[A,B]
get the non-duplicate values from the duplicate list in D
D = DeleteDuplicates[C]
So for your example:
A = 1, 2, 2, 2, 3, 4, 4
B = 1, 2, 3, 4
C = 2, 2, 4
D = 2, 4
so your answer would be DeleteDuplicates[Complement[x,DeleteDuplicates[x]]] where x is your list. I don't know mathematica, so the syntax may or may not be perfect here. Just going by the docs on the page you linked to.

Another short possibility is
Last /# Select[Gather[x], Length[#] > 1 &]