The objective is to disambiguate two given names: the original with another

Let's start simple, and just work with plain ascii strings. 

The function ```could_be``` is given the original name and another one to test
against. 

```python
# should return True if the other name could be the same person 
> could_be("Chuck Norris", "Chuck")
True

# should False otherwise (whatever you may personnaly think)
> could_be("Chuck Norris", "superman")
False
``` 

Let's say your name is *Carlos Ray Norris*, your objective is to return True if
the other given name matches any combinaison of the original fullname:

```python
could_be("Carlos Ray Norris", "Carlos Ray Norris") : True
could_be("Carlos Ray Norris", "Carlos Ray") : True
could_be("Carlos Ray Norris", "Norris") : True
could_be("Carlos Ray Norris", "Norris Carlos") : True
```

For the sake of simplicity:

 * the function is case sensitive and accent sensitive for now
 * it is also punctuation sensitive
 * an empty other name should not match any original
 * an empty orginal name should not be matchable
 * the function is not symmetrical

The following matches should therefore fail:

```python
could_be("Carlos Ray Norris", " ") : False
could_be("Carlos Ray Norris", "carlos") : False
could_be("Carlos Ray Norris", "Norris!") : False
could_be("Carlos Ray Norris", "Carlos-Ray Norris") : False
could_be("Ray Norris", "Carlos Ray Norris") : False
could_be("Carlos", "Carlos Ray Norris") : False
```

Too easy ? Try the next steps: 

* [Author Disambiguation: a name is a Name!](https://www.codewars.com/kata/author-disambiguation-a-name-is-a-name)
* or even harder: [Author Disambiguation: Signatures worth it](https://www.codewars.com/kata/author-disambiguation-signatures-worth-it)

Source: codewars | Difficulty: EASY
Tags: Fundamentals

Starter code: def could_be(original, another):
	

Solutions:
def could_be(original, another):
	if not another.strip():
		return False
	return all((name in original.split() for name in another.split()))


def could_be(original, another):
	(original, another) = (set(s.split()) for s in (original, another))
	return bool(another) and another <= original


def could_be(original, another):
	(s1, s2) = (set(another.split()), set(original.split()))
	return len(s1) > 0 and len(s2) > 0 and (s1 <= s2)


def could_be(original, another):
	(o, a) = (set(original.split()), set(another.split()))
	return a.issubset(o) if a and o else False


def could_be(original, another):
	original_words = original.split()
	another_words = another.split()
	if not original_words or not another_words:
		return False
	return all((w in original_words for w in another_words))


def could_be(original, another):
	(a, b) = (original.split(), another.split())
	return bool(a and b and (set(a) >= set(b)))


def could_be(original, another):
	if not original.strip() or not another.strip():
		return False
	return set(another.split()).issubset(original.split())


could_be = lambda a, b, s=set: s() < s(b.split()) <= s(a.split()) > s()


def could_be(original, another):
	return bool(original and another and (set(original.split(' ')) >= set(another.split(' '))))


def could_be(o, a):
	return all([x in o.split() for x in a.split()]) if a.strip() and o.strip() else False