In this Kata, two players, Alice and Bob, are playing a palindrome game. Alice starts with `string1`, Bob starts with `string2`, and the board starts out as an empty string. Alice and Bob take turns; during a turn, a player selects a letter from his or her string, removes it from the string, and appends it to the board; if the board becomes a palindrome (of length >= 2), the player wins. Alice makes the first move. Since Bob has the disadvantage of playing second, then he wins automatically if letters run out or the board is never a palindrome. Note also that each player can see the other player's letters.

The problem will be presented as `solve(string1,string2)`. Return 1 if Alice wins and 2 it Bob wins.

For example:
```Haskell
solve("abc","baxy") = 2 -- There is no way for Alice to win. If she starts with 'a', Bob wins by playing 'a'. The same case with 'b'. If Alice starts with 'c', Bob still wins because a palindrome is not possible. Return 2.
solve("eyfjy","ooigvo") = 1 -- Alice plays 'y' and whatever Bob plays, Alice wins by playing another 'y'. Return 1.
solve("abc","xyz") = 2 -- No palindrome is possible, so Bob wins; return 2
solve("gzyqsczkctutjves","hpaqrfwkdntfwnvgs") = 1 -- If Alice plays 'g', Bob wins by playing 'g'. Alice must be clever. She starts with 'z'. She knows that since she has two 'z', the win is guaranteed. Note that she also has two 's'. But she cannot play that. Can you see why? 
solve("rmevmtw","uavtyft") = 1 -- Alice wins by playing 'm'. Can you see why? 
```
Palindrome lengths should be at least `2` characters. More examples in the test cases. 

Good luck!

Difficulty: introductory

Starter code:

def solve(str1, str2):
	

Solutions:
from collections import Counter

def solve(*args):
    c1, c2 = map(Counter, args)
    return 2 - any(c1[k]-c2[k] >= 2 and k not in c2 for k in c1)

def solve(str1, str2):
    return 2 - any(str1.count(c) > 1 and c not in str2 for c in str1)

def solve(a, b):
    return [2, 1][any(a.count(e) > 1 for e in a if e not in b)]

from collections import Counter

def solve(str1, str2):
    C, S = Counter(str1), set(str2)
    return all(v == 1 or k in S for k,v in C.items()) + 1

def solve(str1, str2):
    s = set(str1) - set(str2)
    return 1 if any(c for c in s if str1.count(c) > 1) else 2 

def solve(str1,str2):
    for i in range(len(str1)):
        if str1[i] not in str2 and str1.count(str1[i]) > 1: return 1
    return 2


solve=lambda s,s1:any(s.count(i)>=2 and i not in s1 for i in s) or 2

solve=lambda Q,S:1 if any(V in Q[1+F:] and V not in S for F,V in enumerate(Q)) else 2

from collections import Counter
def solve(str1,str2):
    c1=Counter(str1)
    for k,v in c1.items():
        if v>=2 and k not in str2:
            return 1
    return 2

def solve(str1,str2):
    a=set(str1)
    return 1 if any(str1.count(i)>1 and i not in str2 for i in a) else 2