Trending March 2024 # How Quicksort Work In C++ With Algorithm # Suggested April 2024 # Top 10 Popular

You are reading the article How Quicksort Work In C++ With Algorithm updated in March 2024 on the website We hope that the information we have shared is helpful to you. If you find the content interesting and meaningful, please share it with your friends and continue to follow and support us for the latest updates. Suggested April 2024 How Quicksort Work In C++ With Algorithm

Introduction to C++ QuickSort

The following article provides an outline for C++ QuickSort. In programming language we always need algorithm to make it efficient and quicksort is one of them. As the name suggest it is used to sort the elements. It follows some steps to do this. This algorithm select one element from the list which is known as ‘pivot’ and it turns divide the list two parts for effective sorting.

Start Your Free Software Development Course

Web development, programming languages, Software testing & others

Syntax of C++ QuickSort

As it is an algorithm so it does not have syntax with it but it defines some step which need to be followed while implementing quick sort in any language.

Step A: Pick one element from list as pivot.

Step B: Pick two element as left and right.

Step C: Left element represent low index.

Step D: Right element represent high index.

Step E: If value at left is less move right.

Step F: If value at right is more move left.

We will perform this steps until the smaller and greater elements passes each other.

How QuickSort work in C++ with Algorithm

As now we know that QuickSort is used to sort the element in an efficient way. It is an algorithm which define some steps to follow in order to implement this in code. This algorithm basically work with pivot element, it takes one element from list as pivot and divide the whole list into two sub list and sort them.

We can choose the pivot element in different ways which are defined below:

We can take last element as the pivot element.

We can take middle element as the pivot element.

We can take first element as the pivot element.

We can take any random element as the pivot element.

We can follow any of the approaches which will turn divide our list of element into two different sub list further. We will move the other elements into the array or list to left and right in order to sort.

Below we can see one simple algorithm which is used to define the QuickSort in C++ language.


quickSorAlgo(Array, less, more)

//starting algo logic


Here we are defining an array which needs to be sorted

less = first element;

more = last element;


if(less < more)

//starting sorting logic




//here it ends


//algo ends


Let’s understand the algorithm in detail:

50, 25, 15, 20, 60, 30.

Consider the above array which contains various element inside it. We are selecting here pivot element as the last element, and accordingly we have marked first element of array as low and last element of array as high. Now we will iterate our pointers to the respective positions, but for this we will follow one rule to compare the elements.

If marked element high is smaller than our selected pivot element and low marked element is greater than our pivot element in this case we will exchange the potions of the element with each other and we are going to increment the positions of our respective elements as well where they should point to. We are going to continue this iteration until our low and high element cross each other and the pivot element is in the proper position where it should be, this will portioned the array or list into two sub list, this two list can be sorted with QuickSort algorithm independently.

So the final output from the above sorting algorithm would be this. We can easily and effectively sort our arrays by using QuickSort algorithm in C++.

Points to remember while working with QuickSort:

First we need to select the pivot elements from the array, it can be anything like, first, last, random or middle elements from the array of elements.

It has different complexity which are mentioned below:

Worst case: O (n 2 )

Average case: O (n log n)

Best case: O (n log n)

By the use of it we can sort our array elements faster which improves the performance as well.

Example of C++ QuickSort

In this example we are sorting array elements using quick sort an considering the pivot element as the last element from the array.


using namespace std; void elementSwap(int* ele1, int* ele2) { int temp = *ele1; *ele1 = *ele2; *ele2 = temp; } int elementPartition (int array[], int less, int more) { int pivotelement = array[more]; int indexSmaller = (less – 1); for (int qs = less; qs <= more – 1; qs++) { if (array[qs] < pivotelement) { indexSmaller++; elementSwap(&array[indexSmaller], &array[qs]); } } elementSwap(&array[indexSmaller + 1], &array[more]); return (indexSmaller + 1); } void demoquickSort(int array[], int less, int greater) { if (less < greater) { int parInd = elementPartition(array, less, greater); demoquickSort(array, less, parInd – 1); demoquickSort(array, parInd + 1, greater); } } int main() { cout << “Sorting array elemnts using quick sort in C++ ::** n”; int array[] = {35, 15, 90, 26, 87, 12, 5, 44, 23, 1}; int arrsize = sizeof(array) / sizeof(array[0]); cout << “Before sort array is : n”; int z; for (z = 0; z < arrsize; z++) cout << array[z] << ” “; cout << endl; demoquickSort(array, 0, arrsize – 1); cout << “After sorted array is : n”; int i; for (i = 0; i < arrsize; i++) cout << array[i] << ” “; cout << endl; return 0; }



By using QuickSort algorithm we can efficiently sort our array list elements. We just need to select the pivot element in order to proceed with it. This will divide the array or list into two parts then we can perform QuickSort algorithm recursively in order to get the sorted elements list.

Recommended Articles

This is a guide to C++ QuickSort. Here we discuss the introduction, how QuickSort work in C++ with algorithm and example respectively. You may also have a look at the following articles to learn more –

You're reading How Quicksort Work In C++ With Algorithm

Topological Sort: Python, C++ Algorithm Example

What is Topological Sort Algorithm?

Topological Sorting is also known as Kahn’s algorithm and is a popular Sorting Algorithm. Using a directed graph as input, Topological Sort sorts the nodes so that each appears before the one it points to.

This algorithm is applied on a DAG (Directed Acyclic Graph) so that each node appears in the ordered array before all other nodes are pointed to it. This algorithm follows some rules repeatedly until the sort is completed.

To simplify, look at the following example:

Directed Graph

Here, we can see that “A” has no indegree. It means the edge that points to a node. “B” and “C” have a pre-requisite of “A”, then “E” has a pre-requisite of “D” and “F” nodes. Some of the nodes are dependent on other nodes.

Here’s another representation of the above Graph:

Dependency of each node (Linear Ordering)

So, when we pass the DAG (Directed Acyclic Graph) to the topological sort, it will give us an array with linear ordering, where the first element has no dependency.

This example shows a graph with a cycle:

Here’re the steps to do this:

Step 1) Find the node with zero incoming edges, a node with zero degrees.

Step 2) Store that zeroes in-degree node in a Queue or Stack and removes the node from the Graph.

Step 3) Then delete the outgoing edge from that node.

This will decrement the in-degree count for the next node.

Topological ordering requires that the graph data structure will not have any cycle.

A graph will be considered a DAG if it follows these requirements:

One or more nodes with an indegree value of zero.

Graph doesn’t contain any cycle

As long as there’re nodes in the Graph and the Graph is still DAG, we will run the above three steps. Otherwise, the algorithm will fall into the cyclic dependency, and Kahn’s Algorithm won’t be able to find a node with zero in-degree.

How Topological Sort Works

Here, we will use “Kahn’s Algorithm” for the topological sort. Let’s say we have the following Graph:

Here’re the steps for Kahn’s Algorithm:

Step 1) Calculate the indegree or incoming edge of all nodes in the Graph.


Indegree means the directed edges pointing to the node.

Outdegree means the directed edges that come from a node.

Here’s the indegree and outdegree of the above Graph:

Step 2) Find the node with zero indegrees or zero incoming edges.

The node with zero indegree means no edges are coming toward that node. Node “A” has zero indegrees, meaning there’s no edge pointing to node “A”.

So, we will do the following actions:

Remove this node and its outdegree edges (outgoing edges)

Place the node in the Queue for ordering.

Update the in-degree count of the neighbor node of “A.”

Step 3) We need to find a node with an indegree value of zero. In this example, “B” and “C” have zero indegree.

Here, we can take either of these two. Let’s take “B” and delete it from the Graph.

Then update the indegree values of other nodes.

After performing these operations, our Graph and Queue will look like the following:

Step 4) Node “C” has no incoming edge. So, we will remove node “C” from the Graph and push it into the Queue.

We can also delete the edge that is outgoing from “C”.

Now, our Graph will look like this:

Step 5) We can see that nodes “D” and “F” have the indegree of zero. We will take a node and put it in the Queue.

Let’s take out “D” first. Then the indegree count for node “E” will be 1. Now, there’ll be no node from D to E.

We need to do the same for node “F”, our result will be like the following:

Step 6) The indegree (ingoing edges) and outdegree (outgoing edges) of node “E” became zero. So, we have met all the pre-requisite for node “E”.

Here, we l put “E” at the end of the Queue. So, we don’t have any nodes left, so the algorithm ends here.

Pseudo Code for Topological Sorting

Here’s the pseudo-code for the topological sort while using Kahn’s Algorithm.

function TopologicalSort( Graph G ): for each node in G: calculate the indegree start = Node with 0 indegree G.remove(start) topological_list = [start] While node with O indegree present: topological_list.append(node) G.remove(node) Update Indegree of present nodes Return topological_list

Topological sort can also be implemented using the DFS (Depth First Search) method. However, that approach is the recursive method. Kahn’s algorithm is more efficient than the DFS approach.

C++ Implementation of Topological Sorting

using namespace std; class graph{ int vertices; public: graph(int vertices){ } void createEdge(int u, int v){ adjecentList[u].push_back(v); } void TopologicalSort(){

for(int i=0;i<vertices;i++){ for(itr=adjecentList[i].begin(); itr!=adjecentList[i].end();itr++){ indegree_count[*itr]++; } } for(int i=0; i<vertices;i++){ if(indegree_count[i]==0){ Q.push(i); } } int visited_node = 0; while(!Q.empty()){ int u = Q.front(); Q.pop(); order.push_back(u);

for(itr=adjecentList[u].begin(); itr!=adjecentList[u].end();itr++){ if(–indegree_count[*itr]==0){ Q.push(*itr); } } visited_node++; } if(visited_node!=vertices){ cout<<“There’s a cycle present in the Graph.nGiven graph is not DAG”<<endl; return; } for(int i=0; i<order.size();i++){ cout<<order[i]<<“t”; } } }; int main(){ graph G(6); G.createEdge(0,1); G.createEdge(0,2); G.createEdge(1,3); G.createEdge(1,5); G.createEdge(2,3); G.createEdge(2,5); G.createEdge(3,4); G.createEdge(5,4); G.TopologicalSort(); }

Output: 0 1 2 3 5 4 Python Implementation of Topological Sorting from collections import defaultdict class graph: def __init__(self, vertices): self.adjacencyList = defaultdict(list) self.Vertices = vertices # No. of vertices # function to add an edge to adjacencyList def createEdge(self, u, v): self.adjacencyList[u].append(v) # The function to do Topological Sort. def topologicalSort(self): total_indegree = [0]*(self.Vertices) for i in self.adjacencyList: for j in self.adjacencyList[i]: total_indegree[j] += 1 queue = [] for i in range(self.Vertices): if total_indegree[i] == 0: queue.append(i) visited_node = 0 order = [] while queue: u = queue.pop(0) order.append(u) for i in self.adjacencyList[u]: total_indegree[i] -= 1 if total_indegree[i] == 0: queue.append(i) visited_node += 1 if visited_node != self.Vertices: print("There's a cycle present in the Graph.nGiven graph is not DAG") else: print(order) G = graph(6) G.createEdge(0,1) G.createEdge(0,2) G.createEdge(1,3) G.createEdge(1,5) G.createEdge(2,3) G.createEdge(2,5) G.createEdge(3,4) G.createEdge(5,4) G.topologicalSort() Output: [0, 1, 2, 3, 5, 4] Cyclic Graphs of Topological Sort Algorithm

A graph containing a cycle can’t be topologically ordered. As the cyclic Graph has the dependency in a cyclic manner.

For example, check this Graph:

This Graph is not DAG (Directed Acyclic Graph) because A, B, and C create a cycle. If you notice, there’s no node with zero in-degree value.

According to Kahn’s Algorithm, if we analyze the above Graph:

Find a node with zero indegrees (no incoming edges).

However, in the above Graph, there’s no node with zero in degrees. Every node has an in-degree value greater than 0.

Return an empty queue, as it could not find any node with zero in degrees.

We can detect cycles using the topological ordering with the following steps:

Step 1) Perform topological Sorting.

Step 2) Calculate the total number of elements in the topologically sorted list.

Step 3) If the number of elements equals the total number of vertex, then there’s no cycle.

Step 4) If it’s not equal to the number of vertices, then there’s at least one cycle in the given graph data structure.

Complexity Analysis of Topological Sort

There are two types of complexity in algorithms. They’re

Time Complexity

Space Complexity

These complexities are represented with a function that provides a general complexity.

Time Complexity: All time complexity is the same for Topological Sorting. There are worst, average, and best-case scenarios for time complexity.

The time complexity for topological Sorting is O(E + V), here, E means the number of Edges in the Graph, and V means the number of vertices in the Graph.

Let’s break through this complexity:

Step 1) At the beginning, we will calculate all the indegrees. To do that, we need to go through all the edges, and initially, we will assign all V vertex indegrees to zero. So, the incremental steps we complete will be O(V+E).

Step 2) We will find the node with zero indegree value. We need to search from the V number of the vertex. So, the steps completed will be O(V).

Step 3) For each node with zero indegrees, we will remove that node and decrement the indegree. Performing this operation for all the nodes will take O(E).

Step 4) Finally, we will check if there is any cycle or not. We will check whether the total number of elements in the sorted array is equal to the total number of nodes. It will take O(1).

So, these were the individual time complexity for each step of the topological Sorting or topological ordering. We can say that the time complexity from the above calculation will be O( V + E ); here, O means the complexity function.

Space Complexity: We needed O(V) spaces for running the topological sorting algorithm.

Here are the steps where we needed the space for the program:

We had to calculate all the indegrees of nodes present in the Graph. As the Graph has a total of V nodes, we need to create an array of size V. So, the space required was O(V).

A Queue data structure was used to store the node with zero indegree. We removed the nodes with zero indegree from the original Graph and placed them in the Queue. For this, the required space was O(V).

The array is named “order.” That stored the nodes in topological order. That also required O(V) spaces.

These were the individual space complexity. So, we need to maximize these spaces in the run time.

Space complexity stands for O(V), where V means the number of the vertex in the Graph.

Application of Topological Sort

There’s a huge use for Topological Sorting. Here are some of them:

It is used when Operating system needs to perform the resource allocation.

Finding a cycle in the Graph. We can validate if the Graph is DAG or not with topological sort.

Sentence ordering in the auto-completion apps.

It is use for detecting deadlocks.

Different type of Scheduling or course scheduling uses the topological sort.

Resolving dependencies. For example, if you try to install a package, that package might also need other packages. Topological ordering finds out all the necessary packages to install the current package.

Linux uses the topological sort in the “apt” to check the dependency of the packages.

How Iife Work In Javascript With Programming Examples

Introduction to JavaScript IIFE

The JavaScript Immediately Invoked Function Expression (IIFE) is a function which helps in providing a method that defines a sequence of a particular context. Once a variable is defined inside a function it is not possible to access it outside the function where it is defined. The functions which are created in JavaScript have named functions, anonymous functions and by making use of IIFE we can execute these as soon as they are mounted. This functionality makes them IIFE. Let us have a look in detail at how this function works

Start Your Free Software Development Course


Below is the syntax for JavaScript IIFE:

(function () { })();

Explanation: The primary use of this function is that the variables should be accessible only within the scope of the defined function that is there.

The declaration should begin with the keyword function(). In the function definition, you can define any statements which are to be performed. This function should be hoisted. A hoisted function is always placed at the start of the program or functional scope when the JavaScript code is being executed. You can also use the below syntax:

The parentheses let JavaScript know that there is a function expression and the last pair of parentheses will invoke the function.

How does IIFE work in JavaScript?

Let us see how does it work:


(function () { var userName = "Snehal"; function display(name) { alert("MyCode2.js: " + name); } display(userName); })();

The above code is an example of IIFE. The IIFE helps in including all functions and variables with the same name and they can be accessed globally. Here we define a function and in its definition,  we are creating a variable username. We immediately write another function that will display this username. This is the display function where we are sending the username as a parameter. We have created an alert for the same where we display the code script name and then by making use of IIFE we have simply called the function at the end. In this way we have called two functions one after the other. We have rather immediately invoked. Let us check a few examples to understand better.

Examples to Implement JavaScript IIFE

Below are the examples mentioned:

Example #1


// anonymous function #1 var isLucky = function() { var iife = Math.round(Math.random() * 100); return “You are checking Immediate Invoking Function Expression!”; } else { return “We are not in IIFE, better luck next time!”; } }; var me = isLucky(); alert(me); window.setTimeout(function() { alert(“JavaScript and EduCBA is awesome!!!”); }, 2000);

At first, the result is displayed as per the condition. When we again run the program the result is the else part. Once the time outspan is over then the output of the above program will be as below:

Explanation: The above script helps us understand the IIFE in Javascript better. Here we have created a function isLucky where we are rounding off a random number and then multiplying it by 100. The random number is being generated by the Math.random() function. After this number is generated then we check if the number is less or greater than 50. If the number is greater than 50 then the message will be displayed as: “You are checking Immediate Invoking Function Expression!”. Else the corresponding message for it will be displayed. Once this function is done we are calling it and storing it in a variable called me. Whatever message is returned it will be displayed in the form is an alert window in the browser. Just after this, another function is invoked. This function will time out and display another alert will be displayed. Below will be the output when we run for the first time.

Example #2

Let us take another example of IIFE. We can use this function without if else block as well.

(function() { var create = “I have learnt what is Immediate Invoking Function Expression from EduCBA successfully !!!”; alert(create); })(); window.setTimeout(function() { alert(“JavaScript and Edu is awesome!!!”); }, 2000);


The message is displayed as soon as the above code is run. Once the timeout happens below alert window turns up automatically.

Explanation: The above code is an example of a classic and simple IIFE. We create a function and immediately call it. We have not named this function with any name. We have just created a variable create. This function then uses this to display this message as the sun as the function is invoked. As per the syntax, we are bound to use the parenthesis correctly. If there are any misses in the parenthesis then the code will not give the desired result. We can easily invoke the function as soon as the function is declared and defined. We will just pass empty parentheses in order to invoke the function that we have created. We send the variable to create as a parameter to an alert. When the program is run the alert will be called and whatever is present in the created variable will be displayed in the alert window. We also created a similar function as in Example 1. This will work in a similar way. It will wait for timeout and will again display an alert window with the specified message. The timeout time we have mentioned here is 2 milliseconds. Once this is over the message will be displayed automatically. Let us see the output of the above code.


The Immediate Invoking Function Expression is an easy way of calling a function just after it is created. It helps in keeping the local variables local or global variables as global whenever required. It is fast and hence very efficient to use. It fulfills the programmer’s purpose of keeping the variables intact. IIFE can be used with a name or without any name. They can also be used with unary operators when needed.

Recommended Articles

This is a guide to JavaScript IIFE. Here we discuss an introduction to JavaScript IIFE, syntax, how does it work and programming examples. You can also go through our other related articles to learn more –

Working Of Predicate Delegate In C# With Examples

Introduction to C# Predicate

Web development, programming languages, Software testing & others


Where the object type is represented by P and obj is the object which compares the criteria that is defined within a method and is  represented by predicate delegate.

Working of Predicate Delegate in C#

A function that returns true or false is a predicate and the reference to a predicate is a predicate delegate.

The feature of predicate delegate was introduced with the release of .NET 2.0. framework.

The predicate function can be defined, and it can be passed as a parameter to any other function through predicate delegate.

A special case of Func is predicate delegate which takes only one parameter as input and it returns a Boolean value that is either true of false.

Any method can be written inside a predicate delegate even the expression of lambda or anonymous method.

A generic type is taken as an argument by the predicate delegate when it is used with the expression of lambda.

Examples of C# Predicate

Given below are the examples mentioned:

Example #1

C# program to demonstrate the use of predicate delegate in a program to check if the given string passed as a parameter is in capital letters or not.


using System; namespace program { public class check { static bool IsUC(string stri) { return stri.Equals(stri.ToUpper()); } static void Main(string[] args) { bool res = isU("welcome to c#"); Console.WriteLine(res); } } }


In the above program, a namespace called program is defined. Then a class called check is defined. Then a Boolean method is defined to check if the given string is written in capital letters or not. If the given string is written in capital letters, true is returned else False is returned. Then the main method is called.

Then a predicate delegate is defined with object type as string and IsUC is an object which compares the criteria that is defined within a method and is represented by predicate delegate. Then the result of the predicate delegate is stored in a variable called res. Then the result is displayed.

Example #2

C# program to demonstrate the use of predicate delegate in a program to check if the length of the given string is less than a specified value or not.

using System; class program { public delegate bool my_del(string stri); public static bool fun(string stri) { if (stri.Length < 5) { return true; } else { return false; } } static public void Main() { my_del obj = fun; Console.WriteLine(obj("Shobha")); } }



In the above program, a class called program is defined. Then a predicate delegate is defined with object type as string. Then a method is defined inside a predicate delegate by passing the object as parameter to check if the length of the given string is less than a specified value. If the length of the string is less than the given specified value, true is returned else false is returned.

Then the Main method is called. Then a predicate delegate is defined with object type as string and fun is an object which compares the criteria that is defined within a method and is represented by predicate delegate. Then the string to be passed as a parameter to predicate delegate is written at last.


The Predicate delegates are useful when we have to filter out a list of values.

The predicate delegates can be made inline for one off search function.

The predicate delegates can be used when we have to search for items in a generic collection.

By using predicate delegates, the length of the code is shortened and either true or false is returned.

Anonymous methods, expression of lambda can be assigned to predicate delegates.

The predicate delegates provide the logic at runtime and it can be a simple logic or complicated logic.

Recommended Articles

How Does Kafka Work In Nutshell With Its Keywords?

Introduction to Kafka Client

The Kafka client is defined as it has been generated to interpret the data and put down that data into the Kafka system. The clients could be the producers who can produce the fulfillment to the topics in Kafka, and the clients could be subscribers who can interpret the fulfillment from Kafka topics. If we have Kafka streaming on our cluster, there are some commands like creating a topic, producing a message, consuming messages, and setting a Zookeeper root node; those can have unusual steps we have to utilize in Kafka functionality.

Start Your Free Data Science Course

Hadoop, Data Science, Statistics & others

What is Kafka Client?

The Kafka client can convey within Kafka brokers with the help of a network for reading or writing the events and generating the consumers and producers; both are the same. It can work with the use of a native Kafka client library. Still, we have to arrange them with the help of properties defined in Apache Kafka’s testimonial, particularly for the consumers and producers. As we see in the definition, the Kafka clients can be generated for reading and writing the data into the Kafka system, in which Kafka clients can bring out the content to the topics of Kafka. The client can also behave as a subscriber, interpreting the data from the Kafka topics. The client can construct it quickly and simplify to create and overwhelm the messages with the help of Apache Kafka.

How does Kafka Work in Nutshell? 1. Servers

Kafka can run as a cluster of one or more servers that can reach various ranges in the cloud, some servers come from the reserved layer, which can be known as brokers, and the rest of the servers can run Kafka connect to constantly import and export the data as an event data flow to combine Kafka with the surviving system which can be the RDBMS or other Kafka cluster in which a Kafka cluster is scalable, so if any server breaks down then, another server can take charge of their task to make sure that the operation has been continued with no data loss.

2. Clients

The clients can authorize us to write the disperse application, which can interpret, communicate, and exercises the flow of events in parallel if there is any network issue found; Kafka can vessel with a few other clients, which are supplemented by the dozens of clients which the Kafka group gives, the clients are obtainable for Java and Scala containing the excessive Kafka flow.

Kafka Client Confluent

Open source: The Kafka confluent is the open-source dispersal platform for Apache Kafka.

Enterprise: It is a dispersal of Apache Kafka that can be used for the production environment; it can clarify the operations and administration of the Kafka cluster, so with the administration, it can support and monitors the tools, and it can enlarge the open-source version with the confluent control center.

Cloud: The cloud in the confluent can provide the service organized by Apache Kafka, which is in the public cloud as it is a data-flowing service for cloud-based enterprises.

Kafka Client Keywords

Given below are the Kafka client keywords:

bootstrap_servers: The ‘host[: port]’ is the string in which consumers can communicate to bootstrap beginning cluster metadata, which cannot have the complete list of nodes with one broker that can be acknowledged the request of metadata.

client-id(str): This is a name for the client, and it can be passed in every application to the server; it can be utilized to specify the particular server-side log appearance that can communicate to this client.

group_id(str or none): It is the name for the consumer group that can attach the dynamic sections that cannot join the attachment, and it can be utilized to raise and execute the data from offsets.

key-deserializer (callable): It can call the string that can have the sensitive message and give back the de-serialized key.

value-deserializer(callable): A callable string can accept the raw message value and give back a de-serialized value.

fetch_min_bytes(int): The minimum quantity of data the server can give back for an attractive request.

fetch_max_wait_ms(int): The maximum quantity of time in time that can stop up before the request response if it does not have enough data to clarify the request, which this keyword can provide suddenly.

fetch_max_bytes(int): This can give the maximum quantity of the data by fetching the request, which does not have a correct if it first comes from the non-empty section of the huge than his value, the value which can give back to the consumer can make sure that consumer is in development.

max_partition_fetch_byte(int): It can fetch the maximum data that one server can give back, and the consumer can remain when he is trying to send a large message.


In this article, we conclude that the Kafka client can read and write the data into the Kafka system, which can also have commands; we also saw how it works in a nutshell, Kafka client confluent and Kafka client keyword.

Recommended Articles

This is a guide to Kafka Client. Here we discuss the introduction; how does Kafka work in a nutshell? And keywords, respectively. You may also have a look at the following articles to learn more –

How Does The Format Tag Work In Jsp With Examples?

Introduction to JSP format

Web development, programming languages, Software testing & others


Some dependent libraries should be included in the project’s lib folder as the format tag has dependencies in the JSTL library. You can either link a full set of libraries in jSTL or can target specific files as per your purpose. Two statements to be written before start writing the code to use the format tag are:

The prefix denotes the format one would like to use. One can get a complete list of “prefixes” with uri the same as above as per the requirements.

The syntaxes used by JSP Format are:

How does the format tag work in JSP?

JSP Format uses the JSTL library to use the inbuilt formatting options incorporated in predefined format tags with the help of various formats. The prerequisite to use formatting in JSP is that libraries should be attached and present in the lib folder of your project. The syntax above contains some of the common property names. Formatting can be done to match up the existing standards with the help of inbuilt properties, but sometimes the format is local; for example, we want a pricing rate format to be 1 rupee per word, i.e. “1/word”. To save this format, a new pattern or a local xml database has to be created. While just showing the time from “timestamp” is more of formatting from the existing pattern. These are explained in more detail with the help of examples provided in the below section.

Examples of JSP format

Some of the examples to demonstrate the use of the JSP format tag in JSP is explained below for a better understanding of the topic.

Example #1

Here is one of the items on the list, along with its price. The list in the background is a customized list along with its defined pricing style.


Example #2

Code : NewFile2.jsp


Explanation: This is an example of the pre-existing format used to display the inputted information in the applied format. The “fmt:parseDate” helps in identifying the use of formatter in JSP, which is dependent on the JSTL library. “Vale” attributes get the value to be passed into this tag, the “pattern” attribute helps JSP understand the pattern being inputted in the program, and the “var” attribute is used to identify the formatted data, which will be outputted. After the date is passed as input to this tag, then the output is provided in the form of string date and time. This pattern can be seen in the output screen.


JSP format is an easy tag that comes with many functionalities offered by JSP libraries, but it can be complex if looking for a customized, unique data format. Its simplicity does not outweigh the importance attached to this tag. This tag is used very commonly in many websites or businesses linked to finance, export, transportation, agriculture, and many more such sectors.

Recommended Articles

This is a guide to the JSP format. Here we discuss How does the format tag work in JSP and Examples, along with the codes and outputs. You may also have a look at the following articles to learn more –

Update the detailed information about How Quicksort Work In C++ With Algorithm on the website. We hope the article's content will meet your needs, and we will regularly update the information to provide you with the fastest and most accurate information. Have a great day!