{"id":14091,"date":"2022-10-26T23:03:13","date_gmt":"2022-10-26T17:33:13","guid":{"rendered":"https:\/\/blog.guvi.in\/?p=14091"},"modified":"2026-01-19T18:06:07","modified_gmt":"2026-01-19T12:36:07","slug":"paytm-coding-interview-questions","status":"publish","type":"post","link":"https:\/\/www.guvi.in\/blog\/paytm-coding-interview-questions\/","title":{"rendered":"10 Important Paytm Coding Interview Questions"},"content":{"rendered":"\n

If you are in a rush to crack that Paytm coding Interview round, then here is a short pocketbook that you should go through. Make sure you practice all 10 coding questions in here (and study the related ones) because these are the most asked Paytm coding interview questions, say the interviewees!<\/p>\n\n\n\n

Top 10 Paytm Coding Interview Questions<\/h2>\n\n\n\n

Coding comes in handy when you practise it several times. And one coding question can solve multiple related queries on the go. So do practise as many coding questions as you can! <\/p>\n\n\n\n

\nhttps:\/\/giphy.com\/gifs\/life-interesting-footage-ZVik7pBtu9dNS\n<\/div>
Paytm coding interview questions<\/figcaption><\/figure>\n\n\n\n

Before diving into the next section, ensure you’re solid on full-stack development<\/a><\/em> essentials like front-end frameworks, back-end technologies, and database management. If you are looking for a detailed full-stack development career program, you can join HCL GUVI\u2019s Full Stack Development Course<\/a> with placement assistance. You will be able to master the MERN stack<\/a> (MongoDB, Express.js, React, Node.js) and build real-life projects.<\/em><\/p>\n\n\n\n

Additionally, if you would like to explore JavaScript through a self-paced course, try HCL GUVI\u2019s JavaScript certification course<\/a>.<\/em><\/p>\n\n\n\n

1. Given an integer number, convert it to a Roman numeral.<\/h3>\n\n\n\n

Answer: A combination of some symbols represents Roman numerals.<\/p>\n\n\n\n

Value <\/td>Symbol<\/td><\/tr>
1<\/td>I<\/td><\/tr>
5<\/td>V<\/td><\/tr>
10<\/td>X<\/td><\/tr>
50<\/td>L<\/td><\/tr>
100<\/td>C<\/td><\/tr>
500<\/td>D<\/td><\/tr>
1000<\/td>M<\/td><\/tr><\/tbody><\/table>
Integers & their roman numerals<\/strong><\/figcaption><\/figure>\n\n\n\n

<\/p>\n\n\n\n

Sample Input: <\/strong><\/p>\n\n\n\n

num: 10<\/p>\n\n\n\n

Expected output:<\/strong><\/p>\n\n\n\n

\u201cX\u201d<\/p>\n\n\n\n

Code: IntegerToRoman.java<\/strong><\/h4>\n\n\n\n
\n

public<\/strong> class<\/strong> IntegerToRoman   <\/p>\n\n\n\n

{  <\/p>\n\n\n\n

\/\/method to convert integer to roman  <\/p>\n\n\n\n

\/\/function that converts an integer to roman  <\/p>\n\n\n\n

public<\/strong> static<\/strong> String intToRoman(int<\/strong> number)   <\/p>\n\n\n\n

{  <\/p>\n\n\n\n

\/\/creating an array of place values      <\/p>\n\n\n\n

String[] thousands = {“”, “M”, “MM”, “MMM”};  <\/p>\n\n\n\n

String[] hundreds = {“”, “C”, “CC”, “CCC”, “CD”, “D”, “DC”, “DCC”, “DCCC”, “CM”};  <\/p>\n\n\n\n

String[] tens = {“”, “X”, “XX”, “XXX”, “XL”, “L”, “LX”, “LXX”, “LXXX”, “XC”};  <\/p>\n\n\n\n

String[] units = {“”, “I”, “II”, “III”, “IV”, “V”, “VI”, “VII”, “VIII”, “IX”};  <\/p>\n\n\n\n

return<\/strong> thousands[number \/ 1000] + hundreds[(number % 1000) \/ 100] + tens[(number % 100) \/ 10] + units[number % 10];  <\/p>\n\n\n\n

}  <\/p>\n\n\n\n

public<\/strong> static<\/strong> void<\/strong> main(String args[])   <\/p>\n\n\n\n

{  <\/p>\n\n\n\n

\/\/creating an array of integers to be converted into roman      <\/p>\n\n\n\n

int<\/strong>[] numbers = {13, 21, 38, 50, 190, 141, 117, 120, 125, 138, 149, 6, 712, 181, 197, 918, 199, 1100, 1101, 1248, 1253};  <\/p>\n\n\n\n

for<\/strong> (int<\/strong> number: numbers)   <\/p>\n\n\n\n

{  <\/p>\n\n\n\n

System.out.printf(“%4d -> %8s\\n”, number, intToRoman(number));  <\/p>\n\n\n\n

}  <\/p>\n\n\n\n

}  <\/p>\n\n\n\n

}  <\/p>\n<\/div><\/div>\n\n\n\n

Output:<\/strong><\/p>\n\n\n\n

\"Paytm
Paytm coding interview questions<\/figcaption><\/figure>\n\n\n\n

2. Given a string s, reverse the order of words.<\/h3>\n\n\n\n

Sample Input <\/strong><\/p>\n\n\n\n

life is beautiful\nenjoy it\nlive upto it<\/code><\/pre>\n\n\n\n
Expected Output<\/strong><\/p>\n\n\n\n
beautiful is life\nit enjoy\nit upto live<\/code><\/pre>\n\n\n\n
Code: <\/strong><\/h4>\n\n\n\n
class Solution {\n   String reverseWords(String s) {\n       int numOfWords = 1;\n       for (int i = 0; i < s.length(); i++) {\n           if(s.charAt(i) == ' ') {\n               numOfWords++;\n           }\n       }\n       String[] allWords = new  String[numOfWords];\n       String currentWord = \"\";\n       int index = 0;\n       for(int i = 0; i < s.length(); i++) {\n           if(s.charAt(i) == ' ') {\n               allWords[index++] = currentWord;\n               currentWord = \"\";\n           } else {\n               currentWord += s.charAt(i);\n           }\n       }\n       allWords[index++] = currentWord;\n       String ans = \"\";\n       for(int i = index - 1; i > 0; i--) {\n           ans += allWords[i];\n           ans += ' ';\n       }\n       ans += allWords[0];\n       return ans;\n   }\n}<\/code><\/pre>\n\n\n\n
3. Sort an array of 0s, 1s and 2s<\/h3>\n\n\n\n
Sample Input:<\/strong><\/p>\n\n\n\n
\n
\n
 {0, 1, 2, 0, 1, 2}<\/p>\n<\/div>\n<\/div>\n\n\n\n

Output<\/strong>:<\/em><\/p>\n\n\n\n
 {0, 0, 1, 1, 2, 2}<\/p>\n\n\n\n
\"Paytm
Paytm coding interview questions<\/figcaption><\/figure>\n\n\n\n
Code:<\/strong><\/h4>\n\n\n\n
\n
import java.io.*;<\/code><\/p>\n\n\n\n
classcountzot{<\/code><\/p>\n\n\n\n
    <\/code>\/\/ Sort the input array, the array is assumed to<\/code><\/p>\n\n\n\n
    <\/code>\/\/ have values in {0, 1, 2}<\/code><\/p>\n\n\n\n
    static void sort 012(inta[], intarr_size){<\/code><\/p>\n\n\n\n
        <\/code>int<\/code>lo = <\/code>0<\/code>;<\/code><\/p>\n\n\n\n
        <\/code>int<\/code>hi = arr_size - <\/code>1<\/code>;<\/code><\/p>\n\n\n\n
        <\/code>int<\/code>mid = <\/code>0<\/code>, temp = <\/code>0<\/code>;<\/code><\/p>\n\n\n\n
        \/\/ Iterate till all the elements<\/code> are sorted<\/code><\/p>\n\n\n\n
        <\/code>while<\/code>(mid <= hi) {<\/code><\/p>\n\n\n\n
            <\/code>switch<\/code>(a[mid]) {<\/code><\/p>\n\n\n\n
                <\/code>\/\/ If the element is 0<\/code><\/p>\n\n\n\n
            <\/code>case<\/code>0<\/code>: {<\/code><\/p>\n\n\n\n
                <\/code>temp = a[lo];<\/code><\/p>\n\n\n\n
                <\/code>a[lo] = a[mid];<\/code><\/p>\n\n\n\n
                <\/code>a[mid] = temp;<\/code><\/p>\n\n\n\n
                <\/code>lo++;<\/code><\/p>\n\n\n\n
                <\/code>mid++;<\/code><\/p>\n\n\n\n
                <\/code>break<\/code>;<\/code><\/p>\n\n\n\n
            <\/code>}<\/code><\/p>\n\n\n\n
                <\/code>\/\/ If the element is 1<\/code><\/p>\n\n\n\n
            <\/code>case<\/code>1<\/code>:<\/code><\/p>\n\n\n\n
                <\/code>mid++;<\/code><\/p>\n\n\n\n
                <\/code>break<\/code>;<\/code><\/p>\n\n\n\n
                <\/code>\/\/ If the element is 2<\/code><\/p>\n\n\n\n
            <\/code>case<\/code>2<\/code>: {<\/code><\/p>\n\n\n\n
                <\/code>temp = a[mid];<\/code><\/p>\n\n\n\n
                <\/code>a[mid] = a[hi];<\/code><\/p>\n\n\n\n
                <\/code>a[hi] = temp;<\/code><\/p>\n\n\n\n
                <\/code>hi--;<\/code><\/p>\n\n\n\n
                <\/code>break<\/code>;<\/code><\/p>\n\n\n\n
            <\/code>}<\/code><\/p>\n\n\n\n
            <\/code>}<\/code><\/p>\n\n\n\n
        <\/code>}<\/code><\/p>\n\n\n\n
    <\/code>}<\/code><\/p>\n\n\n\n
    <\/code>\/* Utility function to print array arr[] *\/<\/code><\/p>\n\n\n\n
    static void print Array(intarr[], intarr_size){<\/code><\/p>\n\n\n\n
        <\/code>int<\/code>i;<\/code><\/p>\n\n\n\n
        <\/code>for<\/code>(i = <\/code>0<\/code>; i < arr_size; i++)<\/code><\/p>\n\n\n\n
            <\/code>System.out.print(arr[i] + <\/code>\" \"<\/code>);<\/code><\/p>\n\n\n\n
        <\/code>System.out.println(<\/code>\"\"<\/code>);<\/code><\/p>\n\n\n\n
    <\/code>}<\/code><\/p>\n\n\n\n
    <\/code>\/*Driver function to check for above functions*\/<\/code><\/p>\n\n\n\n
    public static void main(String[] args){<\/code><\/p>\n\n\n\n
        <\/code>int<\/code>arr[] = { <\/code>0<\/code>, <\/code>1<\/code>, <\/code>1<\/code>, <\/code>0<\/code>, <\/code>1<\/code>, <\/code>2<\/code>, <\/code>1<\/code>, <\/code>2<\/code>, <\/code>0<\/code>, <\/code>0<\/code>, <\/code>0<\/code>, <\/code>1<\/code>};<\/code><\/p>\n\n\n\n
        <\/code>int<\/code>arr_size = arr.length;<\/code><\/p>\n\n\n\n
        sort012(arr, arr_size);<\/code> <\/p>\n\n\n\n
        <\/code>printArray(arr, arr_size);<\/code><\/p>\n\n\n\n
    <\/code>}<\/code><\/p>\n\n\n\n
}<\/code><\/p>\n<\/div><\/div>\n\n\n\n
Practice more Paytm coding interview questions: Placement Preparation with HCL GUVI<\/a><\/p>\n\n\n\n
\"Data
Paytm coding interview questions<\/figcaption><\/figure>\n\n\n\n
4. Convert a Binary Tree into its Mirror Tree<\/h3>\n\n\n\n
\"Convert
Binary tree & its Mirror tree- Paytm coding interview questions <\/figcaption><\/figure>\n\n\n\n
Code:<\/h4>\n\n\n\n

\/* Class containing left and right child of current   node and key value*\/<\/code>

classNode {    <\/code>
intdata;    <\/code>
Node left, right;    <\/code>
publicNode(intitem)    <\/code>
{        <\/code>
data = item;        <\/code>
left = right = null;    <\/code>
}<\/code>
}<\/code>

classBinaryTree {    <\/code>
Node root;    <\/code>
voidmirror() { <\/code>
root = mirror(root); <\/code>
}    <\/code>

Node mirror(Node node)    {<\/code>
        if(node == null)            <\/code>
returnnode;      <\/code>

  \/* do the subtrees *\/       <\/code>
Node left = mirror(node.left);        <\/code>
Node right = mirror(node.right);        <\/code>
\/* swap the left and right pointers *\/        <\/code>
node.left = right;        <\/code>
node.right = left;        <\/code>
returnnode;   <\/code>
 }    <\/code>

voidinOrder() { <\/code>

inOrder(root);<\/code>
 }    <\/code>
\/* Helper function to test mirror(). <\/code>

Given a binary search tree, print out its data elements in increasing sorted order.*\/    <\/code>

voidinOrder(Node node){        <\/code>
if(node == null)            <\/code>
return;        <\/code>
inOrder(node.left);        <\/code>
System.out.print(node.data + \" \");   <\/code>
     inOrder(node.right);    }    <\/code>

\/* testing for example nodes *\/    <\/code>

publicstaticvoidmain(String args[]){  <\/code>
     <\/code>
\/* creating a binary tree and entering the nodes *\/      <\/code>
  <\/code>
BinaryTree tree = newBinaryTree();       <\/code>
tree.root = newNode(1);        <\/code>
tree.root.left = newNode(2);       <\/code>
tree.root.right = newNode(3);        <\/code>
tree.root.left.left = newNode(4);     <\/code>
tree.root.left.right = newNode(5);       <\/code>
 <\/code>
\/* print inorder traversal of the input tree *\/        <\/code>
System.out.println(\"<\/code>Binary tree is\");        <\/code>
tree.inOrder();        <\/code>
System.out.println(\"\");        <\/code>

\/* convert tree to its mirror *\/        <\/code>
tree.mirror();        <\/code>

\/* print inorder traversal of the minor tree *\/        <\/code>
System.out.println(\"<\/code>Mirror tree is \");       <\/code>
tree.inOrder();    <\/code>
}<\/code>
}<\/code>
<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
Output<\/strong><\/p>\n\n\n\n
Binary tree is\n\n4 2 5 1 3 \n\nMirror tree is \n\n3 1 5 2 4 <\/pre>\n\n\n\n
5. Remove duplicates from an unsorted linked list<\/h3>\n\n\n\n
Input: <\/strong><\/p>\n\n\n\n
linked list = 12->11->12->21->41->43->21 <\/p>\n\n\n\n
Output:<\/strong> <\/em><\/p>\n\n\n\n
12->11->21->41->43. <\/p>\n\n\n\n
Code:<\/p>\n\n\n\n
\/\/ Java program to remove duplicates from unsorted\/\/ <\/code>
linked listclassLinkedList {    <\/code>
static Node head;    <\/code>
static class Node{        <\/code>
int data;        <\/code>
Node next;        <\/code>
Node(intd){            <\/code>
data = d;            <\/code>
next = null;        <\/code>
}   <\/code>
 }    <\/code>

\/* Function to remove duplicates from an unsorted linked list *\/   <\/code>
 void remove_duplicates(){        <\/code>
Node ptr1 = null, ptr2 = null, dup = null;        <\/code>
ptr1 = head;        <\/code>
\/* Pick elements one by one *\/        <\/code>
while(ptr1 != null&& ptr1.next != null) <\/code>
{ <\/code>
          ptr2 = ptr1;           <\/code>
 \/* Compare the picked element with rest of the elements *\/           <\/code>

 while(ptr2.next != null) {                <\/code>

\/* If duplicate then delete it *\/                <\/code>
if(ptr1.data == ptr2.next.data) {                    <\/code>

\/* sequence of steps is important here                     *\/                   <\/code>
 ptr2.next = ptr2.next.next;                    <\/code>
System.gc();                <\/code>
}               <\/code>
 else\/* This is tricky *\/{                   <\/code>
 ptr2 = ptr2.next;                <\/code>
}            <\/code>
}            <\/code>

ptr1 = ptr1.next;        <\/code>
}    <\/code>
}    <\/code>

voidprintList(Node node){  <\/code>
      <\/code>
while(node != null){            <\/code>
System.out.print(node.data + \" \");            <\/code>
node = node.next;        <\/code>
}    <\/code>
}    <\/code>

public static void main(String[] args){<\/code>
        <\/code>
LinkedList list = newLinkedList();        <\/code>
list.head = newNode(10);        <\/code>
list.head.next = newNode(12);        <\/code>
list.head.next.next = newNode(11);        <\/code>
list.head.next.next.next = newNode(11);        <\/code>
list.head.next.next.next.next = newNode(12);        <\/code>
list.head.next.next.next.next.next = newNode(11);        <\/code>
list.head.next.next.next.next.next.next= newNode(10);        <\/code>

System.out.println(\"Linked List before removing duplicates:\");        <\/code>

list.printList(head);        <\/code>
list.remove_duplicates();        <\/code>

System.out.println(\"\\n\");        <\/code>

System.out.println(\"Linked List after removing duplicates:\");        <\/code>
list.printList(head);    <\/code>
}<\/code>
}<\/code><\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
Output<\/strong><\/p>\n\n\n\n
Linked list before removing duplicates 10 12 11 11 12 11 10 \nLinked list after removing duplicates 10 12 11 <\/pre>\n\n\n\n
More articles related to Paytm coding interview questions: Interview Questions<\/a><\/p>\n\n\n\n
6. Write a function to get the Nth node in a Linked List<\/h3>\n\n\n\n
Input:  5->10->15->20,  index = 2\nOutput: 15 \nThe node at index 2 is 15<\/pre>\n\n\n\n
\/\/ Java program to find n'th node in linked listclassNode{    <\/code>
intdata;    <\/code>
Node next;    <\/code>
Node(intd){        <\/code>
data = d;        <\/code>
next = null;    <\/code>
}<\/code>
}<\/code>
classLinkedList{    <\/code>
Node head; \/\/ the head of list    <\/code>

\/* Takes index as argument and return data at index*\/    <\/code>

publicintGetNth(intindex){        <\/code>
Node current = head;        <\/code>
intcount = 0; <\/code>
\/* index of Node we are currently looking at *\/      <\/code>
while(current != null)        <\/code>
{            <\/code>
if(count == index)                <\/code>
returncurrent.data;            <\/code>
count++;            <\/code>
current = current.next;        <\/code>
}        <\/code>
\/* if we get to this line, the caller was asking for a non-existent element so we assert fail *\/        <\/code>
assert(false);        <\/code>
return0;    <\/code>
}    <\/code>

\/* Given a reference to the head of a list and an int, inserts a new Node on the front of the list. *\/    <\/code>

publicvoidpush(intnew_data)    <\/code>
{        <\/code>
\/* 1. alloc the Node and put data*\/        <\/code>
Node new_Node = newNode(new_data);       <\/code>
\/* 2. Make next of new Node as head *\/        <\/code>
new_Node.next = head;        <\/code>
\/* 3. Move the head to point to new Node *\/        <\/code>
head = new_Node;    }    <\/code>

\/* Driver code*\/    <\/code>

publicstaticvoidmain(String[] args)    <\/code>
{        <\/code>
\/* Start with empty list *\/        <\/code>
LinkedList llist = newLinkedList();   <\/code>
    <\/code>
 \/* Use push() to construct below list 1->12->1->4->1  *\/        <\/code>
llist.push(1);        <\/code>
llist.push(4);        <\/code>
llist.push(1);        <\/code>
llist.push(12);        <\/code>
llist.push(1);        <\/code>
\/* Check the count function *\/        <\/code>
System.out.println(\"Element at index 3 is \"+ llist.GetNth(3));    <\/code>
}<\/code>
}<\/code><\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
Output<\/strong><\/p>\n\n\n\n
Element at index 3 is 4<\/pre>\n\n\n\n
7. Delete a node in a Doubly Linked List<\/h3>\n\n\n\n
\"Delete
Paytm coding interview questions<\/figcaption><\/figure>\n\n\n\n
Code:<\/strong><\/h4>\n\n\n\n
\/\/ Java program to delete a node from<\/code>
\/\/ Doubly Linked List\/\/ <\/code>

Class for Doubly Linked ListpublicclassDLL {    <\/code>
Node head; \/\/ head of list    <\/code>

\/* Doubly Linked list Node*\/    <\/code>
classNode {        <\/code>
intdata;        <\/code>
Node prev;        <\/code>
Node next;        <\/code>

\/\/ Constructor to create a new node next and prev is by default initialized as null<\/code>
 <\/code>
Node(intd) { data = d; }    }    <\/code>

\/\/ Adding a node at the front of the list    <\/code>
publicvoidpush(intnew_data)    <\/code>
{        <\/code>

\/\/ 1. allocate node        <\/code>
\/\/ 2. put in the data        <\/code>

Node new_Node = newNode(new_data);        <\/code>

\/\/ 3. Make next of new node as head and previous as NULL        <\/code>

new_Node.next = head;        <\/code>
new_Node.prev = null;        <\/code>

\/\/ 4. change prev of head node to new node        <\/code>
if(head != null)            <\/code>
head.prev = new_Node;        <\/code>

\/\/ 5. move the head to point to the new node        <\/code>
head = new_Node;    <\/code>
}    <\/code>

\/\/ This function prints contents of linked list starting from the given node    <\/code>

public void print list(Node node)    <\/code>
{        <\/code>
Node last = null;        <\/code>
while(node != null) {            <\/code>
System.out.print(node.data + \" \");            <\/code>
last = node;            <\/code>
node = node.next;        <\/code>
}        <\/code>
System.out.println();    <\/code>
}    <\/code>

\/\/ Function to delete a node in a Doubly Linked List. head_ref --> pointer to head node pointer.    <\/code>
\/\/ del --> data of node to be deleted.    <\/code>

void delete Node(Node del){        <\/code>
\/\/ Base case        <\/code>

if(head == null|| del == null){            <\/code>
return;        <\/code>
}        <\/code>

\/\/ If node to be deleted is head node        <\/code>
if(head == del) {            <\/code>
head = del.next;        <\/code>
}        <\/code>

\/\/ Change next only if node to be deleted is NOT the last node        <\/code>
if(del.next != null) {            <\/code>
del.next.prev = del.prev;        <\/code>
}        <\/code>

\/\/ Change prev only if node to be deleted is NOT the first node        <\/code>

if(del.prev != null) {            <\/code>
del.prev.next = del.next;        <\/code>
}        <\/code>

\/\/ Finally, free the memory occupied by del        <\/code>
return;    <\/code>
}    <\/code>

\/\/ Driver Code    <\/code>

public static void main(String[] args){        <\/code>
\/\/ Start with the empty list        <\/code>
DLL dll = newDLL();        <\/code>
\/\/ Insert 3. So linked list becomes 3->NULL        dll.push(3);        <\/code>
\/\/ Insert 6. So linked list becomes 6->3->NULL     dll.push(6);        <\/code>
\/\/ Insert 9. So linked list becomes 9->6->3->NULL  dll.push(9);        <\/code>

\/\/ Insert 12. So linked list becomes        <\/code>
\/\/ 12->9->6->3->NULL        <\/code>

dll.push(12);        <\/code>
System.out.print(\"Original Linked list \");        <\/code>
dll.printlist(dll.head);        <\/code>
dll.deleteNode(dll.head); <\/code>

\/*delete first node*\/        <\/code>

dll.deleteNode(dll.head.next); <\/code>
\/*delete middle node*\/        <\/code>

dll.deleteNode(dll.head.next); <\/code>
\/*delete last node*\/       <\/code>
System.out.print(\"\\nModified Linked list \");        <\/code>
dll.printlist(dll.head);    <\/code>
}<\/code>
}<\/code><\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
Output<\/strong><\/p>\n\n\n\n
Original Linked list 12  9  6  3 \nModified Linked list 9<\/pre>\n\n\n\n
8. Delete all the nodes from the doubly linked list that are greater than a given value<\/h3>\n\n\n\n
Input:<\/strong> 20  31  6  3  11,  X = <\/em>11
Output:<\/strong> 6 3 11 <\/em><\/p>\n\n\n\n
Code: <\/strong><\/h4>\n\n\n\n
\/\/ Java implementation to delete all the nodes from the double linked list that are greater than the specified value <\/code>

xclassGFG{<\/code>
\/\/ Node of the doubly linked list<\/code>

static<\/code> class Node{    <\/code>
intdata;    <\/code>
Node prev, next;<\/code>
};<\/code>

\/\/ function to insert a node at the beginning of the Doubly Linked <\/code>List

static Node push(Node head_ref, intnew_data){    <\/code>
\/\/ allocate node    <\/code>
Node new_node = newNode();    <\/code>
\/\/ put in the data    <\/code>
new_node.data = new_data;    \/\/ since we are adding at the beginning,    <\/code>

\/\/ prev is always null    <\/code>

new_node.prev = null;    <\/code>
\/\/ link the old list off the new node    <\/code>

new_node.next = (head_ref);    <\/code>

\/\/ change prev of head node to new node    <\/code>

if((head_ref) != null)        <\/code>
(head_ref).prev = new_node;    \/\/ move the head to point to the new node    <\/code>

(head_ref) = new_node;        <\/code>
returnhead_ref;<\/code>
}<\/code>
\/\/ function to delete a node in a Doubly Linked List.\/\/ head_ref -. pointer to head node pointer.\/\/ del -. pointer to node to be deleted<\/code>


static<\/code> Node deleteNode(Node head_ref, Node del){   <\/code>
\/\/ base case    <\/code>
if(head_ref == null|| del == null)        <\/code>
returnnull;    <\/code>

\/\/ If node to be deleted is head node    <\/code>

if(head_ref == del)        <\/code>
head_ref = del.next;    <\/code>
\/\/ Change next only if node to be deleted is NOT the last node    <\/code>

if(del.next != null)        <\/code>
del.next.prev = del.prev;    <\/code>

\/\/ Change prev only if node to be<\/code> deleted is NOT the first node    <\/code>

if(del.prev != null)        <\/code>
del.prev.next = del.next;    <\/code>
returnhead_ref;<\/code>
}<\/code>
\/\/ function to delete all the nodes from the doubly linked list that are greater than the specified value <\/code>
x <\/code>

static Node deleteGreaterNodes(Node head_ref, intx){   <\/code>
Node ptr = head_ref;    <\/code>
Node next;    <\/code>
while(ptr != null){        <\/code>
next = ptr.next;                <\/code>
\/\/ if true, delete node 'ptr'        <\/code>
if(ptr.data > x){            <\/code>
deleteNode(head_ref, ptr);        <\/code>
ptr = next;    <\/code>
}    <\/code>
returnhead_ref;<\/code>
}<\/code>
\/\/ function to print nodes in a given doubly linked list<\/code>

static<\/code> void printList(Node head){    <\/code>
while(head != null)    <\/code>
{        <\/code>
System.out.print(head.data + \" \");        <\/code>
head = head.next;    <\/code>
}<\/code>
}<\/code>

\/\/ Driver code<\/code>
public<\/code> static void main(String args[]){    <\/code>

\/\/ start with the empty list    <\/code>
Node head = null;    <\/code>

\/\/ create the doubly linked list 10<.8<.4<.11<.9   <\/code>

head = push(head, 9);    <\/code>
head = push(head, 11);    <\/code>
head = push(head, 4);    <\/code>
head = push(head, 8);    <\/code>
head = push(head, 10);    <\/code>
intx = 9;    <\/code>

System.out.print( \"Original List: \");    <\/code>
printList(head);    <\/code>
head=deleteGreaterNodes(head, x);    <\/code>
System.out.print( \"\\nModified List: \");    <\/code>
printList(head);<\/code>
}<\/code>
}<\/code><\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
Output<\/strong><\/p>\n\n\n\n
Original List: 10 8 4 11 9 \nModified List: 8 4 9 <\/pre>\n\n\n\n
9. Interchange elements of the first and last rows in the matrix<\/h3>\n\n\n\n
One of the most asked Paytm coding interview questions:<\/p>\n\n\n\n
Input:<\/strong> 6 4 7 0 5
           3 2 7 1 2 
           4 8 1 2 6
           5 6 1 1 2<\/p>\n\n\n\n
Output:<\/strong> 5 6 1 1 2
              3 2 7 1 2 
              4 8 1 2 6
             6 4 7 0 5<\/p>\n\n\n\n
Code:<\/h4>\n\n\n\n
\/\/ Java code to swap the element of first and last row and display the result<\/code>

importjava.io.*;<\/code>

publicclassInterchange {    <\/code>

static void inter changeFirstLast(intm[][]){<\/code>
        introws = m.length;        \/\/ swapping of element between first and last rows        <\/code>

for(inti = 0; i < m[0].length; i++) {            <\/code>
intt = m[0][i];            <\/code>
m[0][i] = m[rows - 1][i];            <\/code>
m[rows - 1][i] = t;        }    <\/code>
}    <\/code>


\/\/ Driver code    <\/code>
public static void main(String args[])        <\/code>
throwsIOException    {        \/\/ input in the array        <\/code>
intm[][] = { { 8, 9, 7, 6}, { 4, 7, 6, 5},{ 3, 2, 1, 8},{ 9, 9, 7, 7} }; \/\/ Function call        <\/code>

interchangeFirstLast(m);        \/\/ printing the interchanged matrix        <\/code>
for(inti = 0; i < m.length; i++) {   <\/code>
for(intj = 0; j < m[0].length; j++)                <\/code>
System.out.print(m[i][j] + \" \");            <\/code>
System.out.println();        <\/code>
}    <\/code>
}<\/code>
}<\/code><\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
Output<\/strong><\/p>\n\n\n\n
9 9 7 7 \n4 7 6 5 \n3 2 1 8 \n8 9 7 6 <\/pre>\n\n\n\n
10. Write a function to print the ZigZag order traversal of a binary tree. <\/h3>\n\n\n\n
The zigzag order traversal for the below binary tree will be 1 3 2 7 6 5 4.<\/strong><\/p>\n\n\n\n
\"Write
Paytm coding interview questions<\/figcaption><\/figure>\n\n\n\n
Code:<\/h4>\n\n\n\n
\/\/ Java implementation of a O(n) time method for Zigzag order traversal<\/code>

importjava.util.*;<\/code>
\/\/ Binary Tree <\/code>
node classNode{<\/code>
intdata;<\/code>
Node leftChild;<\/code>
Node rightChild;<\/code>
Node(intdata){    <\/code>
this.data = data;<\/code>
}<\/code>
}<\/code>

classBinaryTree {<\/code>
Node rootNode;<\/code>
\/\/ function to print the zigzag traversal<\/code>

void<\/code> print ZigZagTraversal() {        <\/code>
\/\/ if null then return    <\/code>
if(rootNode == null) {    <\/code>
return;    <\/code>
}    <\/code>
\/\/ declare two stacks    <\/code>
Stack<Node> currentLevel = newStack<>();    <\/code>
Stack<Node> nextLevel = newStack<>();    \/\/ push the root    <\/code>
currentLevel.push(rootNode);    <\/code>
booleanleftToRight = true;    \/\/ check if stack is empty    <\/code>
while(!currentLevel.isEmpty()) {   <\/code>
 \/\/ pop out of stack    <\/code>

Node node = currentLevel.pop();        <\/code>
\/\/ print the data in it    <\/code>

System.out.print(node.data + \" \");    \/\/ store data according to current order.    <\/code>

if(leftToRight) {        <\/code>
if(node.leftChild != null) {<\/code>
nextLevel.push(node.leftChild);        <\/code>
}                if(node.rightChild != null) {        <\/code>
nextLevel.push(node.rightChild);        <\/code>
}    <\/code>
}    <\/code>
else{        <\/code>
if(node.rightChild != null) {        <\/code>
nextLevel.push(node.rightChild);        <\/code>
}                if(node.leftChild != null) {        <\/code>
nextLevel.push(node.leftChild);        <\/code>
}    <\/code>
}    <\/code>

if(currentLevel.isEmpty()) {        <\/code>

leftToRight = !leftToRight;        <\/code>
Stack<Node> temp = currentLevel;        <\/code>
currentLevel = nextLevel;        nextLevel = temp;    <\/code>
}    <\/code>
}<\/code>
}<\/code>
}<\/code>

publicclasszigZagTreeTraversal {<\/code>
\/\/ driver program to test the above function<\/code>

public static void main(String[] args){    <\/code>
BinaryTree tree = newBinaryTree();    <\/code>
tree.rootNode = newNode(1);    <\/code>
tree.rootNode.leftChild = newNode(2);    <\/code>
tree.rootNode.rightChild = newNode(3);    <\/code>
tree.rootNode.leftChild.leftChild = newNode(7);    <\/code>
tree.rootNode.leftChild.rightChild = newNode(6);    <\/code>
tree.rootNode.rightChild.leftChild = newNode(5);    <\/code>
tree.rootNode.rightChild.rightChild = newNode(4);    <\/code>
System.out.println(\"ZigZag Order traversal of binary tree is\");    <\/code>
tree.printZigZagTraversal();}<\/code>
}<\/code><\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
Output<\/strong><\/p>\n\n\n\n
ZigZag Order traversal of binary tree is \n1 3 2 7 6 5 4 <\/pre>\n\n\n\n
More Paytm coding interview questions<\/h2>\n\n\n\n
Definitely, there is more to this. Find the top Paytm coding interview questions on our award-winning practice platform- CODEKATA: where practice always makes you perfect! <\/strong><\/a><\/p>\n\n\n\n
For more Paytm coding interview-related questions, click here: Placement Preparation with HCL GUVI<\/strong><\/a><\/p>\n\n\n\n
\"<\/a>
Paytm coding interview questions<\/figcaption><\/figure>\n\n\n\n
Related blogs: Paytm coding interview questions<\/p>\n\n\n\n
Paytm Interview Experience<\/a><\/p>\n\n\n\n
CRED Interview Questions<\/a><\/p>\n\n\n\n
Amazon Interview Questions<\/a><\/p>\n\n\n\n
Kickstart your Full Stack Development journey by enrolling in HCL GUVI’s certified Full Stack Development Course<\/a> with placement assistance, where you will master the MERN stack (MongoDB, Express.js, React, Node.js) and build interesting real-life projects. This program is crafted by our team of experts to help you upskill and assist you in placements. <\/em><\/p>\n\n\n\n
Alternatively, if you want to explore JavaScript through a self-paced course, try HCL GUVI\u2019s JavaScript course.<\/a><\/em><\/p>\n","protected":false},"excerpt":{"rendered":"
If you are in a rush to crack that Paytm coding Interview round, then here is a short pocketbook that you should go through. Make sure you practice all 10 coding questions in here (and study the related ones) because these are the most asked Paytm coding interview questions, say the interviewees! Top 10 Paytm […]<\/p>\n","protected":false},"author":9,"featured_media":14423,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[719,13],"tags":[],"views":"12323","authorinfo":{"name":"Archana","url":"https:\/\/www.guvi.in\/blog\/author\/archana\/"},"thumbnailURL":"https:\/\/www.guvi.in\/blog\/wp-content\/uploads\/2022\/10\/blog-post-3-300x157.png","jetpack_featured_media_url":"https:\/\/www.guvi.in\/blog\/wp-content\/uploads\/2022\/10\/blog-post-3.png","_links":{"self":[{"href":"https:\/\/www.guvi.in\/blog\/wp-json\/wp\/v2\/posts\/14091"}],"collection":[{"href":"https:\/\/www.guvi.in\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.guvi.in\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.guvi.in\/blog\/wp-json\/wp\/v2\/users\/9"}],"replies":[{"embeddable":true,"href":"https:\/\/www.guvi.in\/blog\/wp-json\/wp\/v2\/comments?post=14091"}],"version-history":[{"count":17,"href":"https:\/\/www.guvi.in\/blog\/wp-json\/wp\/v2\/posts\/14091\/revisions"}],"predecessor-version":[{"id":90177,"href":"https:\/\/www.guvi.in\/blog\/wp-json\/wp\/v2\/posts\/14091\/revisions\/90177"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.guvi.in\/blog\/wp-json\/wp\/v2\/media\/14423"}],"wp:attachment":[{"href":"https:\/\/www.guvi.in\/blog\/wp-json\/wp\/v2\/media?parent=14091"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.guvi.in\/blog\/wp-json\/wp\/v2\/categories?post=14091"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.guvi.in\/blog\/wp-json\/wp\/v2\/tags?post=14091"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}