[XKCD 1609]( http://xkcd.com/1609/) provides us with the following fun fact:

![If anyone tries this on you, the best reply is a deadpan "Oh yeah, that's a common potato chip flavor in Canada."](http://imgs.xkcd.com/comics/food_combinations.png)

### Task:

Given an array containing a list of good foods, return a string containing the assertion that any two of the individually good foods are really good when combined.

eg: `"You know what's actually really good? Pancakes and relish."`

### Examples:
```python
Good_foods = ["Ice cream", "Ham", "Relish", "Pancakes", "Ketchup", "Cheese", "Eggs", "Cupcakes", "Sour cream", "Hot chocolate", "Avocado", "Skittles"]

actually_really_good( Good_foods ) #  "You know what's actually really good? Pancakes and relish."

actually_really_good( ['Peanut butter'] ) #  "You know what's actually really good? Peanut butter and more peanut butter."

actually_really_good( [] ) #  "You know what's actually really good? Nothing!"
```

### Notes:
There are many different valid combinations of 2 foods it doesn't matter which one you choose.  
But there should be 2 different foods listed **unless** there was only one food given in the input array.   
Capitalization should be correct, the first given food should be capitalized, but the second should not.   
The input array should not be modified by the method.   

The test cases for this kata are fairly complicated, see if you can trick them. (Then let me know about it in the discourse.)   

The original kata language is *Ruby*

### Bonus:
If you thought this kata was easy, try this one: [Testing 'Food combinations'](http://www.codewars.com/kata/testing-food-combinations) in which you get to write a method similar to the one the tests here use to check that a result is valid and returns any errors it has.

Difficulty: introductory

Starter code:

def actually_really_good(foods):
	

Solutions:
OUTPUT = 'You know what\'s actually really good? {}'.format


def actually_really_good(foods):
    foods = list(set(foods))
    length = len(foods)
    if length == 0:
        return OUTPUT('Nothing!')
    return OUTPUT('{} and more {}.'.format(
        foods[0].capitalize(), foods[0 if length == 1 else 1].lower()))


import random
def actually_really_good(foods):
    if foods == []: return "You know what's actually really good? Nothing!"
    elif len(foods) == 1:
        s = random.choice(foods)
        return "You know what's actually really good? " + s.capitalize() + " and more " + s.lower() + "."
    else:
        return "You know what's actually really good? " + random.choice(foods).capitalize() + " and more " + random.choice(foods).lower() + "."


from random import choice
def actually_really_good(foods):
    res, foods = 'Nothing!', [f.lower() for f in foods]
    if len(foods)==1: 
        res="{} and more {}.".format(foods[0].capitalize(), foods[0])
    elif  len(foods)>=2:
        res="{} and {}.".format(foods[0].capitalize(), choice(foods[1:]))
    return "You know what's actually really good? {}".format(res)

def actually_really_good(foods):
    if len(foods) > 1:
        good = "{} and {}.".format(foods[0].capitalize(), foods[1].lower())
    elif len(foods) == 1:
        good = "{} and more {}.".format(foods[0].capitalize(), foods[0].lower())
    else:
        good = "Nothing!"
    return "You know what's actually really good? {}".format(good)

import random

def actually_really_good(foods):
    if not foods:
        return "You know what's actually really good? Nothing!"
    food1, food2 = random.sample(foods, 2) if len(foods) > 1 else foods + ["more {}".format(foods[0])]
    return "You know what's actually really good? {} and {}.".format(food1.capitalize(), food2.lower())

def actually_really_good(foods):
    def formatter(pairFood):
        return (f(s) for f,s in zip((str.capitalize, str.lower), pairFood))
    START = "You know what's actually really good? "
    return START + ("Nothing!" if not foods else
                    "{1} and {0}{2}.".format("more "*(len(foods)==1), *formatter(foods*2 if len(foods)==1 else foods[:2])))

actually_really_good=lambda a:"You know what's actually really good? "+(a and"%s and %s."%(a[0],"more "*(a[0]==a[-1])+a[-1])or"Nothing!").capitalize()

def actually_really_good(foods):
    return "You know what's actually really good? {}".format('Nothing!' if not foods else '{} and {}.'.format(str.capitalize(foods[0]), (foods[1] if len(foods) > 1 else 'more %s' % foods[0]).lower()))

from random import shuffle
def actually_really_good(foods):
    if not foods: return "You know what's actually really good? Nothing!"
    elif len(foods) == 1:
        return "You know what's actually really good? {0} and more {1}.".format(foods[0].capitalize(), foods[0].lower())
    elif len(foods) > 2: shuffle(foods)
    
    return "You know what's actually really good? {0} and {1}.".format(foods[0].capitalize(), foods[1].lower())

def actually_really_good(foods):   
    phrase="You know what's actually really good? "
    if len(foods)==0:return phrase+"Nothing!"
    elif len(foods)==1:return phrase+f"{foods[0].capitalize()} and more {foods[0].lower()}."
    else:return phrase+f"{foods[0].capitalize()} and {foods[1].lower()}."