Make a function that returns the value multiplied by 50 and increased by 6. If the value entered is a string it should return "Error".

Note: in `C#`, you'll always get the input as a string, so the above applies if the string isn't representing a double value.

Difficulty: EASY
Tags: Fundamentals

Starter code:
def problem(a):
	

Solutions:
def problem(a):
	try:
		return a * 50 + 6
	except TypeError:
		return 'Error'


def problem(a):
	return 'Error' if isinstance(a, str) else a * 50 + 6


def problem(a):
	try:
		return float(a) * 50 + 6
	except ValueError:
		return 'Error'


def problem(x):
	return x * 50 + 6 if isinstance(x, (int, float)) else 'Error'


problem = lambda a: 50 * a + 6 if isinstance(a, (int, float)) else 'Error'


def problem(a):
	return 'Error' if type(a) is str else a * 50 + 6


problem = lambda a: 'Error' * isinstance(a, str) or a * 50 + 6


def problem(n):
	return 'Error' if type(n) is str else n * 50 + 6


def problem(a):
	try:
		return a * 50 + 6
	except TypeError as e:
		return 'Error'


from typing import Union

def problem(a: Union[int, str]) -> Union[int, str]:
	try:
		return a * 50 + 6
	except TypeError:
		return 'Error'


def problem(a):
	try:
		print((a, type(a)))
		return float(a) * 50 + 6
	except:
		print((a, type(a)))
		return 'Error'


problem = lambda a: a * 50 + 6 if type(a) in [int, float] else 'Error'


def problem(a):
	if type(a) == str:
		return 'Error'
	else:
		answer = a * 50 + 6
		return answer


def problem(a):
	if type(a) is float or type(a) is int:
		return a * 50 + 6
	else:
		return 'Error'


problem = lambda a: 50 * float(a) + 6 if all((i.isdigit() or i == '.' for i in str(a))) else 'Error'


def problem(a):
	if type(a) == type('str'):
		return 'Error'
	elif type(a) == type(19) or type(9.3):
		return a * 50 + 6
	else:
		return 'Error'


def problem(a):
	if type(a) == type('lol'):
		return 'Error'
	return a * 50 + 6


def problem(a):
	return 50 * a + 6 if type(a) in (int, float) else 'Error'


def problem(a):
	return a * 50 + 6 if str(a).replace('.', '').isdigit() else 'Error'


problem = lambda n: 'Error' if type(n) == str else n * 50 + 6


problem = lambda x: x * 50 + 6 if type(x) in (int, float) else 'Error'


def problem(a):
	z = lambda a: 'Error' if str(a).isalpha() else a * 50 + 6
	return z(a)


def problem(a):
	try:
		if a != str:
			return a * 50 + 6
	except TypeError:
		return 'Error'


def problem(a):
	b = str(a)
	if b.replace('.', '').isdigit():
		return a * 50 + 6
	elif a.isalpha():
		return 'Error'


def problem(a):
	if a == 1.2:
		return a * 50 + 6
	if str(a).isnumeric() or type(a) == 'float':
		return a * 50 + 6
	else:
		return 'Error'


def problem(value):
	try:
		int(value)
	except:
		return 'Error'
	return value * 50 + 6


def problem(a):
	if type(a) == type(4) or type(a) == type(0.12):
		return a * 50 + 6
	else:
		return 'Error'


def isDigit(s):
	try:
		float(s)
		return True
	except ValueError:
		return False

def problem(a):
	if isDigit(a):
		return int(a * 50 + 6)
	else:
		return 'Error'


def problem(a):
	if type(a).__name__ != 'str':
		return a * 50 + 6
	else:
		return 'Error'


def problem(a):
	if isinstance(a, (int, float)):
		print(a)
		resultado = a * 50 + 6
		print(resultado)
		return resultado
	else:
		return 'Error'


def problem(a):
	if str(type(a)) == "<class 'str'>":
		return 'Error'
	else:
		return a * 50 + 6


def problem(a=''):
	try:
		int(a)
		a = a * 50 + 6
		return a
	except ValueError:
		return 'Error'


def problem(a):
	if type(a) == str:
		return 'Error'
	elif type(a) is not str:
		return a * 50 + 6


def problem(a):
	try:
		if type(a) != str:
			return a * 50 + 6
		else:
			return 'Error'
	except ValueError:
		return 'Error'


def problem(a):
	try:
		n = float(a)
		return n * 50 + 6
	except:
		return 'Error'


def problem(a):
	if isinstance(a, (int, float)) == True:
		return a * 50 + 6
	else:
		return 'Error'


def problem(n):
	if type(n) == str:
		return 'Error'
	return n * 50 + 6


def problem(a):
	if type(a) == type('s'):
		return 'Error'
	else:
		return a * 50 + 6
print(problem('jf'))


def problem(a):
	return a * 50 + 6 if type(a) != type('') else 'Error'


problem = lambda a: 'Error' if isinstance(a, str) else 6 + a * 50


def problem(a):
	try:
		if a.isalnum():
			return 'Error'
	except:
		return a * 50 + 6


def problem(a):
	try:
		ans = a * 50 + 6
		return ans
	except:
		if a.isdigit() == False:
			return 'Error'


def problem(a):
	b = 'ma'
	return 'Error' if type(a) == type(b) else a * 50 + 6


def problem(a):
	if a == str(a):
		return 'Error'
	elif a == float(a):
		return a * 50 + 6


def problem(a):
	try:
		a == type(int)
		return a * 50 + 6
	except:
		return 'Error'


def problem(a):
	print(a)
	return a * 50 + 6 if not isinstance(a, str) else 'Error'


def problem(a):
	fifty = 50
	six = 6
	return 'Error' if a == str(a) else a * fifty + six


def problem(a):
	if str(a).isdigit():
		num = int(a) * 50 + 6
		return num
	elif isinstance(a, float):
		num = a * 50 + 6
		return num
	return 'Error'


def problem(a):
	str_ref = isinstance(a, str)
	if str_ref is True:
		return 'Error'
	else:
		return a * 50 + 6


def problem(a):
	value = 0
	if isinstance(a, str):
		return 'Error'
	else:
		value = a * 50
		value = value + 6
		return value


def problem(a):
	if type(a) == int or type(a) == float:
		return int(a * 50 + 6)
	else:
		return 'Error'
print(problem(1.2))


def problem(a):
	x = isinstance(a, str)
	if x == True:
		return 'Error'
	else:
		return a * 50 + 6


def problem(a):
	if type(a) == str:
		return 'Error'
	else:
		result = a * 50 + 6
		return result


def problem(a):
	if a == str(a):
		return 'Error'
	elif a == int(a) or a == float(a):
		return 50 * a + 6


def problem(a):
	print(a, type(a))
	return a * 50 + 6 if isinstance(a, int) or isinstance(a, float) else 'Error'


def problem(a):
	try:
		v = float(a)
		return 50 * v + 6
	except Exception as e:
		return 'Error'


import re

def problem(a):
	if re.match('\\d', str(a)):
		return a * 50 + 6
	else:
		return 'Error'


def problem(a):
	a = str(a)
	return 'Error' if a.isalpha() else 50 * eval(a) + 6