I am expecting the list to be sorted and then duplicates will be spaced by increments of 0.1. Why is my code below not working? Here is what I am expecting to get versus what my program is returning:

Expected Output: [11, 15, 15.1, 20, 20.1, 20.2, 20.3, 20.4, 30,
30.1, 40, 40.1, 50, 50.1]

Actual output:[11, 15, 15.1, 20, 20.1, 20.1, 20.1, 20.1, 30, 30.1, 40,
40.1, 50, 50.1]

Python Code:

my_list = [20,20,20,30,20,30,40,50,15,11,20,40,50,15]

my_list.sort()

dup_list = 





for i in range (len(my_list)):

    if my_list[i] not in dup_list:

        dup_list.append(my_list[i])

    else:

        my_list[i] = my_list[i] + 0.10



    dup_list.append(my_list[i])

here is the solution according to your code.
your code is right what you were lacking was the case when my_list[i]+0.1*i
value is already present. ie in example when 20 is there you increase it to
20.1 (happening) but you miss that but when 20.1 is there . you just checking
only for 20 not for 20.1 . that is why 20.1 is coming in your solution not 20.2.

my_list = [20,20,20,30,20,30,40,50,15,11,20,40,50,15]

my_list.sort()

dup_list = 





for i in range (len(my_list)):

    if my_list[i] not in dup_list:

        dup_list.append(my_list[i])

    else:

        j=1

        res = True

        while res:

            val = my_list[i]+j*0.1

            if val  not in dup_list:

                dup_list.append(val)

                res = False

            j+=1 



print(dup_list)



#output [11, 15, 15.1, 20, 20.1, 20.2, 20.3, 20.4, 30, 30.1, 40, 40.1, 50, 50.1]

You could use itertools.groupby to group equal consecutive elements:

from itertools import groupby



my_list = [20,20,20,30,20,30,40,50,15,11,20,40,50,15]

my_list.sort()

result = [g + i * 0.1 for k, group in groupby(my_list) for i, g in enumerate(group)]

print(result)

Output

[11.0, 15.0, 15.1, 20.0, 20.1, 20.2, 20.3, 20.4, 30.0, 30.1, 40.0, 40.1, 50.0, 50.1]

I can propose simple fix to the original code:

my_list = [20,20,20,30,20,30,40,50,15,11,20,40,50,15]

my_list.sort()

dup_list = 



for i in range (len(my_list)):

    if my_list[i] not in dup_list:

        dup_list.append(my_list[i])

    else:

        dup_list.append(dup_list[i-1]+0.1)

The problem is you are only incrementing it once. You are not keeping a count of how many times a number has appeared before.

What you need is some kind of frequency dictionary that will store how many times this number has appeared. Using that frequency f you add f-1 increments to the number.

my_list = [20,20,20,30,20,30,40,50,15,11,20,40,50,15]

my_list.sort()

dup_list = 

feq = {}



for i in range (len(my_list)):

    if my_list[i] not in feq:

        feq[my_list[i]] = 1

    else:

        feq[my_list[i]] += 1



    dup_list.append(my_list[i] + (feq[my_list[i]]-1)*0.1)

Try this improved code:

my_list = [20,20,20,30,20,30,40,50,15,11,20,40,50,15]

my_list.sort()

out_list = 



for value in my_list:

    if value in out_list:

        while value in out_list:

            value += .1

    out_list.append(value)

Using defaultdict:

from collections import defaultdict



my_list = [20,20,20,30,20,30,40,50,15,11,20,40,50,15]

my_list.sort()

dup_list = 

occurrences = defaultdict(int)



for elmt in my_list:

    dup_list.append(elmt + occurrences[elmt] * 0.10)

    occurrences[elmt] += 1

Output:

[11.0, 15.0, 15.1, 20.0, 20.1, 20.2, 20.3, 20.4, 30.0, 30.1, 40.0, 40.1, 50.0, 50.1]

If you need the original values to still be integers, comment below and I'll change that.

Another (more advanced) option is to write a cusom generator:

from itertools import count



def gen(value):

    """Returns a generator that first yields `value` and then `value + x * 0.10` (where x is 1, 2, ...).

    """

    yield value

    yield from map(lambda x: value + x * 0.10, count(1))



my_list = [20, 20, 20, 30, 20, 30, 40, 50, 15, 11, 20, 40, 50, 15]



# create a generator for each distinct value in my_list

generators = {k: gen(k) for k in set(my_list)}



# calculate the result list

dup_list = [next(generators[elmt]) for elmt in sorted(my_list)]



print(dup_list)

IMO, this is not the easiest solution. I'm sharing it anyways because it might help others understand generators, especially yield from.