100+ Python challenging programming exercises for Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 100+ Python challenging programming exercises for Python   \n",
    "\n",
    "Source: https://github.com/zhiwehu   \n",
    "Work in progress (by K. Malakhova)   \n",
    "<br/>\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Question 1\n",
    "Write a program which will find all such numbers which are divisible by 7 but are not a multiple of 5, between 2000 and 3200 (both included). The numbers obtained should be printed in a comma-separated sequence on a single line.\n",
    "\n",
    "Hints: Consider use range(#begin, #end) method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "numbers = []\n",
    "for number in range(2000, 3201):\n",
    "  if number % 7 == 0 and number % 5 != 0:\n",
    "    numbers.append(str(number))\n",
    "\n",
    "print(','.join(numbers))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Question 2\n",
    "Write a program which can compute the factorial of a given numbers. The results should be printed in a comma-separated sequence on a single line. Suppose the following input is supplied to the program: 8 Then, the output should be: 40320\n",
    "\n",
    "Hints: In case of input data being supplied to the question, it should be assumed to be a console input."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Option 1\n",
    "def factorial(num):\n",
    "    \"\"\"Calculate the factorial of a given number\"\"\"\n",
    "    if num == 0:\n",
    "        return 1\n",
    "    return num * factorial(num - 1)\n",
    "\n",
    "num = int(input('Enter an inger: '))\n",
    "\n",
    "print(f'The factorial of number {num} is {factorial(num)}.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Option 2\n",
    "def factorial(num):\n",
    "    \"\"\"Calculate the factorial of a given number\"\"\"\n",
    "    fact = 1\n",
    "    if num == 0:\n",
    "        return 1\n",
    "    else:\n",
    "        for i in range (1, int(num) + 1):\n",
    "      fact = fact * i\n",
    "    return fact\n",
    "\n",
    "num = int(input('Enter an inger: '))\n",
    "\n",
    "print(f'The factorial of number {num} is {factorial(num)}.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Question 3\n",
    "With a given integral number n, write a program to generate a dictionary that contains (i, i*i) such that is an integral number between 1 and n (both included). and then the program should print the dictionary.\n",
    "\n",
    "Hints: In case of input data being supplied to the question, it should be assumed to be a console input. Consider use dict()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('Enter \"q\" to exit.')\n",
    "\n",
    "number_square = {}\n",
    "while True:\n",
    "  user_input = (input('Enter an integer: '))\n",
    "\n",
    "  if user_input.lower() == 'q':\n",
    "    break    \n",
    "\n",
    "  if user_input.isdigit():\n",
    "    user_number = int(user_input)\n",
    "  else:\n",
    "    print(f'Entered value \"{user_input}\" is not an integer.')\n",
    "    continue\n",
    "\n",
    "  for i in range(1, user_number+1):\n",
    "    number_square[user_number] = i*i\n",
    "\n",
    "if number_square:\n",
    "  print('\\nPrinting the results\\n...') \n",
    "  for key, value in number_square.items():\n",
    "    print(f'{key}: {value}')    \n",
    "else:\n",
    "  print('\\nYou didn\\'t enter any number.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Question 4\n",
    "Write a program which accepts a sequence of comma-separated numbers from console and generate a list and a tuple which contains every number.  \n",
    "\n",
    "Suppose the following input is supplied to the program:  \n",
    "34,67,55,33,12,98\n",
    "\n",
    "Then, the output should be:   \n",
    "['34', '67', '55', '33', '12', '98']   \n",
    "('34', '67', '55', '33', '12', '98')  \n",
    "\n",
    "Hints:\n",
    "In case of input data being supplied to the question, it should be assumed to be a console input.\n",
    "tuple() method can convert list to tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "user_numbers = input('Enter a sequence of comma-separated numbers: ')\n",
    "numbers_list = user_numbers.split(\",\")\n",
    "numbers_tuple = tuple(numbers_list)\n",
    "\n",
    "print(numbers_list)\n",
    "print(numbers_tuple)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Question 5\n",
    "Define a class which has at least two methods:  \n",
    "getString: to get a string from console input  \n",
    "printString: to print the string in upper case.  \n",
    "Also please include simple test function to test the class methods.  \n",
    "\n",
    "Hints:\n",
    "Use __init__ method to construct some parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class InputOutString(object):\n",
    "    def __init__(self):\n",
    "        self.str = \"\"\n",
    "\n",
    "    def getString(self):\n",
    "        self.str = input('Enter a sentence, and I\\'ll capitalize it: ')\n",
    "    \n",
    "    def printString(self):\n",
    "        print(f'Here\\'s your formatted sentence: {self.str.upper()}')\n",
    "\n",
    "strObj = InputOutString()\n",
    "strObj.getString()\n",
    "strObj.printString()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Question 6\n",
    "Write a program that calculates and prints the value according to the given formula:   \n",
    "Q = Square root of [(2 * C * D)/H]   \n",
    "Following are the fixed values of C and H:   \n",
    "C is 50. H is 30.   \n",
    "D is the variable whose values should be input to your program in a comma-separated sequence.   \n",
    "Example   \n",
    "Let us assume the following comma separated input sequence is given to the program:   \n",
    "100,150,180   \n",
    "The output of the program should be:   \n",
    "18,22,24   \n",
    "\n",
    "Hints:\n",
    "If the output received is in decimal form, it should be rounded off to its nearest value (for example, if the output received is 26.0, it should be printed as 26)   \n",
    "In case of input data being supplied to the question, it should be assumed to be a console input. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "\n",
    "def square_root(c = 50, h = 30):\n",
    "    \"\"\"\n",
    "    Calculate and print value according to a formula:\n",
    "    Q = Square root of [(2 * C * D)/H]\n",
    "    \"\"\"\n",
    "    \n",
    "    user_numbers = input('Enter a sequence of comma-separated numbers: ').split(',')\n",
    "\n",
    "    result_list = []\n",
    "\n",
    "    for number in user_numbers:\n",
    "        result_list.append(str(int(round(math.sqrt(2 * c * float(number) / h)))))\n",
    "        \n",
    "    return(','.join(result_list))\n",
    "\n",
    "square_root()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Question 7\n",
    "Write a program which takes 2 digits, X,Y as input and generates a 2-dimensional list. The element value in the i-th row and j-th column of the list should be i*j.   \n",
    "Note: i=0,1.., X-1; j=0,1,¡­Y-1.   \n",
    "Example   \n",
    "Suppose the following inputs are given to the program:   \n",
    "3,5   \n",
    "Then, the output of the program should be:   \n",
    "[[0, 0, 0, 0, 0], [0, 1, 2, 3, 4], [0, 2, 4, 6, 8]]    \n",
    "\n",
    "Hints:   \n",
    "Note: In case of input data being supplied to the question, it should be assumed to be a console input in a comma-separated form."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Prompt user for input\n",
    "input_str = input('Enter 2 comma-separated numbers: ')\n",
    "\n",
    "# Create new list of entered integers\n",
    "dimensions = [int(x) for x in input_str.split(',')]\n",
    "\n",
    "# Define number of rows and columns\n",
    "row_num = dimensions[0]\n",
    "col_num = dimensions[1]\n",
    "\n",
    "# Create multi-dimensial list\n",
    "matrix = [[0 for col in range(col_num)] for row in range(row_num)]\n",
    "\n",
    "# Populate matrix\n",
    "for row in range(row_num):\n",
    "    for col in range(col_num):\n",
    "        matrix[row][col]= row * col\n",
    "\n",
    "print(matrix)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Question 8\n",
    "Write a program that accepts a comma separated sequence of words as input and prints the words in a comma-separated sequence after sorting them alphabetically.   \n",
    "Suppose the following input is supplied to the program:   \n",
    "without,hello,bag,world   \n",
    "Then, the output should be:   \n",
    "bag,hello,without,world   \n",
    "\n",
    "Hints:   \n",
    "In case of input data being supplied to the question, it should be assumed to be a console input."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "words = input('Enter comma-separated words: ').split(',')\n",
    "\n",
    "print(sorted(words))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Question 9\n",
    "Write a program that accepts sequence of lines as input and prints the lines after making all characters in the sentence capitalized.\n",
    "Suppose the following input is supplied to the program:   \n",
    "Hello world   \n",
    "Practice makes perfect   \n",
    "Then, the output should be:   \n",
    "HELLO WORLD   \n",
    "PRACTICE MAKES PERFECT   \n",
    "   \n",
    "Hints:    \n",
    "In case of input data being supplied to the question, it should be assumed to be a console input.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lines = []\n",
    "print('Enter a word to capitalize.\\nTo exit press enter.')\n",
    "while True:\n",
    "    user_input = input('>> ')\n",
    "    if user_input:\n",
    "        lines.append(user_input.upper())\n",
    "    else:\n",
    "        break;\n",
    "\n",
    "for sentence in lines:\n",
    "    print(sentence)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Question 10\n",
    "Write a program that accepts a sequence of whitespace separated words as input and prints the words after removing all duplicate words and sorting them alphanumerically.   \n",
    "Suppose the following input is supplied to the program:   \n",
    "hello world and practice makes perfect and hello world again   \n",
    "Then, the output should be:   \n",
    "again and hello makes perfect practice world   \n",
    "\n",
    "Hints:\n",
    "In case of input data being supplied to the question, it should be assumed to be a console input.\n",
    "We use set container to remove duplicated data automatically and then use sorted() to sort the data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Option 1\n",
    "words = input('Enter a sentence: ').split(' ')\n",
    "print(\" \".join(sorted(list(set(words)))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Option 2\n",
    "words = input('Enter a sentence: ').split(' ')\n",
    "print(\" \".join(sorted(list(dict.fromkeys(words)))))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Question 11\n",
    "Write a program which accepts a sequence of comma separated 4 digit binary numbers as its input and then check whether they are divisible by 5 or not. The numbers that are divisible by 5 are to be printed in a comma separated sequence.   \n",
    "Example:   \n",
    "0100,0011,1010,1001   \n",
    "Then the output should be:   \n",
    "1010   \n",
    "Notes: Assume the data is input by console.   \n",
    "\n",
    "Hints:   \n",
    "In case of input data being supplied to the question, it should be assumed to be a console input."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "binary_numbers = input('Enter a sequence of comma separated 4 digit binary numbers: ').split(',')\n",
    "\n",
    "divisible_by_5 = []\n",
    "for number in binary_numbers:\n",
    "    if int(number, 2) % 5 == 0:\n",
    "        divisible_by_5.append(number)\n",
    "        \n",
    "print(','.join(divisible_by_5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Question 12\n",
    "Write a program, which will find all such numbers between 1000 and 3000 (both included) such that each digit of the number is an even number.\n",
    "The numbers obtained should be printed in a comma-separated sequence on a single line.   \n",
    "\n",
    "Hints:   \n",
    "In case of input data being supplied to the question, it should be assumed to be a console input."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "even_numbers = []\n",
    "\n",
    "for number in range(1000, 3001):\n",
    "\n",
    "        number_to_string = str(number)\n",
    "        is_ok = True\n",
    "\n",
    "        for digit in number_to_string:\n",
    "                if int(digit) % 2 == 0:\n",
    "                        is_ok = False\n",
    "                        break\n",
    "        if is_ok:\n",
    "                even_numbers.append(str(number))\n",
    "\n",
    "print(\",\".join(even_numbers))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Question 13\n",
    "Write a program that accepts a sentence and calculate the number of letters and digits.   \n",
    "Suppose the following input is supplied to the program:   \n",
    "hello world! 123   \n",
    "Then, the output should be:   \n",
    "LETTERS 10   \n",
    "DIGITS 3   \n",
    "\n",
    "Hints:   \n",
    "In case of input data being supplied to the question, it should be assumed to be a console input."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "inputs = input('Enter some letters and digits: ')\n",
    "\n",
    "letters_digits_count = {\n",
    "    'LETTERS' : 0,\n",
    "    'DIGITS' : 0\n",
    "}\n",
    "\n",
    "for char in inputs: \n",
    "    if char.isnumeric():\n",
    "        letters_digits_count ['DIGITS'] += 1\n",
    "    if char.isalpha():\n",
    "        letters_digits_count ['LETTERS'] += 1\n",
    "\n",
    "print('LETTERS', letters_digits_count ['LETTERS'])\n",
    "print('DIGITS', letters_digits_count ['DIGITS'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Question 14\n",
    "Write a program that accepts a sentence and calculate the number of upper case letters and lower case letters.   \n",
    "Suppose the following input is supplied to the program:   \n",
    "Hello world!   \n",
    "Then, the output should be:   \n",
    "UPPER CASE 1  \n",
    "LOWER CASE 9   \n",
    "\n",
    "Hints:  \n",
    "In case of input data being supplied to the question, it should be assumed to be a console input."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "words = input('Enter a sentence with upper case letters and lower case letters: ')\n",
    "upper_lower_count = {\n",
    "    'UPPER' : 0,\n",
    "    'LOWER' : 0\n",
    "}\n",
    "\n",
    "for letter in words:\n",
    "    if letter.isupper():\n",
    "        upper_lower_count['UPPER'] += 1\n",
    "    if letter.islower():\n",
    "        upper_lower_count['LOWER'] += 1\n",
    "            \n",
    "print('UPPER CASE', upper_lower_count['UPPER'])\n",
    "print('LOWER CASE', upper_lower_count['LOWER'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Question 15\n",
    "Write a program that computes the value of a+aa+aaa+aaaa with a given digit as the value of a.\n",
    "Suppose the following input is supplied to the program:\n",
    "9\n",
    "Then, the output should be:\n",
    "11106\n",
    "\n",
    "Hints:\n",
    "In case of input data being supplied to the question, it should be assumed to be a console input."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Option 1\n",
    "number = input('Enter a numberber: ')\n",
    "\n",
    "answer = 0\n",
    "i = 1\n",
    "string = number\n",
    "while i <= 4:\n",
    "    answer += int(string) \n",
    "\tstring += number \n",
    "\ti += 1\n",
    "print(answer)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Option 2\n",
    "number = input('Enter a numberber: ')\n",
    "\n",
    "answer = 'a+aa+aaa+aaaa'.replace('a', number)\n",
    "print(eval(answer))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Option 3\n",
    "number = input('Enter a number: ')\n",
    "\n",
    "i = 1\n",
    "answer = 0\n",
    "multiplier = 1\n",
    "\n",
    "while i != 5:\n",
    "    new_number = int(number) * multiplier\n",
    "    multiplier = 10*multiplier +1\n",
    "    i += 1\n",
    "    answer += new_number\n",
    "\n",
    "print(answer)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Question 16\n",
    "Use a list comprehension to square each odd number in a list. The list is input by a sequence of comma-separated numbers.\n",
    "Suppose the following input is supplied to the program:\n",
    "1,2,3,4,5,6,7,8,9\n",
    "Then, the output should be:\n",
    "1,3,5,7,9\n",
    "\n",
    "Hints:\n",
    "In case of input data being supplied to the question, it should be assumed to be a console input."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "values = [1,2,3,4,5,6,7,8,9]\n",
    "\n",
    "numbers = [str(x) for x in values if int(x)%2!=0]\n",
    "print(','.join(numbers))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "values = input('Enter a sequence of numbers: ')\n",
    "\n",
    "numbers = [x for x in values.split(\",\") if int(x)%2!=0]\n",
    "print(','.join(numbers))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "celltoolbar": "Raw Cell Format",
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}