We have two consecutive integers k1 and k2, k2 = k1 + 1

We need to calculate the lowest integer `n`, such that:
the values nk1 and nk2 have the same digits but in different order.

E.g.# 1:
```
k1 = 100
k2 = 101
n = 8919
#Because 8919 * 100 = 891900 
and      8919 * 101 = 900819
```

E.g.# 2:
```
k1 = 325
k2 = 326
n = 477
#Because 477 * 325 = 155025
and      477 * 326 = 155502
```

Your task is to prepare a function that will receive the value of `k` and outputs the value of `n`.

The examples given above will be:
```python
find_lowest_int(100) === 8919
find_lowest_int(325) ===  477
```
Features of the random tests
```
10 < k < 10.000.000.000.000.000 (For Python, Ruby and Haskell)
10 < k < 1.000.000.000  (For Javascript 1e9)
```
Enjoy it!!

Ruby and Javascript versions will be released soon.

Source: codewars | Difficulty: EASY
Tags: Fundamentals

String algorithms

Combinatorics

Sorting

Mathematics

Matrices

Data structures

Starter code: def find_lowest_int(k):
	

Solutions:
def find_lowest_int(k1):
	(k2, n) = (k1 + 1, 1)

	def digits(n):
		return sorted(str(n))
	while digits(n * k1) != digits(n * k2):
		n += 1
	return n


from itertools import count as c

def find_lowest_int(k):
	return next((n for n in c(1) if sorted(str(n * k)) == sorted(str(n * (k + 1)))))


def find_lowest_int(k):
	return next((n for n in range(9, 9999999, 9) if sorted(str(n * k)) == sorted(str(n * (k + 1)))))


def find_lowest_int(k):
	(l, n) = (k + 1, 9)
	while digits(k * n) != digits(l * n):
		n += 9
	return n

def digits(n):
	return sorted(str(n))


def find_lowest_int(number):
	multiplier = 1
	while sorted(str(number * multiplier)) != sorted(str((number + 1) * multiplier)):
		multiplier += 1
	return multiplier


from collections import Counter

def find_lowest_int(k):
	n = 9
	while True:
		if Counter(str(k * n)) == Counter(str((k + 1) * n)):
			return n
		n += 9


def find_lowest_int(k):
	n = 2
	while True:
		if sorted(str(n * k)) == sorted(str(n * (k + 1))):
			return n
		n += 1