# Definition

A **_Tidy number_**  *is a number whose*  **_digits are in non-decreasing order_**.
___
# Task

**_Given_** a number, **_Find if it is Tidy or not_** . 
____

# Warm-up (Highly recommended)

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

# Notes 


* **_Number_** *passed is always*  **_Positive_** .

* **_Return_** *the result as* a **_Boolean_** 

~~~if:prolog
* Since prolog doesn't have booleans,  return value should be 1 for (True) or 0 for (false)
~~~
___

# Input >> Output Examples

```
tidyNumber (12) ==> return (true)
```

## **_Explanation_**:

**_The number's digits_**    `{ 1 , 2 }`  are *in non-Decreasing Order* (i.e) *1 <= 2* .
____

```
tidyNumber (32) ==> return (false)
```

## **_Explanation_**:

**_The Number's Digits_**  `{ 3, 2}`  are **_not in non-Decreasing Order_** (i.e) *3 > 2* .
___

```
tidyNumber (1024) ==> return (false)
```

## **_Explanation_**:

**_The Number's Digits_**  `{1 , 0, 2, 4}`  are **_not in non-Decreasing Order_**  as  *0 <= 1* .

___

```
tidyNumber (13579) ==> return (true)
```

## **_Explanation_**:

**_The number's digits_**    `{1 , 3, 5, 7, 9}`  are *in non-Decreasing Order* .
____

```
tidyNumber (2335) ==> return (true)
```

## **_Explanation_**:

**_The number's digits_**    `{2 , 3, 3, 5}`  are *in non-Decreasing Order* , **_Note_**   *3 <= 3* 

___
___
___

# [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 tidyNumber(n):
	

Solutions:
def tidyNumber(n):
    s = list(str(n))
    return s == sorted(s)

def tidyNumber(n):
    s = str(n)
    return all(a<=b for a,b in zip(s,s[1:]))

def tidyNumber(n):
    return n == int(''.join(sorted(str(n))))

def tidyNumber(n):
    n = str(n)
    for i in range(0, len(n) - 1):
        if n[i] > n[i + 1]:
            return False

    return True

def tidyNumber(n):
    n = str(n)
    backnumber = n[0]
    for number in n:
        if number < backnumber:
           return False
        backnumber = number
    return True

def tidyNumber(n):
    return sorted(list(str(n))) == list(str(n))


def tidyNumber(n):
    n= str(n)
    back = n[0]
    for number in n:
        if number < back:
           return False
        back = number
    return True

def tidyNumber(n):
    l = list(str(n))
    return sorted(l) == l

def tidyNumber(n):
    o = str(n)[0]
    for i in str(n):
        if i >= o:
            o = i
        else:
            return False
    return True


def tidyNumber(n):
    n=str(n)
    return sorted(n)==list(n)

def tidyNumber(n):
    a = str(n)
    index = 0
    while index<len(a)-1:
        if int(a[index])>int(a[index+1]):
            return False
        index +=1
    return True

def tidyNumber(n):
    str_num = str(n)
    digit_list = [d for d in str_num]
    return digit_list == sorted(digit_list)


def tidyNumber(n):
    string_n = str(n)
    for n1, n2 in zip(string_n, string_n[1:]):
        if n1 > n2: return False
    return True

tidyNumber=lambda n,f=(lambda x:list(str(x))):f(n)==sorted(f(n))

def tidyNumber(n):
    return sorted(str(n))==list(str(n))

import re

def tidyNumber(n):
    return bool(re.fullmatch('0*1*2*3*4*5*6*7*8*9*', str(n)))

def tidyNumber(n):
    return all(int(a) <= int(b) for a, b in zip(str(n), str(n)[1:]))

def tidyNumber(n):
    i = n % 10
    n = n // 10
    while (n > 0):
        s = n % 10
        print((i, s, n))
        n = n // 10
        if i < s: 
            return False
        i = s
    return True
    #pass


def tidyNumber(n):
    before = list(str(n))
    after = sorted(before)
    if(after == before):
        return True
    else:
        return False

def tidyNumber(n):
    l=len(str(n))
    x=[int(x) for x in str(n)]
    return  all ( x[i+1]>=x[i]  for i in range(l-1) )


def tidyNumber(n):
    print(n)
    previous = n % 10
    while( n > 0):
        n//=10
        checking = n % 10
        if(previous < checking):
            return False
        previous = checking
    return True 


def tidyNumber(n):
    for i in range(len(str(n))-1):
        if not str(n)[i] <= str(n)[i+1]:
            return False
    return True

from functools import reduce
def tidyNumber(n):
    if n < 10:
        return True
    l = [str(n)[i] <= str(n)[i+1] for i in range(len(str(n))-1)]
    return reduce(lambda x, y:x & y, l)

def tidyNumber(n):
    a=list(str(n))
    return sorted(a)==a

def tidyNumber(n):
    prev = 10
    while n:
        n, curr = divmod(n, 10)
        if curr > prev:
            return False
        prev = curr
    return True

def tidyNumber(n):
    for idx, val in enumerate(str(n)):
        if idx != 0:
            if val < str(n)[idx - 1]:
                return False
    return True            
            


def tidyNumber(n):
    print(n)
    nums = [int(x) for x in str(n)]
    
    for m,i in enumerate(nums[:-1]):
        if i<=nums[m+1]:
            continue
        else:
            return False
    return True        

def tidyNumber(n):
    
    
    d = [int(x) for x in str(n)]
    
    if all(i<=j for i,j in zip(d,d[1:])):
    
        return True
            
    else:
        
        return False


def tidyNumber(n):
    return True if sorted([int(x) for x in str(n)]) == [int(x) for x in str(n)] else False

def tidyNumber(n):
    for x in range(len(str(n)) - 1):
        if str(n)[x] <= str(n)[x + 1]:
            continue
        else:
            return False
    return True

def tidyNumber(n):
    n = list(str(n))
    n = [int(i) for i in n]
    sorted = n[:]
    sorted.sort()
    print(sorted)
    if n != sorted:
        return False
    else:
        return True

def tidyNumber(n):
    n = str(n)
    p = 0
    for i in n:
        if int(i) < int(p):
            return False
        else:
            p = i
    
    return True
        
            
        


def tidyNumber(n):
    for i, digit in enumerate(str(n)[1:]):
        if int(digit) >= int(str(n)[i]):
            pass
        else:
            return False
    return True

def tidyNumber(n):
    for i,c in enumerate(str(n)):
        if i!=0:
            if c < str(n)[i-1]:
                return False
            
    return True


def tidyNumber(n):
    tidy=True
    for i in range(1,len(str(n))):
        if(int(str(n)[i])<int(str(n)[i-1])):
            tidy=False
    return tidy

def tidyNumber(n):
    numLst=list(str(n))
    for i in range(len(numLst)-1):
        if not numLst[i+1]>=numLst[i]:
            return False
    return True

def tidyNumber(n):
    return [x for x in range(len(str(n))-1) if int(str(n)[x]) > int(str(n)[x+1]) ] == []

def tidyNumber(n,p=''):
    for s in str(n):
        if(s < p): return False 
        else: p = s

    return True

def tidyNumber(n):
    n = str(n)
    tidy = True
    for i in range(1,len(n)):
        if int(n[i]) >= int(n[i-1]):
            continue
        else:
            tidy = False
            break
    return tidy


def tidyNumber(n):
    last_seen = 10
    while n:
        if n % 10 > last_seen:
            return False
        last_seen = n % 10
        n //= 10
    return True

def tidyNumber(n):
    j = str(n)
    for x in range(len(j) - 1) : 
        if int(j[x]) > int(j[x + 1]) :
           return False
    return True
            


def tidyNumber(n):
    count = 0
    play = str(n)
    for i in range(1,len(play)):
        if int(play[i])>=int(play[i-1]):
            count += 1
    return count == len(play)-1

def tidyNumber(n): 
    digits = [x for x in str(n)]
    return True if digits == sorted(digits) else False

def tidyNumber(n):
    n = str(n)
    for i in range(len(n)-1):
        if int(n[i])>int(n[i+1]):
            return False
            break
    return True

def tidyNumber(n):
    nums = list(map(int, str(n)))
    for i in range(len(nums)-1):
        if nums[i]>nums[i+1]:
            return False
    return True

def tidyNumber(n):
    print(n)
    n = [int(x) for x in str(n)]
    prev = n[0]
    for i,x in enumerate(n[1:]):
        if x >= prev:
            prev = x
        else:
            return False
    return True

def tidyNumber(n):
    previous_number = 0
    for number in str(n):
        if previous_number > int(number):
            return False
        previous_number = int(number)
    return True

def tidyNumber(n):
    return str(n) == ''.join(sorted(str(n)))
    # return all(x <= y for x, y in zip(str(n), str(n)[1:]))


def tidyNumber(n):
    return n==int(''.join(x for x in sorted(list(str(n)))))

def tidyNumber(n):
    ns = str(n)
    return all(a <= b for a,b in zip(ns,ns[1:]))


tidyNumber = lambda n: list(str(n)) == sorted(str(n))

def tidyNumber(n):
    nums = [int(num) for num in str(n)]
    srted = sorted(nums)
    if nums == srted:
        return True 
    else:     
        return False

def tidyNumber(n):

    n = str(n)
    print(n)
    for i in range(1,len(n)):
        if n[i] >= n[i-1]:
            continue
        else:
            return False
            
    return True


def tidyNumber(n):
    x = str(n)
    arr = list(x)
    if len(x) == 1:
        return True
    else:
        for j in range(0,len(x)-1):
            if arr[j] > arr[j+1]:
                return False
        return True


def tidyNumber(n):
    """
    given a number
    return True if each number following is >=
    """
    
    if n != int("".join(sorted(str(n)))):
        return False
    return True



def tidyNumber(n):
    digits = [int(i) for i in str(n)]
    return all([digits[i] <= digits[i+1] for i in range(len(digits)-1)])

def tidyNumber(n):
    if len(str(n)) == 1:
        return True
    else:
        for i in range(0,len(str(n))-1):
            if int(str(n)[i]) > int(str(n)[i+1]):
                return False
        return True

def tidyNumber(n):
    
    return all(map(lambda x: int(str(n)[x]) >= int(str(n)[x-1]), range(1,len(str(n)))))

def tidyNumber(n):
    n = list(map(str, str(n)))
    return sorted(n) == n

def tidyNumber(n):
    s = 0
    if len(str(n)) > 1:
        for i in str(n):
            if int(i) >= s:
                s = int(i)
                continue
            else:
                return False

    return True

def tidyNumber(n):
    s = str(n)
    return all(x <= y for x, y in zip(s, s[1:]))

def tidyNumber(n):
    numbers = [int(num) for num in str(n)]
    
    # assume tidy until proven otherwise
    flag = True
    
    while len(numbers) > 1:
        if numbers[0] > numbers[1]: # check counter-condition for each
            flag = False            # if satisfies, not tidy
            break                   # escape loop
        numbers.pop(0)              # else, remove first element and iterate
    return flag

def tidyNumber(n):
    print(n)
    n = str(n)
    for i in range(len(n)-1):
        if int(n[i]) > int(n[i+1]):
            return False
            
    return True

def tidyNumber(n):
    new_string = str(n)
    count = 0
    for i in range(0, len(new_string)-1):
        if new_string[i]<=new_string[i+1]:
            count+=1
    return count == len(new_string)-1

def tidyNumber(n):
    for i in range(len(str(n))-1):
          if str(n)[i]>str(n)[i+1]:
                return False 
                break
    return True
          


def tidyNumber(n):
    z=[int(x) for x in str(n)]
    print(z)
    
    
    return all(v<=y for v,y in zip(z,z[1:])) 


def tidyNumber(n):
    return int(''.join(sorted(f'{n}'))) == n

def tidyNumber(n):
    s = str(n)
    return "".join(sorted(s)) == s

def tidyNumber(n):
    digits=[]
    while n>0:
        digit=n%10
        n=n//10
        digits.append(digit)
    tidy=True
    i=1
    while i<len(digits):
        if digits[i]>digits[i-1]:
            tidy=False
            break
        i=i+1
    return tidy

def tidyNumber(n):
    return n == int(''.join(sorted(i for i in str(n))))

def tidyNumber(n):
    a = str(n)
    for i in range(len(a)-1):
        if int(a[i]) > int(a[i+1]):
            return False
    return True

def tidyNumber(n):
    return sorted(map(int,str(n))) == list(map(int,str(n)))

def tidyNumber(n):
 return sorted([el for el in str(n)])==[el for el in str(n)]

def tidy_number(n):
    return list(str(n)) == sorted(str(n))
    
    
# camel bad snake good
tidyNumber = tidy_number

def tidyNumber(n):
    x = list(str(n))
    return True if x == sorted(x) else False

def tidyNumber(n):
    lst = [x for x in list(str(n))]
    lst1 = sorted(lst,key = int)
    return  int(''.join(lst1)) == n

def tidyNumber(n):
    return n == int(''.join(sorted([x for x in str(n)])))

def tidyNumber(n):
    a = list(str(n))
    a.sort()
    b = ("").join(a)
    c = int(b)
    if c == n:
        return True
    else:
        return False

def tidyNumber(n):
    for k,v in enumerate(str(n)):
        if k == 0:
            pass
        else:
            if v < str(n)[k-1]:
                return False
    return True


def tidyNumber(n):
    digits=[int(d) for d in str(n)]
    
    for i in range(len(digits)-1):
        if digits[i]>digits[i+1]:
            return False
    
    return True

def tidyNumber(n):
    print(n)
    for i in range(len(list(str(n)))):
        try:
            if not (int(str(n)[i]) <= int(str(n)[i+1])):
                return False
        except:
            return True

def tidyNumber(n):
    digits = [int(s) for s in str(n)]
    return sorted(digits) == digits 

def tidyNumber(n):
    digits = list(map(int, str(n)))
    actual_digit = digits[0]
    
    for digit in digits[1:]:
        if digit < actual_digit:
            return False
            
        actual_digit = digit
        
    return True
    


def tidyNumber(n):
    n = str(n)
    for i in range(1,len(n)):
        if n[i-1] > n[i]:
            return False
    return True

def tidyNumber(n):
    n = str(n)

    if ''.join(sorted(n)) == n:
        return True
    else:
        return False


def tidyNumber(n):
    cpy=n
    l=len(str(cpy))
    cpy=[int(i) for i in str(cpy)]
    for i in range(l):
        for j in range(i,l-1):
            if cpy[j]<=cpy[j+1]:
                continue
            else:
                return False
    return True
    #your code here     
    #pass


def tidyNumber(n):
    s = str(n)
    for c in list(zip(s[1:],s)):
        if c[0] < c[1]:
            return False
    return True

def tidyNumber(n):
    return True if  all( [ front <= behind for front, behind in zip( str( n), str( n)[ 1:])]) else False

def tidyNumber(number):
    number = str(number)
    return sorted(number) == list(number)

import unittest


def tidyNumber(n):
    n = str(n)
    return all(e0 <= e1 for e0, e1 in zip(n, n[1:]))
    
    
class TestTidyNumber(unittest.TestCase):
    def test_should_return_true_when_given_n_is_12(self):
        n = 12
        actual = tidyNumber(n)
        self.assertEqual(actual, True)

    def test_should_return_false_when_given_n_is_102(self):
        n = 102
        actual = tidyNumber(n)
        self.assertEqual(actual, False)


import unittest


def tidyNumber(n):
    return all(False for ele in zip(str(n), str(n)[1:]) if int(ele[1]) - int(ele[0]) < 0)
    
    
class TestTidyNumber(unittest.TestCase):
    def test_should_return_true_when_given_n_is_12(self):
        n = 12
        actual = tidyNumber(n)
        self.assertEqual(actual, True)

    def test_should_return_false_when_given_n_is_102(self):
        n = 102
        actual = tidyNumber(n)
        self.assertEqual(actual, False)


def tidyNumber(n):
    return ([int(i) for i in str(n)]) == (sorted([int(i) for i in str(n)]))


def tidyNumber(n):
    result = True
    for i in range(len(str(n))-1):
        if int(str(n)[i+1]) >= int(str(n)[i]):
            continue
        else:
            return False
    return result

def tidyNumber(n):
    n = str(n)
    k = list(map(int,n))
    l = sorted(k)
    if k == l:
        return True
    else:
        return False

def tidyNumber(n):
    if n == int("".join(sorted(str(n)))):
        return True
    return False

def tidyNumber(n):
    num_str = str(n)
    for x in range(len(num_str)-1):
        if int(num_str[x]) > int(num_str[x+1]):
            return False
    return True

def tidyNumber(n):
    string = str(n)
    j = 0;
    #print(string)
    for i in string:
        if int(i) >= j:
            j = int(i)
            continue
        else :
            return False
    return True

def tidyNumber(n):
    tidy = True
    y = ''
    for x in str(n):
        if y != None:
            if x < y:
                tidy = False
            else:
                y = x
    
    return tidy


def tidyNumber(n):
    A = []
    Count = 0
    for i in str(n) :
        A.append(int(i))
    for i in range(1,len(A)):
        if A[i-1] > A[i] :
          return False
    return True