Subjective Assignment - 2 - Python Function and List.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Assignments"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q1. Write the Python function to get a string made of 4 copies of the last\n",
    "two characters of the specified string (length must be at least 2).\n",
    "\n",
    "    Sample function and result :\n",
    "    insert-end ('Python') -> abababab\n",
    "    insert-end('Exercises') -> jkjkjkjk"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "onononon\n",
      "eseseses\n"
     ]
    }
   ],
   "source": [
    "def insert_end(string):\n",
    "    return(string[-2:]*4)\n",
    "print(insert_end('Python'))\n",
    "print(insert_end('Exercises'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q2. Write the python function to get a string made of its first three\n",
    "characters of a specified string. If the length of the string is less than 3\n",
    "then return the original string.\n",
    "    \n",
    "    Sample function and result :\n",
    "    first-three('ipy') -> ipy\n",
    "    first-three('python') -> pyt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ipy\n",
      "pyt\n"
     ]
    }
   ],
   "source": [
    "def first_three(string):\n",
    "    if len(string) <= 3:\n",
    "        return string\n",
    "    else:\n",
    "        return string[:3]\n",
    "print(first_three('ipy'))\n",
    "print(first_three('python'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q3. Write the Python program to find smallest window that contains all\n",
    "characters of the given string?\n",
    "\n",
    "    Original Strings:\n",
    "    asdaewsqgtwwsa\n",
    "    Smallest window that contains all characters of the said string:\n",
    "    Daewsqgt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original Strings:\n",
      " asdaewsqgtwwsa\n",
      "\n",
      "Smallest window that contains all characters of the said string:\n",
      "daewsqgt\n"
     ]
    }
   ],
   "source": [
    "from collections import defaultdict   \n",
    "\n",
    "def find_sub_string(str): \n",
    "    str_len = len(str) \n",
    "       \n",
    "    dist_count_char = len(set([x for x in str])) \n",
    "  \n",
    "    ctr, start_pos, start_pos_index, min_len = 0, 0, -1, 9999999999\n",
    "    curr_count = defaultdict(lambda: 0) \n",
    "    for i in range(str_len): \n",
    "        curr_count[str[i]] += 1\n",
    " \n",
    "        if curr_count[str[i]] == 1: \n",
    "            ctr += 1\n",
    "  \n",
    "        if ctr == dist_count_char: \n",
    "            while curr_count[str[start_pos]] > 1: \n",
    "                if curr_count[str[start_pos]] > 1: \n",
    "                    curr_count[str[start_pos]] -= 1\n",
    "                start_pos += 1\n",
    "  \n",
    "            len_window = i - start_pos + 1\n",
    "            if min_len > len_window: \n",
    "                min_len = len_window \n",
    "                start_pos_index = start_pos \n",
    "    return str[start_pos_index: start_pos_index + min_len] \n",
    "      \n",
    "str1 = \"asdaewsqgtwwsa\"\n",
    "print(\"Original Strings:\\n\",str1)\n",
    "print(\"\\nSmallest window that contains all characters of the said string:\")\n",
    "print(find_sub_string(str1)) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q4. Write the Python program to count number of substrings from a\n",
    "given string of lowercase alphabets with exactly k distinct (given)\n",
    "characters?\n",
    "\n",
    "    Input a string (lowercase alphabets): wolf\n",
    "    Input k: 4\n",
    "    Number of substrings with exactly 4 distinct characters: 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Input a string (lowercase alphabets):wolf\n",
      "Input k: 4\n",
      "Number of substrings with exactly 4 distinct characters : 1\n"
     ]
    }
   ],
   "source": [
    "def count_k_dist(str1, k): \n",
    "    str_len = len(str1) \n",
    "\n",
    "    result = 0\n",
    "\n",
    "    ctr = [0] * 27\n",
    "\n",
    "    for i in range(0, str_len): \n",
    "        dist_ctr = 0\n",
    "\n",
    "        ctr = [0] * 27\n",
    "\n",
    "        for j in range(i, str_len): \n",
    "\n",
    "            if(ctr[ord(str1[j]) - 97] == 0): \n",
    "                dist_ctr += 1\n",
    "\n",
    "            ctr[ord(str1[j]) - 97] += 1\n",
    "\n",
    "            if(dist_ctr == k): \n",
    "                result += 1\n",
    "            if(dist_ctr > k): \n",
    "                break\n",
    "\n",
    "    return result \n",
    "\n",
    "str1 = input(\"Input a string (lowercase alphabets):\")\n",
    "k = int(input(\"Input k: \"))\n",
    "print(\"Number of substrings with exactly\", k, \"distinct characters : \", end = \"\") \n",
    "print(count_k_dist(str1, k))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q5. Write the Python program to count number of non-empty\n",
    "substrings of the given string?\n",
    "\n",
    "    Input a string: w3resource\n",
    "    Number of substrings:\n",
    "    55"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Input a string: w3resource\n",
      "55\n"
     ]
    }
   ],
   "source": [
    "def count_sub(string):\n",
    "    l = len(string)\n",
    "    res = 0\n",
    "    for i in range(l):\n",
    "        for j in range(i, l):\n",
    "            res += 1\n",
    "    return res\n",
    "sen = input('Input a string: ')\n",
    "print(count_sub(sen))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q6. Write the Python program to count the number of strings where the\n",
    "string length is 2 or more, and first and last character are same\n",
    "from a given list of strings.\n",
    "\n",
    "    Sample List : ['abc', 'xyz', 'wxw', '1331']\n",
    "    Expected Result: 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "def length(list_string):\n",
    "    res = 0\n",
    "    for string in list_string:\n",
    "        if len(string) >=2 and string[0] == string[-1]:\n",
    "            res += 1\n",
    "    return(res)\n",
    "print(length(['abc', 'xyz', 'wxw', '1331']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q7. Write the Python program to get a list, sorted in increasing order by\n",
    "the last element in each tuple from the given list of non-empty\n",
    "tuples?\n",
    "\n",
    "    Sample List - [ (2, 5), (1, 2), (4, 4), (2, 3), (2, 1) ]\n",
    "    Expected Result - [ (2, 1), (1, 2), (2, 3), (4, 4), (2, 5) ]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(2, 1), (1, 2), (2, 3), (4, 4), (2, 5)]\n"
     ]
    }
   ],
   "source": [
    "def sort_list_last(tuples):\n",
    "  return sorted(tuples, key=lambda x: x[-1])\n",
    "\n",
    "print(sort_list_last([(2, 5), (1, 2), (4, 4), (2, 3), (2, 1)]))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q8. Write the Python program to remove duplicates from a list?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[40, 10, 80, 50, 20, 60, 30]\n"
     ]
    }
   ],
   "source": [
    "def rem_duplicate(list1):\n",
    "    return list(set(list1))\n",
    "a = [10,20,30,20,10,50,60,40,80,50,40]\n",
    "print(rem_duplicate(a))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q9. Write the Python program to find the list of words that are longer\n",
    "than n from a given list of words?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Shreya', 'Gupta']\n"
     ]
    }
   ],
   "source": [
    "def filter_long_words(words, n):\n",
    "    x = []\n",
    "    for word in words:\n",
    "        if len(word) > n:\n",
    "            x.append(word)\n",
    "    return x\n",
    "\n",
    "print(filter_long_words(['Shreya', 'Gupta', 'abc'], 4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q10. Write the Python program to print a specified list after removing the\n",
    "0th, 4th, and 5th elements?\n",
    "    \n",
    "    Sample List - ['Red', 'Green', 'White', 'Black', 'Pink', 'Yellow']\n",
    "    Expected Output - ['Green', 'White', 'Black']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Green', 'White', 'Black']\n"
     ]
    }
   ],
   "source": [
    "color = ['Red', 'Green', 'White', 'Black', 'Pink', 'Yellow']\n",
    "color = [x for (i,x) in enumerate(color) if i not in (0,4,5)]\n",
    "print(color)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q11. Write the Python program to generate all permutations of a list in\n",
    "Python?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(1, 2, 3), (1, 3, 2), (2, 1, 3), (2, 3, 1), (3, 1, 2), (3, 2, 1)]\n"
     ]
    }
   ],
   "source": [
    "import itertools\n",
    "print(list(itertools.permutations([1,2,3])))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q12. Write the Python program to convert a pair of values into a sorted\n",
    "unique array?\n",
    " \n",
    "    Original List- [ (1, 2), (3, 4), (1, 2), (5, 6), (7, 8), (1, 2), (3, 4), (3, 4), (7, 8), (9, 10) ]\n",
    "    Sorted Unique Data- [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original List:  [(1, 2), (3, 4), (1, 2), (5, 6), (7, 8), (1, 2), (3, 4), (3, 4), (7, 8), (9, 10)]\n",
      "Sorted Unique Data: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n"
     ]
    }
   ],
   "source": [
    "L = [(1, 2), (3, 4), (1, 2), (5, 6), (7, 8), (1, 2), (3, 4), (3, 4),\n",
    " (7, 8), (9, 10)]\n",
    "print(\"Original List: \", L)\n",
    "print(\"Sorted Unique Data:\",sorted(set().union(*L)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Great job!"
   ]
  }
 ],
 "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.7.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}