Related
Im trying to flip half of the elements inside of a list and then spend it onto itself, for example,
if I pass the list [1, 8, 7, 2, 9, 18, 12, 0] into it, I should get [1, 0, 7, 18, 9, 2, 12, 8] out, here is my current code
def flip_half(list):
for i in range(0,len(list)):
if i % 2 != 0:
listflip = list[i]
print(listflip)
return list
You can directly assign slices in python. So if you can determine the slice you want to assign from and to, you can directly change the elements. This assign from every other element in reverse l[::-2] to every other element starting with the second: l[1::2] :
l = [1, 8, 7, 2, 9, 18, 12, 0]
l[1::2] = l[::-2]
print(l)
#[1, 0, 7, 18, 9, 2, 12, 8]
If you wanted to do it in a loop:
def flip_half(list):
out = []
for i in range(0,len(list)):
if i % 2 != 0:
out.append(list[-i])
else:
out.append(list[i])
return out
print(flip_half([1, 8, 7, 2, 9, 18, 12, 0]))
If you need that elements with odd indexes has reverse order then one of next solutions (l - is your list):
Slices
l[1::2] = l[1::2][::-1]
List comprehension
l = [l[i] if i % 2 == 0 else l[-(i + len(l)%2)] for i in range(len(l))]
Function
def flip_half(lst):
res= []
for i in range(len(lst)):
if i % 2 != 0:
res.append(lst[-(i + len(lst) % 2)])
else:
res.append(lst[i])
return res
l = flip_half(l)
Generator function
def flip_half(lst):
for i in range(len(lst)):
if i % 2 != 0:
yield lst[-(i + len(lst) % 2)]
else:
yield lst[i]
l = list(flip_half(l))
I am new to python programming. I was trying to write a program to find how many 9s are present in the list.enter image description here
seq = [1, 2, 3, 4, 9, 6, 8, 13, 9, 12, 19]
n = 0
t = []
y = len(seq)
for x in range (0, y-1):
if seq[x] == 9:
n += 1
t.append(x+1)
else: continue
print (n, "numbers of 9s are present at", t, "position" )'
output: 2 numbers of 9s are present at [5, 9] position
How i have write the program to get the output as "2 numbers of 9s are present at 5 and 9 position".
You can use the list comprehension. enumerate return the element (num) of list and the index of element (idx) and if the element (num) is equal to 9 then the positions list will contain the idx as a string. The indexing starts from 1 (not 0) (start=1). You can get the number of 9s with len(positions) and you can join the element with " and ".join(positions).
Code:
seq = [1, 2, 3, 4, 9, 6, 8, 13, 9, 12, 19]
positions = [str(idx) for idx, num in enumerate(seq, start=1) if num == 9]
print("{} numbers of 9s are present at {} positions".format(len(positions), " and ".join(positions)))
Output:
>>> python3 test.py
2 numbers of 9s are present at 5 and 9 positions
I guess it is the most elegant way to solve your issue.
your_list = [4,5,6,7,9,6,7,9]
indexes = []
for i, num in enumerate(your_list, start=1):
if num == 9:
indexes.append(i)
def output_list(str_list):
last_value = str_list[-1]
first_indexes = str_list[:-1]
first_indexes_str = ", ".join(first_indexes)
if len(first_indexes) == 0:
return f'{len(indexes)} numbers of 9s are present at {last_value} position'
return f'{len(indexes)} numbers of 9s are present at {first_indexes_str} and {last_value} position'
print(output_list(indexes))
first empty list of the index list.
loop over the list and get the index by using (enumerate).
if the num is nine append to the indexes list.
after that print by using the f'...' and print how much find and where.
and add the function that parses the data as wanted
Well, first make a for loop in your list, taking each element, then compare this element to 9 to see if it's a 9 or not. compt variable will count "9" encounters.
compt = 0
seq = [1, 2, 3, 4, 9, 6, 8, 13, 9, 12, 19]
for k in seq:
if(k == 9):
compt += 1
print(compt)
If you also want the index / position of nines founds, then do the same, looping on index, and keep an index list :
compt = 0
indexlist = []
seq = [1, 2, 3, 4, 9, 6, 8, 13, 9, 12, 19]
for k in range(0, len(seq)):
if(seq[k] == 9):
compt += 1
indexlist.append(k)
print(str(compt) + " nines founds, in following positions : " + str(indexlist))
You can use locate present in more_itertools module
from more_itertools import locate
arr = [1, 2, 3, 4, 9, 6, 8, 13, 9, 12, 19]
indices = list(locate(arr, lambda a: a==9))
You can add +1 to each element in the indices to get the position
seq = [1, 2, 3, 4, 9, 6, 8, 13, 9, 12, 19]
positions = [i + 1 for i in range(len(seq)) if seq[i] == 9]
print(f"{len(positions)} numbers of 9s are present at {positions} position")
I am new to python and was trying to Append duplicate items at the end of list whithout changing the order
testlist = [1, 2, 32, 8, 1, 17, 5, 2, 42, 13, 56]
def duplicate(alist):
p = len(alist)
duplicate = False
for i in range(0, p):
for j in range (i + 1, p):
if alist[i] == alist[j]:
b = alist.index(alist[j])
a = alist.pop(b)
alist.append(a)
p -= 1
duplicate = True
print alist
if duplicate == False:
print "No duplicate item found"
duplicate(testlist)
OUTPUT : [32, 8, 1, 17, 5, 2, 42, 13, 56, 1, 2]
DESIRED OUTPUT : [1, 2, 32, 8, 17, 5, 42, 13, 56, 1, 2]
Any help what wrong I am doing here
I think that in this case the creation of a new list is more efficient and clear in comparison with the permutations in the original list:
testlist = [1, 2, 32, 8, 1, 17, 5, 2, 42, 13, 56]
def duplicate(alist):
filtered, duplicates = [], []
for element in alist:
if element in filtered:
duplicates.append(element)
continue
filtered.append(element)
if not duplicates:
print "No duplicate item found"
return alist
return filtered + duplicates
new_list = duplicate(testlist)
print new_list
You may use the Collections module to get OrderedDict for maintaining the order of elements.
The technique we use here is to create a dictionary to store the number of occurrences of each element in the array and use the dict to lookup the number of occurrences for later use.
In the for loop we look up if there is already element present in the dict using the get method. If true then we increase the counter else initialize the counter to be zero.
import collections
lst = [1, 2, 32, 8, 1, 17, 5, 2, 42, 13, 56]
# Create a dictionary storing the the number of occurences
occurences_dict = collections.OrderedDict()
for i in lst:
occurences_dict[i] = occurences_dict.get(i, 0) + 1
final = occurences_dict.keys() + [k for k, v in occurences_dict.items() if v>1]
print final
>>> [1, 2, 32, 8, 17, 5, 42, 13, 56, 1, 2]
I solved it this way. I also made some changes to make the code a bit more Pythonic.
test_list = [1, 2, 32, 8, 1, 17, 5, 2, 42, 13, 56]
def duplicate(a_list):
list_length = len(a_list)
duplicate = False
checked = []
for i in range(list_length):
if a_list.count(a_list[i]) > 1:
if a_list[i] not in checked:
duplicate = True
a_list.append(a_list[i])
checked.append(a_list[i])
if duplicate == False:
print("No duplicate item found")
return None
return a_list
print(duplicate(test_list))
Instead of checking values, compare on index.
Please check this code:
testlist = [1, 2, 32, 8, 1, 17, 5, 2, 42, 13, 56,32]
print("Original list - ",testlist)
tmp_list = []
exclude =[]
for i in range(len(testlist)):
if i == testlist.index(testlist[i]):
tmp_list.append(testlist[i])
else:
exclude.append(testlist[i])
tmp_list.extend(exclude)
testlist = tmp_list
print("Updated list - ",testlist)
Output:
C:\Users\dinesh_pundkar\Desktop>python c.py
Original list - [1, 2, 32, 8, 1, 17, 5, 2, 42, 13, 56, 32]
Updated list - [1, 2, 32, 8, 17, 5, 42, 13, 56, 1, 2, 32]
C:\Users\dinesh_pundkar\Desktop>
I have developed a algo which extends the duplicates in such a way that if duplicate contains duplicate we are extends them to end also
eg - input - [1,1,2,2,3,3,4,5,2,5]
output - [1, 2, 3, 4, 5, 2, 3, 2] - (Solution 2)
others ouput - [1, 2, 3, 4, 5, 2, 2, 3] where 2 repeats (Solution 1)
Solution 1 -
def remove_extend(l):
stack = []
duplicates = []
for i in l:
if i not in stack:
stack.append(i)
elif i in stack:
duplicates.append(i)
stack.extend(duplicates)
return stack
l = [1,2,2,2,3,3,4,5]
ans = remove_extend(l)
print(l)
print(ans)
Solution 2
def check_dict(d):
if d == {}:
return False
# stack = []
for k,v in d.items():
if v == 0:
del d[k]
return True
def add_to_stack(stack, d):
for k,v in d.items():
if v>=1:
stack.append(k)
d[k] -= 1
return [stack,d]
def duplicates_extend2(ls):
d = {}
stack = []
for i in ls:
if i in d:
d[i] += 1
else:
d[i] = 1
print(d)
if_dict = check_dict(d)
while if_dict:
ans = add_to_stack(stack, d)
stack = ans[0]
d = ans[1]
if_dict = check_dict(d)
return stack
ls = [1,1,2,2,3,3,4,5,2,5]
ans = duplicates_extend2(ls)
print(ans)
I got a list like these:
List1: [1, 5, 9, 1, 5, 9, 15, 21, 29, 1, 5, 9, 15]
I want a new list, which should content the highest number, before it starts again with 1.
List_new: [9, 29, 15]
I tried this:
List_new = []
for i in range(len(List1)):
j = List1[i]
if j + 1 == '1':
List_new += [j]
else:
continue
print(j)
But I got an empty list back.
Simply with built-in only libs:
from itertools import groupby
result = [max(group) for r, group in groupby(your_list, lambda x: x == 1) if not r]
def max_of_sublists(megalist):
maxitem = 0
for item in megalist:
if item == 1 and maxitem:
yield maxitem
maxitem = 0
if maxitem < item:
maxitem = item
yield maxitem
biglist=[1, 5, 9, 1, 5, 9, 15, 21, 29, 1, 5, 9, 15]
print([x for x in max_of_sublists(biglist)])
Your code has a few issues. Here's a version that works.
list1 = [1, 5, 9, 1, 5, 9, 15, 21, 29, 1, 5, 9, 15]
list2 = []
for i in range(len(list1)-1):
if list1[i+1] == 1:
list2.append(list1[i])
list2.append(list1[-1]) # adds the last element
This outputs:
>>> list2
[9, 29, 15]
Here is a simple for loop that will answer your question:
List_new = [List1[0]] # initialize with first element
for i in List1[1:]: # simply iterate over list elements, not indices
if i != 1 and i > List_new[-1]:
List_new[-1] = i # current element is the new maximum
elif i == 1:
List_new.append(i) # encountered a 1, start looking for new maximum
See inline comments for explanations.
This problem can be implemented in a one liner using python modules as in the very elegant solution suggested by Andrey. However, if you would like to follow on the logic, check out this solution.
def max_values_between_ones(numbers):
max_values = []
max_value = None
for i in range(len(numbers)):
if numbers[i] == 1:
if max_value != None:
max_values.append(max_value)
max_value = None
# max_value is None when they were no values != 1 before this 1
else:
if max_value != None:
# this part was missing in your code, to get the max value
# you should be comparing the current value with the max value so far
max_value = max(numbers[i], max_value)
else:
# set max_value to any not 1 value
max_value = numbers[i]
# if the list didn't end with 1, add the last max_value
if max_value != None:
max_values.append(max_value)
return max_values
numbers = [1, 5, 9, 1, 5, 9, 15, 21, 29, 1, 5, 9, 15]
max_values = max_values_between_ones(numbers)
print(max_values)
>> [9, 29, 15]
Like this:
l = [1, 5, 9, 1, 5, 9, 15, 21, 29, 1, 5, 9, 15]
pos = [item for item in range(0, len(l)) if l[item] == 1]
new_list = []
for n in range(len(pos)):
if n != len(pos) - 1:
new_list.append(l[pos[n]:pos[n+1]])
else:
new_list.append(l[pos[n]:])
print map(lambda x: max(x), new_list)
List1 = [1, 5, 9, 1, 5, 9, 15, 21, 29, 1, 5, 9, 15]
maxi = 0
List2 = []
for i in range(0,len(List1)):
if maxi < List1[i]:
maxi = List1[i]
if (i == len(List1)-1 or List1[i] == 1) and maxi > 1:
List2.append(maxi)
maxi = 0
print List2
I'm trying to run selection sort in python, this is the code that I'm using
def main(list):
input_array = [12, 9, 13, 7, 3, 19, 6, 5]
output_array = selection_sort(input_array)
print(output_array)
def selection_sort(param):
for i in range(0, (len(param) - 1)):
min = i
for j in range(i + 1, len(param)):
if param[min] < param[j]:
min = j
if min != i:
temp = param[i]
param[i] = param[min]
param[min] = temp
return param
The output that I get is
Process finished with exit code 0
I'm using PyCharm as the idea, if that's of any consequence.
input_array should be a list, you are making it a set
input_array = [12, 9, 13, 7, 3, 19, 6, 5]
don't use the variable name list, it is the name for the built-in list
don't use min as a variable name, it is the name for the built-in function min
you don't need an argument for your main method here
you are not calling your main method, call it after the definition of selection_sort
change the line
minimum, i, j, temp = 0
to
minimum, i, j, temp = 0, 0, 0, 0
This will sort in ascending order:
def selection_sort(my_list):
for j in range(len(my_list)):
for i in range(j, len(my_list)):
if my_list[i] < my_list[j]:
my_list[j], my_list[i] = my_list[i], my_list[j]
return my_list
def main():
input_array = [12, 9, 13, 7, 3, 19, 6, 5]
output_array = selection_sort(input_array)
print(output_array)
[3, 5, 6, 7, 9, 12, 13, 19]