Exercise.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# List Overlap \n",
    "Write a program that returns a list that contains only the elements that are common between the lists (without duplicates). Make sure your program works on two lists of different sizes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "list1 = [1, 2, 2, 3, 4, 5, 6]\n",
    "list2 = [2, 3, 4, 4, 5, 7, 8, 9]\n",
    "\n",
    "common_elements = []\n",
    "\n",
    "\n",
    "for item in list1:\n",
    "   \n",
    "    if item in list2 and item not in common_elements:\n",
    "        common_elements.append(item)\n",
    "\n",
    "\n",
    "print(common_elements)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Rock Paper Scissors\n",
    "\n",
    "Make a two-player Rock-Paper-Scissors game. (Hint: Ask for player plays (using input), compare them, print out a message of congratulations to the winner.)\n",
    "\n",
    "Remember the rules:\n",
    "\n",
    "* Rock beats scissors\n",
    "* Scissors beats paper\n",
    "* Paper beats rock"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def determine_winner(player1, player2):\n",
    "    if player1 == player2:\n",
    "        return \"It's a tie!\"\n",
    "\n",
    "    if player1 == \"rock\":\n",
    "        if player2 == \"scissors\":\n",
    "            return \"Player 1 wins! Rock beats scissors.\"\n",
    "        else:\n",
    "            return \"Player 2 wins! Paper beats rock.\"\n",
    "\n",
    "    if player1 == \"scissors\":\n",
    "        if player2 == \"paper\":\n",
    "            return \"Player 1 wins! Scissors beats paper.\"\n",
    "        else:\n",
    "            return \"Player 2 wins! Rock beats scissors.\"\n",
    "\n",
    "    if player1 == \"paper\":\n",
    "        if player2 == \"rock\":\n",
    "            return \"Player 1 wins! Paper beats rock.\"\n",
    "        else:\n",
    "            return \"Player 2 wins! Scissors beats paper.\"\n",
    "\n",
    "\n",
    "player1_choice = input(\"Player 1, choose rock, paper, or scissors: \").lower()\n",
    "player2_choice = input(\"Player 2, choose rock, paper, or scissors: \").lower()\n",
    "\n",
    "\n",
    "result = determine_winner(player1_choice, player2_choice)\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Palindrome \n",
    "\n",
    "Ask the user for a string and print out whether this string is a palindrome or not. (A palindrome is a string that reads the same forwards and backwards.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "user_input = input(\"Enter a string: \")\n",
    "\n",
    "\n",
    "cleaned_input = user_input.replace(\" \", \"\").lower()\n",
    "\n",
    "\n",
    "if cleaned_input == cleaned_input[::-1]:\n",
    "    print(\"Yes, it's a palindrome!\")\n",
    "else:\n",
    "    print(\"No, it's not a palindrome.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Password Generator\n",
    "Write a password generator in Python. Be creative with how you generate passwords - strong passwords have a mix of lowercase letters, uppercase letters, numbers, and symbols. The passwords should be random.  Ask the user to input how long they want their password to be. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "import string\n",
    "\n",
    "\n",
    "while True:\n",
    "    try:\n",
    "        password_length = int(input(\"Enter the desired password length: \"))\n",
    "        if password_length < 4:\n",
    "            print(\"Your Password length must be at least 4 characters.\")\n",
    "        else:\n",
    "            break\n",
    "    except ValueError:\n",
    "        print(\"Please enter a number.\")\n",
    "\n",
    "\n",
    "characters = string.digits + string.punctuation\n",
    "\n",
    "\n",
    "password = ''.join(random.choice(characters) for _ in range(password_length))\n",
    "\n",
    "\n",
    "print(\"Generated Password:\", password)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Divisors Solutions\n",
    "\n",
    "Create a program that asks the user for a number and then prints out a list of all the divisors of that number. (If you don’t know what a divisor is, it is a number that divides evenly into another number. For example, 13 is a divisor of 26 because 26 / 13 has no remainder.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "number=int(input(\"Enter a number\"))\n",
    "\n",
    "for i in range(1,number):\n",
    "    if number%i==0:\n",
    "        print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Missing Character\n",
    "Given a non-empty string and an int n, return a new string where the char at index n has been removed. The value of n will be a valid index of a char in the original string (i.e. n will be in the range 0..len(str)-1 inclusive).\n",
    "\n",
    "```\n",
    "missing_char('kitten', 1) → 'ktten'\n",
    "missing_char('kitten', 0) → 'itten'\n",
    "missing_char('kitten', 4) → 'kittn'\n",
    "\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def missing_char(word, n):\n",
    "    if n==0:\n",
    "        word=word[1:len(word)]\n",
    "    elif n==len(word)-1:\n",
    "        word=word[0:len(word)-1]\n",
    "    elif n>0 and n<len(word)-1:\n",
    "        word=word[0:n]+word[n+1:len(word)]\n",
    "    return(word)\n",
    "\n",
    "missing_char(\"kitten\",4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Centered Average\n",
    "\n",
    "Return the \"centered\" average of an array of ints, which we'll say is the mean average of the values, except ignoring the largest and smallest values in the array. If there are multiple copies of the smallest value, ignore just one copy, and likewise for the largest value.  You may assume that the array is length 3 or more and will never contain negative values. \n",
    "* Round your answer to the nearest whole number.\n",
    "\n",
    "```\n",
    "centered_average([1, 2, 3, 4, 100]) → 3\n",
    "centered_average([1, 1, 5, 5, 10, 8, 7]) → 5\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "example_list = [100, 100, 50, 75, 50, 25, 25, 25]\n",
    "example_list.sort()\n",
    "\n",
    "example_list[len(example_list)//2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}