Atoi() used to convert the string to number

Sprintf- this will convert the string to number

6. Why doesn’t C support function overloading?

After you compile the C source, the symbol names need to be intact in the object
code. If we introduce function overloading in our source, we should also provide
name mangling as a preventive measure to avoid function name clashes. Also, as C is
not a strictly typed language many things(ex: data types) are convertible to each
other in C. Therefore, the complexity of overload resolution can introduce confusion
in a language such as C.

9. Why n++ execute faster than n+1 ?

n++ being a unary operation, it just needs one variable. Whereas, n = n + 1 is a

binary operation that adds overhead to take more time (also binary operation: n +=
1).

11. Specify different types of decision control statements?

All statements written in a program are executed from top to bottom one by one.
Control statements are used to execute/transfer the control from one part of the
program to another depending on the condition.

 If-else statement.
o normal if-else statement.
o Else-if statement
o nested if-else statement.
 Switch statement
When we caller function makes a function call bypassing the addresses of actual
parameters being passed, then this is called call by reference. In incall by reference, the
operation performed on formal parameters affects the value of actual parameters because
all the operations performed on the value stored in the address of actual parameters
Types 0f storage classes

Storage Class Declaration Storage

auto Inside a function/block Memory

register Inside a function/block CPU Registers

extern Outside all functions Memory

Static (local) Inside a function/block Memory

When we assign a variable it takes space of our RAM (either heap or RAM)dependent on
the size of data type, however, if a programmer uses a memory available on the heap and
forgets to a delta it, at some point all the memory available on the ram will be occupied
with no memory left this can lead to a memory leak.

C is a language known for its low-level control over the memory allocation of variables in
DMA there are two major standard library malloc() and free. The malloc() function takes a
single input parameter which tells the size of the memory requested It returns a pointer to
the allocated memory. If the allocation fails, it returns NULL. The prototype for the
standard library function is like this:

There are 4 library functions provided by C defined under <stdlib.h> header file to
facilitate dynamic memory allocation in C programming. They are:
  malloc()
 calloc()
 free()
 realloc

 The standard input library gets() reads user input till it encounters a new line
character. However, it does not check on the size of the variable being
provided by the user is under the maximum size of the data type due to
which makes the system vulnerable to buffer overflow and the input being
written into memory where it isn’t supposed to.
 We, therefore, use fgets() to achieve the same with a restricted range of
input
 In practice, the difference is in the location where the preprocessor searches
for the included file.
 For #include <filename> the C preprocessor looks for the filename in the
predefined list of system directories first and then to the directories told by
the user(we can use -I option to add directories to the mentioned predefined
list). 
 For #include "filename" the preprocessor searches first in the same directory
as the file containing the directive, and then follows the search path used for
the #include <filename> form. This method is normally used to include
programmer-defined header files

n C double-quotes variables are identified as a string whereas single-quoted variables

are identified as the character. Another major difference being the string (double-
quoted) variables end with a null terminator that makes it a 2 character array.

// Computes quotient
quotient = dividend / divisor;

// Computes remainder
remainder = dividend % divisor;
#include<stdio.h>
int main() {
int intType;
float floatType;
double doubleType;
char charType;

// sizeof evaluates the size of a variable

printf("Size of int: %zu bytes\n", sizeof(intType));
printf("Size of float: %zu bytes\n", sizeof(floatType));
 printf("Size of double: %zu bytes\n", sizeof(doubleType));
printf("Size of char: %zu byte\n", sizeof(charType));

return 0;
}

Program to Check Vowel or consonant

#include <stdio.h>
int main() {
char c;
int lowercase_vowel, uppercase_vowel;
printf("Enter an alphabet: ");
scanf("%c", &c);

// evaluates to 1 if variable c is a lowercase vowel

lowercase_vowel = (c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u');

// evaluates to 1 if variable c is a uppercase vowel

uppercase_vowel = (c == 'A' || c == 'E' || c == 'I' || c == 'O' || c == 'U');

// evaluates to 1 (true) if c is a vowel

if (lowercase_vowel || uppercase_vowel)
printf("%c is a vowel.", c);
else
printf("%c is a consonant.", c);
return 0;
}

Program to Check Leap Year

#include <stdio.h>
int main() {
int year;
printf("Enter a year: ");
scanf("%d", &year);

// leap year if perfectly divisible by 400

if (year % 400 == 0) {
printf("%d is a leap year.", year);
}
 // not a leap year if divisible by 100
// but not divisible by 400
else if (year % 100 == 0) {
printf("%d is not a leap year.", year);
}
// leap year if not divisible by 100
// but divisible by 4
else if (year % 4 == 0) {
printf("%d is a leap year.", year);
}
// all other years are not leap years
else {
printf("%d is not a leap year.", year);
}

return 0;
}

Fibonacci Series up to n terms

#include <stdio.h>
int main() {

int i, n;

// initialize first and second terms

int t1 = 0, t2 = 1;

// initialize the next term (3rd term)

int nextTerm = t1 + t2;

// get no. of terms from user

printf("Enter the number of terms: ");
scanf("%d", &n);

// print the first two terms t1 and t2

printf("Fibonacci Series: %d, %d, ", t1, t2);

// print 3rd to nth terms

for (i = 3; i <= n; ++i) {
printf("%d, ", nextTerm);
t1 = t2;
t2 = nextTerm;
 nextTerm = t1 + t2;
}

return 0;
}

Example #1: GCD Using for loop and if Statement

#include <stdio.h>
int main()
{
int n1, n2, i, gcd;

printf("Enter two integers: ");

scanf("%d %d", &n1, &n2);

for(i=1; i <= n1 && i <= n2; ++i)

{
// Checks if i is factor of both integers
if(n1%i==0 && n2%i==0)
gcd = i;
}

printf("G.C.D of %d and %d is %d", n1, n2, gcd);

return 0;
}

LCM using while and if

#include <stdio.h>
int main() {
int n1, n2, max;
printf("Enter two positive integers: ");
scanf("%d %d", &n1, &n2);

// maximum number between n1 and n2 is stored in max

max = (n1 > n2) ? n1 : n2;

while (1) {
if (max % n1 == 0 && max % n2 == 0) {
 printf("The LCM of %d and %d is %d.", n1, n2, max);
break;
}
++max;
}
return 0;
}

Reverse an Integer

#include <stdio.h>
int main() {
int n, rev = 0, remainder;
printf("Enter an integer: ");
scanf("%d", &n);
while (n != 0) {
remainder = n % 10;
rev = rev * 10 + remainder;
n /= 10;
}
printf("Reversed number = %d", rev);
return 0;
}

Program to Check Prime Number

#include <stdio.h>
int main() {
int n, i, flag = 0;
printf("Enter a positive integer: ");
scanf("%d", &n);

for (i = 2; i <= n / 2; ++i) {

// condition for non-prime
if (n % i == 0) {
flag = 1;
break;
}
}

if (n == 1) {
 printf("1 is neither prime nor composite.");
}
else {
if (flag == 0)
printf("%d is a prime number.", n);
else
printf("%d is not a prime number.", n);
}

Simple Calculator using switch Statement

#include <stdio.h>
int main() {
char op;
double first, second;
printf("Enter an operator (+, -, *, /): ");
scanf("%c", &op);
printf("Enter two operands: ");
scanf("%lf %lf", &first, &second);

switch (op) {
case '+':
printf("%.1lf + %.1lf = %.1lf", first, second, first + second);
break;
case '-':
printf("%.1lf - %.1lf = %.1lf", first, second, first - second);
break;
case '*':
printf("%.1lf * %.1lf = %.1lf", first, second, first * second);
break;
case '/':
printf("%.1lf / %.1lf = %.1lf", first, second, first / second);
break;
// operator doesn't match any case constant
default:
printf("Error! operator is not correct");
}

return 0;
}
Factorial of a Number Using Recursion

#include<stdio.h>
long int multiplyNumbers(int n);
int main() {
int n;
printf("Enter a positive integer: ");
scanf("%d",&n);
printf("Factorial of %d = %ld", n, multiplyNumbers(n));
return 0;
}

long int multiplyNumbers(int n) {

if (n>=1)
return n*multiplyNumbers(n-1);
else
return 1;
}

Store Numbers and Calculate Average Using Arrays

#include <stdio.h>
int main() {
int n, i;
float num[100], sum = 0.0, avg;

printf("Enter the numbers of elements: ");

scanf("%d", &n);

while (n > 100 || n < 1) {

printf("Error! number should in range of (1 to 100).\n");
printf("Enter the number again: ");
scanf("%d", &n);
}

for (i = 0; i < n; ++i) {

printf("%d. Enter number: ", i + 1);
scanf("%f", &num[i]);
sum += num[i];
}
 avg = sum / n;
printf("Average = %.2f", avg);
return 0;
}

Example: Largest Element in an array

#include <stdio.h>
int main() {
int n;
double arr[100];
printf("Enter the number of elements (1 to 100): ");
scanf("%d", &n);

for (int i = 0; i < n; ++i) {

printf("Enter number%d: ", i + 1);
scanf("%lf", &arr[i]);
}

// storing the largest number to arr[0]

for (int i = 1; i < n; ++i) {
if (arr[0] < arr[i]) {
arr[0] = arr[i];
}
}

printf("Largest element = %.2lf", arr[0]);

return 0;
}

Program to Add Two Matrices

#include <stdio.h>
int main() {
int r, c, a[100][100], b[100][100], sum[100][100], i, j;
printf("Enter the number of rows (between 1 and 100): ");
scanf("%d", &r);
 printf("Enter the number of columns (between 1 and 100): ");
scanf("%d", &c);

printf("\nEnter elements of 1st matrix:\n");

for (i = 0; i < r; ++i)
for (j = 0; j < c; ++j) {
printf("Enter element a%d%d: ", i + 1, j + 1);
scanf("%d", &a[i][j]);
}

printf("Enter elements of 2nd matrix:\n");

for (i = 0; i < r; ++i)
for (j = 0; j < c; ++j) {
printf("Enter element b%d%d: ", i + 1, j + 1);
scanf("%d", &b[i][j]);
}

// adding two matrices

for (i = 0; i < r; ++i)
for (j = 0; j < c; ++j) {
sum[i][j] = a[i][j] + b[i][j];
}

// printing the result

printf("\nSum of two matrices: \n");
for (i = 0; i < r; ++i)
for (j = 0; j < c; ++j) {
printf("%d ", sum[i][j]);
if (j == c - 1) {
printf("\n\n");
}
}

return 0;
}

Multiply Matrices by Passing it to a Function

#include <stdio.h>

// function to get matrix elements entered by the user

void getMatrixElements(int matrix[][10], int row, int column) {
 printf("\nEnter elements: \n");

for (int i = 0; i < row; ++i) {

for (int j = 0; j < column; ++j) {
printf("Enter a%d%d: ", i + 1, j + 1);
scanf("%d", &matrix[i][j]);
}
}
}

// function to multiply two matrices

void multiplyMatrices(int first[][10],
int second[][10],
int result[][10],
int r1, int c1, int r2, int c2) {

// Initializing elements of matrix mult to 0.

for (int i = 0; i < r1; ++i) {
for (int j = 0; j < c2; ++j) {
result[i][j] = 0;
}
}

// Multiplying first and second matrices and storing it in result

for (int i = 0; i < r1; ++i) {
for (int j = 0; j < c2; ++j) {
for (int k = 0; k < c1; ++k) {
result[i][j] += first[i][k] * second[k][j];
}
}
}
}

// function to display the matrix

void display(int result[][10], int row, int column) {

printf("\nOutput Matrix:\n");
for (int i = 0; i < row; ++i) {
for (int j = 0; j < column; ++j) {
printf("%d ", result[i][j]);
if (j == column - 1)
printf("\n");
}
 }
}

int main() {
int first[10][10], second[10][10], result[10][10], r1, c1, r2, c2;
printf("Enter rows and column for the first matrix: ");
scanf("%d %d", &r1, &c1);
printf("Enter rows and column for the second matrix: ");
scanf("%d %d", &r2, &c2);

// Taking input until

// 1st matrix columns is not equal to 2nd matrix row
while (c1 != r2) {
printf("Error! Enter rows and columns again.\n");
printf("Enter rows and columns for the first matrix: ");
scanf("%d%d", &r1, &c1);
printf("Enter rows and columns for the second matrix: ");
scanf("%d%d", &r2, &c2);
}

// get elements of the first matrix

getMatrixElements(first, r1, c1);

// get elements of the second matrix

getMatrixElements(second, r2, c2);

// multiply two matrices.

multiplyMatrices(first, second, result, r1, c1, r2, c2);

// display the result

display(result, r1, c2);

return 0;
}

#include <stdio.h>
int main() {
char line[150];

printf("Enter a string: ");

fgets(line, sizeof(line), stdin); // take input
 for (int i = 0, j; line[i] != '\0'; ++i) {

// enter the loop if the character is not an alphabet

// and not the null character
while (!(line[i] >= 'a' && line[i] <= 'z') && !(line[i] >= 'A' && line[i] <=
'Z') && !(line[i] == '\0')) {
for (j = i; line[j] != '\0'; ++j) {

// if jth element of line is not an alphabet,

// assign the value of (j+1)th element to the jth element
line[j] = line[j + 1];
}
line[j] = '\0';
}
}
printf("Output String: ");
puts(line);
return 0;
}

Store Information and Display it Using Structure

#include <stdio.h>
struct student {
char name[50];
int roll;
float marks;
} s;

int main() {
printf("Enter information:\n");
printf("Enter name: ");
fgets(s.name, sizeof(s.name), stdin);

printf("Enter roll number: ");

scanf("%d", &s.roll);
printf("Enter marks: ");
scanf("%f", &s.marks);

printf("Displaying Information:\n");
printf("Name: ");
 printf("%s", s.name);
printf("Roll number: %d\n", s.roll);
printf("Marks: %.1f\n", s.marks);

return 0;
}

4. What is an Interpreted language?

An Interpreted language executes its statements line by line. Languages such as

Python, Javascript, R, PHP, and Ruby are prime examples of Interpreted languages.
Programs written in an interpreted language runs directly from the source code, with
no intermediary compilation step.

5. What is PEP 8 and why is it important?

PEP stands for Python Enhancement Proposal. A PEP is an official design document

providing information to the Python community, or describing a new feature for
Python or its processes. PEP 8 is especially important since it documents the style
guidelines for Python Code. Apparently contributing to the Python open-source
community requires you to follow these style guidelines sincerely and strict
Every object in Python functions within a scope. A scope is a block of code where an object
in Python remains relevant. Namespaces uniquely identify all the objects inside a program.
However, these namespaces also have a scope defined for them where you could use their
objects without any prefix. A few examples of scope created during code execution in
Python 

12. What is self in Python?

Self is a keyword in Python used to define an instance of an object of a class. In

Python, it is explicitly used as the first parameter, unlike in Java where it is optional. It
helps in distinguishing between the methods and attributes of a class from its local
variables
Break The break statement terminates the loop immediately and the control
flows to the statement after the body of the loop.
Continue The continue statement terminates the current iteration of the statement,
skips the rest of the code in the current iteration and the control flows to
the next iteration of the loop.
Pass As explained above, the pass keyword in Python is generally used to fill
up empty blocks and is similar to an empty statement represented by a
semi-colon in languages such as Java, C++, Javascript, etc.
  Arrays in python can only contain elements of same data types i.e., data type
of array should be homogeneous. It is a thin wrapper around C language
arrays and consumes far less memory than lists.
 Lists in python can contain elements of different data types i.e., data type of
lists can be heterogeneous. It has the disadvantage of consuming large
memory.

25. What is lambda in Python? Why is it used?

Lambda is an anonymous function in Python, that can accept any number of

arguments, but can only have a single expression. It is generally used in situations
requiring an anonymous function for a short time period. Lambda functions can be
used in either of the two ways:

28. What is pickling and unpickling?

Python library offers a feature - serialization out of the box. Serializing an object

refers to transforming it into a format that can be stored, so as to be able to
deserialize it, later on, to obtain the original object. Here, the pickle module comes
into play.
Pickling:
 Pickling is the name of the serialization process in Python. Any object in Python can
be serialized into a byte stream and dumped as a file in the memory. The process of
pickling is compact but pickle objects can be compressed further. Moreover, pickle
keeps track of the objects it has serialized and the serialization is portable across
versions.
 The function used for the above process is pickle.dump().
Unpickling:
 Unpickling is the complete inverse of pickling. It deserializes the byte stream to
recreate the objects stored in the file and loads the object to memory.
 The function used for the above process is pickle.load().
Note: Python has another, more primitive, serialization module called  marshall, which
exists primarily to  support .pyc files  in Python and  differs significantly from the
pickle.

*args

 *args is a special syntax used in the function definition to pass variable-

length arguments.
 “*” means variable length and “args” is the name used by convention. You
can use any other.
def multiply(a, b, *argv):
mul = a * b
for num in argv:
mul *= num
return mul
print(multiply(1, 2, 3, 4, 5)) #output: 120

**kwargs

 **kwargs is a special syntax used in the function definition to pass variable-

length keyworded arguments.
 Here, also, “kwargs” is used just by convention. You can use any other name.
 Keyworded argument means a variable that has a name when passed to a
function.
 It is actually a dictionary of the variable names and its value.

43. Are access specifiers used in python?

Python does not make use of access specifiers specifically like private, public,
protected, etc. However, it does not deprive this to any variables. It has the concept
of imitating the behaviour of variables by making use of a single (protected) or
double underscore (private) as prefixed to the variable names. By default, the
variables without prefixed underscores are public.
Example:

49. How will you check if a class is a child of another class?

This is done by using a method called issubclass() provided by python. The method

tells us if any class is a child of another class by returning true or false accordingly.