Develop Reference

Insertion Sort not working for single digit entries if #entries> 9

I am trying to implement insertion sort using python. Below is my code:
import numpy as np
N=int(input())
A=input().split()
#A=[int(x) for x in input().split()]
B_sorted=A.copy()
C= A.copy()
def inssort(arr):
for i in range(1, len(arr)):
key = arr[i]
j = i-1
while (j >=0 and key < arr[j]):
arr[j+1] = arr[j]
j -= 1
arr[j+1] = key
inssort(B_sorted)
for i in range(0,len(A)):
for j in range(0,len(A)):
if A[i]==B_sorted[j]:
C[i]=j+1
break
j=j+1
i=i+1
for x in B_sorted:
print (x, "",end="")
My code works for the following set of entries:
[9,8,7,...,2,1]
[20,19,...,12,11]
[20,19,...,11,10]
but it doesn't work for following
[10,9,8,...,2,1]
I don't understand what exactly is the issue here.
I tried to go to the detail by printing the output at every loop:
10 9 8 7 6 5 4 3 2 1
['10', '9', '8', '7', '6', '5', '4', '3', '2', '1']
['10', '8', '9', '7', '6', '5', '4', '3', '2', '1']
['10', '7', '8', '9', '6', '5', '4', '3', '2', '1']
['10', '6', '7', '8', '9', '5', '4', '3', '2', '1']
['10', '5', '6', '7', '8', '9', '4', '3', '2', '1']
['10', '4', '5', '6', '7', '8', '9', '3', '2', '1']
['10', '3', '4', '5', '6', '7', '8', '9', '2', '1']
['10', '2', '3', '4', '5', '6', '7', '8', '9', '1']
['1', '10', '2', '3', '4', '5', '6', '7', '8', '9']
Looks like for some reason at the first iteration j is not taking the value 0 for this particular sequence. As I mentioned before, it works perfectly for a lot of other sequences.
Kindly help.

Python - Cryptographic Feistel function (AUT64) - Math/programming trouble in implementation

Don't know how to add math symbols, hence the image paste:
Based on this:
https://tches.iacr.org/index.php/TCHES/article/view/874/826 (page 52)
I managed, I think to implement compression function (1)
However, don't understand what 2,3 and 4 mean.
Can somebody with math/programming knowledge explain it? Ideally, how to implement it in Python.
Here is my code snippet:
aut64.py
import ctypes
def hexTobinary(hexdigits):
binarydigits = ""
for hexdigit in hexdigits:
binarydigits += bin(int(hexdigit, 16))[2:].zfill(4)
return binarydigits
t_offset = [['0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '0'],
['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'],
['0', '2', '4', '6', '8', 'A', 'C', 'E', '3', '1', '7', '5', 'B', '9', 'F', 'D'],
['0', '3', '6', '5', 'C', 'F', 'A', '9', 'B', '8', 'D', 'E', '7', '4', '1', '2'],
['0', '4', '8', 'C', '3', '7', 'B', 'F', '6', '2', 'E', 'A', '5', '1', 'D', '9'],
['0', '5', 'A', 'F', '7', '2', 'D', '8', 'E', 'B', '4', '1', '9', 'C', '3', '6'],
['0', '6', 'C', 'A', 'B', 'D', '7', '1', '5', '3', '9', 'F', 'E', '8', '2', '4'],
['0', '7', 'E', '9', 'F', '8', '1', '6', 'D', 'A', '3', '4', '2', '5', 'C', 'B'],
['0', '8', '3', 'B', '6', 'E', '5', 'D', 'C', '4', 'F', '7', 'A', '2', '9', '1'],
['0', '9', '1', '8', '2', 'B', '3', 'A', '4', 'D', '5', 'C', '6', 'F', '7', 'E'],
['0', 'A', '7', 'D', 'E', '4', '9', '3', 'F', '5', '8', '2', '1', 'B', '6', 'C'],
['0', 'B', '5', 'E', 'A', '1', 'F', '4', '7', 'C', '2', '9', 'D', '6', '8', '3'],
['0', 'C', 'B', '7', '5', '9', 'E', '2', 'A', '6', '1', 'D', 'F', '3', '4', '8'],
['0', 'D', '9', '4', '1', 'C', '8', '5', '2', 'F', 'B', '6', '3', 'E', 'A', '7'],
['0', 'E', 'F', '1', 'D', '3', '2', 'C', '9', '7', '6', '8', '4', 'A', 'B', '5'],
['0', 'F', 'D', '2', '9', '6', '4', 'B', '1', 'E', 'C', '3', '8', '7', '5', 'A']]
tu = ['1', '0', '3', '2', '5', '4', '7', '6',
'0', '1', '2', '3', '4', '5', '6', '7',
'3', '2', '1', '0', '7', '6', '5', '4',
'2', '3', '0', '1', '6', '7', '4', '5',
'5', '4', '7', '6', '1', '0', '3', '2',
'4', '5', '6', '7', '0', '1', '2', '3',
'7', '6', '5', '4', '3', '2', '1', '0',
'6', '7', '4', '5', '2', '3', '0', '1',
'3', '2', '1', '0', '7', '6', '5', '4',
'2', '3', '0', '1', '6', '7', '4', '5',
'1', '0', '3', '2', '5', '4', '7', '6',
'0', '1', '2', '3', '4', '5', '6', '7',
'7', '6', '5', '4', '3', '2', '1', '0',
'6', '7', '4', '5', '2', '3', '0', '1',
'5', '4', '7', '6', '1', '0', '3', '2',
'4', '5', '6', '7', '0', '1', '2', '3',
'2', '3', '0', '1', '6', '7', '4', '5',
'3', '2', '1', '0', '7', '6', '5', '4',
'0', '1', '2', '3', '4', '5', '6', '7',
'1', '0', '3', '2', '5', '4', '7', '6',
'6', '7', '4', '5', '2', '3', '0', '1',
'7', '6', '5', '4', '3', '2', '1', '0',
'4', '5', '6', '7', '0', '1', '2', '3',
'5', '4', '7', '6', '1', '0', '3', '2']
tl = ['4', '5', '6', '7', '0', '1', '2', '3',
'5', '4', '7', '6', '1', '0', '3', '2',
'6', '7', '4', '5', '2', '3', '0', '1',
'7', '6', '5', '4', '3', '2', '1', '0',
'0', '1', '2', '3', '4', '5', '6', '7',
'1', '0', '3', '2', '5', '4', '7', '6',
'2', '3', '0', '1', '6', '7', '4', '5',
'3', '2', '1', '0', '7', '6', '5', '4',
'5', '4', '7', '6', '1', '0', '3', '2',
'4', '5', '6', '7', '0', '1', '2', '3',
'7', '6', '5', '4', '3', '2', '1', '0',
'6', '7', '4', '5', '2', '3', '0', '1',
'1', '0', '3', '2', '5', '4', '7', '6',
'0', '1', '2', '3', '4', '5', '6', '7',
'3', '2', '1', '0', '7', '6', '5', '4',
'2', '3', '0', '1', '6', '7', '4', '5',
'6', '7', '4', '5', '2', '3', '0', '1',
'7', '6', '5', '4', '3', '2', '1', '0',
'4', '5', '6', '7', '0', '1', '2', '3',
'5', '4', '7', '6', '1', '0', '3', '2',
'2', '3', '0', '1', '6', '7', '4', '5',
'3', '2', '1', '0', '7', '6', '5', '4',
'0', '1', '2', '3', '4', '5', '6', '7',
'1', '0', '3', '2', '5', '4', '7', '6']
w = 0xFFFFFF00
val = ctypes.c_uint32(~w).value
kg = [val]
kq = ['1', '2', '3', '0', '0', '0', '0', '0']
kt = ['1', '2', '3', '0', '0', '0', '0', '0',
'0', '0', '0', '0', '0', '0', '0', '0']
AUT64_key = []
AUT64_key.extend(kg)
AUT64_key.extend(kq)
AUT64_key.extend(kt)
def apply_permutation_r(P_TABLE, PLAINTEXT):
permutated_M = ""
for index in P_TABLE:
permutated_M += PLAINTEXT[int(index) - 1]
return permutated_M
def apply_compression_g(o1, r_no, lk, uk):
ln = int(o1[0:4], 2)
un = int(o1[4:8], 2)
gl = int(t_offset[int(lk)][int(ln)], 16)
gu = int(t_offset[int(uk)][int(un)], 16)
g = gl >> 4 | gu
return g
def uk_round_key(i, r_no):
uk = int(tu[(r_no * 8) + i])
return uk
def lk_round_key(i, r_no):
lk = int(tl[(r_no * 8) + i])
return lk
def apply_fiestel_f(o1, r_no, i):
uk = uk_round_key(i, r_no)
lk = lk_round_key(i, r_no)
o2 = apply_compression_g(o1, r_no, lk, uk)
# o3 = apply_substitution_s(o2)
# o4 = apply_permutation_bitwise(o3)
# o5 = apply_permutation_substitution_s(o4)
# return o5
return o2
M = '01234567'
plaintext = hexTobinary(M)
enc = []
for r_no in range(8):
o1 = apply_permutation_r(kq, plaintext)
for i in range(8):
enc.append(apply_fiestel_f(o1, r_no, i))
print enc
Any help is greatly appreciate. I am a beginner, this above could be all wrong :)
Thanks in advance!

Transformation of a group of real values to a list

I am collecting measurements from an equipment in .csv format. Each cell has a group of values separated by comma. Example is given below,
cell = 0.0871666666666667,0.0866,0.0862,0.083,0.0834,0.0812857142857143,0.08075,0.0782,0.0751,0.0748181818181818,0.0737142857142857,0.072,0.07,0.07,0.0680833333333333,0.068,0.0654615384615385,0.0641818181818182,0.0616428571428571,0.0615714285714286,0.0599411764705882,0.0587857142857143,0.0573478260869565,0.0554285714285714,0.0545652173913044,0.0523225806451613,0.0511818181818182,0.0492553191489362,0.0480322580645161,
Above cell is on object format.
I want to convert this to a list of float values as
desired_output = [0.0871666666666667,0.0866,0.0862,0.083,0.0834,0.0812857142857143,0.08075,0.0782,0.0751,0.0748181818181818,0.0737142857142857,0.072,0.07,0.07,0.0680833333333333,0.068,0.0654615384615385,0.0641818181818182,0.0616428571428571,0.0615714285714286,0.0599411764705882,0.0587857142857143,0.0573478260869565,0.0554285714285714,0.0545652173913044,0.0523225806451613,0.0511818181818182,0.0492553191489362,0.0480322580645161]
I did the following conversion. But it did not do as I wanted above. My code is given below.
actual_output = list(cell)
print(actual_output)
actual_output = ['0', '.', '0', '9', '3', ',', '0', '.', '0', '9', '1', '4', '2', '8', '5', '7', '1', '4', '2', '8', '5', '7', '1', '4', ',', '0', '.', '0', '9', '0', '6', '6', '6', '6', '6', '6', '6', '6', '6', '6', '6', '6', '7', ',', '0', '.', '0', '8', '7', '1', '6', '6', '6', '6', '6', '6', '6', '6', '6', '6', '6', '7', ',', '0', '.', '0', '8', '6', '6', ',', '0', '.', '0', '8', '6', '2', ',', '0', '.', '0', '8', '3', ',', '0', '.', '0', '8', '3', '4', ',', '0', '.', '0', '8', '1', '2', '8', '5', '7', '1', '4', '2', '8', '5', '7', '1', '4', '3', ',', '0', '.', '0', '8', '0', '7', '5', ',', '0', '.', '0', '7', '8', '2', ',', '0', '.', '0', '7', '5', '1', ',', '0', '.', '0', '7', '4', '8', '1', '8', '1', '8', '1', '8', '1', '8', '1', '8', '1', '8', ',', '0', '.', '0', '7', '3', '7', '1', '4', '2', '8', '5', '7', '1', '4', '2', '8', '5', '7', ',', '0', '.', '0', '7', '2', ',', '0', '.', '0', '7', ',', '0', '.', '0', '7', ',', '0', '.', '0', '6', '8', '0', '8', '3', '3', '3', '3', '3', '3', '3', '3', '3', '3', '3', ',', '0', '.', '0', '6', '8', ',', '0', '.', '0', '6', '5', '4', '6', '1', '5', '3', '8', '4', '6', '1', '5', '3', '8', '5', ',', '0', '.', '0', '6', '4', '1', '8', '1', '8', '1', '8', '1', '8', '1', '8', '1', '8', '2', ',', '0', '.', '0', '6', '1', '6', '4', '2', '8', '5', '7', '1', '4', '2', '8', '5', '7', '1', ',', '0', '.', '0', '6', '1', '5', '7', '1', '4', '2', '8', '5', '7', '1', '4', '2', '8', '6', ',', '0', '.', '0', '5', '9', '9', '4', '1', '1', '7', '6', '4', '7', '0', '5', '8', '8', '2', ',', '0', '.', '0', '5', '8', '7', '8', '5', '7', '1', '4', '2', '8', '5', '7', '1', '4', '3', ',', '0', '.', '0', '5', '7', '3', '4', '7', '8', '2', '6', '0', '8', '6', '9', '5', '6', '5', ',', '0', '.', '0', '5', '5', '4', '2', '8', '5', '7', '1', '4', '2', '8', '5', '7', '1', '4', ',', '0', '.', '0', '5', '4', '5', '6', '5', '2', '1', '7', '3', '9', '1', '3', '0', '4', '4', ',', '0', '.', '0', '5', '2', '3', '2', '2', '5', '8', '0', '6', '4', '5', '1', '6', '1', '3', ',', '0', '.', '0', '5', '1', '1', '8', '1', '8', '1', '8', '1', '8', '1', '8', '1', '8', '2', ',', '0', '.', '0', '4', '9', '2', '5', '5', '3', '1', '9', '1', '4', '8', '9', '3', '6', '2', ',', '0', '.', '0', '4', '8', '0', '3', '2', '2', '5', '8', '0', '6', '4', '5', '1', '6', '1', ',']
Any suggestions please.
One of suggested approach:
x = 2.809,2.812,2.813,2.808,2.804
print(x)
str_list = x.split(',')
print(str_list)
flt_lst = [float(a) for a in str_list]
print(flt_lst)
Output is:
x = 2.809,2.812,2.813,2.808,2.804
str_list = ['2.809', '2.812', '2.813', '2.808', '2.804']
string could not be converted to float

Your variable cell is a string so your list call is making it an iterable. Try
str_lst = cell.split(',')
float_lst = [float(x) for x in str_lst]

how to sort python list in a way that if 1 should come before and 10 and 2 before 20

['2', '8', '2', '3', '6', '4', '1', '1', '10', '6', '3', '3', '6', '1', '3', '8', '4', '6', '1', '10', '8', '4', '10', '4', '1', '3', '2', '3', '2', '6', '1', '5', '2', '9', '8', '5', '10', '8', '7', '9', '6', '4', '2', '6', '3', '8', '8', '9', '8', '2', '9', '10', '3', '10', '7', '5', '7', '1', '7', '5', '1', '4', '7', '6', '1', '10', '5', '4', '8', '4', '2', '7', '8', '1', '1', '7', '4', '1', '1', '9', '8', '6', '5', '9', '9', '3', '7', '6', '3', '10', '8', '10', '7', '2', '5', '1', '1', '9', '9', '5']
after using lambda function inf following way:
a.sort(key=lambda a: int(a.split()[0]))
a = a[::-1]
I got
['10', '10', '10', '10', '10', '10', '10', '10', '10', '9', '9', '9', '9', '9', '9', '9', '9', '9', '8', '8', '8', '8', '8', '8', '8', '8', '8', '8', '8', '8', '7', '7', '7', '7', '7', '7', '7', '7', '7', '6', '6', '6', '6', '6', '6', '6', '6', '6', '6', '5', '5', '5', '5', '5', '5', '5', '5', '4', '4', '4', '4', '4', '4', '4', '4', '4', '3', '3', '3', '3', '3', '3', '3', '3', '3', '3', '2', '2', '2', '2', '2', '2', '2', '2', '2', '1', '1', '1', '1', '1', '1', '1', '1', '1', '1', '1', '1', '1', '1', '1']
But i want
10 in end after 1 , likewise if put 20 and 2 in list than 2 should come before 20 and 20 before 10 etc

The operation:
a.sort()
with no other options sets a to:
['1', '1', '1', '1', '1', '1', '1', '1', '1', '1', '1', '1', '1', '1', '1', '10', '10', '10', '10', '10', '10', '10', '10', '10', '2', '2', '2', '2', '2', '2', '2', '2', '2', '3', '3', '3', '3', '3', '3', '3', '3', '3', '3', '4', '4', '4', '4', '4', '4', '4', '4', '4', '5', '5', '5', '5', '5', '5', '5', '5', '6', '6', '6', '6', '6', '6', '6', '6', '6', '6', '7', '7', '7', '7', '7', '7', '7', '7', '7', '8', '8', '8', '8', '8', '8', '8', '8', '8', '8', '8', '8', '9', '9', '9', '9', '9', '9', '9', '9', '9']

You want an ordered list of strings. Those strings are representations of numbers. Now you want a grouped sorting. First everything that starts with a '9', then '8' and down to '1'. In each of those groups the values should be sorted in numeric order.
An example list:
a = ['11', '105', '2', '8', '2', '3', '6', '4', '1', '1', '10', '81', '3', '3', '5', '10', '8', '7', '9', '6', '4', '2']
Now let's do a grouped sorting with a.sort(key=lambda v: v[0]):
['11', '105', '1', '1', '10', '10', '2', '2', '2', '3', '3', '3', '4', '4', '5', '6', '6', '7', '8', '81', '8', '9']
We see, that the values are grouped now, but we want the values starting with '9' first. We're going to fix this by reversing the result with a.sort(key=lambda v: v[0], reversed=True)
['9', '8', '81', '8', '7', '6', '6', '5', '4', '4', '3', '3', '3', '2', '2', '2', '11', '105', '1', '1', '10', '10']
The groups are correct, now we have to sort the values in the groups. So after the sorting according to the first character we have to sort the value by number. That's easy, we just have to create a tuple for the key: a.sort(key=lambda v: (v[0], int(v)), reverse=True)
['9', '81', '8', '8', '7', '6', '6', '5', '4', '4', '3', '3', '3', '2', '2', '2', '105', '11', '10', '10', '1', '1']
OK, the values are sorted now, but we have to reverse them in the groups. The easiest way to do that ist to take the negative number: a.sort(key=lambda v: (v[0], -int(v)), reverse=True).
['9', '8', '8', '81', '7', '6', '6', '5', '4', '4', '3', '3', '3', '2', '2', '2', '1', '1', '10', '10', '11', '105']

you can use the following sample using key=str
integers = ['2', '8', '2', '3', '6', '4', '1', '1', '10', '6', '3', '3', '6', '1', '3', '8', '4', '6', '1', '10', '8', '4', '10', '4', '1', '3', '2', '3', '2', '6', '1', '5', '2', '9', '8', '5', '10', '8', '7', '9', '6', '4', '2', '6', '3', '8', '8', '9', '8', '2', '9', '10', '3', '10', '7', '5', '7', '1', '7', '5', '1', '4', '7', '6', '1', '10', '5', '4', '8', '4', '2', '7', '8', '1', '1', '7', '4', '1', '1', '9', '8', '6', '5', '9', '9', '3', '7', '6', '3', '10', '8', '10', '7', '2', '5', '1', '1', '9', '9', '5']
print(sorted(integers, key=str))

you don't need to use lambda method here. Instead of using lambda you can use '.sort()' method to sort the items in the list. like this one:
li=['2', '8', '2', '3', '6', '4', '1', '1', '10', '6', '3', '3', '6', '1', '3', '8', '4', '6', '1', '10', '8', '4', '10', '4', '1', '3', '2', '3', '2', '6', '1', '5', '2', '9', '8', '5', '10', '8', '7', '9', '6', '4', '2', '6', '3', '8', '8', '9', '8', '2', '9', '10', '3', '10', '7', '5', '7', '1', '7', '5', '1', '4', '7', '6', '1', '10', '5', '4', '8', '4', '2', '7', '8', '1', '1', '7', '4', '1', '1', '9', '8', '6', '5', '9', '9', '3', '7', '6', '3', '10', '8', '10', '7', '2', '5', '1', '1', '9', '9', '5','20']
li.sort()
print(li)
output:
['1', '1', '1', '1', '1', '1', '1', '1', '1', '1', '1', '1', '1', '1', '1', '10', '10', '10', '10', '10', '10', '10', '10', '10', '2', '2', '2', '2', '2', '2', '2', '2', '2', '20', '3', '3', '3', '3', '3', '3', '3', '3', '3', '3', '4', '4', '4', '4', '4', '4', '4', '4', '4', '5', '5', '5', '5', '5', '5', '5', '5', '6', '6', '6', '6', '6', '6', '6', '6', '6', '6', '7', '7', '7', '7', '7', '7', '7', '7', '7', '8', '8', '8', '8', '8', '8', '8', '8', '8', '8', '8', '8', '9', '9', '9', '9', '9', '9', '9', '9', '9']
I hope you get your answere.

This might helps you:
a.sort(key=str)
or
new list = sorted(a, key=str) # if you dont want to change a
this will sort the list as you want even if the items are integer

Swap indexes using slices?

I know that you can swap 2 single indexes in Python
r = ['1', '2', '3', '4', '5', '6', '7', '8']
r[2], r[4] = r[4], r[2]
output:
['1', '2', '5', '4', '3', '6', '7', '8']
But why can't you swap 2 slices of indexes in python?
r = ['1', '2', '3', '4', '5', '6', '7', '8']
I want to swap the numbers 3 + 4 with 5 + 6 + 7 in r:
r[2:4], r[4:7] = r[4:7], r[2:4]
output:
['1', '2', '5', '6', '3', '4', '7', '8']
expected output:
['1', '2', '5', '6', '7', '3', '4', '8']
What did I wrong?
output:

The slicing is working as it should. You are replacing slices of different lengths. r[2:4] is two items, and r[4:7] is three items.
>>> r = ['1', '2', '3', '4', '5', '6', '7', '8']
>>> r[2:4]
['3', '4']
>>> r[4:7]
['5', '6', '7']
So when ['3', '4'] is replaced, it can only fit ['5', '6'], and when ['5', '6', '7'] is replaced, it only gets ['3', '4']. So you have ['1', '2',, then the next two elements are the first two elements from ['5', '6', '7'] which is just ['5', '6', then the two elements from ['3', '4' go next, then the remaining '7', '8'].
If you want to replace the slices, you have to start slices at the right places and allocate an appropriate size in the array for each slice:
>>> r = ['1', '2', '3', '4', '5', '6', '7', '8']
>>> r[2:5], r[5:7] = r[4:7], r[2:4]
>>> r
['1', '2', '5', '6', '7', '3', '4', '8']
old index: 4 5 6 2 3
new index: 2 3 4 5 6

Think of this:
r[2:4], r[4:7] = r[4:7], r[2:4]
as similar to this:
original_r = list(r)
r[2:4] = original_r[4:7]
r[4:7] = original_r[2:4]
So, by the time it gets to the third line of that, the 4th element isn't what you think it is anymore... You replaced '3', '4' with '5', '6', '7', and now the [4:7] slice starts with that '7'.

>>> r = ['1', '2', '3', '4', '5', '6', '7', '8']
>>> r[2:5], r[5:7] = r[4:7], r[2:4]
>>> r
['1', '2', '5', '6', '7', '3', '4', '8']
In your code:
>>> r[2:4], r[4:7] = r[4:7], r[2:4]
You are assigning r[4:7] which have 3 elements to r[2:4] which have only 2.
In the code I posted:
>>> >>> r[2:5], r[5:7] = r[4:7], r[2:4]
r[4:7] which is ['5', '6', '7'], replaces
r[2:5] which is ['3', '4', '5']
r resulting in ['1', '2', '5', '6', '7', '6', '7', '8']
and then:
r[2:4] which was ['3', '4'], replaces
r[5:7] which is ['6', '7']
So final result being:
['1', '2', '5', '6', '7', '3', '4', '8']