**Introduction**
 Little Petya very much likes sequences. However, recently he received a sequence as a gift from his mother.
 Petya didn't like it at all! He decided to make a single replacement. After this replacement, Petya would like to the sequence in increasing order.
 He asks himself: What is the lowest possible value I could have got after making the replacement and sorting the sequence?

**About the replacement**
 Choose exactly one element from the sequence and replace it with another integer > 0. You are **not allowed** to replace a number with itself, or to change no number at all.

**Task**
 Find the lowest possible sequence after performing a valid replacement, and sorting the sequence.

**Input:**
 Input contains sequence with `N` integers. All elements of the sequence > 0. The sequence will never be empty.

**Output:**
 Return sequence with `N` integers — which includes the lowest possible values of each sequence element, after the single replacement and sorting has been performed.

**Examples**:
```
([1,2,3,4,5])  =>  [1,1,2,3,4]
([4,2,1,3,5])  =>  [1,1,2,3,4]
([2,3,4,5,6])  =>  [1,2,3,4,5]
([2,2,2])      =>  [1,2,2]
([42])         =>  [1]
```

Source: codewars | Difficulty: EASY

Starter code: def sort_number(a):
	

Solutions:
def sort_number(a):
	a = sorted(a)
	return [1] + a if a.pop() != 1 else a + [2]


def sort_number(a):
	if max(a) != 1:
		a.remove(max(a))
		a.append(1)
	else:
		a.remove(max(a))
		a.append(2)
	return sorted(a)


def sort_number(a):
	a = sorted(a)
	m = a.pop(-1)
	return [[1] + a, a + [2]][m == 1]


sort_number = lambda a: sum(a) / len(a) != 1 and [1] + sorted(a)[:-1] or a[:-1] + [2]


def sort_number(a):
	a.sort()
	return a[:-1] + [2] if set(a) == {1} else [] if len(a) == 0 else [1] if len(a) == 0 else [1] + a[:-1]


def sort_number(a):
	a.sort()
	if a == [1] * len(a):
		del a[-1]
		a.append(2)
		return a
	l = [1]
	a.remove(max(a))
	for i in range(len(a)):
		l.append(a[i])
	return l


def sort_number(a):
	a = sorted(a)
	if a[len(a) - 1] != 1:
		a[len(a) - 1] = 1
	else:
		a[len(a) - 1] = 2
	return sorted(a)


import heapq

def sort_number(a):
	l = a[:]
	heapq._heapify_max(l)
	mx = heapq.heappop(l)
	heapq.heappush(l, 2 if mx == 1 else 1)
	return heapq.nsmallest(len(a), l)


def sort_number(a):
	if a == [1, 1, 1]:
		return [1, 1, 2]
	if a == [1]:
		return [2]
	l = sorted(a)[:-1]
	l.append(1)
	return sorted(l)