In this Kata, we will check if a string contains consecutive letters as they appear in the English alphabet and if each letter occurs only once. 

```Haskell
Rules are: (1) the letters are adjacent in the English alphabet, and (2) each letter occurs only once.

For example: 
solve("abc") = True, because it contains a,b,c
solve("abd") = False, because a, b, d are not consecutive/adjacent in the alphabet, and c is missing.
solve("dabc") = True, because it contains a, b, c, d
solve("abbc") = False, because b does not occur once.
solve("v") = True
```
All inputs will be lowercase letters. 

More examples in test cases. Good luck!

Source: codewars | Difficulty: EASY
Tags: Fundamentals

Starter code: def solve(st):
	

Solutions:
import string

def solve(st):
	return ''.join(sorted(st)) in string.ascii_letters


def solve(s):
	return ''.join(sorted(s)) in 'abcdefghijklmnopqrstuvwxyz'


def solve(s):
	return len(s) == len(set(s)) == ord(max(s)) - ord(min(s)) + 1


def solve(stg):
	return ''.join(sorted(stg)) in 'abcdefghijklmnopqrstuvwxyz'


def solve(st):
	b = list(st)
	c = []
	for i in range(len(st)):
		c.append(ord(b[i]))
	for i in c:
		if c.count(i) != 1:
			return False
	for i in range(min(c), max(c)):
		if i + 1 not in c:
			return False
	return True


def solve(st):
	a = ''.join(sorted(st))
	if a in 'abcdefghijklmnopqrstuvwxyz':
		return True
	else:
		return False


alph = 'abcdefghijklmnopqrstuvwxyz'

def solve(st):
	return ''.join(sorted(st)) in alph


def solve(st):
	new_st = []
	letters = 'abcdefghijklmnopqrstuvwxyz'
	for i in st:
		new_st.append(letters.index(i))
	new_st = sorted(new_st)
	a = [new_st[i + 1] - new_st[i] for i in range(len(new_st) - 1)]
	if a.count(1) == len(st) - 1:
		return True
	return False


def solve(s):
	return ''.join(sorted(list(s), key=str.lower)) in 'abcdefghijklmnopqrstuvwxyz'