Explore topic-wise InterviewSolutions in .

ceil(x) 

Description : The method ceil( ) returns ceiling value of x-the smallest integer not less than x. 

Syntax: 

Following is the syntax for ceil() method import math math.ceil(x) 

Note: This function is not accessible directly so we need to import math module and then we need to call this function using math static object. 

Parameters : x—This is a numeric expression. Return Value : This method returns smallest integer not less than x. Example:

# !/usr/bin/py thon 

import math # This will import math module print “math.ceil(-45.17):”, 

math.ceil(-45.17) 

print “math.ceil(100.12):”, 

math.ceil(100.12) 

print “math.ceil(100.72):”, 

math.ceil(100.72) 

print “math.ceil(119L):”, 

math.ceil(119L) 

print “math.ceil(math.pi):”, 

math.ceil(math.pi), 

This will produce the following result math.ceil(-45.17) :-45.0

math.ceil(100.12): 101.0 

math.ceil(100.72): 101.0 

math.ceil(119L): 119.0 

math.ceil(math.pi): 4.0

Variables are names (identifiers) that map to objects. A namespace is a dictionary of variable names (keys) and their corres-ponding objects (values). 

A Python statement can access variables in a local namespace and in the global namespace. If a local and a global variable have the same name, the local variable shadows the global variable. Each function has its own local namespace. Class methods follow the same scoping rule as ordinary functions. Python makes educated guesses on whether variables are local or global. It assumes that any variable assigned a value in a function is local.

 Therefore, in order to assign a value to a global variable within a function, you must first use the global statement.The statement global VarName tells Python that VarName is a global variable. 

Python stops searching the local namespace for the variable.

Description : The method random( ) returns a random float r, such that 0 is less than or equal to r and r is less than 1. 

Syntax: Following is the syntax for 

random() method 

random() 

Note : This function is not accessible directly so we need to import random module and then we need to call this function using random static object. 

Parameters: NA 

Return Value : This method returns a random float r, such that 0 is less than or equal to r and r is less than 1. 

Example: The following example shows the usage of random() method.

#!/usr/bin/python 

import random # First random number 

print “random(): “, 

random.random() # Second random number print “random(): “, 

random.random()

This will produce the following result:

random(): 0.281954791393 

random(): 0.309090465205

The statement return [expression] exits a function, optionally passing back an expression to the caller. A return statement with no arguments is the same as return None. 

All the above examples are not returning any value, but if you like you can return a value from a function as follows :

#!/usr/bin/py thon 

# Function definition is here 

def sum(arg1,arg2):

# Add both the parameters and return them.

” total=arg1+arg2 

print “Inside the function : “, 

total 

return total; 

# Now you can call sum function total=sum(10,20); 

print “Outside the function total

This will produce the following result:

Inside the function : 30 

Outside the function : 30

Once the basic structure of a function is finalized, we can execute it

Defining a function only gives it a specific name, specifies the parameters that are to be included in the function, and structures the blocks of code. Once the basic structure of a function is finalized, you can execute it by calling it from another function or directly from the Python prompt. Following is the example to call printme( ) function:

# !/usr/bin/py thon 

# Function definition

def printme(str): 

“This prints a passed string into this function”

 print str; 

return; 

# Now you can call printme function 

printme (“I’m first call to user defined function!”); 

printme (“Again second call to the same function”);

This will produce the following result:

I’m first call to user defined function! 

Again second call to the same function

The standard module random implements a radom number generator. *’

There are also many other in this module, such as :

uniform(a, b) returns a floating point number in the range [a, b]. 

randint(a, b) returns a random integer number in the range [a, bj. 

random() returns a floating point number in the range [0,1]. 

Following code snippet show usage of all the different functions, evertime it is executed.

import random 

i = random.randint (1, 99) # i randomly initialized by integer between range 1 and 99. 

j = random randient (1,99) # j randomly initialized by float between range 1 and 99. 

k = random.random() # k randomly initialized by float between range 0 and 1

Print (“i.”, i) 

Print (“j.”,j) 

Print (“k.”, k) 

_______________ 

Output: 

(‘i:’, 64) (‘j:’ 701.85008797642115) 

(‘k:’: 0.18173593240301023) 

Output: 

(‘i:’,83) 

(‘j:’,56.817584548210945) 

(‘k:’; 0.9946957743038618

Gather the arguments using the * and ** specifiers in the function’s parameter list. It gives us positional arguments as a tuple and the keyword arguments as a dictionary. Then we can pass these arguments while calling another function by using

# and ** 

def funl (a, *tup, ** keyword.Arg): 

keyword Argj’width’j = ‘23.3c’ 

fun2 (a, *tup, **keywordArg)

Correct option is (c) Arguments

Program:

#include<stdio.h>
void main (void)
{
void display (void); /* function declaration */ display (); /* function calling */
}
void display (void)/* function definition */
{
printf (“this is a test program \n”);
printf (“for demonstrating a function call \n”);
printf (“in C \n”);
}

Output:
this is a test program for demonstrating a function call in C

You can use the lambda keyword to create small anonymous functions.

Yes, The first statement of a function can be an optional statement.

EXP function is used to return the exponential value of the argument.

sqrt() is a mathematical function that returns the square root of the given “num” value. Syntax to find the Square root: float sqrt( float num);

Character functions are functions used for the process of a character enclosed in single quotes. The ctype.h is the header for character functions.

exp() is a mathematical function that returns the natural logarithm base “e” raised to the argument’s power. Syntax to find exponential value: float exp( float num);

pow() is a mathematical function that returns the “base” value raised to the “exp” power. Syntax to find power of a number: float pow (float base, float exp);

Introduction: Sometimes, to perform a particular task in a program, you may have to write another program which may be a very cumbersome process. Functions are very useful to read, write, debug and modify complex programs. They can also be easily incorporated in the main program. In ‘C’ language, main() itself is a function that means the main function is invoking the other functions to perform various tasks.

There are two types of functions:

1. Built-in functions/Library Function.
2. User-defined functions.

1. Built-in Functions/Library Functions: These are the pre-defined routines that are included as an integral part of the language. Each function is accessed simply by stating its name, followed by whatever information must be supplied to the function, enclosed in parentheses (A numeric quantity or a string that is passed to a function in this manner is called an argument). Library functions are also called standard functions or elementary functions. These functions provide a quick and easy way to evaluate many mathematical functions and to carry out certain logical operations.

There are several library functions in ‘C’ Language. Basic Library functions are of two types:

• String Functions: String functions operate on strings, e.g., strlen (), strrev()
• Numeric Functions: Numeric functions operate on numeric values, e.g., ABS(), EXP(), SIN(), cos().

2. User-defined Functions: This feature allows you to define functions within a program, which you can call whenever you need them. While running the program (FUNC) statement can save space as well time, as a complex calculation can be defined with a short name and called up by its name where needed.

User-defined Functions: This feature allows you to define functions within a program, which you can call whenever you need them. While running the program (FUNC) statement can save space as well as time, as a complex calculation can be defined with a short name and called up by its name where needed.
Defining a Function

main()
{
printf (“I am in function main \n”);
India();
printf (“I am finally back in function main \n”);
}
India()
{
printf (“I am in India \n”);
Delhi();
printf (“I am back in India \n”);
1
Delhi();
{
printf (“I am in Delhi \n”);
Bombay();
}
Bombay()
{
printf (“I am in Bombay”);
}

Output:
I am in function main
I am in India
I am in Delhi
I am in Bombay
I am back in India
I am finally back in function main

Programming Language is a set of instructions and keywords which help a user to communicate with the computer. The ‘C’ programming language was developed by Dennis Ritchie in Bell Telephone Laboratories, in the early 1970s. Ken Thompson and his team supported him in developing this language. In the late seventies, ‘C’ began to replace the more familiar languages of that time like PL/I, ALGOL, etc. In less than a decade of its introduction, ‘C’ has become a language of choice for software professionals because it is reliable, simple and easy to use. The UNIX operating system was written in ‘C’ language.

One of the most interesting things about the ‘C’ language is that its compiler is written in ‘C’. ‘C’ language is considered as a middle-level language since it was designed to have both a relatively good programming efficiency and a relatively good machine efficiency. It is a bridge between low level and high-level languages.

• ‘C’ language possesses features of both low level and high-level languages.
• It provides the facility to do programming with easy approaches.
• It provides the facility to do programming at register level which leads to fast processing.
• It consists of simple English like commands, which are easy to understand.
• The programs written in ‘C’ language are 100 per cent efficient and are also machine-independent and portable.
• A ‘C’ program is easier to write and does not vary much from computer to computer.

Correct option is (a) void

The pre-defined function is also known as built-in function.

Correct option is (b) Control + S

A loop within a loop is known as Nested loop.

Correct option is (c) HTML

Dennis Ritchie and Ken Thompson.

A module allows you to logically organize your Python code. Grouping related code into a module makes the code easier to understand and use. A module is a Python object with arbitarily named attributes that you can bind and reference. Simply, a module is a file consisting of Python code. A module can define functions, classes, and variables. A module can also include runnable code.

A generator function or generator method is one which contains a yield expression. When a generator function is called it returns an iterator. Values are extracted from the iterator one at a time by calling its_next_( ) method. At each call to_next_( ) the generator function’s yield expression’s value (None if none is specified) is returned. If the generator function finishes or executes return a Stop Iteration exception is raised.

 Generators provide an elegant way to write simple and efficient code for functions that return a list of elements. Based on the yield directive, they allow you to pause a function and return an intermediate result. The function saves its execution context and can be resumed later if necessary.

The globals( ) and locals( ) functions can be used to return-the names in the global and local namespaces depending on the location from where they are called. If locals() is called from within a function, it will return all the names that can be accessed locally from that function. 

If globals() is called from within a function, it will return all the names that can be accessed globally from that function .The return type of both these functions is dictionary. Therefore, names can be extracted using the keys() function

The numeric function works on numeric values.

The value we pass in a function at the time of its calling is known as an argument.

SQR(X): function returns the square root of its argument which should never be negative.
For example:

#include<stdio.h>
#include<conio.h>
void main()
{
int a = 4, b;
b = sqr(a);
printf (“%d”, b);
}

Output: 2

ABS(X): This function gives the absolute value of X. The absolute value of a constant is always independent of its sign le., it is always positive.
For example:

#include<stdio.h>
#include<conio.h>
void main()
{
int a = -20, b = -20.23, c = 18.5
printf (“%d %d %d”, abs(a), abs(b), abs(c));}

Output: 20 20.23 18.5

It converts angle x from degrees to radians.

Return the next random floating point number in the range (0.0,1.0).

(B) 5

log (5x – 9) – log (x + 3) = log 2

\(\therefore\frac{5x-9}{x+3}=2\) 

 \(\therefore\) 3x = 9 + 6

\(\therefore\) 3x = 9 + 6

\(\therefore\) x = 5

A function is a block of organized, reusable code that is used to perform a single, related action. Functions provides better modularity for your application and a high degree of code reusing.As you already know, Python gives you many built-in functions like 

print( ) etc. but you can also create your own functions. These functions are called 

user – defined functions. 

Syntax: def functionname(parameters):

“function_docstring” 

function_suite return[expression] 

By default, parameters have a positional behavior, and you need to inform them in the same order that they were defined. 

Example: 

Here is the simplest form of a Python function. This function takes a string as input parameter and prints it on standard screen.

def printme(str): 

“This prints a passed string into this function”

 print str 

return

The following example shows the usage of choice( ) method. 

# !/usr/bin/py 

thon import random 

print “choice([l, 2, 3, 5, 9]): “,

 random.choice([l,2,3,5,9]) 

print “choice(‘A String*): “,

 random.choice(‘A String’)

This will produce the following result choice

([l, 2, 3,5,9]): 2 

choice(‘A String’) :n