├── README.md
├── Problem 2-Time Complexity.ipynb
├── Problem1.py
├── Problem 1- Generating Binary strings.ipynb
└── Problem 8- Anagram Problem.ipynb


/README.md:
--------------------------------------------------------------------------------
1 | # Competitive-Programming


--------------------------------------------------------------------------------
/Problem 2-Time Complexity.ipynb:
--------------------------------------------------------------------------------
 1 | {
 2 |  "cells": [
 3 |   {
 4 |    "cell_type": "markdown",
 5 |    "metadata": {},
 6 |    "source": [
 7 |     "### Find The Time Complexity"
 8 |    ]
 9 |   },
10 |   {
11 |    "cell_type": "code",
12 |    "execution_count": 10,
13 |    "metadata": {},
14 |    "outputs": [],
15 |    "source": [
16 |     "### What is the Time Complexity\n",
17 |     "def Func(n):\n",
18 |     "    for i in range(1,n):\n",
19 |     "        j=i\n",
20 |     "        while j<i*i:\n",
21 |     "            j=j+1\n",
22 |     "            if j%i==0:\n",
23 |     "                for k in range(0,j):\n",
24 |     "                    print(\"Krish\")"
25 |    ]
26 |   },
27 |   {
28 |    "cell_type": "code",
29 |    "execution_count": null,
30 |    "metadata": {},
31 |    "outputs": [],
32 |    "source": []
33 |   },
34 |   {
35 |    "cell_type": "markdown",
36 |    "metadata": {},
37 |    "source": [
38 |     "### Options\n",
39 |     "- 1. O(n^3)\n",
40 |     "- 2. O(n^2)\n",
41 |     "- 3. O(n^5)\n",
42 |     "- 4. O(n(n-1))"
43 |    ]
44 |   }
45 |  ],
46 |  "metadata": {
47 |   "kernelspec": {
48 |    "display_name": "Python 3",
49 |    "language": "python",
50 |    "name": "python3"
51 |   },
52 |   "language_info": {
53 |    "codemirror_mode": {
54 |     "name": "ipython",
55 |     "version": 3
56 |    },
57 |    "file_extension": ".py",
58 |    "mimetype": "text/x-python",
59 |    "name": "python",
60 |    "nbconvert_exporter": "python",
61 |    "pygments_lexer": "ipython3",
62 |    "version": "3.7.7"
63 |   }
64 |  },
65 |  "nbformat": 4,
66 |  "nbformat_minor": 4
67 | }
68 | 


--------------------------------------------------------------------------------
/Problem1.py:
--------------------------------------------------------------------------------
 1 | # Python3 implementation of the approach 
 2 | DIGITS = 4; MIN = 1000; MAX = 9999; 
 3 | 
 4 | # Function to return the minimum element 
 5 | # from the range [prev, MAX] such that 
 6 | # it differs in at most 1 digit with cur 
 7 | def getBest(prev, cur) : 
 8 | 
 9 | 	# To start with the value 
10 | 	# we have achieved in the last step 
11 | 	maximum = max(MIN, prev); 
12 | 
13 | 	for i in range(maximum, MAX + 1) : 
14 | 		cnt = 0; 
15 | 
16 | 		# Store the value with which the 
17 | 		# current will be compared 
18 | 		a = i; 
19 | 
20 | 		# Current value 
21 | 		b = cur; 
22 | 
23 | 		# There are at most 4 digits 
24 | 		for k in range(DIGITS) : 
25 | 
26 | 			# If the current digit differs 
27 | 			# in both the numbers 
28 | 			if (a % 10 != b % 10) : 
29 | 				cnt += 1; 
30 | 
31 | 			# Eliminate last digits in 
32 | 			# both the numbers 
33 | 			a //= 10; 
34 | 			b //= 10; 
35 | 
36 | 		# If the number of different 
37 | 		# digits is at most 1 
38 | 		if (cnt <= 1) : 
39 | 			return i; 
40 | 
41 | 	# If we can't find any number for which 
42 | 	# the number of change is less than or 
43 | 	# equal to 1 then return -1 
44 | 	return -1; 
45 | 
46 | # Function to get the non-decreasing list 
47 | def getList(arr, n) : 
48 | 
49 | 	# Creating a vector for the updated list 
50 | 	myList = []; 
51 | 	
52 | 	# Let's assume that it is possible to 
53 | 	# make the list non-decreasing 
54 | 	possible = True; 
55 | 
56 | 	myList.append(0); 
57 | 
58 | 	for i in range(n) : 
59 | 
60 | 		# Element of the original array 
61 | 		cur = arr[i]; 
62 | 
63 | 		myList.append(getBest(myList[-1], cur)); 
64 | 
65 | 		# Can't make the list non-decreasing 
66 | 		if (myList[-1] == -1) : 
67 | 			possible = False; 
68 | 			break; 
69 | 
70 | 	# If possible then print the list 
71 | 	if (possible) : 
72 | 		for i in range(1, len(myList)) : 
73 | 			print(myList[i], end = " "); 
74 | 	else : 
75 | 		print("-1"); 
76 | 
77 | # Driver code 
78 | if __name__ == "__main__" : 
79 | 
80 | 	arr = [ 1095, 1094, 1095 ]; 
81 | 	n = len(arr); 
82 | 
83 | 	getList(arr, n); 
84 | 
85 | # This code is contributed by AnkitRai01 
86 | 


--------------------------------------------------------------------------------
/Problem 1- Generating Binary strings.ipynb:
--------------------------------------------------------------------------------
 1 | {
 2 |  "cells": [
 3 |   {
 4 |    "cell_type": "markdown",
 5 |    "metadata": {},
 6 |    "source": [
 7 |     "##  First Competitive Programming Problem"
 8 |    ]
 9 |   },
10 |   {
11 |    "cell_type": "markdown",
12 |    "metadata": {},
13 |    "source": [
14 |     "### Generate All Binary Strings\n",
15 |     "- if n=2 ['00', '01', '10', '11']\n",
16 |     "- if n=3 ['000', '001', '010', '011', '100', '101', '110', '111']\n",
17 |     "- if n=4 ['0000', '0001', '0010', '0011', '0100', '0101', '0110', '0111', '1000', '1001', '1010', '1011', '1100', '1101', '1110', '1111']"
18 |    ]
19 |   },
20 |   {
21 |    "cell_type": "code",
22 |    "execution_count": 34,
23 |    "metadata": {},
24 |    "outputs": [
25 |     {
26 |      "name": "stdout",
27 |      "output_type": "stream",
28 |      "text": [
29 |       "['000', '001', '010', '011', '100', '101', '110', '111']\n"
30 |      ]
31 |     }
32 |    ],
33 |    "source": [
34 |     "def append_bits(x, L):\n",
35 |     "    return [x + element for element in    L]\n",
36 |     "\n",
37 |     "def generate_bit(n):\n",
38 |     "    if n == 0: return []\n",
39 |     "    if n == 1: return [\"0\", \"1\"]\n",
40 |     "    else:\n",
41 |     "        return (append_bits(\"0\", generate_bit(n - 1)) + \n",
42 |     "                append_bits(\"1\", generate_bit(n - 1)))\n",
43 |     "                \n",
44 |     "print(generate_bit(3))"
45 |    ]
46 |   },
47 |   {
48 |    "cell_type": "code",
49 |    "execution_count": null,
50 |    "metadata": {},
51 |    "outputs": [],
52 |    "source": [
53 |     "generate_bits(3)\n",
54 |     "append_bits(\"0\",[\"00\",\"01\"])n==2\n",
55 |     "[\"000\",\"001\"]"
56 |    ]
57 |   }
58 |  ],
59 |  "metadata": {
60 |   "kernelspec": {
61 |    "display_name": "Python 3",
62 |    "language": "python",
63 |    "name": "python3"
64 |   },
65 |   "language_info": {
66 |    "codemirror_mode": {
67 |     "name": "ipython",
68 |     "version": 3
69 |    },
70 |    "file_extension": ".py",
71 |    "mimetype": "text/x-python",
72 |    "name": "python",
73 |    "nbconvert_exporter": "python",
74 |    "pygments_lexer": "ipython3",
75 |    "version": "3.7.7"
76 |   }
77 |  },
78 |  "nbformat": 4,
79 |  "nbformat_minor": 4
80 | }
81 | 


--------------------------------------------------------------------------------
/Problem 8- Anagram Problem.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "code",
  5 |    "execution_count": null,
  6 |    "metadata": {},
  7 |    "outputs": [],
  8 |    "source": [
  9 |     "str1=\"Elbow\"\n",
 10 |     "str2=\"below\"\n",
 11 |     "anagram(str1,str2)\n",
 12 |     "### You also have to handle spaces and capital letters"
 13 |    ]
 14 |   },
 15 |   {
 16 |    "cell_type": "markdown",
 17 |    "metadata": {},
 18 |    "source": [
 19 |     "### Problem 8-Anagram Check Analysis- Competitive Programming\n",
 20 |     "An anagram is a word or phrase formed by rearranging the letters of a different word or phrase, typically using all the original letters exactly once. For example, the word anagram itself can be rearranged into nag a ram, also the word binary into brainy and the word adobe into abode\n",
 21 |     "\n",
 22 |     "Examples\n",
 23 |     "\n",
 24 |     "- below = elbow\n",
 25 |     "- study = dusty\n",
 26 |     "- night = thing\n",
 27 |     "- act = cat\n",
 28 |     "- dessert = stressed\n",
 29 |     "- bad credit = debit card\n",
 30 |     "- gainly = laying\n",
 31 |     "- conversation = voice rants on\n",
 32 |     "- eleven plus two = twelve plus one\n"
 33 |    ]
 34 |   },
 35 |   {
 36 |    "cell_type": "code",
 37 |    "execution_count": 1,
 38 |    "metadata": {},
 39 |    "outputs": [],
 40 |    "source": [
 41 |     "### Check Whether 2 string is Anagram"
 42 |    ]
 43 |   },
 44 |   {
 45 |    "cell_type": "code",
 46 |    "execution_count": 1,
 47 |    "metadata": {},
 48 |    "outputs": [],
 49 |    "source": [
 50 |     "### Failed\n",
 51 |     "def check(str1, str2): \n",
 52 |     "    if(sorted(str1)== sorted(str2)): \n",
 53 |     "        print(\" strings are anagram.\")  \n",
 54 |     "    else: \n",
 55 |     "        print(\" strings aren't anagrams \")        \n"
 56 |    ]
 57 |   },
 58 |   {
 59 |    "cell_type": "code",
 60 |    "execution_count": 4,
 61 |    "metadata": {},
 62 |    "outputs": [
 63 |     {
 64 |      "name": "stdout",
 65 |      "output_type": "stream",
 66 |      "text": [
 67 |       " strings aren't anagrams \n"
 68 |      ]
 69 |     }
 70 |    ],
 71 |    "source": [
 72 |     "check(\"Study\",\"dusty\")"
 73 |    ]
 74 |   },
 75 |   {
 76 |    "cell_type": "code",
 77 |    "execution_count": 13,
 78 |    "metadata": {},
 79 |    "outputs": [],
 80 |    "source": [
 81 |     "### Failed\n",
 82 |     "str1 = \"eleven0 plus two\"\n",
 83 |     "str2 = \"twelve1 plus one\"\n",
 84 |     "\n",
 85 |     "def anagram(str1, str2):\n",
 86 |     "    str1 = str1.replace(\" \",\"\").lower()\n",
 87 |     "    str2 = str2.replace(\" \",\"\").lower()\n",
 88 |     "    if len(str1) == len(str2):\n",
 89 |     "        for i in str1:\n",
 90 |     "            if i in str2:\n",
 91 |     "                pass\n",
 92 |     "        return True\n",
 93 |     "    return False\n"
 94 |    ]
 95 |   },
 96 |   {
 97 |    "cell_type": "code",
 98 |    "execution_count": 14,
 99 |    "metadata": {},
100 |    "outputs": [
101 |     {
102 |      "data": {
103 |       "text/plain": [
104 |        "True"
105 |       ]
106 |      },
107 |      "execution_count": 14,
108 |      "metadata": {},
109 |      "output_type": "execute_result"
110 |     }
111 |    ],
112 |    "source": [
113 |     "anagram(str1,str2)"
114 |    ]
115 |   },
116 |   {
117 |    "cell_type": "code",
118 |    "execution_count": 17,
119 |    "metadata": {},
120 |    "outputs": [
121 |     {
122 |      "name": "stdout",
123 |      "output_type": "stream",
124 |      "text": [
125 |       "Enter the first stringtwelve plus one\n",
126 |       "Enter the second stringeleven plus two\n",
127 |       "Yes\n"
128 |      ]
129 |     }
130 |    ],
131 |    "source": [
132 |     "def Anagram(str1,str2):\n",
133 |     "    dict = {}\n",
134 |     "    for i in range(len(str1)):\n",
135 |     "        if ord(str1[i]) <= 122 and ord(str1[i])>=97:\n",
136 |     "            if ord(str1[i])-32 not in dict:\n",
137 |     "                dict[ord(str1[i])-32] = 1\n",
138 |     "            else:\n",
139 |     "                dict[ord(str1[i])-32] = dict[ord(str1[i])-32] + 1\n",
140 |     "        else:\n",
141 |     "            if ord(str1[i]) not in dict:\n",
142 |     "                dict[ord(str1[i])] = 1\n",
143 |     "            else:\n",
144 |     "                dict[ord(str1[i])] = dict[ord(str1[i])] + 1\n",
145 |     "\n",
146 |     "    for i in range(len(str2)):\n",
147 |     "        if ord(str2[i])<=122 and ord(str2[i])>=97:\n",
148 |     "            if ord(str2[i])-32 in dict:\n",
149 |     "                if dict[ord(str2[i])-32] != 0:\n",
150 |     "                    dict[ord(str2[i])-32] = dict[ord(str2[i])-32] - 1\n",
151 |     "                else:\n",
152 |     "                    return 0\n",
153 |     "            else:\n",
154 |     "                return 0\n",
155 |     "        else:\n",
156 |     "            if ord(str2[i]) in dict:\n",
157 |     "                if dict[ord(str2[i])] != 0:\n",
158 |     "                    dict[ord(str2[i])] = dict[ord(str2[i])] - 1\n",
159 |     "                else:\n",
160 |     "                    return 0\n",
161 |     "            else:\n",
162 |     "                return 0\n",
163 |     "\n",
164 |     "    return 1\n",
165 |     "\n",
166 |     "\n",
167 |     "\n",
168 |     "str1 = input(\"Enter the first string\")\n",
169 |     "str2 = input(\"Enter the second string\")\n",
170 |     "if Anagram(str1,str2):\n",
171 |     "    print(\"Yes\")\n",
172 |     "else:\n",
173 |     "    print(\"No\")\n",
174 |     "\n",
175 |     "\n",
176 |     "\n"
177 |    ]
178 |   },
179 |   {
180 |    "cell_type": "code",
181 |    "execution_count": 23,
182 |    "metadata": {},
183 |    "outputs": [],
184 |    "source": [
185 |     "### Final Solution\n",
186 |     "def anagram(str1,str2):\n",
187 |     "    group_letters={}\n",
188 |     "    for i in str1:\n",
189 |     "        if i in group_letters:\n",
190 |     "            group_letters[i]+=1\n",
191 |     "        else:\n",
192 |     "            group_letters[i]=1\n",
193 |     "    for i in str2:\n",
194 |     "        if i in group_letters:\n",
195 |     "            group_letters[i]-=1\n",
196 |     "        else:\n",
197 |     "            group_letters[i]=1\n",
198 |     "    for j in group_letters:\n",
199 |     "        if group_letters[j]!=0:\n",
200 |     "            return False\n",
201 |     "    return True"
202 |    ]
203 |   },
204 |   {
205 |    "cell_type": "code",
206 |    "execution_count": 22,
207 |    "metadata": {},
208 |    "outputs": [
209 |     {
210 |      "name": "stdout",
211 |      "output_type": "stream",
212 |      "text": [
213 |       "Enter the first string: Eleven plus two\n",
214 |       "Enter the first string: twelve plus one\n",
215 |       "The entered strings are anagram\n"
216 |      ]
217 |     }
218 |    ],
219 |    "source": [
220 |     "string1=input(\"Enter the first string: \")\n",
221 |     "string1=string1.replace(\" \",\"\").lower()\n",
222 |     "string2=input(\"Enter the first string: \")\n",
223 |     "string2=string2.replace(\" \",\"\").lower()\n",
224 |     "var=anagram(string1,string2)\n",
225 |     "if(var):\n",
226 |     "    print(\"The entered strings are anagram\")\n",
227 |     "else:\n",
228 |     "    print(\"The entered strings are not anagram\")"
229 |    ]
230 |   },
231 |   {
232 |    "cell_type": "markdown",
233 |    "metadata": {},
234 |    "source": [
235 |     "### Find all the anagrams from a list of words\n",
236 |     "['cat', 'dog', 'tac', 'god', 'act']"
237 |    ]
238 |   },
239 |   {
240 |    "cell_type": "code",
241 |    "execution_count": null,
242 |    "metadata": {},
243 |    "outputs": [],
244 |    "source": []
245 |   }
246 |  ],
247 |  "metadata": {
248 |   "kernelspec": {
249 |    "display_name": "Python 3",
250 |    "language": "python",
251 |    "name": "python3"
252 |   },
253 |   "language_info": {
254 |    "codemirror_mode": {
255 |     "name": "ipython",
256 |     "version": 3
257 |    },
258 |    "file_extension": ".py",
259 |    "mimetype": "text/x-python",
260 |    "name": "python",
261 |    "nbconvert_exporter": "python",
262 |    "pygments_lexer": "ipython3",
263 |    "version": "3.7.7"
264 |   }
265 |  },
266 |  "nbformat": 4,
267 |  "nbformat_minor": 4
268 | }
269 | 


--------------------------------------------------------------------------------