AS-2_L19-20

Cour Allotte Cour Cour
Semest Course Course se d se se

ClassNbr Slot
er Code Title Typ Progra Mod Syst
e m e em
Design
and
Winter Analysis VL2023240504 L19+L
BCSE204P ELA UGS LBC CAL
2023-24 of 931 20
Algorith
ms
Student Details: Student Name:
Roll/Reg No:
Email:
Mobile:
Faculty Details: Faculty Name: VENKATA PHANIKRISHNA B
School: SCOPE
Email: Venkata.phanikrishna@vit.ac.in
As.No. 2
Assessment Title. Divide and Conquer
Date of Submission 08-Feb-2024
Questions:
Write programs for the following problems using Divide and Conquer:
1. Maximum Subarray
2. Karatsuba faster integer multiplication algorithm
Question 1 Write programs for the Maximum Subarray using Divide and Conquer
Program or import java.util.Arrays;
Related import java.util.Scanner;
Content //22bci0092
//Sneh Patel
public class MaximumSubarray {
public static void main(String[] args) {

Scanner scanner = new Scanner(System.in);
String userInput = scanner.nextLine();
String[] inputArray = userInput.replaceAll("[\\[\\]]", "").split("\\s*,\\s*");

int[] numbers = Arrays.stream(inputArray)
.mapToInt(Integer::parseInt)
.toArray();
int[] result = findMaximumSubarray(numbers, 0, numbers.length - 1);
System.out.println("The Maximum Subarray is " + Arrays.toString(result) +

" with a max sum of=" + calculateSum(result));
}
private static int[] findMaximumSubarray(int[] numbers, int low, int high) {

if (low == high) {
return new int[]{numbers[low]};
}
int mid = (low + high) / 2;
int[] leftSubarray = findMaximumSubarray(numbers, low, mid);

int[] rightSubarray = findMaximumSubarray(numbers, mid + 1, high);
int[] crossingSubarray = findMaxCrossingSubarray(numbers, low, mid,
high);
if (calculateSum(leftSubarray) >= calculateSum(rightSubarray) &&

calculateSum(leftSubarray) >= calculateSum(crossingSubarray)) {
return leftSubarray;
} else if (calculateSum(rightSubarray) >= calculateSum(leftSubarray) &&
calculateSum(rightSubarray) >= calculateSum(crossingSubarray)) {
return rightSubarray;
} else {
return crossingSubarray;
}
}
private static int[] findMaxCrossingSubarray(int[] numbers, int low, int mid, int
high) {
int leftMaxSum = Integer.MIN_VALUE;
int sum = 0;
int maxLeft = 0;
for (int i = mid; i >= low; i--) {

sum += numbers[i];
if (sum > leftMaxSum) {
leftMaxSum = sum;
maxLeft = i;
}
}
int rightMaxSum = Integer.MIN_VALUE;

sum = 0;
int maxRight = 0;
for (int i = mid + 1; i <= high; i++) {

sum += numbers[i];
if (sum > rightMaxSum) {
rightMaxSum = sum;
maxRight = i;
}
}
int[] result = new int[maxRight - maxLeft + 1];

System.arraycopy(numbers, maxLeft, result, 0, result.length);
return result;
}
private static int calculateSum(int[] numbers) {
int sum = 0;
for (int num : numbers) {
sum += num;
}
return sum;
}
}
//Sneh Patel
//22BCI0092
Output: Case=f1
input=[3,-1,-1,10,-3,-2,4]
output=The Maximum Subarray is [3,-1,-1,10] with a max sum of=11
Your The code efficiently finds the maximum subarray using divide and conquer. It
Observation handles input, recursively divides arrays, calculates subarray sums, and outputs
the maximum subarray with its sum.
Question 2 Write programs for the Karatsuba faster integer multiplication algorithm using Divide
and Conquer
Program or import java.util.Scanner;
Related //22bci0092
Content //Sneh Patel
public class KaratsubaAlgorithm {
public static int karatsuba(int x, int y) {

if (String.valueOf(x).length() == 1 || String.valueOf(y).length() == 1) {
return x * y;
} else {
int n = Math.max(String.valueOf(x).length(), String.valueOf(y).length());
int m = n / 2;
int a = Integer.parseInt(String.valueOf(x).substring(0, m));

int b = Integer.parseInt(String.valueOf(x).substring(m));
int c = Integer.parseInt(String.valueOf(y).substring(0, m));
int d = Integer.parseInt(String.valueOf(y).substring(m));
int ac = karatsuba(a, c);

int bd = karatsuba(b, d);
int ad_plus_bc = karatsuba(a + b, c + d) - ac - bd;
int prod = ac * (int) Math.pow(10, 2 * m) + ad_plus_bc * (int)

Math.pow(10, m) + bd;
return prod;
}
}
public static void main(String[] args) {

Scanner scanner = new Scanner(System.in);
System.out.print("Enter the first number: ");

String a = scanner.nextLine();
System.out.print("Enter the second number: ");
String b = scanner.nextLine();
int numDigitsA = a.length();

int numDigitsB = b.length();
if (numDigitsA != numDigitsB) {
System.out.println("To apply Karatsuba faster integer multiplication, the

number of digits in multiplicand and multiplier must be equal and it must be a
power of 2.");
a += "00";
b += "0";
System.out.println("After conversion, the numbers become " + a + " and "
+ b + ".\n");
} else {
if (numDigitsA != 2 && numDigitsA != 4) {
System.out.println("To apply Karatsuba faster integer multiplication, the
number of digits in multiplicand and multiplier must be a power of 2.");
a += "0";
b += "0";
System.out.println("After conversion, the numbers become " + a + " and
" + b + ".\n");
}
}
int result = karatsuba(Integer.parseInt(a), Integer.parseInt(b));
if (a.length() == 2) {
System.out.println("With the brute-force approach, the required number of
multiplications is: 4");
System.out.println("With Karatsuba faster integer multiplication, the
required number of multiplications is: 3");
System.out.println("Result: " + result);
} else {
System.out.println("With the brute-force approach, the required number of
multiplications is: 16");
System.out.println("With Karatsuba faster integer multiplication, the
required number of multiplications is: 9");
System.out.println("Result: " + result);
}
scanner.close();
}
}
//22BCI0092
//SNEH patel
Output: Case 1:
Input:
Entermultiplicand:15
Entermultiplier:14
Output:
With brute force approach, the required number of multiplications is: 4
With Karatsuba faster integer multiplication, the required number of multiplications is: 3
Result: 210
Case 2:
Input:
Enter multiplicand: 253
Enter multiplier: 123
Output:
To apply Karatsuba faster integer multiplication, the number of digits in
multiplicand and multiplier must be a power of 2.
After conversion, the numbers become 2530 and 1230.
With the brute-force approach, the required number of multiplications is: 16

With Karatsuba faster integer multiplication, the required number of
multiplications is: 9
Result: 3111900
//22BCI0092
//Sneh Patel
Your The Karatsuba algorithm efficiently multiplies large numbers by recursively
Observation dividing them, reducing the number of multiplications needed, enhancing
computational efficiency for integer multiplication.

AS-2_L19-20

Uploaded by

Copyright:

Available Formats

AS-2_L19-20

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

AS-2_L19-20

Uploaded by

Copyright:

Available Formats

Cour Allotte Cour Cour

Semest Course Course se d se se

public static void main(String[] args) {

String userInput = scanner.nextLine();

String[] inputArray = userInput.replaceAll("[\\[\\]]", "").split("\\s*,\\s*");

int[] result = findMaximumSubarray(numbers, 0, numbers.length - 1);

System.out.println("The Maximum Subarray is " + Arrays.toString(result) +

private static int[] findMaximumSubarray(int[] numbers, int low, int high) {

int mid = (low + high) / 2;

int[] leftSubarray = findMaximumSubarray(numbers, low, mid);

if (calculateSum(leftSubarray) >= calculateSum(rightSubarray) &&

for (int i = mid; i >= low; i--) {

int rightMaxSum = Integer.MIN_VALUE;

for (int i = mid + 1; i <= high; i++) {

int[] result = new int[maxRight - maxLeft + 1];

private static int calculateSum(int[] numbers) {

public static int karatsuba(int x, int y) {

int a = Integer.parseInt(String.valueOf(x).substring(0, m));

int ac = karatsuba(a, c);

int prod = ac * (int) Math.pow(10, 2 * m) + ad_plus_bc * (int)

public static void main(String[] args) {

System.out.print("Enter the first number: ");

int numDigitsA = a.length();

System.out.println("To apply Karatsuba faster integer multiplication, the

int result = karatsuba(Integer.parseInt(a), Integer.parseInt(b));

With the brute-force approach, the required number of multiplications is: 16

You might also like

String[] inputArray = userInput.replaceAll("[\\[\\]]", "").split("\\s,\\s");