### 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: EASY
Tags: Fundamentals

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)


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


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


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)


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:
	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):
	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)


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


def combine_names(name, nickname):
	return name + ' ' + nickname


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


def combine_names(z, x):
	l = z + ' ' + x
	return l


def combine_names(j, k):
	return j + ' ' + k


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


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


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


def combine_names(name, last):
	return name + ' ' + 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


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


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}'


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])


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


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


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}'


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


def combine_names(first, last):
	return f'{first} {last}'


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