# Introduction and Warm-up (Highly recommended)

# [Playing With Lists/Arrays Series](https://www.codewars.com/collections/playing-with-lists-slash-arrays)
___

# Task

**_Given_** an *array/list [] of integers* , **_Find_**  *the Nth smallest element in this array of integers*
___

# Notes 

* **_Array/list_** size is *at least 3* .

* **_Array/list's numbers_** *could be a **_mixture_** of positives , negatives and zeros* .

* **_Repetition_** *in array/list's numbers could occur* , so **_don't Remove Duplications_** .
___

# Input >> Output Examples

```
nthSmallest({3,1,2} ,2) ==> return (2) 
```

## **_Explanation_**:

Since the passed number is **_2_** , Then * **_the second smallest_** element in this array/list is **_2_***  
___

```
nthSmallest({15,20,7,10,4,3} ,3) ==> return (7) 
```

## **_Explanation_**:

Since the passed number is **_3_** , Then * **_the third smallest_** element in this array/list is **_7_*** 
___
```
nthSmallest({2,169,13,-5,0,-1} ,4) ==> return (2) 
```

## **_Explanation_**:

Since the passed number is **_4_** , Then * **_the fourth smallest_** element in this array/list is **_2_*** 
___

```
nthSmallest({177,225,243,-169,-12,-5,2,92} ,5) ==> return (92) 
```
## **_Explanation_**:

Since the passed number is **_5_** , Then * **_the fifth smallest_** element in this array/list is **_92_*** 
___
___
___

# [Playing with Numbers Series](https://www.codewars.com/collections/playing-with-numbers)

# [Playing With Lists/Arrays Series](https://www.codewars.com/collections/playing-with-lists-slash-arrays)

# [For More Enjoyable Katas](http://www.codewars.com/users/MrZizoScream/authored)
___

## ALL translations are welcomed

## Enjoy Learning !!
# Zizou

Difficulty: introductory

Starter code:

def nth_smallest(arr, pos):
	

Solutions:
def nth_smallest(arr, pos):
    return sorted(arr)[pos-1] # Gotta love Python

def nth_smallest(arr, pos):
    return sorted(arr)[pos-1]

from heapq import nsmallest
def nth_smallest(arr, pos):
    return nsmallest(pos, arr)[-1]

def nth_smallest(arr, pos):
    arr.sort()
    return arr[pos-1]

"""
Description:
Given an array/list [] of integers , Find the Nth smallest element in this array
of integers
"""
import random


def quick_select(arr, pos):
    pivot = random.choice(arr)
    less = []
    greater = []
    k = 0
    if len(arr) == 1:
        return arr[0]
    for i in arr:
        if i < pivot:
            less.append(i)
        elif i > pivot:
            greater.append(i)
        else:
            k += 1
    if pos < len(less):
        return quick_select(less, pos)
    elif pos < len(less) + k:
        return pivot
    else:
        return quick_select(greater, pos - len(less) - k)


def nth_smallest(arr, pos):
    return quick_select(arr, pos - 1)


def __starting_point():
    print((nth_smallest([15, 20, 7, 10, 4, 3], 3)))

__starting_point()

def nth_smallest(arr, pos):
    # The quickselect algorithm!
    # O(n) average case and o(n**2) worst case (sorted or reverse sorted list)
    # Using random pivots would better handle edgy edge cases but too lazy for that
    if len(arr) == 1: return arr[0]
    pivot_value = arr[0]
    smaller = [num for num in arr[1:] if num < pivot_value]
    bigger = [num for num in arr[1:] if num > pivot_value]
    count_smaller_or_equal = len(arr) - len(bigger)
    if len(smaller) > pos - 1: # -1 because pos is 1-based
        return nth_smallest(smaller, pos)
    elif count_smaller_or_equal > pos - 1: # -1 because pos is 1-based
        return pivot_value
    else:
        return nth_smallest(bigger, pos - count_smaller_or_equal)

def nth_smallest(arr, pos):
    var = sorted(arr)
    return var[pos-1]

def nth_smallest(arr, pos):
    arr.sort() 
  
    # Return k'th element in the  
    # sorted array  
    return arr[pos-1] 

def nth_smallest(a, n):
    return sorted(a)[n - 1]

def nth_smallest(lst, pos):
    return sorted(lst)[pos - 1]

nth_smallest = lambda a, p: sorted(a)[p-1]

def nth_smallest(arr, pos):
    res = sorted(arr)
    return res[pos - 1]

def nth_smallest(arr, pos):
    if pos > len(arr): return max(arr)
    if len(arr) == 1 :    return arr[0]
    pivot = arr[len(arr)//2]
    lit = [i for i in arr if i < pivot]
    big = [i for i in arr if i > pivot]
    k = len(arr) - len(big)
    if   pos > k:         return nth_smallest(big, pos - k)
    elif pos > len(lit):  return pivot
    else:                 return nth_smallest(lit, pos)

from random import choice

def nth_smallest(arr, pos):
    ar = list(arr)
    while True:
        if len(ar) == 1 :    return ar[0]
        big, lit, pivot = [], [], choice(ar)
        for i in ar:
            if   i > pivot:   big.append(i)
            elif i < pivot:   lit.append(i)
        k = len(ar) - len(big)
        if   pos > k:         ar, pos = big, pos - k
        elif pos > len(lit):  return pivot
        else:                 ar = lit

from random import choice

def nth_smallest(arr, pos):
    if len(arr) == 1 :    return arr[0]
    big, lit, pivot = [], [], choice(arr)
    for i in arr:
        if   i > pivot:   big.append(i)
        elif i < pivot:   lit.append(i)
    k = len(arr) - len(big)
    if   pos > k:         return nth_smallest(big, pos - k)
    elif pos > len(lit):  return pivot
    else:                 return nth_smallest(lit, pos)

def nth_smallest(arr, pos):
    if len(arr) == 1 : return arr[0]
    big, lit, pivot = [], [], arr[pos-1]
    for i in arr:
        if   i > pivot:  big.append(i)
        elif i < pivot:  lit.append(i)
    k = len(arr) - len(big)
    if   pos > k:  return nth_smallest(big, pos - k)
    elif pos > len(lit):      return pivot
    else:                     return nth_smallest(lit, pos)

def nth_smallest(arr, pos):
    return __import__("heapq").nsmallest(pos,arr)[-1]

nth_smallest = lambda *a: sorted(a[0]).pop(a[1]-1)


nth_smallest = lambda a, i: sorted(a).pop(i-1)


def nth_smallest(arr, pos):
    i = (pos - len(arr) if pos >= len(arr) else pos) - 1
    x = sorted(arr)
    return min(x[i:])

def nth_smallest(arr, pos):
    
    res = 0
    
    for _ in range(pos):
        res = min(arr)
        arr.remove(min(arr))
    
    return res

def nth_smallest(ls, nth):
    return sorted(ls)[nth-1]

import heapq
def nth_smallest(arr, pos):
    heap = heapq.nsmallest(pos,arr)
    return heap[-1]

def nth_smallest(arr, pos):
    x = sorted(arr)
    steps = 1
    for i in x:
        if steps == pos:
            return i
        else:
            steps += 1


def nth_smallest(arr, pos):
    #your code here
    a=sorted(arr)
    print(a)
    return a[pos-1]
    
    


import heapq

def nth_smallest(nlist, num):
    return(heapq.nsmallest(num, nlist))[-1]

def nth_smallest(arr, pos):
    arr=sorted(arr)
    for i,j in enumerate(arr):
       if i==pos-1:
          return j

def nth_smallest(arr, pos):
    """
    Returns the nth smallest integer in arr.
    
    Args:
        arr: List of at least 3 integers.
    Returns:
        Nth smallest integer.
    """
    arr_sorted = sorted(arr)
    return arr_sorted[pos - 1]

def nth_smallest(arr, pos):
    numbersSort = sorted(arr)
    return numbersSort[pos-1]
    #your code here


import numpy as np
def nth_smallest(arr, pos):
    res=np.sort(arr)
    d=res[pos-1]
    
    return d


def nth_smallest(arr: list, pos: int):
    return sorted(arr)[pos-1]

from heapq import nsmallest
from typing import List


def nth_smallest(arr: List[int], pos: int) -> int:
    return nsmallest(pos, arr)[-1]


from heapq import nsmallest

nth_smallest = lambda lst, n: nsmallest(n, lst)[-1]

def merged(p,q):
    pc=0
    qc=0
    ra=[]
    while True:
        if pc<len(p) and qc<len(q):
            if p[pc]<q[qc]:
                ra.append(p[pc])
                pc=pc+1
            else:
                ra.append(q[qc])
                qc=qc+1
        elif pc<len(p):
            ra.append(p[pc])
            pc=pc+1
        elif qc<len(q):
            ra.append(q[qc])
            qc=qc+1
        else:
            break
    return ra
def mysort(arr):
    if len(arr)<2:
        return arr
    else:
        mid=len(arr)//2
        part1=mysort(arr[:mid])
        part2=mysort(arr[mid:])
        return merged(part1,part2)

def nth_smallest(arr, pos):
    arr=mysort(arr)
    return arr[pos-1]

def nth_smallest(arr, n):
    return sorted(arr)[n - 1]

nth_smallest = lambda r,i: sorted(r)[i-1]

def nth_smallest(arr, pos):
    i = 0  
    a = 0
    while i < pos:
        a = min(arr)
        arr.remove(a)
        i += 1
    return a


def nth_smallest(arr, pos):
    sar = sorted(arr)
    return sar.pop(pos-1)

def nth_smallest(arr, pos):
    # Alternatively, use max-heap
    return sorted(arr)[pos-1]

def nth_smallest(arr, pos):
    # sort array
    arr.sort()
    
    # get smallest
    nthSmallest = arr[pos - 1];
    
    return nthSmallest;

def nth_smallest(x,y):
    return sorted(x)[y - 1]

def nth_smallest(a, n):
    s = sorted(a)
    return s[n-1]

def nth_smallest(arr, pos):
    for i in range(pos):
        x = min(arr)
        arr.remove(x)
    return x

def nth_smallest(arr, pos):
    sort = sorted(arr,reverse=True)
    return sort[-pos]

def nth_smallest(arr, pos):
    arr.sort()
    min = 0
    for i in range(len(arr)):
        pos -= 1
        if(pos == 0):
            min = arr[i]
            break;
    return min

from heapq import nsmallest

def nth_smallest(a,p):
    return nsmallest(p,a)[-1]

def nth_smallest(arr, pos):
    arr.sort()
    lol=arr[0:pos:]
    return lol[pos-1]

def nth_smallest(arr, pos):
    if len(arr) < 3:
        return "Array needs to be longer"
    a = sorted(arr)
    real_index = pos - 1
    b = a[real_index]
    return b

def nth_smallest(arr, pos):
    while pos>1:
        arr.remove(min(arr))
        if len(arr)<2:
            return arr[0]
        pos-=1
    return min(arr)

def nth_smallest(arr, pos):
    x = sorted(arr)[pos-1]
    return x


def nth_smallest(arr, pos):
    arr.sort()
    return list(arr)[pos - 1]

def nth_smallest(arr, n):
    if n == 1:
        return min(arr)
    del arr[arr.index(min(arr))]
    return nth_smallest(arr, n-1)

def nth_smallest(arr, pos):
    for i in range(pos):
        result = min(arr)
        arr.remove(result)
    return result

def nth_smallest(arr, pos):
    for a in range(pos):
        index = arr.pop(arr.index(min(arr)))
    return index

import heapq
def nth_smallest(arr, pos):
    x = heapq.nsmallest(pos, arr)
    print(x)
    return x[-1]

def nth_smallest(arr, pos):
#    print(arr, pos)
    arr.sort()
#     print(arr, arr[pos-1])
    return arr[pos-1]

def nth_smallest(arr, pos):
    numbers = arr
    numbers.sort()
    return numbers[pos - 1]

def nth_smallest(arr, pos):
  arr.sort()
  #print(arr)
  return arr[pos - 1]

def nth_smallest(arr, pos):
    ref = pos - 1
    arr.sort(reverse=False)
    return arr[ref]

def nth_smallest(arr, pos):
    
    for number in arr:
        if pos == 1:
            return min(arr)
            
        elif pos > 1:
            for to_delete in range(1, pos):
                arr.remove(min(arr))
                
            return min(arr)    

def nth_smallest(arr, pos):
    for _ in range(pos-1):
        arr.remove(min(arr))
        
    return min(arr)

def nth_smallest(arr, k):
    return sorted(arr)[k-1]

def nth_smallest(arr, pos):
    new_list = sorted(arr, reverse=True)
    return new_list[-pos]

def nth_smallest(arr, pos):
    for i, x in enumerate(sorted(arr)):
        if i == pos-1:
            return x

def nth_smallest(arr, pos):
    arr.sort()
    return (0, arr[pos - 1])[pos >= 1]

def nth_smallest(arr, pos):
    for i in range(len(arr) - pos):
        arr.remove(max(arr))
    return max(arr)

def nth_smallest(arr, pos):
    m=0
    while pos!=0:
        m=min(arr)
        arr.pop(arr.index(m))
        pos-=1
    return m

def nth_smallest(arr, pos):
    position=pos-1
    arr.sort()
    return arr[position]
    #your code here


def nth_smallest(arr, pos):
    return sorted(list(arr))[pos-1]


def nth_smallest(arr, pos):
    
    arr.sort()
    
    for i,j in enumerate(arr,1):
    
        if i == pos:
        
    
            return j
    


def nth_smallest(arr, pos):
    arr.sort()
    for i in range(len(arr)):
        if i + 1 == pos:
            return arr[i]

def nth_smallest(arr, pos):

    #print(sorted(arr))
    return (sorted(arr)[pos-1])
    #your code here


def nth_smallest(arr, pos):
    return sorted(arr)[:pos][-1]

def nth_smallest(arr, pos):
    i = pos
    while i > 0:
        result = min(arr)
        arr.remove(min(arr))
        i -= 1
    return result
        
        


def nth_smallest(a,b):
    a.sort()
    return(a[b-1])

def nth_smallest(arr, pos):
        for i in range(0, len( sorted(arr))):
            if i == pos-1:
                return sorted(arr)[i]

def nth_smallest(arr, pos):
    arr.sort()
    [arr.pop(0) for _ in range(pos-1)] 
    return arr[0]

def nth_smallest(list, pos):
    list.sort()
    return list[pos-1]

def nth_smallest(arr, pos):
    if pos > len(arr):
        return sorted(arr)[-1]
    else:
        return sorted(arr)[pos-1]

def nth_smallest(arr, pos):    
    if pos>-1 and pos<len(arr)+1:
        return sorted(arr)[pos-1]
    else:
        return -1

def nth_smallest(arr, pos):
    #your code here
    list = sorted(arr)
    return list[pos-1]

def nth_smallest(arr, pos):
    sorted_arr = sorted(arr)
    while pos > 1:
        sorted_arr.pop(0)
        pos -= 1
    return sorted_arr.pop(0)

def nth_smallest(arr, pos):
    result = None
    if pos <= len(arr):
        arr.sort()
        result = arr[(pos-1):][0]
    return result

def nth_smallest(arr, pos):
    return sorted(arr,reverse=True)[pos*-1]

def nth_smallest(arr,pos):
    newlis = []
    newlis = list(arr)
    newlis.sort()
    return(newlis[pos-1])

def nth_smallest(arr, pos):
    arr.sort()
    count=1
    for x in arr:
        if count== pos:
            return x
        else:
            count+=1

def nth_smallest(arr, pos):
    l = len(arr)
    liste = arr
    n = 1
    while n != pos:
        liste.remove(min(liste))
        n = n + 1
    return min(liste)

def nth_smallest(arr, pos):
    while pos > 0:
        m = min(arr)
        arr.remove(m)
        pos -= 1
    return m

def nth_smallest(arr, pos):
    li = sorted(arr)
    return li[pos-1]

def sel_sort(array):
    for i in range(len(array) - 1):
        m = i
        j = i + 1
        while j < len(array):
            if array[j] < array[m]:
                m = j
            j = j + 1
        array[i], array[m] = array[m], array[i]
        
def nth_smallest(arr, pos):
    if pos <= 0 or arr == []:
        return 'error'
    sel_sort(arr)
    return arr[pos-1]


import pandas as pd

def nth_smallest(arr, pos):
    #your code here
    arr_series = pd.Series(arr)
    return arr_series.sort_values(ascending = True).reset_index(drop = True)[pos - 1]

def nth_smallest(arr, pos):
    sort = sorted(arr)
    print(sort)
    for i in range(len(sort)):
        if i == pos - 1:
            return sort[i]

def nth_smallest(list1, num):
    a = list(list1)
    a.sort()
    return a[num-1]

def nth_smallest(arr, pos):
    #your code here
    minimum = 0
    for i in range(pos):
        minimum = minimum_k(arr)
    
    return minimum
    
def minimum_k(array):
    
    minimum = 99999
    
    for i in array:
        minimum = min(minimum, i)
    
    array.remove(minimum)
    
    return minimum 

def nth_smallest(arr, pos):
    smallest = [0]
    small = 0
    for i in range(len(arr)):
        smallest.append(min(arr))
        arr.pop(arr.index(min(arr)))
    return smallest[pos]
        


def nth_smallest(arr, pos):
    arr.sort()
    newPos = pos - 1
    nSmall = arr[newPos]
    return nSmall

import numpy as np
def nth_smallest(arr, pos):
    arr =sorted(arr)
    return arr[pos-1]
    #your code here


def nth_smallest(arr, pos):
    
    b=sorted(arr)
    a=b[pos-1]
    
    return a
    
    
    
    


def nth_smallest(arr, pos):
  s_arr = sorted(arr)
  return s_arr[pos - 1]

def nth_smallest(arr, pos):
    res = list(arr)
    i = 1
    while i < pos:
      m = min(res)
      for k, x in enumerate(res):
        if x == m:
            res[k] = 999999999
            break
      i = i + 1
    return min(res)