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)

Difficulty: introductory

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