Quicksort AlgorithmQuicksort is a divide and conquer algorithm. Q.pdf
0 likes11 views
Quicksort Algorithm: Quicksort is a divide and conquer algorithm. Quicksort first divides a large array into two smaller sub-arrays: the low elements and the high elements. Quicksort can then recursively sort the sub-arrays. The steps are: The base case of the recursion is arrays of size zero or one, which never need to be sorted. The pivot selection and partitioning steps can be done in several different ways; the choice of specific implementation schemes greatly affects the algorithm\'s performance. This algorithm is based on Divide and Conquer paradigm. It is implemented using merge sort. In this approach the time complexity will be O(n log(n)) . Actually in divide step we divide the problem in two parts. And then two parts are solved recursively. The key concept is two count the number of inversion in merge procedure. In merge procedure we pass two sub-list. The element is sorted and inversion is found as follows a)Divide : Divide the array in two parts a[0] to a[n/2] and a[n/2+1] to a[n]. b)Conquer : Conquer the sub-problem by solving them recursively. 1) Set count=0,0,i=left,j=mid. C is the sorted list. 2) Traverse list1 and list2 until mid element or right element is encountered . 3) Compare list1[i] and list[j]. i) If list1[i]<=list2[j] c[k++]=list1[i++] else c[k++]=list2[j++] count = count + mid-i; 4) add rest elements of list1 and list2 in c. 5) copy sorted list c back to original list. 6) return count. void quickSort(int arr[], int left, int right) { int i = left, j = right; int tmp; int pivot = arr[(left + right) / 2]; /* partition */ while (i <= j) { while (arr[i] < pivot) i++; while (arr[j] > pivot) j--; if (i <= j) { tmp = arr[i]; arr[i] = arr[j]; arr[j] = tmp; i++; j--; } }; /* recursion */ if (left < j) quickSort(arr, left, j); if (i < right) quickSort(arr, i, right); } Solution Quicksort Algorithm: Quicksort is a divide and conquer algorithm. Quicksort first divides a large array into two smaller sub-arrays: the low elements and the high elements. Quicksort can then recursively sort the sub-arrays. The steps are: The base case of the recursion is arrays of size zero or one, which never need to be sorted. The pivot selection and partitioning steps can be done in several different ways; the choice of specific implementation schemes greatly affects the algorithm\'s performance. This algorithm is based on Divide and Conquer paradigm. It is implemented using merge sort. In this approach the time complexity will be O(n log(n)) . Actually in divide step we divide the problem in two parts. And then two parts are solved recursively. The key concept is two count the number of inversion in merge procedure. In merge procedure we pass two sub-list. The element is sorted and inversion is found as follows a)Divide : Divide the array in two parts a[0] to a[n/2] and a[n/2+1] to a[n]. b)Conquer : Conquer the sub-problem by solving them recursively. 1) Set count=0,0,i=left,j=mid. C is the sorted list. 2) Traverse list1 and list2 until mid elem.
1 of 3
Download to read offline
![Quicksort Algorithm:
Quicksort is a divide and conquer algorithm. Quicksort first divides a large array into two
smaller sub-arrays: the low elements and the high elements. Quicksort can then recursively sort
the sub-arrays.
The steps are:
The base case of the recursion is arrays of size zero or one, which never need to be sorted.
The pivot selection and partitioning steps can be done in several different ways; the choice of
specific implementation schemes greatly affects the algorithm's performance.
This algorithm is based on Divide and Conquer paradigm. It is implemented using merge sort. In
this approach the time complexity will be O(n log(n)) . Actually in divide step we divide the
problem in two parts. And then two parts are solved recursively. The key concept is two count
the number of inversion in merge procedure. In merge procedure we pass two sub-list. The
element is sorted and inversion is found as follows
a)Divide : Divide the array in two parts a[0] to a[n/2] and a[n/2+1] to a[n].
b)Conquer : Conquer the sub-problem by solving them recursively.
1) Set count=0,0,i=left,j=mid. C is the sorted list.
2) Traverse list1 and list2 until mid element or right element is encountered .
3) Compare list1[i] and list[j].
i) If list1[i]<=list2[j]
c[k++]=list1[i++]
else
c[k++]=list2[j++]
count = count + mid-i;
4) add rest elements of list1 and list2 in c.
5) copy sorted list c back to original list.
6) return count.
void quickSort(int arr[], int left, int right) {
int i = left, j = right;
int tmp;
int pivot = arr[(left + right) / 2];
/* partition */
while (i <= j) {
while (arr[i] < pivot)
i++;
while (arr[j] > pivot)](https://image.slidesharecdn.com/quicksortalgorithmquicksortisadivideandconqueralgorithm-230412172028-a168ba05/85/Quicksort-AlgorithmQuicksort-is-a-divide-and-conquer-algorithm-Q-pdf-1-320.jpg)
![j--;
if (i <= j) {
tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;
i++;
j--;
}
};
/* recursion */
if (left < j)
quickSort(arr, left, j);
if (i < right)
quickSort(arr, i, right);
}
Solution
Quicksort Algorithm:
Quicksort is a divide and conquer algorithm. Quicksort first divides a large array into two
smaller sub-arrays: the low elements and the high elements. Quicksort can then recursively sort
the sub-arrays.
The steps are:
The base case of the recursion is arrays of size zero or one, which never need to be sorted.
The pivot selection and partitioning steps can be done in several different ways; the choice of
specific implementation schemes greatly affects the algorithm's performance.
This algorithm is based on Divide and Conquer paradigm. It is implemented using merge sort. In
this approach the time complexity will be O(n log(n)) . Actually in divide step we divide the
problem in two parts. And then two parts are solved recursively. The key concept is two count
the number of inversion in merge procedure. In merge procedure we pass two sub-list. The
element is sorted and inversion is found as follows
a)Divide : Divide the array in two parts a[0] to a[n/2] and a[n/2+1] to a[n].
b)Conquer : Conquer the sub-problem by solving them recursively.
1) Set count=0,0,i=left,j=mid. C is the sorted list.
2) Traverse list1 and list2 until mid element or right element is encountered .
3) Compare list1[i] and list[j].](https://image.slidesharecdn.com/quicksortalgorithmquicksortisadivideandconqueralgorithm-230412172028-a168ba05/85/Quicksort-AlgorithmQuicksort-is-a-divide-and-conquer-algorithm-Q-pdf-2-320.jpg)
![i) If list1[i]<=list2[j]
c[k++]=list1[i++]
else
c[k++]=list2[j++]
count = count + mid-i;
4) add rest elements of list1 and list2 in c.
5) copy sorted list c back to original list.
6) return count.
void quickSort(int arr[], int left, int right) {
int i = left, j = right;
int tmp;
int pivot = arr[(left + right) / 2];
/* partition */
while (i <= j) {
while (arr[i] < pivot)
i++;
while (arr[j] > pivot)
j--;
if (i <= j) {
tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;
i++;
j--;
}
};
/* recursion */
if (left < j)
quickSort(arr, left, j);
if (i < right)
quickSort(arr, i, right);
}](https://image.slidesharecdn.com/quicksortalgorithmquicksortisadivideandconqueralgorithm-230412172028-a168ba05/85/Quicksort-AlgorithmQuicksort-is-a-divide-and-conquer-algorithm-Q-pdf-3-320.jpg)
Ad
Recommended
module2_dIVIDEncONQUER_2022.pdf
module2_dIVIDEncONQUER_2022.pdfShiwani Gupta The document describes various divide and conquer algorithms including binary search, merge sort, quicksort, and finding maximum and minimum elements. It begins by explaining the general divide and conquer approach of dividing a problem into smaller subproblems, solving the subproblems independently, and combining the solutions. Several examples are then provided with pseudocode and analysis of their divide and conquer implementations. Key algorithms covered in the document include binary search (log n time), merge sort (n log n time), and quicksort (n log n time on average).
Unit III Version I.pptx
Unit III Version I.pptxssuserd602fd The document discusses various sorting and searching algorithms. It begins by introducing selection sort, insertion sort, and bubble sort. It then covers merge sort and explains how it works by dividing the list, sorting sublists recursively, and merging the results. Finally, it discusses linear/sequential search and binary search, noting that sequential search checks every element while binary search repeatedly halves the search space.
Divide and Conquer
Divide and ConquerMelaku Bayih Demessie In computer science, divide and conquer is an algorithm design paradigm based on multi-branched recursion. A divide-and-conquer algorithm works by recursively breaking down a problem into two or more sub-problems of the same or related type until these become simple enough to be solved directly.
Are there trends, changes in the mi.pptx
Are there trends, changes in the mi.pptxpriyaaajadhav31 SWOT analysis is a strategic planning tool used to identify and evaluate the Strengths, Weaknesses, Opportunities, and Threats of a business, project, or individual. It helps in understanding both internal and external factors that can influence success.
Here's what each component typically refers to:
Strengths (Internal, Positive Factors):
What does the organization or individual do well?
What unique resources or advantages do they have?
Examples: Strong brand reputation, skilled workforce, financial stability, proprietary technology.
Weaknesses (Internal, Negative Factors):
Where could the organization or individual improve?
What factors hinder their success?
Examples: Lack of resources, poor location, outdated technology, weak customer service.
Opportunities (External, Positive Factors):
What external factors could be leveraged for growth or success?
Are there trends, changes in the market, or unmet needs that could be capitalized on?
Examples: Market growth, changes in regulations, emerging technologies, changes in consumer preferences.
Threats (External, Negative Factors):
What external factors could challenge the success or growth?
Are there competitors, market shifts, or other risks that could have a negative impact?
Examples: Increased competition, economic downturns, regulatory changes, supply chain disruptions.
Would you like to create a SWOT analysis for a specific project, business, or anything else? Let me know!
DAA-Divide and Conquer methodology, DAA 2024
DAA-Divide and Conquer methodology, DAA 2024RUHULAMINHAZARIKA The document discusses divide and conquer algorithms. It explains that divide and conquer algorithms follow three steps: 1) divide the problem into subproblems, 2) conquer the subproblems by solving them recursively, and 3) combine the results to solve the original problem. Binary search, merge sort, and quicksort are provided as examples of divide and conquer algorithms. Binary search divides a sorted array in half at each step to search for a target value. Merge sort divides the array in half, recursively sorts the halves, and then merges the sorted halves. Quicksort chooses a pivot to partition the array into left and right halves, recursively sorts the halves, and returns the fully sorted array.
Please I want a detailed complete answers for each part.Then make.pdf
Please I want a detailed complete answers for each part.Then make.pdfsiennatimbok52331 Please I want a detailed complete answers for each part.Then make sure you provide clear
picture(s) of soultions that I can read. Try making all numbers and letters clrearly readable easy
to recognize. You also can type it which I prefer so I can copy all later, paste them in Microsoft
Word to enlarge & edit if needed. Thanks for all :) 1. Sort the record 9, 34,17,6, 15, 3:8 by using
the following sorting techniques, respectively, 1) QuickSort with a good call for the first pivot
value 2) MergeSort 3) HeapSort (including the details for building 1st Heap, and all 6 heaps) 4)
Binsort (Choose Bins as: 0-9; 10-19, 20-29, 30-39) 5) Radix sort The details of each sorting step
should be ncluded The details of each sorting step should be included
Solution
QuickSort:
QuickSort is a Divide and Conquer algorithm. It picks an element as pivot and partitions the
given array around the picked pivot. There are many different versions of quickSort that pick
pivot in different ways.
The key process in quickSort is partition(). Target of partitions is, given an array and an element
x of array as pivot, put x at its correct position in sorted array and put all smaller elements
(smaller than x) before x, and put all greater elements (greater than x) after x. All this should be
done in linear time
elements:
9 34 17 6 15 38
9 34 17 6 15 38
9 34 17 6 15 38
9 34 17 6 15 38
9 34 17 6 15 38
9 34 17 6 15 38
9 6 17 34 15 38
swapping 15 and 34
15 is choosing pivot
compare with i-1 value
Program
def quickSort(alist):
quickSortHelper(alist,0,len(alist)-1)
def quickSortHelper(alist,first,last):
if first= pivotvalue and rightmark >= leftmark:
rightmark = rightmark -1
if rightmark < leftmark:
done = True
else:
temp = alist[leftmark]
alist[leftmark] = alist[rightmark]
alist[rightmark] = temp
temp = alist[first]
alist[first] = alist[rightmark]
alist[rightmark] = temp
return rightmark
alist = [9,34,17,6,15,8]
quickSort(alist)
print(alist)
Mergesort:
MergeSort is a Divide and Conquer algorithm. It divides input array in two halves, calls itself for
the two halves and then merges the two sorted halves. The merge() function is used for merging
two halves. The merge(arr, l, m, r) is key process that assumes that arr[l..m] and arr[m+1..r] are
sorted and merges the two sorted sub-arrays into one. See following C implementation for
details.
9 34 17 6 15 38
divide two parts
9 34 17 6 15 38
divide separate parts
9 34 17 6 15 38
compare two elements in each section
9 34 17 6 15 38
compare section to section
9 17 34 6 15 38
compare two section
6 9 15 17 34 38
Merges two subarrays of arr[].
# First subarray is arr[l..m]
# Second subarray is arr[m+1..r]
def merge(arr, l, m, r):
n1 = m - l + 1
n2 = r- m
# create temp arrays
L = [0] * (n1)
R = [0] * (n2)
# Copy data to temp arrays L[] and R[]
for i in range(0 , n1):
L[i] = arr[l + i]
for j in range(0 , n2):
R[j] = arr[m + 1 + j]
# Merge the temp arrays back into arr[l..r]
i = 0 # Initial index of first subarray
j = 0 # Initial index of second.
Unit 7 sorting
Unit 7 sortingkalyanineve The document discusses various sorting algorithms including insertion sort, selection sort, bubble sort, merge sort, and quick sort. It provides detailed explanations of how each algorithm works through examples using arrays or lists of numbers. The key steps of each algorithm are outlined in pseudocode to demonstrate how they sort a set of data in either ascending or descending order.
An Experiment to Determine and Compare Practical Efficiency of Insertion Sort...
An Experiment to Determine and Compare Practical Efficiency of Insertion Sort...Tosin Amuda Sorting is a fundamental operation in computer science (many programs use it as an intermediate step), and as a result a large number of good sorting algorithms have been developed. Which algorithm is best for a given application depends on—among other factors—the number of items to be sorted, the extent to which the items are already somewhat sorted, possible restrictions on the item values, and the kind of storage device to be used: main memory, disks, or tapes.
There are three reasons to study sorting algorithms. First, sorting algorithms illustrate many creative approaches to problem solving, and these approaches can be applied to solve other problems. Second, sorting algorithms are good for practicing fundamental programming techniques using selection statements, loops, methods, and arrays. Third, sorting algorithms are excellent examples to demonstrate algorithm performance.
However, this paper attempt to compare the practical efficiency of three sorting algorithms – Insertion, Quick and mere Sort using empirical analysis. The result of the experiment shows that insertion sort is a quadratic time sorting algorithm and that it’s more applicable to subarray that is sufficiently small. The merge sort performs better with larger size of input as compared to insertion sort. Quicksort runs the most efficiently.
Introduction to Algorithms
Introduction to Algorithmspppepito86 The document discusses algorithms and their analysis. It begins by defining an algorithm and key aspects like correctness, input, and output. It then discusses two aspects of algorithm performance - time and space. Examples are provided to illustrate how to analyze the time complexity of different structures like if/else statements, simple loops, and nested loops. Big O notation is introduced to describe an algorithm's growth rate. Common time complexities like constant, linear, quadratic, and cubic functions are defined. Specific sorting algorithms like insertion sort, selection sort, bubble sort, merge sort, and quicksort are then covered in detail with examples of how they work and their time complexities.
Data Structures & Algorithms - Lecture 2
Data Structures & Algorithms - Lecture 2Faculty of Computers and Informatics, Suez Canal University, Ismailia, Egypt Data Structures and Algorithms using C++ programming language.
DATA STRUCTURE CLASS 12 COMPUTER SCIENCE
DATA STRUCTURE CLASS 12 COMPUTER SCIENCEDev Chauhan Arrays, stacks, queues, and linked lists are common data structures in computer science. Arrays allow direct access to elements but have fixed size, while linked lists can dynamically grow and shrink but require traversing nodes sequentially. Stacks follow LIFO (last in first out) and queues follow FIFO (first in first out) ordering for inserting and removing elements. Linked lists store data in nodes that link to the next node, allowing efficient insertion/removal anywhere in the list. Common operations on these structures include push/pop for stacks, enqueue/dequeue for queues, and insert/delete nodes for linked lists.
Design and Analysis of Algorithm in Compter Science.pptx
Design and Analysis of Algorithm in Compter Science.pptxrahulshawit2023 Design and Analysis of Algorithm in Compter Science
Daa chapter5
Daa chapter5B.Kirron Reddi The document introduces algorithms for sorting and searching tasks. It discusses sequential search, binary search, selection sort, bubble sort, merge sort, and quick sort algorithms. For each algorithm, it provides pseudocode to describe the steps, an example, and analysis of time complexity in the best, worst and average cases. The time complexities identified are Θ(n) for sequential search average case, Θ(log n) for binary search, Θ(n2) for selection, bubble and quick sort worst cases, and Θ(n log n) for merge and quick sort average cases.
Ada notes
Ada notesVIKAS SINGH BHADOURIA This document provides an introduction to algorithms and data structures. It discusses algorithm design and analysis tools like Big O notation and recurrence relations. Selecting the smallest element from a list, sorting a list using selection sort and merge sort, and merging two sorted lists are used as examples. Key points made are that merge sort has better time complexity than selection sort, and any sorting algorithm requires at least O(n log n) comparisons. The document also introduces data structures like arrays and linked lists, and how the organization of data impacts algorithm performance.
Data structure using c module 1
Data structure using c module 1smruti sarangi This file contains the concepts of Array, Sparse Matrix,
Stack, Queue, Linked List, Polynomial Representation and Dynamic Storage Management.
14-sorting.ppt
14-sorting.pptRenalthaPujaBagaskar Merge sort has a runtime of O(n log n). It works by recursively dividing an array into halves and then merging the sorted halves. First it divides the array into single elements, sorts those, then merges them back together piece by piece into a fully sorted array.
14-sorting (3).ppt
14-sorting (3).pptyasser3omr Merge sort has a runtime of O(n log n). It works by recursively dividing an array into halves and then merging the sorted halves. First it divides the array into single elements, sorts those, then merges them back together piece by piece into a fully sorted array.
14-sorting.ppt
14-sorting.pptSushantRaj25 Merge sort has a runtime of O(n log n). It works by recursively dividing an array into halves and then merging the sorted halves. First it divides the array into subarrays of 1 element, sorts those, and then merges those sorted subarrays back together until the entire array is sorted.
14-sorting.ppt
14-sorting.pptKamalAlbashiri Merge sort has a runtime of O(n log n). It works by recursively dividing an array into halves and then merging the sorted halves. First it divides the array into single elements, sorts those, then merges them back together piece by piece into a fully sorted array.
data structure and algorithm Array.pptx btech 2nd year
data structure and algorithm Array.pptx btech 2nd yearpalhimanshi999 The document discusses arrays and algorithms. It begins by defining arrays as lists of homogeneous data elements referenced by indices. Linear arrays are one-dimensional while multi-dimensional arrays include matrices. Common array operations like traversal, insertion, deletion and searching algorithms like linear and binary search are described. For linear search, the best, average and worst case complexities are analyzed to be O(1), O(n/2) and O(n) respectively. Binary search is more efficient, having a complexity of O(log n) as it halves the search space on each comparison. Examples and pseudocode are provided to illustrate key concepts.
Data analysis and algorithms - UNIT 2.pptx
Data analysis and algorithms - UNIT 2.pptxsgrishma559 The document summarizes algorithms related to divide and conquer and greedy algorithms. It discusses binary search, finding maximum and minimum, merge sort, quick sort, and Huffman codes. The key steps of divide and conquer algorithms are to divide the problem into subproblems, conquer the subproblems by solving them recursively, and combine the solutions to solve the overall problem. Greedy algorithms make locally optimal choices at each step to find a global optimal solution. Huffman coding assigns variable-length codes to characters based on frequency to compress data.
Array 2
Array 2Abbott The document discusses arrays and their representation in memory. It contains 3 main points:
1) It introduces linear arrays and how they are represented in memory with sequential and contiguous locations. It also discusses multidimensional arrays.
2) It provides algorithms for common linear array operations like traversing, inserting, deleting and searching using binary search. It explains how each algorithm works through examples.
3) It discusses how 2D arrays are represented in memory and visualized, using an example of storing student exam marks in a 2D array.
Sorting2
Sorting2Saurabh Mishra The document discusses various sorting algorithms and their time complexities, including:
1) Quicksort, which has an average case time complexity of O(n log n) but a worst case of O(n^2). It works by recursively partitioning an array around a pivot element.
2) Heapsort, which also has a time complexity of O(n log n). It uses a binary heap to extract elements in sorted order.
3) Counting sort and radix sort, which can sort in linear time O(n) when the input has certain properties like a limited range of values or being represented by a small number of digits.
chapter7.ppt
chapter7.pptPreetiverma538521 The document discusses various sorting algorithms including insertion sort, quicksort, merge sort, and their time complexities. Insertion sort has worst-case time complexity of O(n^2) but works well for small lists. Quicksort and merge sort have average time complexity of O(nlogn). Merge sort uses additional storage space while quicksort may have worst-case time of O(n^2) if the pivot choice is poor.
chapter7.pptfuifbsdiufbsiudfiudfiufeiufiuf
chapter7.pptfuifbsdiufbsiudfiudfiufeiufiufWrushabhShirsat3 The document discusses various sorting algorithms including insertion sort, quicksort, merge sort, and their time complexities. Insertion sort has worst-case time complexity of O(n^2) but works well for small lists. Quicksort and merge sort have average time complexity of O(nlogn). Merge sort uses additional storage space while quicksort may have worst-case time of O(n^2) if the pivot choice is poor.
chapter7 Sorting.ppt
chapter7 Sorting.pptNielmagahod The document discusses various sorting algorithms including insertion sort, quicksort, merge sort, and their time complexities. Insertion sort has worst-case time complexity of O(n^2) but works well for small lists. Quicksort and merge sort have average time complexity of O(nlogn). Merge sort uses additional storage space while quicksort may have worst-case time of O(n^2) if the pivot choice is poor.
Problem1 java codeimport java.util.Scanner; Java code to pr.pdf
Problem1 java codeimport java.util.Scanner; Java code to pr.pdfanupamfootwear // Problem1 java code
import java.util.Scanner;
// Java code to print all possible strings of letter L and R
class Problem1 {
static void print(char set[], int length) {
int setLength = set.length;
printRecursion(set, \"\", setLength, length);
}
static void printRecursion(char set[], String prefixset, int setLength, int length) {
// Base case: length is 0
if (length == 0) {
System.out.println(prefixset);
return;
}
for (int i = 0; i < setLength; ++i) {
String newPrefixset = prefixset + set[i];
printRecursion(set, newPrefixset, setLength, length - 1);
}
}
public static void main(String[] args) {
Scanner scan=new Scanner(System.in);
System.out.println(\"Enter length: \");
int length = scan.nextInt();
char set[] = {\'L\', \'R\'};
print(set, length);
}
}
/*
output:
Enter length:
3
LLL
LLR
LRL
LRR
RLL
RLR
RRL
RRR
*/
// Problem2 java code
import java.util.Scanner;
// Java code to print all possible strings of letter L and R
class Problem2 {
static void print(char set[], int length) {
int setLength = set.length;
printRecursion(set, \"\", setLength, length);
}
static void printRecursion(char set[], String prefixset, int setLength, int length) {
// Base case: length is 0
if (length == 0) {
System.out.print(prefixset + \" \");
return;
}
for (int i = 0; i < setLength; ++i) {
String newPrefixset = prefixset + set[i];
printRecursion(set, newPrefixset, setLength, length - 1);
}
}
public static void main(String[] args) {
Scanner scan=new Scanner(System.in);
System.out.println(\"Enter length: \");
int length = scan.nextInt();
char set[] = {\'1\', \'3\', \'5\', \'7\', \'9\'};
print(set, length);
System.out.println();
}
}
/*
output:
Enter length:
3
111 113 115 117 119 131 133 135 137 139 151 153 155
157 159 171 173 175 177 179 191 193 195 197 199 311
313 315 317 319 331 333 335 337 339 351 353 355 357
359 371 373 375 377 379 391 393 395 397 399 511 513
515 517 519 531 533 535 537 539 551 553 555 557 559
571 573 575 577 579 591 593 595 597 599 711 713 715
717 719 731 733 735 737 739 751 753 755 757 759 771
773 775 777 779 791 793 795 797 799 911 913 915 917
919 931 933 935 937 939 951 953 955 957 959 971 973
975 977 979 991 993 995 997 999
*/
// Problem3 java code
import java.util.Scanner;
// Java code to multiply 2 numbers
class Problem3 {
public static int multiply(int a, int b)
{
int temp = b;
for (int i = 1; i < a; i++ ) {
b = b + temp;
}
return b;
}
public static void main(String[] args) {
Scanner scan=new Scanner(System.in);
System.out.println(\"Enter a: \");
int a = scan.nextInt();
System.out.println(\"Enter b: \");
int b = scan.nextInt();
System.out.println(a + \"X\" + b + \" = \" + multiply(a,b));
}
}
/*
output:
Enter a:
7
Enter b:
6
7X6 = 42
*/
// Problem4 java code
import java.util.Scanner;
// Java code to find gcd 2 numbers
class Problem4 {
public static int gcd(int a, int b)
{
if (b!=0)
return gcd(b, a%b);
else
return a;
}
public static void main(String[] args) {
Scanner scan=new Scanner(System.in);
System.out.println(\"Enter a: \");
int a = scan.ne.
All of the aboveSolution All of the above.pdf
All of the aboveSolution All of the above.pdfanupamfootwear All of the above
Solution
All of the above.
Ad
More Related Content
Similar to Quicksort AlgorithmQuicksort is a divide and conquer algorithm. Q.pdf (20)
Unit 7 sorting
Unit 7 sortingkalyanineve The document discusses various sorting algorithms including insertion sort, selection sort, bubble sort, merge sort, and quick sort. It provides detailed explanations of how each algorithm works through examples using arrays or lists of numbers. The key steps of each algorithm are outlined in pseudocode to demonstrate how they sort a set of data in either ascending or descending order.
An Experiment to Determine and Compare Practical Efficiency of Insertion Sort...
An Experiment to Determine and Compare Practical Efficiency of Insertion Sort...Tosin Amuda Sorting is a fundamental operation in computer science (many programs use it as an intermediate step), and as a result a large number of good sorting algorithms have been developed. Which algorithm is best for a given application depends on—among other factors—the number of items to be sorted, the extent to which the items are already somewhat sorted, possible restrictions on the item values, and the kind of storage device to be used: main memory, disks, or tapes.
There are three reasons to study sorting algorithms. First, sorting algorithms illustrate many creative approaches to problem solving, and these approaches can be applied to solve other problems. Second, sorting algorithms are good for practicing fundamental programming techniques using selection statements, loops, methods, and arrays. Third, sorting algorithms are excellent examples to demonstrate algorithm performance.
However, this paper attempt to compare the practical efficiency of three sorting algorithms – Insertion, Quick and mere Sort using empirical analysis. The result of the experiment shows that insertion sort is a quadratic time sorting algorithm and that it’s more applicable to subarray that is sufficiently small. The merge sort performs better with larger size of input as compared to insertion sort. Quicksort runs the most efficiently.
Introduction to Algorithms
Introduction to Algorithmspppepito86 The document discusses algorithms and their analysis. It begins by defining an algorithm and key aspects like correctness, input, and output. It then discusses two aspects of algorithm performance - time and space. Examples are provided to illustrate how to analyze the time complexity of different structures like if/else statements, simple loops, and nested loops. Big O notation is introduced to describe an algorithm's growth rate. Common time complexities like constant, linear, quadratic, and cubic functions are defined. Specific sorting algorithms like insertion sort, selection sort, bubble sort, merge sort, and quicksort are then covered in detail with examples of how they work and their time complexities.
Data Structures & Algorithms - Lecture 2
Data Structures & Algorithms - Lecture 2Faculty of Computers and Informatics, Suez Canal University, Ismailia, Egypt Data Structures and Algorithms using C++ programming language.
DATA STRUCTURE CLASS 12 COMPUTER SCIENCE
DATA STRUCTURE CLASS 12 COMPUTER SCIENCEDev Chauhan Arrays, stacks, queues, and linked lists are common data structures in computer science. Arrays allow direct access to elements but have fixed size, while linked lists can dynamically grow and shrink but require traversing nodes sequentially. Stacks follow LIFO (last in first out) and queues follow FIFO (first in first out) ordering for inserting and removing elements. Linked lists store data in nodes that link to the next node, allowing efficient insertion/removal anywhere in the list. Common operations on these structures include push/pop for stacks, enqueue/dequeue for queues, and insert/delete nodes for linked lists.
Design and Analysis of Algorithm in Compter Science.pptx
Design and Analysis of Algorithm in Compter Science.pptxrahulshawit2023 Design and Analysis of Algorithm in Compter Science
Daa chapter5
Daa chapter5B.Kirron Reddi The document introduces algorithms for sorting and searching tasks. It discusses sequential search, binary search, selection sort, bubble sort, merge sort, and quick sort algorithms. For each algorithm, it provides pseudocode to describe the steps, an example, and analysis of time complexity in the best, worst and average cases. The time complexities identified are Θ(n) for sequential search average case, Θ(log n) for binary search, Θ(n2) for selection, bubble and quick sort worst cases, and Θ(n log n) for merge and quick sort average cases.
Ada notes
Ada notesVIKAS SINGH BHADOURIA This document provides an introduction to algorithms and data structures. It discusses algorithm design and analysis tools like Big O notation and recurrence relations. Selecting the smallest element from a list, sorting a list using selection sort and merge sort, and merging two sorted lists are used as examples. Key points made are that merge sort has better time complexity than selection sort, and any sorting algorithm requires at least O(n log n) comparisons. The document also introduces data structures like arrays and linked lists, and how the organization of data impacts algorithm performance.
Data structure using c module 1
Data structure using c module 1smruti sarangi This file contains the concepts of Array, Sparse Matrix,
Stack, Queue, Linked List, Polynomial Representation and Dynamic Storage Management.
14-sorting.ppt
14-sorting.pptRenalthaPujaBagaskar Merge sort has a runtime of O(n log n). It works by recursively dividing an array into halves and then merging the sorted halves. First it divides the array into single elements, sorts those, then merges them back together piece by piece into a fully sorted array.
14-sorting (3).ppt
14-sorting (3).pptyasser3omr Merge sort has a runtime of O(n log n). It works by recursively dividing an array into halves and then merging the sorted halves. First it divides the array into single elements, sorts those, then merges them back together piece by piece into a fully sorted array.
14-sorting.ppt
14-sorting.pptSushantRaj25 Merge sort has a runtime of O(n log n). It works by recursively dividing an array into halves and then merging the sorted halves. First it divides the array into subarrays of 1 element, sorts those, and then merges those sorted subarrays back together until the entire array is sorted.
14-sorting.ppt
14-sorting.pptKamalAlbashiri Merge sort has a runtime of O(n log n). It works by recursively dividing an array into halves and then merging the sorted halves. First it divides the array into single elements, sorts those, then merges them back together piece by piece into a fully sorted array.
data structure and algorithm Array.pptx btech 2nd year
data structure and algorithm Array.pptx btech 2nd yearpalhimanshi999 The document discusses arrays and algorithms. It begins by defining arrays as lists of homogeneous data elements referenced by indices. Linear arrays are one-dimensional while multi-dimensional arrays include matrices. Common array operations like traversal, insertion, deletion and searching algorithms like linear and binary search are described. For linear search, the best, average and worst case complexities are analyzed to be O(1), O(n/2) and O(n) respectively. Binary search is more efficient, having a complexity of O(log n) as it halves the search space on each comparison. Examples and pseudocode are provided to illustrate key concepts.
Data analysis and algorithms - UNIT 2.pptx
Data analysis and algorithms - UNIT 2.pptxsgrishma559 The document summarizes algorithms related to divide and conquer and greedy algorithms. It discusses binary search, finding maximum and minimum, merge sort, quick sort, and Huffman codes. The key steps of divide and conquer algorithms are to divide the problem into subproblems, conquer the subproblems by solving them recursively, and combine the solutions to solve the overall problem. Greedy algorithms make locally optimal choices at each step to find a global optimal solution. Huffman coding assigns variable-length codes to characters based on frequency to compress data.
Array 2
Array 2Abbott The document discusses arrays and their representation in memory. It contains 3 main points:
1) It introduces linear arrays and how they are represented in memory with sequential and contiguous locations. It also discusses multidimensional arrays.
2) It provides algorithms for common linear array operations like traversing, inserting, deleting and searching using binary search. It explains how each algorithm works through examples.
3) It discusses how 2D arrays are represented in memory and visualized, using an example of storing student exam marks in a 2D array.
Sorting2
Sorting2Saurabh Mishra The document discusses various sorting algorithms and their time complexities, including:
1) Quicksort, which has an average case time complexity of O(n log n) but a worst case of O(n^2). It works by recursively partitioning an array around a pivot element.
2) Heapsort, which also has a time complexity of O(n log n). It uses a binary heap to extract elements in sorted order.
3) Counting sort and radix sort, which can sort in linear time O(n) when the input has certain properties like a limited range of values or being represented by a small number of digits.
chapter7.ppt
chapter7.pptPreetiverma538521 The document discusses various sorting algorithms including insertion sort, quicksort, merge sort, and their time complexities. Insertion sort has worst-case time complexity of O(n^2) but works well for small lists. Quicksort and merge sort have average time complexity of O(nlogn). Merge sort uses additional storage space while quicksort may have worst-case time of O(n^2) if the pivot choice is poor.
chapter7.pptfuifbsdiufbsiudfiudfiufeiufiuf
chapter7.pptfuifbsdiufbsiudfiudfiufeiufiufWrushabhShirsat3 The document discusses various sorting algorithms including insertion sort, quicksort, merge sort, and their time complexities. Insertion sort has worst-case time complexity of O(n^2) but works well for small lists. Quicksort and merge sort have average time complexity of O(nlogn). Merge sort uses additional storage space while quicksort may have worst-case time of O(n^2) if the pivot choice is poor.
chapter7 Sorting.ppt
chapter7 Sorting.pptNielmagahod The document discusses various sorting algorithms including insertion sort, quicksort, merge sort, and their time complexities. Insertion sort has worst-case time complexity of O(n^2) but works well for small lists. Quicksort and merge sort have average time complexity of O(nlogn). Merge sort uses additional storage space while quicksort may have worst-case time of O(n^2) if the pivot choice is poor.
Data Structures & Algorithms - Lecture 2
Data Structures & Algorithms - Lecture 2Faculty of Computers and Informatics, Suez Canal University, Ismailia, Egypt
More from anupamfootwear (20)
Problem1 java codeimport java.util.Scanner; Java code to pr.pdf
Problem1 java codeimport java.util.Scanner; Java code to pr.pdfanupamfootwear // Problem1 java code
import java.util.Scanner;
// Java code to print all possible strings of letter L and R
class Problem1 {
static void print(char set[], int length) {
int setLength = set.length;
printRecursion(set, \"\", setLength, length);
}
static void printRecursion(char set[], String prefixset, int setLength, int length) {
// Base case: length is 0
if (length == 0) {
System.out.println(prefixset);
return;
}
for (int i = 0; i < setLength; ++i) {
String newPrefixset = prefixset + set[i];
printRecursion(set, newPrefixset, setLength, length - 1);
}
}
public static void main(String[] args) {
Scanner scan=new Scanner(System.in);
System.out.println(\"Enter length: \");
int length = scan.nextInt();
char set[] = {\'L\', \'R\'};
print(set, length);
}
}
/*
output:
Enter length:
3
LLL
LLR
LRL
LRR
RLL
RLR
RRL
RRR
*/
// Problem2 java code
import java.util.Scanner;
// Java code to print all possible strings of letter L and R
class Problem2 {
static void print(char set[], int length) {
int setLength = set.length;
printRecursion(set, \"\", setLength, length);
}
static void printRecursion(char set[], String prefixset, int setLength, int length) {
// Base case: length is 0
if (length == 0) {
System.out.print(prefixset + \" \");
return;
}
for (int i = 0; i < setLength; ++i) {
String newPrefixset = prefixset + set[i];
printRecursion(set, newPrefixset, setLength, length - 1);
}
}
public static void main(String[] args) {
Scanner scan=new Scanner(System.in);
System.out.println(\"Enter length: \");
int length = scan.nextInt();
char set[] = {\'1\', \'3\', \'5\', \'7\', \'9\'};
print(set, length);
System.out.println();
}
}
/*
output:
Enter length:
3
111 113 115 117 119 131 133 135 137 139 151 153 155
157 159 171 173 175 177 179 191 193 195 197 199 311
313 315 317 319 331 333 335 337 339 351 353 355 357
359 371 373 375 377 379 391 393 395 397 399 511 513
515 517 519 531 533 535 537 539 551 553 555 557 559
571 573 575 577 579 591 593 595 597 599 711 713 715
717 719 731 733 735 737 739 751 753 755 757 759 771
773 775 777 779 791 793 795 797 799 911 913 915 917
919 931 933 935 937 939 951 953 955 957 959 971 973
975 977 979 991 993 995 997 999
*/
// Problem3 java code
import java.util.Scanner;
// Java code to multiply 2 numbers
class Problem3 {
public static int multiply(int a, int b)
{
int temp = b;
for (int i = 1; i < a; i++ ) {
b = b + temp;
}
return b;
}
public static void main(String[] args) {
Scanner scan=new Scanner(System.in);
System.out.println(\"Enter a: \");
int a = scan.nextInt();
System.out.println(\"Enter b: \");
int b = scan.nextInt();
System.out.println(a + \"X\" + b + \" = \" + multiply(a,b));
}
}
/*
output:
Enter a:
7
Enter b:
6
7X6 = 42
*/
// Problem4 java code
import java.util.Scanner;
// Java code to find gcd 2 numbers
class Problem4 {
public static int gcd(int a, int b)
{
if (b!=0)
return gcd(b, a%b);
else
return a;
}
public static void main(String[] args) {
Scanner scan=new Scanner(System.in);
System.out.println(\"Enter a: \");
int a = scan.ne.
All of the aboveSolution All of the above.pdf
All of the aboveSolution All of the above.pdfanupamfootwear All of the above
Solution
All of the above.
Yields a colorless solution and a white precipita.pdf
Yields a colorless solution and a white precipita.pdfanupamfootwear Yields a colorless solution and a white precipitate
Solution
Yields a colorless solution and a white precipitate.
ROund to one significant figures, THen, its 2..pdf
ROund to one significant figures, THen, its 2..pdfanupamfootwear ROund to one significant figures, THen, it\'s 2.2*10^8
Solution
ROund to one significant figures, THen, it\'s 2.2*10^8.
P=7.7(0.92)^t growth rate is dPdt differentiate .pdf
P=7.7(0.92)^t growth rate is dPdt differentiate .pdfanupamfootwear P=7.7(0.92)^t growth rate is dP/dt differentiate p wrt t dP/dt = 7.7(0.92)^tlog(0.92)
similarly P=15e^(-0.06t) dP/dt = 15.(-0.06)e^(-0.06t) dP/dt = -0.9e^(-0.06t)
Solution
P=7.7(0.92)^t growth rate is dP/dt differentiate p wrt t dP/dt = 7.7(0.92)^tlog(0.92)
similarly P=15e^(-0.06t) dP/dt = 15.(-0.06)e^(-0.06t) dP/dt = -0.9e^(-0.06t).
option (D) ... reason posted in my previous answe.pdf
option (D) ... reason posted in my previous answe.pdfanupamfootwear option (D) ... reason posted in my previous answer
Solution
option (D) ... reason posted in my previous answer.
no.of moles of H2moles=28.82=14.4moles no.of mol.pdf
no.of moles of H2moles=28.82=14.4moles no.of mol.pdfanupamfootwear no.of moles of H2moles=28.8/2=14.4moles no.of moles of C2H6
formed=14.4moles
Solution
no.of moles of H2moles=28.8/2=14.4moles no.of moles of C2H6
formed=14.4moles.
Ionic Compounds Think of an ionic compound as a .pdf
Ionic Compounds Think of an ionic compound as a .pdfanupamfootwear Ionic Compounds: Think of an ionic compound as a sea of ions. All these ions are
carefully arranged in some sort of 3D pattern with positive and negative ions in specific locations
in the pattern. Take common table salt, Sodium Chloride, as an example. In Sodium Chloride,
there aren\'t specific NaCl molecules, but a mix of Na+ ions and Cl- ions. Each Na+ ion is
surrounded by Cl- ions, and each Cl- ion is surrounded by Na+ ions. The whole structure is held
together by the attraction between the positive and negative ions. Molecular Substances: A
molecule is a group of atoms which are sharing electrons with one another through covalent
bonds. Because the sharing results in a lower energy state, the atoms are more stable together
than alone. When a sample of a molecular substance is looked at, say water (H2O), within the
substance each molecule is being attracted to other molecules. These attractive forces are called
intermolecular forces and they are much weaker than covalent bonds or ionic bonds. For a
substance to melt and then boil, the forces which hold the substance together must be broken.
When water boils, the intermolecular forces between H2O molecules are broken and the
molecules separate from one another. (Note that the covalent bonds are NOT broken, the gas is
still made up of H2O molecules, they\'re just not \"sticking\" to one another anymore.) As you
can imagine, the ionic forces holding an ionic compound together are MUCH stronger than the
intermolecular forces holding a molecular substance together. A lot more energy is required to
break the ionic bonds. So, ionic substances melt at very high temperatures and boil at even
higher temperatures.
Solution
Ionic Compounds: Think of an ionic compound as a sea of ions. All these ions are
carefully arranged in some sort of 3D pattern with positive and negative ions in specific locations
in the pattern. Take common table salt, Sodium Chloride, as an example. In Sodium Chloride,
there aren\'t specific NaCl molecules, but a mix of Na+ ions and Cl- ions. Each Na+ ion is
surrounded by Cl- ions, and each Cl- ion is surrounded by Na+ ions. The whole structure is held
together by the attraction between the positive and negative ions. Molecular Substances: A
molecule is a group of atoms which are sharing electrons with one another through covalent
bonds. Because the sharing results in a lower energy state, the atoms are more stable together
than alone. When a sample of a molecular substance is looked at, say water (H2O), within the
substance each molecule is being attracted to other molecules. These attractive forces are called
intermolecular forces and they are much weaker than covalent bonds or ionic bonds. For a
substance to melt and then boil, the forces which hold the substance together must be broken.
When water boils, the intermolecular forces between H2O molecules are broken and the
molecules separate from one another. (Note that the covalent bonds are NOT broken, the gas is
still made u.
In the First molecule there will be Resonance whi.pdf
In the First molecule there will be Resonance whi.pdfanupamfootwear In the First molecule there will be Resonance which will distribute the -ve charge
between the two O atoms making it the least Basic. (Increase in concentrated -ve charge
increases basicity) The first molecule i.e CH3CH2O-Li+. is the most basic due to the +I
(Inductive) Effect of the CH3CH2- group. This group would push e- towards the O atom
increasing its charge by delta-.
Solution
In the First molecule there will be Resonance which will distribute the -ve charge
between the two O atoms making it the least Basic. (Increase in concentrated -ve charge
increases basicity) The first molecule i.e CH3CH2O-Li+. is the most basic due to the +I
(Inductive) Effect of the CH3CH2- group. This group would push e- towards the O atom
increasing its charge by delta-..
He down the group, IE decreases. Solution.pdf
He down the group, IE decreases. Solution.pdfanupamfootwear This very short document does not provide enough context or information to generate a meaningful 3 sentence summary. It contains only two sentences that are unclear and do not seem to form a coherent paragraph.
Uncouple agents will never disrupt the electron transport (they will.pdf
Uncouple agents will never disrupt the electron transport (they will.pdfanupamfootwear Uncouple agents will never disrupt the electron transport (they will not damage or disrupt the
mitochondrial structure), they only inhibit the ATP synthesis and best example for this Uncouple
agents are 2,4-dinitrophenol (DNP) and carbonylcyanide-ptrifluoromethoxyphenylhydrazone
(FCCP) and these agents are known to bear H+ and are capable of diffusing into the matrix. Like
this these two chemicals successfully reduce the electrochemical potential across the inner
mitochondrial membrane and as a result you can see an inhibition of ATP synthesis.
2,4-Dinitrophenol, dicumarol and carbonyl cyanidep-trifluorocarbonyl-cyanide methoxyphenyl
hydrazone (FCCP) chemicals have hydrophobic character, thus these are easily soluble in the
bilipid membrane (this gives them any easy entry into the matrix in its protonated form and thus
they releases a proton and can successfully dissipate the proton gradients. Another things through
resonance stabilization will delocalize the charge which is there on anionic forms and thus this
chemical again will diffuse back across the membrane will try to pick up a proton and will try to
repeat the process) and in these chemical decouples by having the dissociable protons will carry
protons from the intermembrane space to the matrix, so that the pH gradient existing there can be
collapsed and all the potential energy of the proton gradient will be seen losing as mere heat.
Research has showed when 2,4-dintrophenol is added to the reaction mixture, it has uncoupled
electron transfer from that of ATP synthesis and as a result the oxygen is completely seen to be
consumed in the absence of ADP.
Solution
Uncouple agents will never disrupt the electron transport (they will not damage or disrupt the
mitochondrial structure), they only inhibit the ATP synthesis and best example for this Uncouple
agents are 2,4-dinitrophenol (DNP) and carbonylcyanide-ptrifluoromethoxyphenylhydrazone
(FCCP) and these agents are known to bear H+ and are capable of diffusing into the matrix. Like
this these two chemicals successfully reduce the electrochemical potential across the inner
mitochondrial membrane and as a result you can see an inhibition of ATP synthesis.
2,4-Dinitrophenol, dicumarol and carbonyl cyanidep-trifluorocarbonyl-cyanide methoxyphenyl
hydrazone (FCCP) chemicals have hydrophobic character, thus these are easily soluble in the
bilipid membrane (this gives them any easy entry into the matrix in its protonated form and thus
they releases a proton and can successfully dissipate the proton gradients. Another things through
resonance stabilization will delocalize the charge which is there on anionic forms and thus this
chemical again will diffuse back across the membrane will try to pick up a proton and will try to
repeat the process) and in these chemical decouples by having the dissociable protons will carry
protons from the intermembrane space to the matrix, so that the pH gradient existing there can be
collapsed and all the potenti.
The N and O atoms are both sp2 hybridized.The sp2 hybrid orbitals .pdf
The N and O atoms are both sp2 hybridized.The sp2 hybrid orbitals .pdfanupamfootwear The N and O atoms are both sp2 hybridized.
The sp2 hybrid orbitals (three each for N and O) either form sigma bonds or contain lone
electron pairs.
The pi bond is formed by overlap of the remaining unhybridized p orbital of N and the remaining
unhybridized p orbital of O.
Solution
The N and O atoms are both sp2 hybridized.
The sp2 hybrid orbitals (three each for N and O) either form sigma bonds or contain lone
electron pairs.
The pi bond is formed by overlap of the remaining unhybridized p orbital of N and the remaining
unhybridized p orbital of O..
d.Addition of sulfuric acid to copper(II) oxide p.pdf
d.Addition of sulfuric acid to copper(II) oxide p.pdfanupamfootwear d.Addition of sulfuric acid to copper(II) oxide produces water as a by-product
Solution
d.Addition of sulfuric acid to copper(II) oxide produces water as a by-product.
The 2nd statement and 3rd statement follow the seed and soil theory .pdf
The 2nd statement and 3rd statement follow the seed and soil theory .pdfanupamfootwear The 2nd statement and 3rd statement follow the seed and soil theory of metastasis or simply
metastasis. It involves the main step “spreading of cells”. Integrins are responsible for signal
transduction and do not move. Seed and soil theory is acceptable to the both statements.
Micrometastases even remain dormant but have some growth in an organ. This organ is still
work as soil for Micrometastases. So tumor cell are still as seed and organ is soil for them.
Solution
The 2nd statement and 3rd statement follow the seed and soil theory of metastasis or simply
metastasis. It involves the main step “spreading of cells”. Integrins are responsible for signal
transduction and do not move. Seed and soil theory is acceptable to the both statements.
Micrometastases even remain dormant but have some growth in an organ. This organ is still
work as soil for Micrometastases. So tumor cell are still as seed and organ is soil for them..
Pictures are not legible, could you plz post it again.Solution.pdf
Pictures are not legible, could you plz post it again.Solution.pdfanupamfootwear Pictures are not legible, could you plz post it again.
Solution
Pictures are not legible, could you plz post it again..
Carbonic acid leaves the soda solution as CO2 (ca.pdf
Carbonic acid leaves the soda solution as CO2 (ca.pdfanupamfootwear Carbonic acid leaves the soda solution as CO2 (carbon dioxide). When a soda goes
flat, all the CO2 leaves, however the H+ (acidic protons) are still left in the solution, leaving the
solution acidic but flat.
Solution
Carbonic acid leaves the soda solution as CO2 (carbon dioxide). When a soda goes
flat, all the CO2 leaves, however the H+ (acidic protons) are still left in the solution, leaving the
solution acidic but flat..
mass= density volume= 2.330.10.10.01 = 2.3310-4gmsatomic .pdf
mass= density volume= 2.330.10.10.01 = 2.3310-4gmsatomic .pdfanupamfootwear mass= density *volume= 2.33*0.1*0.1*0.01 = 2.33*10-4gms
atomic mass of Si = 28.1 amu
moles of Si =2.33*10-4/28.1 = 8.29*10-6
number of atoms =8.29*10-6*6.023*1023= 5*1018 atoms
Solution
mass= density *volume= 2.33*0.1*0.1*0.01 = 2.33*10-4gms
atomic mass of Si = 28.1 amu
moles of Si =2.33*10-4/28.1 = 8.29*10-6
number of atoms =8.29*10-6*6.023*1023= 5*1018 atoms.
John is suffering from fifth disease.It is caused by an airborne v.pdf
John is suffering from fifth disease.It is caused by an airborne v.pdfanupamfootwear John is suffering from fifth disease.
It is caused by an airborne virus called parvovirus B19. It causes a red rash on children\'s arms,
legs and cheeks and hence it is also known as \"slapped cheek disease\". It is more common in
children, but it can be more severe for pregnant women or anyone with a compromised immune
system. For children with healthy immune systems, fifth disease is a common, mild illness that
rarely presents lasting consequences.
John can go to kindergarden- in the initial stages of this disease the symptoms such as headache,
sore throat, running nose etc are seen, most young people develop a red rash that frist appears on
cheeks, the rash often spreads to the arms, legs and trunk of the body within a few days. The rash
may last for weeks, but usually by the time you see it you\'re no longer contagious.
This infection is common among school age children but is rare in infants and adults
Measles
A paramyxovirus causes the disease, it usually begins with nasal congestion, eye redness,
swelling and tearing, cough, lethargy and high fever. On the third or fourth day of the illness, the
child will develop a red rash on the face, which dpreads rapidly and lasts about 7 days. A
measles rash, which appears as red, itchy bumps, commonly develops on the head and slowly
spreads to other parts of the body.
Solution
John is suffering from fifth disease.
It is caused by an airborne virus called parvovirus B19. It causes a red rash on children\'s arms,
legs and cheeks and hence it is also known as \"slapped cheek disease\". It is more common in
children, but it can be more severe for pregnant women or anyone with a compromised immune
system. For children with healthy immune systems, fifth disease is a common, mild illness that
rarely presents lasting consequences.
John can go to kindergarden- in the initial stages of this disease the symptoms such as headache,
sore throat, running nose etc are seen, most young people develop a red rash that frist appears on
cheeks, the rash often spreads to the arms, legs and trunk of the body within a few days. The rash
may last for weeks, but usually by the time you see it you\'re no longer contagious.
This infection is common among school age children but is rare in infants and adults
Measles
A paramyxovirus causes the disease, it usually begins with nasal congestion, eye redness,
swelling and tearing, cough, lethargy and high fever. On the third or fourth day of the illness, the
child will develop a red rash on the face, which dpreads rapidly and lasts about 7 days. A
measles rash, which appears as red, itchy bumps, commonly develops on the head and slowly
spreads to other parts of the body..
Ad
Recently uploaded (20)
"Basics of Heterocyclic Compounds and Their Naming Rules"
"Basics of Heterocyclic Compounds and Their Naming Rules"rupalinirmalbpharm This video is about heterocyclic compounds, which are chemical compounds with rings that include atoms like nitrogen, oxygen, or sulfur along with carbon. It covers:
Introduction – What heterocyclic compounds are.
Prefix for heteroatom – How to name the different non-carbon atoms in the ring.
Suffix for heterocyclic compounds – How to finish the name depending on the ring size and type.
Nomenclature rules – Simple rules for naming these compounds the right way.
Common rings – Examples of popular heterocyclic compounds used in real life.
K12 Tableau Tuesday - Algebra Equity and Access in Atlanta Public Schools
K12 Tableau Tuesday - Algebra Equity and Access in Atlanta Public Schoolsdogden2 Algebra 1 is often described as a “gateway” class, a pivotal moment that can shape the rest of a student’s K–12 education. Early access is key: successfully completing Algebra 1 in middle school allows students to complete advanced math and science coursework in high school, which research shows lead to higher wages and lower rates of unemployment in adulthood.
Learn how The Atlanta Public Schools is using their data to create a more equitable enrollment in middle school Algebra classes.
How to track Cost and Revenue using Analytic Accounts in odoo Accounting, App...
How to track Cost and Revenue using Analytic Accounts in odoo Accounting, App...Celine George Analytic accounts are used to track and manage financial transactions related to specific projects, departments, or business units. They provide detailed insights into costs and revenues at a granular level, independent of the main accounting system. This helps to better understand profitability, performance, and resource allocation, making it easier to make informed financial decisions and strategic planning.
World war-1(Causes & impacts at a glance) PPT by Simanchala Sarab(BABed,sem-4...
World war-1(Causes & impacts at a glance) PPT by Simanchala Sarab(BABed,sem-4...larencebapu132 This is short and accurate description of World war-1 (1914-18)
It can give you the perfect factual conceptual clarity on the great war
Regards Simanchala Sarab
Student of BABed(ITEP, Secondary stage)in History at Guru Nanak Dev University Amritsar Punjab 🙏🙏
pulse ppt.pptx Types of pulse , characteristics of pulse , Alteration of pulse
pulse ppt.pptx Types of pulse , characteristics of pulse , Alteration of pulsesushreesangita003 what is pulse ?
Purpose
physiology and Regulation of pulse
Characteristics of pulse
factors affecting pulse
Sites of pulse
Alteration of pulse
for BSC Nursing 1st semester
for Gnm Nursing 1st year
Students .
vitalsign
How to Manage Purchase Alternatives in Odoo 18
How to Manage Purchase Alternatives in Odoo 18Celine George Managing purchase alternatives is crucial for ensuring a smooth and cost-effective procurement process. Odoo 18 provides robust tools to handle alternative vendors and products, enabling businesses to maintain flexibility and mitigate supply chain disruptions.
Presentation on Tourism Product Development By Md Shaifullar Rabbi
Presentation on Tourism Product Development By Md Shaifullar RabbiMd Shaifullar Rabbi Presentation on Tourism Product Development By Md Shaifullar Rabbi, Assistant Manager- SABRE Bangladesh.
Link your Lead Opportunities into Spreadsheet using odoo CRM
Link your Lead Opportunities into Spreadsheet using odoo CRMCeline George In Odoo 17 CRM, linking leads and opportunities to a spreadsheet can be done by exporting data or using Odoo’s built-in spreadsheet integration. To export, navigate to the CRM app, filter and select the relevant records, and then export the data in formats like CSV or XLSX, which can be opened in external spreadsheet tools such as Excel or Google Sheets.
Biophysics Chapter 3 Methods of Studying Macromolecules.pdf
Biophysics Chapter 3 Methods of Studying Macromolecules.pdfPKLI-Institute of Nursing and Allied Health Sciences Lahore , Pakistan. This chapter provides an in-depth overview of the viscosity of macromolecules, an essential concept in biophysics and medical sciences, especially in understanding fluid behavior like blood flow in the human body.
Key concepts covered include:
✅ Definition and Types of Viscosity: Dynamic vs. Kinematic viscosity, cohesion, and adhesion.
⚙️ Methods of Measuring Viscosity:
Rotary Viscometer
Vibrational Viscometer
Falling Object Method
Capillary Viscometer
🌡️ Factors Affecting Viscosity: Temperature, composition, flow rate.
🩺 Clinical Relevance: Impact of blood viscosity in cardiovascular health.
🌊 Fluid Dynamics: Laminar vs. turbulent flow, Reynolds number.
🔬 Extension Techniques:
Chromatography (adsorption, partition, TLC, etc.)
Electrophoresis (protein/DNA separation)
Sedimentation and Centrifugation methods.
Understanding P–N Junction Semiconductors: A Beginner’s Guide
Understanding P–N Junction Semiconductors: A Beginner’s GuideGS Virdi Dive into the fundamentals of P–N junctions, the heart of every diode and semiconductor device. In this concise presentation, Dr. G.S. Virdi (Former Chief Scientist, CSIR-CEERI Pilani) covers:
What Is a P–N Junction? Learn how P-type and N-type materials join to create a diode.
Depletion Region & Biasing: See how forward and reverse bias shape the voltage–current behavior.
V–I Characteristics: Understand the curve that defines diode operation.
Real-World Uses: Discover common applications in rectifiers, signal clipping, and more.
Ideal for electronics students, hobbyists, and engineers seeking a clear, practical introduction to P–N junction semiconductors.
Operations Management (Dr. Abdulfatah Salem).pdf
Operations Management (Dr. Abdulfatah Salem).pdfArab Academy for Science, Technology and Maritime Transport This version of the lectures is provided free of charge to graduate students studying the Operations Management course at the MBA level.
Introduction-to-Communication-and-Media-Studies-1736283331.pdf
Introduction-to-Communication-and-Media-Studies-1736283331.pdfjames5028 Introduction-to-Communication and media studies
How to Manage Opening & Closing Controls in Odoo 17 POS
How to Manage Opening & Closing Controls in Odoo 17 POSCeline George In Odoo 17 Point of Sale, the opening and closing controls are key for cash management. At the start of a shift, cashiers log in and enter the starting cash amount, marking the beginning of financial tracking. Throughout the shift, every transaction is recorded, creating an audit trail.
Introduction to Vibe Coding and Vibe Engineering
Introduction to Vibe Coding and Vibe EngineeringDamian T. Gordon Introduction to Vibe Coding and Vibe Engineering
To study Digestive system of insect.pptx
To study Digestive system of insect.pptxArshad Shaikh Education is one thing no one can take away from you.”
Real GitHub Copilot Exam Dumps for Success
Real GitHub Copilot Exam Dumps for SuccessMark Soia Download updated GitHub Copilot exam dumps to boost your certification success. Get real exam questions and verified answers for guaranteed performance
Odoo Inventory Rules and Routes v17 - Odoo Slides
Odoo Inventory Rules and Routes v17 - Odoo SlidesCeline George Odoo's inventory management system is highly flexible and powerful, allowing businesses to efficiently manage their stock operations through the use of Rules and Routes.
Biophysics Chapter 3 Methods of Studying Macromolecules.pdf
Biophysics Chapter 3 Methods of Studying Macromolecules.pdfPKLI-Institute of Nursing and Allied Health Sciences Lahore , Pakistan.
Operations Management (Dr. Abdulfatah Salem).pdf
Operations Management (Dr. Abdulfatah Salem).pdfArab Academy for Science, Technology and Maritime Transport
Ad
Quicksort AlgorithmQuicksort is a divide and conquer algorithm. Q.pdf
- 1. Quicksort Algorithm: Quicksort is a divide and conquer algorithm. Quicksort first divides a large array into two smaller sub-arrays: the low elements and the high elements. Quicksort can then recursively sort the sub-arrays. The steps are: The base case of the recursion is arrays of size zero or one, which never need to be sorted. The pivot selection and partitioning steps can be done in several different ways; the choice of specific implementation schemes greatly affects the algorithm's performance. This algorithm is based on Divide and Conquer paradigm. It is implemented using merge sort. In this approach the time complexity will be O(n log(n)) . Actually in divide step we divide the problem in two parts. And then two parts are solved recursively. The key concept is two count the number of inversion in merge procedure. In merge procedure we pass two sub-list. The element is sorted and inversion is found as follows a)Divide : Divide the array in two parts a[0] to a[n/2] and a[n/2+1] to a[n]. b)Conquer : Conquer the sub-problem by solving them recursively. 1) Set count=0,0,i=left,j=mid. C is the sorted list. 2) Traverse list1 and list2 until mid element or right element is encountered . 3) Compare list1[i] and list[j]. i) If list1[i]<=list2[j] c[k++]=list1[i++] else c[k++]=list2[j++] count = count + mid-i; 4) add rest elements of list1 and list2 in c. 5) copy sorted list c back to original list. 6) return count. void quickSort(int arr[], int left, int right) { int i = left, j = right; int tmp; int pivot = arr[(left + right) / 2]; /* partition */ while (i <= j) { while (arr[i] < pivot) i++; while (arr[j] > pivot)
- 2. j--; if (i <= j) { tmp = arr[i]; arr[i] = arr[j]; arr[j] = tmp; i++; j--; } }; /* recursion */ if (left < j) quickSort(arr, left, j); if (i < right) quickSort(arr, i, right); } Solution Quicksort Algorithm: Quicksort is a divide and conquer algorithm. Quicksort first divides a large array into two smaller sub-arrays: the low elements and the high elements. Quicksort can then recursively sort the sub-arrays. The steps are: The base case of the recursion is arrays of size zero or one, which never need to be sorted. The pivot selection and partitioning steps can be done in several different ways; the choice of specific implementation schemes greatly affects the algorithm's performance. This algorithm is based on Divide and Conquer paradigm. It is implemented using merge sort. In this approach the time complexity will be O(n log(n)) . Actually in divide step we divide the problem in two parts. And then two parts are solved recursively. The key concept is two count the number of inversion in merge procedure. In merge procedure we pass two sub-list. The element is sorted and inversion is found as follows a)Divide : Divide the array in two parts a[0] to a[n/2] and a[n/2+1] to a[n]. b)Conquer : Conquer the sub-problem by solving them recursively. 1) Set count=0,0,i=left,j=mid. C is the sorted list. 2) Traverse list1 and list2 until mid element or right element is encountered . 3) Compare list1[i] and list[j].
- 3. i) If list1[i]<=list2[j] c[k++]=list1[i++] else c[k++]=list2[j++] count = count + mid-i; 4) add rest elements of list1 and list2 in c. 5) copy sorted list c back to original list. 6) return count. void quickSort(int arr[], int left, int right) { int i = left, j = right; int tmp; int pivot = arr[(left + right) / 2]; /* partition */ while (i <= j) { while (arr[i] < pivot) i++; while (arr[j] > pivot) j--; if (i <= j) { tmp = arr[i]; arr[i] = arr[j]; arr[j] = tmp; i++; j--; } }; /* recursion */ if (left < j) quickSort(arr, left, j); if (i < right) quickSort(arr, i, right); }