### Combine strings function
```if:coffeescript,haskell,javascript
Create a function named `combineNames` that accepts two parameters (first and last name). The function should return the full name.
```
```if:python,ruby
Create a function named (`combine_names`) that accepts two parameters (first and last name). The function should return the full name.
```
```if:csharp
Create a function named (`Combine_names`) that accepts two parameters (first and last name). The function should return the full name.
```

Example: 
```python
combine_names('James', 'Stevens')
```
returns:
```python
'James Stevens'
```

Difficulty: introductory

Starter code:

def combine_names(first, last):
	

Solutions:
def combine_names(first, last):
    return first + " " + last

def combine_names(*args):
    return ' '.join(args)


def combine_names(first, second):
    return '{} {}'.format(first, second)

def combine_names(a,b):
    return '%s %s' %(a,b)

def combine_names(*ns): return ' '.join(ns)

# Create the combine_names function here
def combine_names(first_name: str, last_name: str) -> str:
    return f'{first_name} {last_name}'

def combine_names(first, last):
  return '{:s} {:s}'.format(first, last)

def combine_names(one, two):
    assert isinstance(one, str)
    assert isinstance(two, str)
    return one+' '+two

def combine_names(first, last):
    return ' '.join([first, last])

def combine_names(n1, n2):
    return n1+' '+n2

# Create the combine_names function here
def combine_names(a,b):
    return a+' '+b


# Create the combine_names function here
def combine_names(first, last):
    return '''%s %s''' % (first, last)

combine_names = lambda *x: " ".join(x)

def combine_names(*string):
    return ' '.join(string)

combine_names = lambda x,y: " ".join([x,y])

def combine_names(*names):
    return ' '.join(names)

combine_names=lambda*n:' '.join(n)

def combine_names(first_name, last_name):
 return "{0} {1}".format(first_name, last_name)

# Create the combine_names function here
def combine_names(f,l):
  return ' '.join([f,l])

def combine_names(wa,wb):
    return wa + ' ' + wb

combine_names = lambda *args: " ".join(args)

combine_names = '{} {}'.format

combine_names = lambda *a: " ".join(a)

from typing import Tuple

def combine_names(*args: Tuple[str]) -> str:
    """ Get a full name containing two parameters (first and last name). """
    return " ".join(args)

def combine_names(n,n2):
    return n + " " + n2 

def combine_names(name,f_name):
    return name +" "+ f_name

def combine_names(n1,n2):
    return str(n1) + " " + str(n2)

def combine_names(f1,f2):# Create the combine_names function here
    return f1 + ' ' + f2

def combine_names(first, last):
    first = first
    last = last
    answer = first + ' ' + last 
    return answer 

def combine_names(name:str,nik:str)->str:
  result:str = name + " " + nik
  return result  

combine_names = lambda name,surname:f"{name} {surname}"

def combine_names(names,names2):
    return names + ' '+names2

def combine_names(s1,s2):
    return (str(s1)+ " " + str(s2))
# Create the combine_names function here


def combine_names(fist, last_name):
    return fist + ' ' + last_name

def combine_names(f,l):
    return f"{f} {l}"

def combine_names(name, name2):
    return str(name)+" "+str(name2)

def combine_names(*args: str) -> str:
    return " ".join(args)

def combine_names(*arr):
    return ' '.join(arr)

def combine_names(first, second):
    return f"{first} {second}"

def combine_names(x,x1):
    name = x + " " + x1
    return name

combine_names = lambda first_name, last_name: first_name + " " + last_name

# Create the combine_names function here
def combine_names(name, nickname):
    return name + " "+ nickname

def combine_names(x, a):
    return x + ' '+ a

# Create the combine_names function here
def combine_names(z,x):
    l = z + " " + x
    return l

# Create the combine_names function here
def combine_names(j,k):
    return j+' '+ k

def combine_names(*names):
    # the * takes in all the input
    return " ".join(names)
    # .join joins the two strings


def combine_names(F,L):
    return F +" " + L

def combine_names(fname: str, lname: str) -> str:
    return fname + " " + lname

def combine_names(first_name:str, last_name:str):
    return f'{first_name} {last_name}'

def combine_names(name, lastname):
    return "{} {}".format(name, lastname)

def combine_names(name,last):
    return name+" "+last

def combine_names(first, last):
    '''Combines first and last names into a single properly formatted name.'''
    return ' '.join([first, last])

def combine_names(*parts):
    return ' '.join(parts)

def combine_names(*a):
    return '{0} {1}'.format(*a)

def combine_names(n,p):
    return n + " " + p

def combine_names(p1, p2):
    return p1 + ' ' + p2

def combine_names(f,l):
    return " ".join((f,l))

combine_names = lambda *n : ' '.join(list(n))

# Create the combine_names function here
def combine_names(name, surname):
    comb_names = name + ' ' + surname
    return comb_names

def combine_names(fname, lname):
    res = "{} {}".format(fname, lname)
    return res

combine_names = lambda x, y: f'{x} {y}'

combine_names = lambda f,l : f'{f} {l}'

# Create the combine_names function here
def combine_names(firstname, lastname ):
    return f'{firstname} {lastname}'

def combine_names(x, y):
    return "{0} {1}".format(x, y)

def combine_names(first, second):
    return " ".join([first, second])

def combine_names(*args):
   return " ".join([*args]) 

combine_names = lambda n, m: f"{n} {m}"

def combine_names(fore, sur):
    return '{} {}'.format(fore, sur)

# Create the combine_names function here
def combine_names(name1, name2):
    whole = name1 + ' ' + name2
    return whole

def combine_names(surname, name):
    return '{} {}'.format(surname, name)

def combine_names(x,y):
    return f'{x} {y}'

def combine_names(fn, ls):
    return fn + " "+ ls

def combine_names(name1,name2):
    return str(name1 + ' ' + name2)




def combine_names(fn, ln):
    return f"{fn} {ln}"

# Create the combine_names function here
def combine_names(first, last):
    j = first + ' ' + last
    return j

combine_names('James', 'Stevens')

def combine_names (first_name, last_name):
    first_name = first_name + " "
    return first_name + last_name

def combine_names(fname, lname):
    return f"{fname} {lname}"

def combine_names(name1,name2):
    
    full_name = "{} {}".format(name1, name2)
    
    return full_name

# Combines 'first' and 'last'
def combine_names(first, last):
    return f"{first} {last}" # Returns a full-ish name


def combine_names(name, surname):
    a = name + " " + surname 
    return a