We Keep Coding

A linked list as a tuple Python

A connected list is given, which is implemented as a tuple (a number, link to the following pair) of the form in which the values are already sorted:
x = (1, (3, (4, (7, (9, None)
It is necessary to implement a function that reverses the list:
example of a call:
reverse((1, (3, (6, (8, None)))))
Result:
(8, (6, (3, (1, None))))
This is what i've done, i know it's incorrect cause first element would be doubled then
def reverse(linked_list: tuple):
last_pair = (linked_list[0], None)
while linked_list[1]:
new_list = (linked_list[0], last_pair)
return new_list
return reverse(linked_list[1])
This is the result:
(1, (1, None))
I have no idea how to do it in correct way, there is nothing about linked lists as tuples on the internet

The implementation in the question does not evaluate all parts of the argument passed to reverse().
Here's one way to achieve your objective:
def reverse(t):
result = None
while True:
a, b = t
result = a, result
if (t := b) is None:
break
return result
print(reverse((1, (3, (6, (8, None))))))
Output:
(8, (6, (3, (1, None))))

If you supply an additional argument for "reverse" sequence you can also succeed with recursive function:
def reverse(linked_t: tuple, rev_seq=None):
while linked_t[1] is not None:
rev_seq = (linked_t[0], rev_seq)
return reverse(linked_t[1], rev_seq)
else:
return linked_t[0], rev_seq
print(reverse((1, (3, (6, (8, None))))))
(8, (6, (3, (1, None))))

Longest continuous pairs

1st pair's 1st element should be less than the 2nd pairs 1st element : same for 2nd elements individually in a sorted list of pairs.
xlist = [(3, 9), (4, 6), (5, 7), (6, 0)] # sorted by first element of pair
ylist = [(j,i) for i,j in (sorted([(y,x) for x,y in xlist]))] = [(6, 0), (4, 6), (5, 7), (3, 9)] # sorted by second element of pair
What I want is to find the longest pair that is continuous, i.e. (4, 6), (5, 7)
PS. there can be other continuous pairs like that, but is there a way to extract the longest continuous pairs?
(4, 6), (5, 7) is determined as the longest pair based on the fact that the next pair's 1st element(5) is less than current(4). The next pair's 2nd element(7) is less than current(6) (Basically 5 > 4 and 6 > 7). And lets add another element to that list say (8, 10); this is added to the output sequence as well, as 8 > 5 and 10 > 7. So the longest pairs become (4, 6), (5, 7), (8, 10)

If you mean the maximal common subsequence of the two lists, here a code using difflib that do what you want. I don't know exactly the implementation of SequenceMatcher but it seems quite optimized as it avoids for-loop in the whole lists:
from difflib import SequenceMatcher
xlist = [(3, 9), (4, 6), (5, 7), (6, 0), (7, 8)]
ylist = [(6, 0), (4, 6), (5, 7), (7, 8), (3, 9)]
out = SequenceMatcher(None, xlist, ylist).get_matching_blocks()
max_block = max(out, key=lambda x: x.size)
start, end = max_block.a, max_block.a + max_block.size
out = xlist[start:end]
print(out) # [(4, 6), (5, 7)]
If you mean the longest increasing sequence of the second coordinate in xlist (same as previously but allowing "skips" in sequence), you can go with:
xlist = [(3, 9), (4, 6), (5, 7), (6, 0), (7, 8)]
def find_lis_2nd_coord(pairs: List[Tuple]) -> List[Tuple]:
"""Find longest increasing subsequence (LIS).
LIS is determined along 2nd coordinate of input pairs.
"""
# lis[i] stores the longest increasing subsequence of sublist
# `pairs[0…i][1]` that ends with `pairs[i][1]`
lis = [[] for _ in range(len(pairs))]
# lis[0] denotes the longest increasing subsequence ending at `pairs[0][1]`
lis[0].append(pairs[0])
# Start from the second element in the list
for i in range(1, len(pairs)):
# Do for each element in sublist `pairs[0…i-1][1]`
for j in range(i):
# Find the longest increasing subsequence that ends with
# `pairs[j][1]` where it is less than the current element
# `pairs[i][1]`
if pairs[j][1] < pairs[i][1] and len(lis[j]) > len(lis[i]):
lis[i] = lis[j].copy()
# include `pairs[i]` in `lis[i]`
lis[i].append(pairs[i])
return max(lis, key=len)
print(find_lis_2nd_coord(xlist)) # [(4, 6), (5, 7), (7, 8)]
Disclaimer: this version is O(n^2) but I didn't find more optimized idea or implementation. At least it works.

How to sort a list of tuples which contain two integer element firstly by its second, then by its first element descending in Python?

I've been using loops in order to solve my problem but my brain has stopped. I have a input as a list which contains couple of tuples like this:
input_list = [(1, 2), (2, 2), (3, 2), (5, 3), (7, 3), (4, 4)]
I would like to mix this tuples. Here are the steps:
Tuples have to be sorted in ascending by its second element for every time. ((X, 2), (X, 3), (X, 4), (X, 2), (X, 3), (X, 2))
First element of the tuple must be the smallest value. ((1, 2), (5, 3), (4, 4), (2, 2), (7, 3), (3, 2))
Here is the output I would like to achieve:
output_list = [(1, 2), (5, 3), (4, 4), (2, 2), (7, 3), (3, 2)]
Can someone help me to find the algorithm to mix and convert to input list to the output list?

Sort the input by the second, then the first element. For each tuple in the sorted list, iterate a list of "slots" (lists) and add the tuple to the first slot whose last item is less than the tuple. If there's no such slot, create a new slot. Finally, join the slots into one list:
slots = []
for p in sorted(INPUT, key=lambda p: p[::-1]):
for s in slots:
if s[-1][1] < p[1]:
s.append(p)
break
else:
slots.append([p])
result = sum(slots, [])

You could use roundrobin from the itertools recipes. The function group_values sorts the data so that it can be used as an input for roundrobin.
from collections import defaultdict
from itertools import cycle, islice
def roundrobin(*iterables):
"roundrobin('ABC', 'D', 'EF') --> A D E B F C"
# Recipe credited to George Sakkis
num_active = len(iterables)
nexts = cycle(iter(it).__next__ for it in iterables)
while num_active:
try:
for next_ in nexts:
yield next_()
except StopIteration:
# Remove the iterator we just exhausted from the cycle.
num_active -= 1
nexts = cycle(islice(nexts, num_active))
def group_values(data):
result = defaultdict(list)
# sort by the second element first
for entry in sorted(data, key=lambda x: (x[1], x[0])):
result[entry[1]].append(entry)
return result
def main():
input_list = [(1, 2), (2, 2), (3, 2), (5, 3), (7, 3), (4, 4)]
grouped_lists = group_values(input_list)
result = list(roundrobin(*grouped_lists.values()))
print(result)
if __name__ == '__main__':
main()
group_values creates a dictionary that looks like this: {2: [(1, 2), (2, 2), (3, 2)], 3: [(5, 3), (7, 3)], 4: [(4, 4)]}. The function takes advantage of the fact that in modern versions of Python, entries in the dictionaries retain the order in which they were added.
The result is [(1, 2), (5, 3), (4, 4), (2, 2), (7, 3), (3, 2)], even if you shuffle the input list.
You might want to use a debugger or add some print functions in the code if you want to see what's happening.

Sort list of tuples based on unique occurrence from beginning to end

Let's say I have a list of tuples like:
x = [(2, 18), (18, 5), (3, 2)]
How can I sort this list of tuples based on the unique occurrence of the values in the tuples?
For example, since the number 3 only occurs in the tuple (3, 2) and is the first value of the tuple, it should be the first entry in the list. This entry is followed by (2, 18) because the second value (2) of (3, 2) occurs in the first value of (2, 18). And finally, the last entry in the list should be (18, 5), since its first value matches the last value of (2, 18).
Expected result:
[(3, 2), (2, 18), (18, 5)]
Pls tell me if you need more info.

Use a recursive function to pick dominos one by one:
def get_elements_filtered_by_first_values(original_list, first_value):
return [each_element for each_element in original_list if each_element[0] == first_value]
def add_next_domino(list_of_remained_dominos, list_of_picked_dominos):
possible_domino_list_to_pick = get_elements_filtered_by_first_values(list_of_remained_dominos, list_of_picked_dominos[-1][1])
if not len(possible_domino_list_to_pick):
return None
for each_possible_domino_to_pick in possible_domino_list_to_pick:
new_list_of_picked_dominos = list_of_picked_dominos + [each_possible_domino_to_pick]
new_list_of_remained_dominos = list_of_remained_dominos[:]
new_list_of_remained_dominos.remove(each_possible_domino_to_pick)
if not len(new_list_of_remained_dominos):
return new_list_of_picked_dominos
pick_domino_result = add_next_domino(new_list_of_remained_dominos, new_list_of_picked_dominos)
if pick_domino_result is not None:
return pick_domino_result
return None
x = [(2, 18), (18, 5), (3, 2)]
eligible_elements = [each_element for each_element in x if each_element[0] not in map(lambda x: x[1], x)]
while len(eligible_elements):
next_eligible_element = eligible_elements.pop()
return_list = add_next_domino([each_element for each_element in x if each_element != next_eligible_element] ,[next_eligible_element])
if return_list is not None:
print(return_list)
break
The output:
[(3, 2), (2, 18), (18, 5)]

How to remove duplicate from list of tuple when order is important

I have seen some similar answers, but I can't find something specific for this case.
I have a list of tuples:
[(5, 0), (3, 1), (3, 2), (5, 3), (6, 4)]
What I want is to remove tuples from this list only when first element of tuple has occurred previously in the list and the tuple which remains should have the smallest second element.
So the output should look like this:
[(5, 0), (3, 1), (6, 4)]

Here's a linear time approach that requires two iterations over your original list.
t = [(5, 0), (3, 1), (3, 2), (5, 3), (6, 4)] # test case 1
#t = [(5, 3), (3, 1), (3, 2), (5, 0), (6, 4)] # test case 2
smallest = {}
inf = float('inf')
for first, second in t:
if smallest.get(first, inf) > second:
smallest[first] = second
result = []
seen = set()
for first, second in t:
if first not in seen and second == smallest[first]:
seen.add(first)
result.append((first, second))
print(result) # [(5, 0), (3, 1), (6, 4)] for test case 1
# [(3, 1), (5, 0), (6, 4)] for test case 2

Here is a compact version I came up with using OrderedDict and skipping replacement if new value is larger than old.
from collections import OrderedDict
a = [(5, 3), (3, 1), (3, 2), (5, 0), (6, 4)]
d = OrderedDict()
for item in a:
# Get old value in dictionary if exist
old = d.get(item[0])
# Skip if new item is larger than old
if old:
if item[1] > old[1]:
continue
#else:
# del d[item[0]]
# Assign
d[item[0]] = item
list(d.values())
Returns:
[(5, 0), (3, 1), (6, 4)]
Or if you use the else-statement (commented out):
[(3, 1), (5, 0), (6, 4)]

Seems to me that you need to know two things:
The tuple that has the smallest second element for each first element.
The order to index each first element in the new list
We can get #1 by using itertools.groupby and a min function.
import itertools
import operator
lst = [(3, 1), (5, 3), (5, 0), (3, 2), (6, 4)]
# I changed this slightly to make it harder to accidentally succeed.
# correct final order should be [(3, 1), (5, 0), (6, 4)]
tmplst = sorted(lst, key=operator.itemgetter(0))
groups = itertools.groupby(tmplst, operator.itemgetter(0))
# group by first element, in this case this looks like:
# [(3, [(3, 1), (3, 2)]), (5, [(5, 3), (5, 0)]), (6, [(6, 4)])]
# note that groupby only works on sorted lists, so we need to sort this first
min_tuples = {min(v, key=operator.itemgetter(1)) for _, v in groups}
# give the best possible result for each first tuple. In this case:
# {(3, 1), (5, 0), (6, 4)}
# (note that this is a set comprehension for faster lookups later.
Now that we know what our result set looks like, we can re-tackle lst to get them in the right order.
seen = set()
result = []
for el in lst:
if el not in min_tuples: # don't add to result
continue
elif el not in seen: # add to result and mark as seen
result.append(el)
seen.add(el)

This will do what you need:
# I switched (5, 3) and (5, 0) to demonstrate sorting capabilities.
list_a = [(5, 3), (3, 1), (3, 2), (5, 0), (6, 4)]
# Create a list to contain the results
list_b = []
# Create a list to check for duplicates
l = []
# Sort list_a by the second element of each tuple to ensure the smallest numbers
list_a.sort(key=lambda i: i[1])
# Iterate through every tuple in list_a
for i in list_a:
# Check if the 0th element of the tuple is in the duplicates list; if not:
if i[0] not in l:
# Add the tuple the loop is currently on to the results; and
list_b.append(i)
# Add the 0th element of the tuple to the duplicates list
l.append(i[0])
>>> print(list_b)
[(5, 0), (3, 1), (6, 4)]
Hope this helped!

Using enumerate() and list comprehension:
def remove_if_first_index(l):
return [item for index, item in enumerate(l) if item[0] not in [value[0] for value in l[0:index]]]
Using enumerate() and a for loop:
def remove_if_first_index(l):
# The list to store the return value
ret = []
# Get the each index and item from the list passed
for index, item in enumerate(l):
# Get the first number in each tuple up to the index we're currently at
previous_values = [value[0] for value in l[0:index]]
# If the item's first number is not in the list of previously encountered first numbers
if item[0] not in previous_values:
# Append it to the return list
ret.append(item)
return ret
Testing
some_list = [(5, 0), (3, 1), (3, 2), (5, 3), (6, 4)]
print(remove_if_first_index(some_list))
# [(5, 0), (3, 1), (6, 4)]

I had this idea without seeing the #Anton vBR's answer.
import collections
inp = [(5, 0), (3, 1), (3, 2), (5, 3), (6, 4)]
od = collections.OrderedDict()
for i1, i2 in inp:
if i2 <= od.get(i1, i2):
od.pop(i1, None)
od[i1] = i2
outp = list(od.items())
print(outp)