Creating nxm index list of array a Here is the problem:

Given a numpy array 'a' that contains n elements, denote by b the set
of its unique values ​​in ascending order, denote by m the size of
array b. You need to create a numpy array with dimensions  n×m , in
each row of which there must be a value of 1 in case it is equal to
the value of the given index of array b, in other places it must be 0.

import numpy as np


def convert(a):
    b = np.unique(sorted(a))
    result = []
    for i in a:
        result.append((b == i) * 1)
    return np.array(result)


a = np.array([1, 1, 2, 3, 2, 4, 5, 2, 3, 4, 5, 1, 1])
b = np.unique(sorted(a))
print(convert(a))

This is my solution. is there some improvments that I can make?
I'm not sure about declaring regular list to the result and then converting it into np.array.
Remove sorted
From the docs: numpy.unique returns the sorted unique elements of an array.
You can simply remove the call to sorted:
b = np.unique(sorted(a))

# produces the same result as

b = np.unique(a)


List comprehension
In most cases you can and should avoid this pattern of list creation:
result = []
for i in a:
    result.append((b == i) * 1)

It can be replaced by a concise list comprehension and directly passed to np.array:
result = np.array([(b == i) * 1 for i in a])

# or directly return it (if applicable)
return np.array([(b == i) * 1 for i in a])

List comprehensions are more pythonic and often faster. Generally, not mutating the list object is also less error-prone.

There might be a better way to map lambda x: (uniques == x) * 1 over the input array a. Here's a discussion on the topic on StackOverflow: Most efficient way to map function over numpy array. Seems like using np.vectorize should be avoided for performance reasons.
Using map might be similiar to the list comprehension performance-wise (I did not properly test performance here):
def convert_listcomp(a):
    uniques = np.unique(a)
    return np.array([(b == i) * 1 for i in a])

def convert_map(a):
    uniques = np.unique(a)
    return np.array(list(map(lambda x: (uniques == x) * 1, a)))