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!

Difficulty: introductory

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(s):
    return len(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"