###Story
Sometimes we are faced with problems when we have a big nested dictionary with which it's hard to work. Now, we need to solve this problem by writing a function that will flatten a given dictionary.

###Info
Python dictionaries are a convenient data type to store and process configurations. They allow you to store data by keys to create nested structures. You are given a dictionary where the keys are strings and the values are strings or dictionaries. The goal is flatten the dictionary, but save the structures in the keys. The result should be a dictionary without the nested dictionaries. The keys should contain paths that contain the parent keys from the original dictionary. The keys in the path are separated by a `/`. If a value is an empty dictionary, then it should be replaced by an empty string `""`.

###Examples
```python
{
    "name": {
        "first": "One",
        "last": "Drone"
    },
    "job": "scout",
    "recent": {},
    "additional": {
        "place": {
            "zone": "1",
            "cell": "2"
        }
    }
}
```
The result will be:
```python
{"name/first": "One",           #one parent
 "name/last": "Drone",
 "job": "scout",                #root key
 "recent": "",                  #empty dict
 "additional/place/zone": "1",  #third level
 "additional/place/cell": "2"}
```

***`Input: An original dictionary as a dict.`***
***`Output: The flattened dictionary as a dict.`***
***`Precondition:
Keys in a dictionary are non-empty strings.
Values in a dictionary are strings or dicts.
root_dictionary != {}`***

```python
flatten({"key": "value"}) == {"key": "value"}
flatten({"key": {"deeper": {"more": {"enough": "value"}}}}) == {"key/deeper/more/enough": "value"}
flatten({"empty": {}}) == {"empty": ""}
```

Difficulty: introductory

Starter code:

def flatten(dictionary):
	

Solutions:
def flatten(dictionary):
    stack = [((), dictionary)]
    result = {}
    while stack:
        path, current = stack.pop()
        for k, v in current.items():
            if v == {}:
                result["/".join((path + (k,)))] = "";
            if isinstance(v, dict):
                stack.append((path + (k,), v))
            else:
                result["/".join((path + (k,)))] = v
    return result

def flatten(dictionary):
    result = {}
    for k, v in dictionary.items():
        if v == {}:
            result[k] = ""
        elif isinstance(v, dict):
            for l, w in flatten(v).items():
                result[k + '/' + l] = w
        else:
            result[k] = v
    return result

def flatten(d):
    result = {}
    for key, value in d.items():
        if value and isinstance(value, dict):
            for k, v in flatten(value).items():
                result[key + '/' + k] = v
        else:
            result[key] = value or ''
    return result

def flatten(dictionary, prefix=[]):
    res = {}
    for key in dictionary.keys():
        if isinstance(dictionary[key], dict) and dictionary[key]:
            res.update(flatten(dictionary[key], prefix + [key]))
        else:
            res["/".join(prefix + [key])] = dictionary[key] or ''
    return res

def flatten(dct):
    
    def extract(dct):
        for k,v in dct.items():
            stk.append(k)
            if isinstance(v,dict) and v: yield from extract(v)
            else:                        yield ('/'.join(stk), v or '')
            stk.pop()
    
    stk = []
    return dict(extract(dct))

def flatten(dictionary):
    result = {}
    for k1,v1 in dictionary.items():
        if type(v1) == str:
            result[k1] = v1
        elif v1:
            for k2,v2 in flatten(v1).items():
                result[f"{k1}/{k2}"] = v2
        else:
            result[k1] = ""
    return result

def flatten(d):
    r = {}
    for x, y in d.items():
        if isinstance(y, dict):
            r.update({f"{x}/{X}" : Y for X, Y in flatten(y).items()} if y else {x: ""})
        else:
            r[x] = y
    return r

def flatten(dictionary):
    stack = [((), dictionary)]
    result = {}
    while stack:
        path, current = stack.pop()
        for k, v in list(current.items()):
            new_path = path + (k,)
            v = v if v else ""
            if isinstance(v, dict):
                stack.append((new_path, v))
            else:
                result["/".join(new_path)] = v
    return result


def flatten(dictionary):
    stack = [("", dictionary)]
    result = {}
    while stack:
        path, current = stack.pop()
        if current:
            if type(current)==dict:
                if path:
                    path+='/'
                for key in current:
                    stack.append((path+key,current[key]))
            else:
                result[path]=current
        elif path:
            result[path]=""
    return result

def flatten(d):
    result = []
    for key in d:
        if isinstance(d[key], str):
            result.append((key, d[key]))
        elif len(d[key]) == 0:
            result.append((key, ""))
        else:
            for key2, value2 in list(flatten(d[key]).items()):
                result.append((key + "/" + key2, value2))
    return dict(result)