**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]
```

Difficulty: introductory

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]

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

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)