14
14
},
15
15
{
16
16
"cell_type" : " code" ,
17
- "execution_count" : 1 ,
17
+ "execution_count" : 5 ,
18
18
"metadata" : {},
19
19
"outputs" : [],
20
20
"source" : [
21
21
" def vol(rad):\n " ,
22
- " pass "
22
+ " return (4/3)*(3.14) * (rad ** 3) "
23
23
]
24
24
},
25
25
{
26
26
"cell_type" : " code" ,
27
- "execution_count" : 2 ,
27
+ "execution_count" : 6 ,
28
28
"metadata" : {},
29
29
"outputs" : [
30
30
{
31
31
"data" : {
32
- "text/plain" : [
33
- " 33.49333333333333"
34
- ]
32
+ "text/plain" : " 33.49333333333333"
35
33
},
36
- "execution_count" : 2 ,
34
+ "execution_count" : 6 ,
37
35
"metadata" : {},
38
36
"output_type" : " execute_result"
39
37
}
53
51
},
54
52
{
55
53
"cell_type" : " code" ,
56
- "execution_count" : 3 ,
54
+ "execution_count" : 25 ,
57
55
"metadata" : {},
58
56
"outputs" : [],
59
57
"source" : [
60
58
" def ran_check(num,low,high):\n " ,
61
- " pass"
59
+ " x = [r for r in range(low, high+1)]\n " ,
60
+ " if num in x:\n " ,
61
+ " return f'{num} is in the range between {low} and {high}'\n " ,
62
+ " else:\n " ,
63
+ " return f'{num} is not in the range between {low} and {high}'"
62
64
]
63
65
},
64
66
{
65
67
"cell_type" : " code" ,
66
- "execution_count" : 4 ,
68
+ "execution_count" : 26 ,
67
69
"metadata" : {},
68
70
"outputs" : [
69
71
{
70
- "name" : " stdout" ,
71
- "output_type" : " stream" ,
72
- "text" : [
73
- " 5 is in the range between 2 and 7\n "
74
- ]
72
+ "data" : {
73
+ "text/plain" : " '5 is in the range between 2 and 7'"
74
+ },
75
+ "execution_count" : 26 ,
76
+ "metadata" : {},
77
+ "output_type" : " execute_result"
75
78
}
76
79
],
77
80
"source" : [
78
81
" # Check\n " ,
79
82
" ran_check(5,2,7)"
80
83
]
81
84
},
85
+ {
86
+ "cell_type" : " code" ,
87
+ "execution_count" : 24 ,
88
+ "metadata" : {},
89
+ "outputs" : [
90
+ {
91
+ "data" : {
92
+ "text/plain" : " '5 is in the range between 2 and 7'"
93
+ },
94
+ "execution_count" : 24 ,
95
+ "metadata" : {},
96
+ "output_type" : " execute_result"
97
+ }
98
+ ],
99
+ "source" : [
100
+ " ran_check(5,2,7)"
101
+ ]
102
+ },
82
103
{
83
104
"cell_type" : " markdown" ,
84
105
"metadata" : {},
88
109
},
89
110
{
90
111
"cell_type" : " code" ,
91
- "execution_count" : 5 ,
112
+ "execution_count" : 29 ,
92
113
"metadata" : {},
93
114
"outputs" : [],
94
115
"source" : [
95
116
" def ran_bool(num,low,high):\n " ,
96
- " pass"
117
+ " x = [r for r in range(low, high+1)]\n " ,
118
+ " if num in x:\n " ,
119
+ " return True\n " ,
120
+ " else:\n " ,
121
+ " return False"
97
122
]
98
123
},
99
124
{
100
125
"cell_type" : " code" ,
101
- "execution_count" : 6 ,
126
+ "execution_count" : 30 ,
102
127
"metadata" : {},
103
128
"outputs" : [
104
129
{
105
130
"data" : {
106
- "text/plain" : [
107
- " True"
108
- ]
131
+ "text/plain" : " True"
109
132
},
110
- "execution_count" : 6 ,
133
+ "execution_count" : 30 ,
111
134
"metadata" : {},
112
135
"output_type" : " execute_result"
113
136
}
135
158
},
136
159
{
137
160
"cell_type" : " code" ,
138
- "execution_count" : 7 ,
161
+ "execution_count" : 107 ,
139
162
"metadata" : {},
140
163
"outputs" : [],
141
164
"source" : [
142
165
" def up_low(s):\n " ,
143
- " pass"
166
+ " import collections\n " ,
167
+ " from collections import Counter\n " ,
168
+ " \n " ,
169
+ " u = Counter()\n " ,
170
+ " l = Counter()\n " ,
171
+ " for letter in s:\n " ,
172
+ " l[letter.islower()] += 1\n " ,
173
+ " u[letter.isupper()] += 1\n " ,
174
+ " \n " ,
175
+ " #print(u[True], l[True])\n " ,
176
+ " return(\n " ,
177
+ " f\" Original String : {s}\"\n " ,
178
+ " f\" No. of Upper case characters : {u[True]}\"\n " ,
179
+ " f\" No. of Lower case characters : {l[True]}\"\n " ,
180
+ " )"
144
181
]
145
182
},
146
183
{
147
184
"cell_type" : " code" ,
148
- "execution_count" : 8 ,
185
+ "execution_count" : 108 ,
149
186
"metadata" : {},
150
187
"outputs" : [
151
188
{
152
- "name" : " stdout" ,
153
- "output_type" : " stream" ,
154
- "text" : [
155
- " Original String : Hello Mr. Rogers, how are you this fine Tuesday?\n " ,
156
- " No. of Upper case characters : 4\n " ,
157
- " No. of Lower case Characters : 33\n "
158
- ]
189
+ "data" : {
190
+ "text/plain" : " 'Original String : Hello Mr. Rogers, how are you this fine Tuesday?No. of Upper case characters : 4No. of Lower case characters : 33'"
191
+ },
192
+ "execution_count" : 108 ,
193
+ "metadata" : {},
194
+ "output_type" : " execute_result"
159
195
}
160
196
],
161
197
"source" : [
176
212
},
177
213
{
178
214
"cell_type" : " code" ,
179
- "execution_count" : 9 ,
215
+ "execution_count" : 109 ,
180
216
"metadata" : {},
181
217
"outputs" : [],
182
218
"source" : [
183
219
" def unique_list(lst):\n " ,
184
- " pass "
220
+ " return set(lst) "
185
221
]
186
222
},
187
223
{
188
224
"cell_type" : " code" ,
189
- "execution_count" : 10 ,
225
+ "execution_count" : 110 ,
190
226
"metadata" : {},
191
227
"outputs" : [
192
228
{
193
229
"data" : {
194
- "text/plain" : [
195
- " [1, 2, 3, 4, 5]"
196
- ]
230
+ "text/plain" : " {1, 2, 3, 4, 5}"
197
231
},
198
- "execution_count" : 10 ,
232
+ "execution_count" : 110 ,
199
233
"metadata" : {},
200
234
"output_type" : " execute_result"
201
235
}
217
251
},
218
252
{
219
253
"cell_type" : " code" ,
220
- "execution_count" : 11 ,
254
+ "execution_count" : 111 ,
221
255
"metadata" : {},
222
256
"outputs" : [],
223
257
"source" : [
224
258
" def multiply(numbers): \n " ,
225
- " pass"
259
+ " x = 1\n " ,
260
+ " for y in numbers:\n " ,
261
+ " x = x * y\n " ,
262
+ " return x"
226
263
]
227
264
},
228
265
{
229
266
"cell_type" : " code" ,
230
- "execution_count" : 12 ,
267
+ "execution_count" : 112 ,
231
268
"metadata" : {},
232
269
"outputs" : [
233
270
{
234
271
"data" : {
235
- "text/plain" : [
236
- " -24"
237
- ]
272
+ "text/plain" : " -24"
238
273
},
239
- "execution_count" : 12 ,
274
+ "execution_count" : 112 ,
240
275
"metadata" : {},
241
276
"output_type" : " execute_result"
242
277
}
257
292
},
258
293
{
259
294
"cell_type" : " code" ,
260
- "execution_count" : 13 ,
295
+ "execution_count" : 141 ,
261
296
"metadata" : {},
262
297
"outputs" : [],
263
298
"source" : [
264
299
" def palindrome(s):\n " ,
265
- " pass"
300
+ " x = [n for n in s]\n " ,
301
+ " y = [n for n in s]\n " ,
302
+ " y.reverse()\n " ,
303
+ " \n " ,
304
+ " if x == y:\n " ,
305
+ " return True\n " ,
306
+ " else:\n " ,
307
+ " return False"
266
308
]
267
309
},
268
310
{
269
311
"cell_type" : " code" ,
270
- "execution_count" : 14 ,
312
+ "execution_count" : 143 ,
271
313
"metadata" : {},
272
314
"outputs" : [
273
315
{
274
316
"data" : {
275
- "text/plain" : [
276
- " True"
277
- ]
317
+ "text/plain" : " True"
278
318
},
279
- "execution_count" : 14 ,
319
+ "execution_count" : 143 ,
280
320
"metadata" : {},
281
321
"output_type" : " execute_result"
282
322
}
302
342
},
303
343
{
304
344
"cell_type" : " code" ,
305
- "execution_count" : 15 ,
345
+ "execution_count" : 217 ,
306
346
"metadata" : {},
307
347
"outputs" : [],
308
348
"source" : [
309
349
" import string\n " ,
310
350
" \n " ,
311
351
" def ispangram(str1, alphabet=string.ascii_lowercase):\n " ,
312
- " pass"
352
+ " x = set([l for l in str1.lower().replace(' ','')])\n " ,
353
+ " alphabet = set(alphabet)\n " ,
354
+ " \n " ,
355
+ " if x == alphabet:\n " ,
356
+ " return True\n " ,
357
+ " else:\n " ,
358
+ " return False"
313
359
]
314
360
},
315
361
{
316
362
"cell_type" : " code" ,
317
- "execution_count" : 16 ,
363
+ "execution_count" : 218 ,
318
364
"metadata" : {},
319
365
"outputs" : [
320
366
{
321
367
"data" : {
322
- "text/plain" : [
323
- " True"
324
- ]
368
+ "text/plain" : " True"
325
369
},
326
- "execution_count" : 16 ,
370
+ "execution_count" : 218 ,
327
371
"metadata" : {},
328
372
"output_type" : " execute_result"
329
373
}
383
427
},
384
428
"nbformat" : 4 ,
385
429
"nbformat_minor" : 1
386
- }
430
+ }
0 commit comments