Asignment No 3.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "f47021b6",
   "metadata": {},
   "source": [
    "#                                   Python Assignment No.3"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eacdce7d",
   "metadata": {},
   "source": [
    "## Name    : Chaudhari Kalyani Annasaheb\n",
    "## Div     :  A\n",
    "## Roll no :  3317"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e32554a6",
   "metadata": {},
   "source": [
    "### 1. Write a Python program to create Fibonacci series using Lambda.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "d97ae777",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]\n"
     ]
    }
   ],
   "source": [
    "fib = lambda n: n if n < 2 else fib(n-1) + fib(n-2)\n",
    "print([fib(i) for i in range(10)])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "25d52940",
   "metadata": {},
   "source": [
    "### 2. Write a Python program to find the intersection of two given arrays using Lambda"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "efc440d4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, 4]\n"
     ]
    }
   ],
   "source": [
    "intersect = lambda a, b: list(set(a) & set(b))\n",
    "print(intersect([1, 2, 3, 4], [3, 4, 5, 6]))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5d7a429d",
   "metadata": {},
   "source": [
    "### 3. Write a Python program to rearrange positive and negative numbers in a given array using Lambda"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "b447ff89",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 4, -1, -3, -5]\n"
     ]
    }
   ],
   "source": [
    "rearrange = lambda lst: [x for x in lst if x >= 0] + [x for x in lst if x < 0]\n",
    "print(rearrange([-1, 2, -3, 4, -5]))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a8799db0",
   "metadata": {},
   "source": [
    "### 4. Write a Python program to count the even, odd numbers in a given array of integers using Lambda"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "3cf50344",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3, 3)\n"
     ]
    }
   ],
   "source": [
    "count_even_odd = lambda lst: (len([x for x in lst if x % 2 == 0]), len([x for x in lst if x % 2 != 0]))\n",
    "print(count_even_odd([1, 2, 3, 4, 5, 6]))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1bc272a4",
   "metadata": {},
   "source": [
    "### 5. Write a Python program to add two given lists using map and lambda\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "69218088",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5, 7, 9]\n"
     ]
    }
   ],
   "source": [
    "add_lists = lambda a, b: list(map(lambda x, y: x + y, a, b))\n",
    "print(add_lists([1, 2, 3], [4, 5, 6]))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cb9e34a3",
   "metadata": {},
   "source": [
    "### 6. Write a Python program to find numbers divisible by nineteen or thirteen from a list of numbers using Lambda"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "6f64076c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[19, 26, 38, 39, 52]\n"
     ]
    }
   ],
   "source": [
    "divisible_by_19_13 = lambda lst: list(filter(lambda x: x % 19 == 0 or x % 13 == 0, lst))\n",
    "print(divisible_by_19_13([19, 26, 38, 39, 52]))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0678b618",
   "metadata": {},
   "source": [
    "### 7.Write a Python program to find palindromes in a given list of strings using Lambda."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "fbdc2f38",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['mom', 'level']\n"
     ]
    }
   ],
   "source": [
    "palindromes = lambda lst: list(filter(lambda x: x == x[::-1], lst))\n",
    "print(palindromes(['mom', 'python', 'level', 'hello']))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "55f818b5",
   "metadata": {},
   "source": [
    "### 8. Write a Python program to find all anagrams of a string in a given list of strings using lambda."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "a4e65676",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['helpfull', 'fullhelp']\n"
     ]
    }
   ],
   "source": [
    "anagrams = lambda s, lst: list(filter(lambda x: sorted(x) == sorted(s), lst))\n",
    "print(anagrams('helpfull', ['helpfull', 'fullhelp', 'helpfyl', 'HELPLLFU']))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5272249f",
   "metadata": {},
   "source": [
    "### 9.Write a Python program that multiplies each number of a given list with a given number using lambda function. Print the result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "f5fe2c51",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 4, 6, 8, 10]\n"
     ]
    }
   ],
   "source": [
    "multiply_by = lambda n, lst: list(map(lambda x: x * n, lst))\n",
    "print(multiply_by(2, [1, 2, 3, 4, 5]))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2a158de9",
   "metadata": {},
   "source": [
    "### 10. Write a Python program to calculate the sum of the positive and negative numbers of a given list of numbers using lambda function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "a45ea6ce",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(6, -9)\n"
     ]
    }
   ],
   "source": [
    "sum_pos_neg = lambda lst: (sum([x for x in lst if x >= 0]), sum([x for x in lst if x < 0]))\n",
    "print(sum_pos_neg([-1, 2, -3, 4, -5]))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "85f01325",
   "metadata": {},
   "source": [
    "### 11. Write a Python program to find the list with maximum and minimum length using lambda."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "791222d6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('abc', '')\n"
     ]
    }
   ],
   "source": [
    "max_min_length = lambda lst: (max(lst, key=len), min(lst, key=len))\n",
    "print(max_min_length(['', 'a', 'ab', 'abc']))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cd396771",
   "metadata": {},
   "source": [
    "### 12. Write a Python program to check whether a specified list is sorted or not using lambda."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "87be9ea1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "is_sorted = lambda lst: all(lst[i] <= lst[i+1] for i in range(len(lst)-1))\n",
    "print(is_sorted([1, 2, 3, 4, 5]))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8b9d248d",
   "metadata": {},
   "source": [
    "### 13. Write a Python program to remove all elements from a given list present in another list using lambda."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "9bc2ab51",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 3, 5]\n"
     ]
    }
   ],
   "source": [
    "remove_elements = lambda lst1, lst2: list(filter(lambda x: x not in lst2, lst1))\n",
    "print(remove_elements([1, 2, 3, 4, 5], [2, 4]))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "96c38e79",
   "metadata": {},
   "source": [
    "### 14. Write a Python program to convert string element to integer inside a given tuple using"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "6e66f9bc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3)\n"
     ]
    }
   ],
   "source": [
    "convert_to_int = lambda t: tuple(int(x) for x in t)\n",
    "print(convert_to_int(('1', '2', '3')))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "793bad10",
   "metadata": {},
   "source": [
    "### 15. Write a Python program to count the occurrences of the items in a given list using Lambda."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "1a81b0e4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1: 1, 2: 2, 3: 3, 4: 1}\n"
     ]
    }
   ],
   "source": [
    "count_occurrences = lambda lst: {x: lst.count(x) for x in set(lst)}\n",
    "print(count_occurrences([1, 2, 2, 3, 3, 3, 4]))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "394ad1b2",
   "metadata": {},
   "source": [
    "### 16. Write a Python program to add three given lists using Python map and lambda"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "5e8ae268",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[12, 15, 18]\n"
     ]
    }
   ],
   "source": [
    "add_three_lists = lambda a, b, c: list(map(lambda x, y, z: x + y + z, a, b, c))\n",
    "print(add_three_lists([1, 2, 3], [4, 5, 6], [7, 8, 9]))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7f7ba610",
   "metadata": {},
   "source": [
    "### 17. Write a Python program to listify the list of given strings individually using Python map"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "00eb314b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[['h', 'e', 'l', 'l', 'o'], ['w', 'o', 'r', 'l', 'd']]\n"
     ]
    }
   ],
   "source": [
    "listify = lambda lst: list(map(list, lst))\n",
    "print(listify(['hello', 'world']))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7af72117",
   "metadata": {},
   "source": [
    "### 18. Write a Python program to square the elements of a list using map() function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "53f8c677",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 9, 16, 25]\n"
     ]
    }
   ],
   "source": [
    "square_elements = lambda lst: list(map(lambda x: x ** 2, lst))\n",
    "print(square_elements([1, 2, 3, 4, 5]))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8b9dc2c1",
   "metadata": {},
   "source": [
    "### 19. Write a Python program to add two given lists and find the difference between lists.Use map() function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "c6b71b07",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "([5, 7, 9], [1, 2, 3])\n"
     ]
    }
   ],
   "source": [
    "add_and_diff = lambda a, b: (list(map(lambda x, y: x + y, a, b)), list(filter(lambda x: x not in b, a)))\n",
    "print(add_and_diff([1, 2, 3], [4, 5, 6]))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "21d988f1",
   "metadata": {},
   "source": [
    "### 20. Write a Python program to convert a given list of integers and a tuple of integers in a list of strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "7556ab45",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['1', '2', '3', '4', '5', '6']\n"
     ]
    }
   ],
   "source": [
    "convert_to_str = lambda lst, tup: list(map(str, lst + list(tup)))\n",
    "print(convert_to_str([1, 2, 3], (4, 5, 6)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a9065083",
   "metadata": {},
   "source": [
    "### 21. Write a Python program to compute the sum of elements of an given array of integers, use map() function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "0fdc8734",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15\n"
     ]
    }
   ],
   "source": [
    "sum_elements = lambda lst: sum(map(int, lst))\n",
    "print(sum_elements(['1', '2', '3', '4', '5']))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f6592659",
   "metadata": {},
   "source": [
    "### 22. Write a Python program to count the same pair in two given lists. use map() function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "bdf2a5ff",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "count_same_pair = lambda a, b: sum(map(lambda x: x in b, a))\n",
    "print(count_same_pair([1, 2, 3], [2, 3, 4]))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9de41c46",
   "metadata": {},
   "source": [
    "### 23. Write a Python program to convert a given list of strings into list of lists using map function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "0eef0cd3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[['h', 'e', 'l', 'l', 'o'], ['w', 'o', 'r', 'l', 'd']]\n"
     ]
    }
   ],
   "source": [
    "convert_to_lists = lambda lst: list(map(list, lst))\n",
    "print(convert_to_lists(['hello', 'world']))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e9b16e39",
   "metadata": {},
   "source": [
    "### 24. Write a Python program to convert a given list of tuples to a list of strings using map Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "4597674b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Hello World', 'Python Programming', 'Ammmuu Assistant']\n"
     ]
    }
   ],
   "source": [
    "tuple_list = [(\"Hello\", \"World\"), (\"Python\", \"Programming\"), (\"Ammmuu\", \"Assistant\")]\n",
    "\n",
    "def tuple_to_string(tup):\n",
    "    return \" \".join(tup)\n",
    "string_list = list(map(tuple_to_string, tuple_list))\n",
    "print(string_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9a86d253",
   "metadata": {},
   "source": [
    "### 25. Python program to find the diff. between two lists using filter() function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "c5f81275",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "List 1: [1, 2, 3, 4, 5]\n",
      "List 2: [4, 5, 6, 7, 8]\n",
      "Elements in List 1 but not in List 2: [1, 2, 3]\n",
      "Elements in List 2 but not in List 1: [6, 7, 8]\n"
     ]
    }
   ],
   "source": [
    "def diff_list(list1, list2):\n",
    "  \n",
    "    diff1 = list(filter(lambda x: x not in list2, list1))\n",
    "    \n",
    "    diff2 = list(filter(lambda x: x not in list1, list2))\n",
    "    \n",
    "    return diff1, diff2\n",
    "\n",
    "list1 = [1, 2, 3, 4, 5]\n",
    "list2 = [4, 5, 6, 7, 8]\n",
    "\n",
    "diff1, diff2 = diff_list(list1, list2)\n",
    "\n",
    "print(\"List 1:\", list1)\n",
    "print(\"List 2:\", list2)\n",
    "print(\"Elements in List 1 but not in List 2:\", diff1)\n",
    "print(\"Elements in List 2 but not in List 1:\", diff2)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.12.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}