Complete the  function `scramble(str1, str2)` that returns `true` if a portion of ```str1``` characters can be rearranged to match ```str2```, otherwise returns ```false```.

**Notes:**
* Only lower case letters will be used (a-z). No punctuation or digits will be included.
* Performance needs to be considered

## Examples

```python
scramble('rkqodlw', 'world') ==> True
scramble('cedewaraaossoqqyt', 'codewars') ==> True
scramble('katas', 'steak') ==> False
```

Difficulty: introductory

Starter code:

def scramble(s1, s2):
	

Solutions:
def scramble(s1,s2):
    for c in set(s2):
        if s1.count(c) < s2.count(c):
            return False
    return True

from collections import Counter
def scramble(s1,s2):
    # Counter basically creates a dictionary of counts and letters
    # Using set subtraction, we know that if anything is left over,
    # something exists in s2 that doesn't exist in s1
    return len(Counter(s2)- Counter(s1)) == 0

def scramble(s1, s2):
    return not any(s1.count(char) < s2.count(char) for char in set(s2))

def scramble(s1,s2):
    return all( s1.count(x) >= s2.count(x) for x in set(s2))
    


def scramble(s1,s2):
    dct={}
    for l in s1:
        if l not in dct:
            dct[l]=1
        else:
            dct[l] +=1
    for l in s2:
        if l not in dct or dct[l] < 1:
            return False
        else:
            dct[l] -= 1
    return True

from collections import Counter

def scramble(s1,s2):
    c1 = Counter(s1)
    c2 = Counter(s2)
    return not (c2 -c1).values()

from collections import Counter
from operator import sub

def scramble(s1,s2):
    return not sub(*map(Counter, (s2,s1)))

from collections import Counter
def scramble(s1,s2):
    return not (Counter(s2) - Counter(s1))

def scramble(s1, s2):
    return all([s1.count(l2) >= s2.count(l2) for l2 in set(s2)])

def scramble(s1,s2):
    return all(s1.count(i)>=s2.count(i) for i in set(s2))

from collections import Counter
scramble = lambda s1, s2: not Counter(s2) - Counter(s1)

scramble=lambda a,b,c=__import__('collections').Counter:not c(b)-c(a)

from collections import Counter
def scramble(s1,s2): return len(Counter(s2) - Counter(s1)) == 0

def scramble(s1, s2):
        return not False in([s1.count(i)>=s2.count(i) for i in set(s2)])

#set() <3


def scramble(s1, s2):
    a='abcdefghijklmnopqrstuvwxyz'
    b=[]
    for char in a:
        if s1.count(char)>=s2.count(char):
            b.append(True)
        else:
            b.append(False)
    if len(set(b))<=1:
        return(True)
    else:
        return(False)

def scramble(s1, s2):
    str1 = {}
    str2 = {}
    for s in s1:
        try:
            str1[s] = str1[s] + 1
        except KeyError:
            str1[s] = 1
    for s in s2:
        try:
            str2[s] = str2[s] + 1
        except KeyError:
            str2[s] = 1
    for key in str2:
        try:
            if str1[key] < str2[key]:
                return False
        except KeyError:
            return False
    return True


def scramble(s1, s2):
    """ returns true of a porton of s1 can be rearranged to match s2. Basic concept: use an indicator 
    dictionary  of the counts of letters in s2, check if s1 has sufficient occurences of each letter to make
    that indicator == 0 for all chars"""
    
    cts = [s2.count(i) for i in list(set(s2)) ] # count occurence of letters
    dic = dict(zip(list(set(s2)) ,cts)) # dictionary of counts.
    truth = True
    
    for char in list(s1):
        try:
            if dic[char] > 0: # If dic[char] already == 0, we know there are suff. occurrences of that char
                dic[char] = (dic[char] - 1) 
        except KeyError:
            pass
    
    if sum(dic.values()) > 0: # if all chars sufficiently occur, sum should be 0
        truth = False

    return truth

# Stack solution:
#    Loop through s2 once, pushing char occurances onto the stack
#    Loop through s1 once, popping any occurances of s2 chars from the stacks
#    If any stack has a count greater than 0, than it's False
def scramble(s1, s2):
    stacks = {}
    
    for char in s2:
        # Checking if stacks already has a key:value pair with the key char
        if char in stacks:
            stacks[char] += 1
        else:
            stacks[char] = 1
    
    for char in s1:
        if char in stacks:
            stacks[char] -= 1
  
    return max(stacks.values()) <= 0

'''
# Turn strings into lists, remove the appropriate element, and keep track of it to compare at the end
# Takes too long, but correct output
def scramble(s1, s2):
    source = [char for char in s1]
    tokens = [char for char in s2]
    result = []
    
    for char in tokens:
        if char in source:
            result.append(char)
            source.remove(char)
    return len(result) == len(tokens)
'''

'''
# Turn strings into lists, remove the appropriate element, and catch ValueError exceptions that signify False-ness
# Takes too long but correct output
def scramble(s1, s2):
    source = [char for char in s1]
    try:
        for char in s2:
            source.remove(char)
    except ValueError:
        return False
    return True
'''

'''
# Count every instance of every char in s1 and s2, then compare the number of s2 char appearances in s1
# slowest of all three
def scramble(s1, s2):
    source = [char for char in s1]
    source.sort()
    tokens = [char for char in s2]
    tokens.sort()
    
    source_len = len(source)
    source_index = 0
    for char in tokens:
        while char != source[source_index]:
            source_index += 1
            if source_index >= source_len:
                return False
    return True
'''

from collections import Counter as c
def scramble(s1, s2):
    s1 = c(s1)
    s2 = c(s2)
    for i in s2:
        if s1[i]<s2[i]:
            return False
    return True

from collections import defaultdict
import gc
def scramble(s1,s2):
#   print(s1,s2)
    a = defaultdict(lambda: False)
    for item in s2:
        a[item] = a.get(item, 0) + 1
    # print(a)
    b = defaultdict(lambda: False)
    for item in s1:
        b[item] = b.get(item, 0) + 1
    # print(b)
    try:
        for item in a:
#           print(a[item],b[item])
            if b[item] and a[item]<=int(b[item]):
                # print(item)
                pass
            else:
                return False
        return True
    finally:
        del a,b,s1,s2
        gc.collect()




def scramble(s1, s2):
    def is_subsequence(needle, haystack):
        it = iter(haystack)
        return all(c in it for c in needle)
    return is_subsequence(sorted(s2), sorted(s1))

def scramble(s1, s2):
    for c in set(s2):
        if s2.count(c) > s1.count(c):
            return False
    return True

def scramble(s1,s2):
    for i in "abcdefghijklmnopqrstuvwxyz":
        if s1.count(i) < s2.count(i):
            return False
    return True

def scramble(s1,s2):
    return all([s2.count(c) <= s1.count(c) for c in set(s2)])

def scramble(s1, s2):
    it = iter(sorted(s1))
    return all(c in it for c in sorted(s2))

def scramble(s1,s2):

    for letter in "abcdefghijklmnopqrstuvwxyz":
        if s1.count(letter) < s2.count(letter):
            return False
    return True
            
            
    


def scramble(s1,s2):
    for letter in 'abcdefghijklmnopqrstuwvxyz':
        if s1.count(letter) < s2.count(letter): return False
    return True




#def costam(s1,s2)
#    print s1
#    for letter in s2:
#        if letter in s1:     
#            m = s1.index(letter)
#            s1 = s1[:m]+s1[m+1:]
#        else: return False
#    return True


class scramble(zip):
    def __eq__(self, other):
        return True

def scramble(str, wrd):
    w=set(wrd)
    for i in w:
        if str.count(i) < wrd.count(i):
            return False
    return True

from collections import  Counter
def scramble(s1, s2):
   
    dict = Counter(s1)
    dict1 = Counter(s2)

    for k in dict1.keys():
        if (not k in dict.keys()):
            return False
        if dict1[k] > dict[k]:
            return False

    return True

from collections import Counter

def scramble(s1, s2):
    se1 = Counter(s1)
    se2 = Counter(s2)
    return se1|se2 == se1

from collections import Counter
def scramble(s1, s2):
    return True if len(Counter(s2)-Counter(s1))==0 else False

def scramble(s1,s2):
    def ccount(s):
        d = {}
        for c in s:
            d[c] = d.get(c,0) + 1
        return d
        
    d1 = ccount(s1)
    for c, count in list(ccount(s2).items()):
        if d1.get(c, 0) < count:
            return False
    return True


def scramble(s1,s2):
    for char in set(s2):
         if s1.count(char) < s2.count(char):
           return False
    return True

from collections import deque

def scramble(s1,s2):
    s1 = deque(sorted(s1))
    s2 = sorted(s2)
    for letter in s2:
        if len(s1) == 0:
            return False
        while len(s1):
            next_letter = s1.popleft()
            if next_letter == letter:
                break
            if next_letter > letter:
                return False
    return True

scramble = lambda s1,s2: len([x for x in [(char, s2.count(char), s1.count(char)) for char in set(s2)] if x[2] < x[1]]) == 0

def scramble(s1,s2):
    l=[]
    for x in s2:
        if x not in l:
            if s1.count(x)<s2.count(x):
                return False
            l.append(x)
    return True

from collections import Counter

def scramble(s1, s2):
    if not set(s2).issubset(set(s1)):
        return False
        
    # your code here
    s1_counts = Counter(s1)
    s2_counts = Counter(s2)
    
    s1_counts.subtract(s2_counts)
    
    return not any([x for x in list(s1_counts.items()) if x[1] < 0]) 


def scramble(s1, s2):
    a = [s1.count(chr(i))-s2.count(chr(i)) for i in range(97,123)]
    for i in a:
        if i<0:
            return False
    return True

from collections import Counter

def scramble(s1,s2):
    a = Counter(s1)
    b = Counter(s2)
    a.subtract(b)
    new = []
    for i in a:
        if a[i] >= 0:
            new.append(i)
    return len(new) == len(a)





from collections import Counter
def scramble(s1, s2):
    a = Counter(s1)
    b = Counter(s2)

    
    for k,v in b.items():
        if k not in a.keys() or a[k] < v:
            return False
    
    return True

def scramble(s1, s2):
    d1, d2 = {}, {}
    for i in s1:
        if i not in d1:
            d1[i] = 1
        else:
            d1[i] += 1
    
    for i in s2:
        if i not in d2:
            d2[i] = 1
        else:
            d2[i] += 1
            
    for key in list(d2.keys()):
        if not key in list(d1.keys()) or d1[key]< d2[key]:
            return False
    return True


def scramble(s1, s2):
    s1_count = dict.fromkeys(set(s1),0)
    for i in s1:
        s1_count[i] += 1
    try:
        for i in s2:
            s1_count[i] -= 1
    except:
        return False
    return all(i >= 0 for i in s1_count.values())

def scramble(s1, s2):
    s1_dict = {}
    for i in s1:
        if i in s1_dict:
            s1_dict[i] += 1
        else:
            s1_dict[i] = 1
    s2_dict = {}
    for i in s2:
        if i in s2_dict:
            s2_dict[i] += 1
        else:
            s2_dict[i] = 1
    for k, v in  s2_dict.items():
        if k not in s1_dict or s1_dict[k] < v:
            return False
    return True

from collections import Counter
def scramble(s1, s2):
    c1 = Counter(s1)
    c2 = Counter(s2)
    c1.subtract(c2)
    c3 = [v<0 for k,v in c1.items() if k in c2.keys()]
    
    return not any(c3)

from collections import Counter 
def scramble(s1, s2):
    s1 = list(s1)
    s2 = list(s2)
    s2 = list((Counter(s2) - Counter(s1)).elements())
    if len(s2) > 0:
        return False
    else:
        return True

from collections import Counter
def scramble(s1, s2):
    if set(s1) < set(s2):
        return False
    cnt1 = Counter(s1)
    cnt2 = Counter(s2)
    cnt1.subtract(cnt2)
    notOk = [x < 0 for x in list(cnt1.values())]
    return not any(notOk)
    


def scramble(s1, s2):
    if len(s2) > len(s1):
        return False
    let1 = [s1.count(chr(i)) for i in range (97, 123)]
    let2 = [s2.count(chr(i)) for i in range (97, 123)]
    sub = [True if (let1[i] >= let2[i]) else False for i in range(26)]
    return (True if False not in sub else False)

import string
alphabet = {key: idx for idx, key in enumerate(string.ascii_lowercase)}

def scramble(s1, s2):
    used_words1 = [0] * 26
    used_words2 = [0] * 26
    for element in s1:
        used_words1[alphabet[element]] += 1
    for element in s2:
        used_words2[alphabet[element]] += 1
    for i in range(26):
        if used_words2[i] > used_words1[i]:
            return False
    return True
        


def scramble(s1, s2):
    while(len(s2) > 0):
        if(s1.count(s2[0]) < s2.count(s2[0])):
            return False
        else:
            s2 = s2.replace(s2[0], '')
    return True


def scramble(s1, s2):
    clean = ""
    boolean = []
    for i in s2:
        if i not in clean:
            clean = clean + i
    for i in clean:
        if s2.count(i) > s1.count(i):
            return False
    return True

def scramble(s1, s2):
    for letter in 'abcdefghijklmnopqrstuvwxyz' :
        if s2.count(letter) <= s1.count(letter) : continue
        else : return False
    return True

#Tests whether a portion of s1 can be rearranged to match s2

from collections import Counter

def scramble(s1, s2):

    count_letters = Counter(s1)
    count_letters.subtract(Counter(s2))
    return (all(n >= 0 for n in count_letters.values()))

def scramble(s1, s2):
    s1_dict = dict()
    for char in s1:
        if char in s1_dict:
            s1_dict[char] = s1_dict[char] + 1
        else:
            s1_dict[char] = 1
    for char in s2:
        if char not in s1_dict or s1_dict[char] == 0:
            return False
        else:
            s1_dict[char] = s1_dict[char] - 1
    return True


def scramble(s1, s2):
    if len(s1) < len(s2):
        return False
    s1_dict = {}
    s2_dict = {}
    for char in s1:
        try:
            s1_dict[char] += 1
        except KeyError:
            s1_dict[char] = 1
    for char in s2:
        try:
            s2_dict[char] += 1
        except KeyError:
            s2_dict[char] = 1
    for key in s2_dict:
        try:
            if s1_dict[key] < s2_dict[key]:
                return False
        except KeyError:
            return False
    return True


def scramble(s1, s2):
    return all((s1.count(l) - s2.count(l)) >= 0 for l in set(s2))
    


def scramble(s1, s2):
    #for ltr in s2:
    #    if s2.count(ltr) > s1.count(ltr):
    #        return False
    s1ct = {}
    for ltr in s1:
        if ltr in s1ct.keys():
            s1ct[ltr] += 1
        else:
            s1ct[ltr] = 1

    s2ct = {}
    for ltr in s2:
        if ltr in s2ct.keys():
            s2ct[ltr] += 1
        else:
            s2ct[ltr] = 1

    for ltr in s2ct.keys():
        if ltr not in s1ct.keys():
            return False
        if s2ct[ltr] > s1ct[ltr]:
            return False
    return True

from collections import Counter

def scramble(s1, s2):
    s1 = Counter(s1)
    s2 = Counter(s2)
    return len([c for c in s2 if s1[c] >= s2[c]]) == len(s2.keys())

from collections import Counter

def scramble(s1, s2):
    one_split = list(s1)
    two_split = list(s2)
    count = 0
    copy = two_split[::]
    one = Counter(one_split)
    two = Counter(two_split)
    for x in two_split:
        if x not in list(two.keys()):
            return False
        if one[x] < two[x]:
            return False
        
    return True

    
    
    
            

  
   



def scramble(s1, s2):    
    s1 = list(s1)
    s2 = list(s2)
    
    s1.sort()
    s2.sort()
    
    len1 = len(s1)
    len2 = len(s2)
        
    i = 0
    j = 0
        
        
    while i < len1 and j < len2:
        if (len1 - i) < (len2 - j):
            return False
        
        if s1[i] == s2[j]:
            i += 1
            j += 1  
            
        elif s1[i] != s2[j]:
            i += 1
    
    
    if j == len(s2):
        return True
    
    return False
            
            


def scramble(s1, s2):
    j,k=1,1
    a={chr(i):0 for i in range(97,123)}
    b={chr(i):0 for i in range(97,123)}
    for i in s1:
        if i not in a:
            continue    
        else:
            a[i]=a[i]+1
    for n in s2:
        if n not in b:
            continue    
        else:
            b[n]=b[n]+1
    for i in s2:
        if a[i]>=b[i]:
            pass
        else:
            return False
    return True    
    # your code here


from collections import Counter as count
def scramble(s1,s2):
    return len(count(s2)- count(s1)) == 0

def scramble(s1, s2):
    for c in "qwertyuiopasdfghjklzxcvbnm":
        if s1.count(c) < s2.count(c): return False
    return True


def scramble(s1, s2):
    Mot = "".join(dict.fromkeys(s2))
    for i in range(len(Mot)):
        if s1.count(Mot[i])<s2.count(Mot[i]):
            return False
            
    return True
    # your code here


from collections import Counter

def scramble(s1, s2):
    return True if sum(((Counter(s2) & Counter(s1)).values())) == len(s2) else False

def scramble(s1, s2):
    d1={}
    for i in set(s1):
        d1[i]=s1.count(i)
    for i in set(s2):
        try:
            if s2.count(i)>d1[i]:
                return False
        except:
            return False
    return True

def scramble(s1, s2):
    set1=set(s1)
    set2=set(s2)
    for letter in set2:
        if letter not in set1:return False
        if s1.count(letter)<s2.count(letter): return False
    else:
        return True


def scramble(s1, s2):
    import numpy
    options={}
    for i in s1:
        if i in options:
            options[i]+=1
        else:
            options[i]=1
    word={}
    for i in s2:
        if i not in options:
            return False
        if i in word:
            word[i]+=1
        else:
            word[i]=1
    for i in word:
        if word[i]>options[i]:
            return False
    return True

def scramble(s1, s2):
    s1_counter = [0] * 256
    s2_counter = {}

    for c in s1:
        idx = ord(c)
        s1_counter[idx] += 1

    for c in s2:
        if c in s2_counter:
            s2_counter[c] += 1
        else:
            s2_counter[c] = 1

    for (key, value) in s2_counter.items():
        idx = ord(key)
        if s1_counter[idx] < value:
            return False

    return True

def scramble(s1, s2):
    s=list(set(s2))
    for i in s:
        if s1.count(i)<s2.count(i):
            return False
    return True
            
            


def scramble(s1, s2):
    
    # other solutions using list timed-out so had to use map.
    
    # create maps of count of two string.
    char_count_s1 = {c:s1.count(c) for c in set(s1) }
    char_count_s2 = {c:s2.count(c) for c in set(s2) }
    
    for c in char_count_s2:
        if c not in char_count_s1:
            return False
        elif char_count_s1[c] < char_count_s2[c]:
            return False
    
    return True

def scramble(s1, s2):
    for l in set(s2):
        if l not in s1 or s1.count(l) < s2.count(l):
            return False
    return True

from collections import Counter

def scramble(s1, s2):
    for c in set(s2):
        if s2.count(c) <= s1.count(c):
            continue
        else:
            return False
    return True


scramble=lambda s,t:(lambda c,d:all(c.get(o,0)>=d[o] for o in t))({i:s.count(i) for i in set(s)},{i:t.count(i) for i in set(t)})

def scramble(s1, s2):
    counter01 = [0] * 26
    counter02 = [0] * 26
    
    for char in s1:
        counter01[ord(char) - 97] += 1
        
    for char in s2:
        counter02[ord(char) - 97] += 1
        
    for i in range(26):
        if counter01[i] < counter02[i]:
            return False
        
    return True

def scramble(s1, s2):
    s2_dict = {}
    for c in set(s2):
        s2_dict[c] = s2.count(c)
    
    output = True
    for c in sorted(s2_dict, key = s2_dict.get, reverse=True):
        s2_count = s2_dict[c]
        if s2_count > s1.count(c):
            output = False
            break
    return output

def scramble(s1, s2):
    s1_dict = dict()
    s2_dict = dict()

    s2_set = set(s2)

    for c in s2_set:
        s2_dict[c] = s2.count(c)
        s1_dict[c] = s1.count(c)

    for c in s2_set:  
        if c not in s1_dict or s2_dict[c] > s1_dict[c]: 
            return False

    return True

def scramble(s1, s2):
    c= {item:s1.count(item) for item in set(s1)}
    d = {item:s2.count(item) for item in set(s2)}
    for item in d:
        e = c.get(item) or None
        if not e or e < d.get(item):
            return False
    return True

def scramble(s1, s2):
    dict_s1 = {}
    for char in s1:
        dict_s1[char] = dict_s1[char] + 1 if char in dict_s1.keys() else 1
    
    for char in set(s2):
        if not char in dict_s1.keys():
            return False
        if s2.count(char) > dict_s1[char]:
            return False
        dict_s1[char] -= s2.count(char)
    return True

from collections import Counter

def scramble(s1, s2):
    d1 = dict(Counter(s1))
    d2 = dict(Counter(s2))
    d3 = {k: v for k,v in d1.items() if k in d2.keys()}
    missing = {k:v for k,v in d2.items() if k not in d3}
    
    if len(missing) >= 1:
        return False
    elif len(s2) == 0 or len(s1) == 0:
        return False
    elif len(missing) == 0:
        calc = {k: d3[k]- d2[k] for k in d2.keys() & d3}
        return True if all(value >= 0 for value in calc.values()) else False

def scramble(s1, s2):
    list_chr=tuple(set(s2))
    for i in list_chr:
        if s1.count(i)<s2.count(i):
            return False
    return True

def scramble(s1, s2):
    fr = set(s1)
    sc = set(s2)
    for i in sc:
        if i not in fr:
            return False
        elif i in fr:
            if s1.count(i) < s2.count(i):
                return False            
    return True


def scramble(s1, s2):
    if None in (s1, s2):
        return False
    
    passed = []   #Added to avoid wasting time on suitable letters
    for letter in s2:
        if letter in passed: continue
        if (letter not in s1) or (s2.count(letter) > s1.count(letter)): return False #2nd condition VERY IMP, cause this was not at all obvious (guess I missed it completely), i.e.,must consider number of letters in s2 and s1
        passed.append(letter)
    else: return True

from collections import Counter
def scramble(s1, s2):
    t1 = Counter(s1)
    t2 = Counter(s2)
    d = t2 - t1
    return len(d) == 0

def scramble(string_to_rearrange, string_to_match):
    letters_in_string_to_match = {}
    for letter in string_to_match:
        if letter not in letters_in_string_to_match:
            letters_in_string_to_match[letter] = string_to_match.count(letter)
    letters_in_string_to_rearrange = {}
    for letter in string_to_rearrange:
        if letter not in letters_in_string_to_rearrange:
            letters_in_string_to_rearrange[letter] = string_to_rearrange.count(letter)
    for letter in letters_in_string_to_match:
        try:
            if letters_in_string_to_match[letter] > letters_in_string_to_rearrange[letter]:
                return False
        except KeyError:
            return False
    return True


from collections import Counter
def scramble(s1, s2):
    l = Counter(s1)
    w = Counter(s2)
    diff = w - l
    return len(diff) == 0

def scramble(s1, s2):
    unique_letters = list(set(s2))
    count_letters = [s2.count(x) for x in unique_letters]
    return not False in [s1.count(x) >= count_letters[i] for i,x in enumerate(unique_letters)]

def scramble(s1, s2):
    for el in set(s2):
        if not s1.count(el) >= s2.count(el):
            return False
    return True

def scramble(s1, s2):
    list=[]
    for letter in s2:
        if letter in list:
            continue
        else:
            list.append(letter)
        if s2.count(letter) <= s1.count(letter):
            pass
        else:
            return False
    return True

def scramble(str1,str2):
    if len(str1) < len(str2):
        return False
    str1 = "".join(sorted(str1))
    str2 = "".join(sorted(str2))
    i = 0
    while i < len(str2):
        N = str2.count(str2[i])
        if str1.count(str2[i]) < N:
            return False
        i += N
    return True

def scramble(s1, s2):
    a1 = 26*[0]
    for c in s1:
        a1[ord(c)-97] += 1
        
    for c in s2:
        a1[ord(c)-97] -= 1
        if a1[ord(c)-97] < 0:
            return False
    return True

def scramble(s1, s2):
    from collections import Counter
    c1 = Counter(s1)
    c2 = Counter(s2)
    for key, val in c2.items():
        if key not in c1.keys():
            return False 
        else:
            if val > c1[key]:
                return False
    return True

def map_char_count(s):
    char_count = {}
    for c in s:
        if c in char_count:
            char_count[c] += 1
        else:
            char_count[c] = 1
    return char_count

def scramble(s1, s2):
    s1_count = map_char_count(s1)
    s2_count = map_char_count(s2)
    for k, v in list(s2_count.items()):
        if k not in s1_count or s1_count[k] < v:
            return False
    return True
    


def scramble(s1, s2):
    for char in list(set(list(s2))):
        if char not in s1: return False
        if s2.count(char) > s1.count(char): return False
    return True

def scramble(s1, s2):
    st1, st2 = set(s1), set(s2)  # Use sets for optimization

    if not st2.issubset(st1):  # Check if every char in s2 is present in s1, if not, game over
        return False
    else:
        if not all(map(lambda char : s1.count(char) >= s2.count(char), st2)): # Use map as an alternative to lists
            return False
        else:
            return True

def scramble(s1, s2):
    seen = []
    for letter in s2:
        if letter not in s1:
            return False
    for letter in s2:
        if letter in seen: continue
        if s1.count(letter) < s2.count(letter):
            return False
        else: seen.append(letter)
    return True

from collections import Counter
def scramble(s1, s2):
    s1_count, s2_count = Counter(s1), Counter(s2)
    return all(s1_count[letter] >= s2_count[letter] for letter in s2) 

def scramble(s1, s2):
    d1={}
    for ch in s1:
        if ch not in d1: d1[ch]=1
        else: d1[ch] = d1[ch]+1
    for ch in s2:
        try:
            if d1[ch]==0: return False
        except KeyError: 
            return False
        else: d1[ch]=d1[ch]-1
    return True

from collections import Counter
def scramble(s1, s2):
    d1, d2 = Counter(s1), Counter(s2)
    for k, v in list(d2.items()):
        if v > d1[k]:
            return False
    return True