For Non-CS - Module 1 - Lab 1 - Java

Time Conversion

import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;

public class Main {

public static void main(String[] args) {
Scanner input = new Scanner(System.in);

if (input.hasNext()) {
String x = input.next();
System.out.println(doSomething(x));
} else {
System.out.println("No input provided");
}
}

public static String doSomething(String x) {

try {
DateFormat inputFormat = new SimpleDateFormat("hh:mm:ssa");
Date date = inputFormat.parse(x);
DateFormat outputFormat = new SimpleDateFormat("HH:mm:ss");
String militaryTime = outputFormat.format(date);
return militaryTime;
} catch (ParseException e) {
return "error";
}
}
}
Reverse a string

import java.util.Scanner;

public class Main{

public static String reverseStringWithPreservation(String input) {

char[] characters = input.toCharArray();
int left = 0, right = characters.length - 1;

while (left < right) {

if (!Character.isLetter(characters[left])) {
left++;
} else if (!Character.isLetter(characters[right])) {
right--;
} else {
char temp = characters[left];
characters[left] = characters[right];
characters[right] = temp;
left++;
right--;
}
}

return new String(characters);

}

public static void main(String[] args) {

Scanner scanner = new Scanner(System.in);
String input = scanner.nextLine();

String output = reverseStringWithPreservation(input);

System.out.println(output);

scanner.close();
}
}
For Non-CS - Module 1 - Lab 2 - Java
Sort Colors
import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;
public class Main {
public static void sortColors(int[] nums) {
sort(nums,0,nums.length-1);
}
public static void sort(int[] nums,int low,int high) {
if(low>=high) {
return;
}
int s = low;
int e = high;
int m= s + (e-s)/2;
int pivot = nums[m];
while(s<=e) {
while(nums[s]<pivot) {
s++;
}
while(nums[e]>pivot) {
e--;
}
if(s<=e) {
int temp = nums[s];
nums[s]=nums[e];
nums[e]=temp;
s++;
e--;
}
}
sort(nums,low,e);
sort(nums,s,high);
}
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String input = sc.nextLine();
String[] numStrings = input.split("\\s+");
int[] nums = new int[numStrings.length];
for (int i = 0; i < numStrings.length; i++) {
nums[i] = Integer.parseInt(numStrings[i]);
}
sortColors(nums);
for (int num : nums) {
System.out.print(num + " ");
}
}
}
Restore IP Addresses

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class Main{

public static List<String> restoreIpAddresses(String s) {

List<String> result = new ArrayList<>();
backtrack(s, 0, new ArrayList<>(), result);
return result;
}

private static void backtrack(String s, int start, List<String> current, List<String> result) {
if (start == s.length() && current.size() == 4) {
result.add(String.join(".", current));
return;
}

for (int end = start + 1; end <= s.length() && end <= start + 3; end++) {
String segment = s.substring(start, end);

if (isValidSegment(segment)) {
current.add(segment);
backtrack(s, end, current, result);
current.remove(current.size() - 1);
}
}
}

private static boolean isValidSegment(String segment) {

if (segment.length() > 1 && segment.charAt(0) == '0') {
return false; // Avoid leading zeros
}

int value = Integer.parseInt(segment);

return value >= 0 && value <= 255;
}
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
String input = scanner.nextLine();

List<String> result = restoreIpAddresses(input);

for (String ipAddress : result) {
System.out.println(ipAddress);
}
scanner.close();
}
}
For Non-CS - Module 2 - Lab 1 - Java
Integer to Roman

import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
public class Main {
public static int romanToInt(String s) {
Map<Character, Integer> romanMap = new HashMap<>();
romanMap.put('I', 1);
romanMap.put('V', 5);
romanMap.put('X', 10);
romanMap.put('L', 50);
romanMap.put('C', 100);
romanMap.put('D', 500);
romanMap.put('M', 1000);
int result = 0;
for (int i = 0; i < s.length(); i++) {
int current = romanMap.get(s.charAt(i));
if (i < s.length() - 1) {
int next = romanMap.get(s.charAt(i + 1));
if (current < next) {
result += (next - current);
i++;
continue;
}
}

result += current;
}

return result;
}

public static void main(String[] args) {

Scanner scanner = new Scanner(System.in);

String romanNumeral = scanner.nextLine();

int result = romanToInt(romanNumeral);

System.out.println(result);
}
}
Generate Brackets
import java.util.ArrayList;
import java.util.List;
public class Main{
public static List<String> generateParenthesis(int n) {
List<String> result = new ArrayList<>();
generate(result, "", 0, 0, n);
return result;
}

private static void generate(List<String> result, String current, int open, int close, int n) {
if (current.length() == 2 * n) {
result.add(current);
return;
}

if (open < n) {
generate(result, current + "(", open + 1, close, n);
}

if (close < open) {

generate(result, current + ")", open, close + 1, n);
}
}

public static void main(String[] args) {

int n = 2;
List<String> combinations = generateParenthesis(n);

// Format output as a string

StringBuilder output = new StringBuilder();
for (String combination : combinations) {
output.append(combination).append(",");
}

// Remove the trailing comma

if (output.length() > 0) {
output.deleteCharAt(output.length() - 1);
}

System.out.println(output.toString());
}
}
For Non-CS - Module 2 - Lab 2 - Java
Closest Triples

import java.util.Arrays;
import java.util.Scanner;

public class Main {

public static int threeSumClosest(int[] nums, int target) {

Arrays.sort(nums);
int closestSum = nums[0] + nums[1] + nums[2];

for (int i = 0; i < nums.length - 2; i++) {

int left = i + 1;
int right = nums.length - 1;

while (left < right) {

int currentSum = nums[i] + nums[left] + nums[right];

if (Math.abs(currentSum - target) < Math.abs(closestSum - target)) {

closestSum = currentSum;
}

if (currentSum < target) {

left++;
} else {
right--;
}
}
}

return closestSum;
}

public static void main(String[] args) {

Scanner scanner = new Scanner(System.in);

String input = scanner.nextLine();

String[] inputArray = input.split(" ");
int[] nums = Arrays.stream(inputArray).mapToInt(Integer::parseInt).toArray();

String targetStr = scanner.next();

int target = Integer.parseInt(targetStr);

int result = threeSumClosest(nums, target);

System.out.print(result);
scanner.close();
}
}
Combination Sum

import java.util.Arrays;
import java.util.Scanner;

public class ThreeSumClosest {

public static int threeSumClosest(int[] nums, int target) {

Arrays.sort(nums);
int closestSum = nums[0] + nums[1] + nums[2];

for (int i = 0; i < nums.length - 2; i++) {

int left = i + 1;
int right = nums.length - 1;

while (left < right) {

int currentSum = nums[i] + nums[left] + nums[right];

if (Math.abs(currentSum - target) < Math.abs(closestSum - target)) {

closestSum = currentSum;
}

if (currentSum < target) {

left++;
} else {
right--;
}
}
}

return closestSum;
}

public static void main(String[] args) {

Scanner scanner = new Scanner(System.in);

System.out.println("Enter the elements of the array separated by spaces:");

String input = scanner.nextLine();
String[] inputArray = input.split(" ");
int[] nums = Arrays.stream(inputArray).mapToInt(Integer::parseInt).toArray();

System.out.println("Enter the target:");

int target = scanner.nextInt();
int result = threeSumClosest(nums, target);
System.out.println("Input: " + Arrays.toString(nums));
System.out.println("Target: " + target);
System.out.println("Output: " + result);
scanner.close();
}
}
For Non-CS - Module 3 - Lab 1 - Java
Word Search
import java.util.Scanner;
public class Main{
public static boolean exist(char[][] board, String word) {
if (board == null || board.length == 0 || board[0].length == 0 || word == null || word.length() == 0)
{
return false;
}
int m = board.length;
int n = board[0].length;
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
if (dfs(board, word, i, j, 0)) {
return true;
}
}
}
return false;
}
private static boolean dfs(char[][] board, String word, int i, int j, int k) {
int m = board.length;
int n = board[0].length;
if (i < 0 || i >= m || j < 0 || j >= n || board[i][j] != word.charAt(k)) {
return false;
}
if (k == word.length() - 1) {
return true;
}
char temp = board[i][j];
board[i][j] = '#'; // mark the cell as visited
boolean found = dfs(board, word, i + 1, j, k + 1) ||
dfs(board, word, i - 1, j, k + 1) ||
dfs(board, word, i, j + 1, k + 1) ||
dfs(board, word, i, j - 1, k + 1);
board[i][j] = temp; // restore the cell
return found;
}
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int m = scanner.nextInt();
int n = scanner.nextInt();
String targetWord = scanner.next();
char[][] grid = new char[m][n];
for (int i = 0; i < m; i++) {
String row = scanner.next();
grid[i] = row.toCharArray();
}
boolean result = exist(grid, targetWord);
System.out.print(result ? "Yes" : "No");
scanner.close();
}
}
Jump Game

import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
try {
String[] inputArray = scanner.nextLine().split(" ");
int[] nums = new int[inputArray.length];
for (int i = 0; i < inputArray.length; i++) {
nums[i] = Integer.parseInt(inputArray[i]);
}
boolean canJump = canJump(nums);
System.out.println(canJump);
} catch (Exception e) {
System.out.println("An error occurred: " + e.getMessage());
} finally {
scanner.close();
}
}
public static boolean canJump(int[] nums) {
int lastGoodPosition = nums.length - 1;
for (int i = nums.length - 1; i >= 0; i--) {
if (i + nums[i] >= lastGoodPosition) {
lastGoodPosition = i;
}
}
return lastGoodPosition == 0;
}
}
For Non-CS - Module 3 - Lab 2 - Java
Find the Longest Substring
import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;
class Main {
static void longestSubstring(String s){

HashMap<String, Integer> indexes = new HashMap<>();

HashMap<Character, Integer> chars = new HashMap<>(){{
put('a', 0);put('e', 1);
put('i', 2);put('o', 3);
put('u', 4);
}} ;
String evenOdd = "00000";
indexes.put(evenOdd , -1);
int length = 0;
for (int i = 0; i < s.length(); ++i) {

char c = s.charAt(i);
boolean it = chars.containsKey(c);
if (it != false) {
if(evenOdd.charAt(chars.get(c)) == '0'){
evenOdd = evenOdd.substring(0,chars.get(c)) + '1' + evenOdd.substring(chars.get(c)+1);
}
else{
evenOdd = evenOdd.substring(0,chars.get(c)) + '0' + evenOdd.substring(chars.get(c)+1);
}
}
boolean lastIndex = indexes.containsKey(evenOdd);
if (lastIndex == false) {
indexes.put(evenOdd, i);
}
else {
length = Math.max(length, i - indexes.get(evenOdd));
}
}
System.out.print(length);
}
public static void main(String args[])
{
// Given Input
Scanner sc=new Scanner(System.in);
String S = sc.next();
longestSubstring(S);
}
}
Mini Max
import java.util.Arrays;
import java.util.ArrayList;
import java.util.Scanner;

public class Main{

public static void main(String[] args) {

Scanner scanner = new Scanner(System.in);

ArrayList<Long> numbers = new ArrayList<>();

// Read input until a non-positive integer is encountered

while (scanner.hasNextLong()) {
long input = scanner.nextLong();
if (input <= 0) {
break;
}
numbers.add(input);
}

// Check if there are at least 4 numbers

if (numbers.size() < 4) {
System.out.println("Insufficient numbers to calculate min and max sums.");
} else {
// Sort the numbers
Object[] sortedNumbers = numbers.toArray();
Arrays.sort(sortedNumbers);

long minSum = 0;
for (int i = 0; i < 4; i++) {
minSum += (Long) sortedNumbers[i];
}

long maxSum = 0;
for (int i = numbers.size() - 4; i < numbers.size(); i++) {
maxSum += (Long) sortedNumbers[i];
}

System.out.println(minSum + " " + maxSum);

}

scanner.close();
}
}
For Non-CS - Module 4 - Lab 1 - Java

Counting Sort 1

import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

public class Main {

public static void main(String[] args) {

Scanner scanner = new Scanner(System.in);

try {

int n = scanner.nextInt();
int[] nums = new int[n];
for (int i = 0; i < n; i++) {
nums[i] = scanner.nextInt();
}
int[] sortedArray = Arrays.copyOf(nums, nums.length);
Arrays.sort(sortedArray);
Map<Integer, Integer> frequencyMap = findFrequency(sortedArray);
for (int i = 0; i <= getMax(nums); i++) {
System.out.print(frequencyMap.getOrDefault(i, 0) + " ");
}
} catch (Exception e) {
System.out.println("An error occurred: " + e.getMessage());
} finally {
scanner.close();
}
}
public static Map<Integer, Integer> findFrequency(int[] nums) {
Map<Integer, Integer> frequencyMap = new HashMap<>();

for (int num : nums) {

frequencyMap.put(num, frequencyMap.getOrDefault(num, 0) + 1);
}
return frequencyMap;
}
public static int getMax(int[] nums) {
int max = nums[0];
for (int num : nums) {
max = Math.max(max, num);
}
return max;
}
}
000G Cipher JAVA

import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

public class Main {

private static final Map<Character, Character> substitutionCipher = new HashMap<>();

static {
// Initialize the substitution cipher
substitutionCipher.put('A', 'Z');
substitutionCipher.put('B', 'Y');
substitutionCipher.put('C', 'X');
substitutionCipher.put('D', 'W');
substitutionCipher.put('E', 'V');
substitutionCipher.put('F', 'U');
substitutionCipher.put('G', 'T');
substitutionCipher.put('H', 'S');
substitutionCipher.put('I', 'R');
substitutionCipher.put('J', 'Q');
substitutionCipher.put('K', 'P');
substitutionCipher.put('L', 'O');
substitutionCipher.put('M', 'N');
substitutionCipher.put('N', 'M');
substitutionCipher.put('O', 'L');
substitutionCipher.put('P', 'K');
substitutionCipher.put('Q', 'J');
substitutionCipher.put('R', 'I');
substitutionCipher.put('S', 'H');
substitutionCipher.put('T', 'G');
substitutionCipher.put('U', 'F');
substitutionCipher.put('V', 'E');
substitutionCipher.put('W', 'D');
substitutionCipher.put('X', 'C');
substitutionCipher.put('Y', 'B');
substitutionCipher.put('Z', 'A');
}

public static String encrypt(String word, int key, String operation) {

if (!operation.equals("addition") && !operation.equals("subtraction")) {
return "Invalid Operation";
}

StringBuilder result = new StringBuilder();

for (char ch : word.toCharArray()) {

if (!Character.isUpperCase(ch)) {
return "Word should be in capitals";
}
 char encryptedChar = ch;

if (substitutionCipher.containsKey(ch)) {
char substitutedChar = substitutionCipher.get(ch);
int asciiValue = (int) substitutedChar;

if (operation.equals("addition")) {
asciiValue += key;
} else {
asciiValue -= key;
}

encryptedChar = (char) asciiValue;

}

result.append(encryptedChar);
}

return result.toString();
}

public static void main(String[] args) {

Scanner scanner = new Scanner(System.in);

if (!scanner.hasNextInt()) {
return;
}

int key = scanner.nextInt();

String operation = scanner.next();

String word = scanner.next();

String result = encrypt(word, key, operation);

System.out.print(result);

scanner.close();
}
}
For Non-CS - Module 4 - Lab 2 - Java
Tower Breakers

import java.util.Scanner;
public class Main{
public static int towerGameWinner(int n, int m) {
// If there is only one tower, Player 1 wins
if (n == 1) {
return 1;
}
// If the height of each tower is 1, Player 1 wins
if (m == 1) {
return 1;
}
// If the height of any tower is even, Player 2 wins
if (m % 2 == 0) {
return 2;
}
// If none of the above conditions are met, Player 1 wins
return 1;
}
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int n = scanner.nextInt();
int m = scanner.nextInt();
int winner = towerGameWinner(n, m);
System.out.print(winner);
scanner.close();
}
}
Grid Challenge

import java.util.Arrays;
import java.util.Scanner;

public class Main {

public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String input = sc.nextLine();
System.out.println(checkGrid(input));
sc.close();
}

static String checkGrid(String input) {

String[] parts = input.split(" ");
int rowsCols = Integer.parseInt(parts[0].split(",")[1]);

char[][] grid = new char[rowsCols][rowsCols];

String[] elements = parts[1].split(",");

int k = 1;
/*for(int i=1;i<4;i++){
System.out.println(elements[i]);
}*/

// Fill the grid with characters

for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
grid[i][j] = elements[k].charAt(0);
}
k++;
}

// Check if rows are sorted

for (int i = 0; i < rowsCols; i++) {
Arrays.sort(grid[i]);
}

// Check if columns are sorted

for (int j = 0; j < rowsCols; j++) {
for (int i = 0; i < rowsCols - 1; i++) {
if (grid[i][j] > grid[i + 1][j]) {
return "NO";
}
}
}

return "YES";
}
}
Contest 1 module 1
Subsets
import java.util.List;
import java.util.Scanner;

public class Main{

public static List<List<Integer>> generateSubsets(int[] nums) {

List<List<Integer>> result = new ArrayList<>();
generate(nums, 0, new ArrayList<>(), result);
return result;
}

private static void generate(int[] nums, int index, List<Integer> current, List<List<Integer>> result) {
result.add(new ArrayList<>(current));

for (int i = index; i < nums.length; i++) {

current.add(nums[i]);
generate(nums, i + 1, current, result);
current.remove(current.size() - 1);
}
}

public static void main(String[] args) {

Scanner scanner = new Scanner(System.in);

String input = scanner.nextLine();

String[] strNums = input.split("\\s+");

int[] nums = new int[strNums.length];

for (int i = 0; i < strNums.length; i++) {
nums[i] = Integer.parseInt(strNums[i]);
}

List<List<Integer>> subsets = generateSubsets(nums);

for (List<Integer> subset : subsets) {

for (int i = 0; i < subset.size(); i++) {
System.out.print(subset.get(i));
if (i < subset.size() - 1) {
System.out.print(" ");
}
}
System.out.println();
}
}
}
000B Dividing the Kingdom's Gold
import java.util.Scanner;

public class Main{

public static int countValidSplits(int[] gold) {

int totalGold = 0;
for (int g : gold) {
totalGold += g;
}

int northernGold = 0;
int validSplits = 0;

for (int i = 0; i < gold.length - 1; i++) {

northernGold += gold[i];
totalGold -= gold[i];

if (northernGold >= totalGold && totalGold > 0) {

validSplits++;
}
}

return validSplits;
}

public static void main(String[] args) {

Scanner scanner = new Scanner(System.in);

String input = scanner.nextLine();

String[] strGold = input.split("\\s+");

int[] gold = new int[strGold.length];

try {
for (int i = 0; i < strGold.length; i++) {
gold[i] = Integer.parseInt(strGold[i]);
}

int result = countValidSplits(gold);

System.out.println(result);
} catch (NumberFormatException e) {
System.out.println("Input string was not in the correct format");
}
}
}
MODULE 2 Contest
Sum Of Two Integers
import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;

public class Main {

public static void main(String[] args) {

Scanner input = new Scanner(System.in);
int a = input.nextInt();
int b = input.nextInt();
int ret = doSomething(a,b);
System.out.println(ret);
}

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

//Do Something
while (y != 0) {
int carry = x & y;
x = x ^ y;
y = carry << 1;
}
return x;

}
}
Diagonal Difference
import java.util.Scanner;

public class Main {

public static void main(String[] args) {

Scanner input = new Scanner(System.in);
int n = input.nextInt();

int[][] matrix = new int[n][n];

for (int i = 0; i < n; i++) {

for (int j = 0; j < n; j++) {
matrix[i][j] = input.nextInt();
}
}

int ret = doSomething(matrix, n);

System.out.println(ret);
}

public static int doSomething(int[][] matrix, int n) {

int leftToRightSum = 0;
int rightToLeftSum = 0;

for (int i = 0; i < n; i++) {

leftToRightSum += matrix[i][i];
rightToLeftSum += matrix[i][n - 1 - i];
}

return Math.abs(leftToRightSum - rightToLeftSum);

}
}
Module 3 Contest
Letter Tile Possibilities
import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;

public class Main {

public static void main(String[] args) {

Scanner input = new Scanner(System.in);

String tiles = input.nextLine();

int ret = countTilePossibilities(tiles);

System.out.println(ret);
}

public static int countTilePossibilities(String tiles) {

Set<String> possibilities = new HashSet<>();
backtrack("", tiles, possibilities);
return possibilities.size();
}

private static void backtrack(String current, String remaining, Set<String> possibilities) {

if (!current.isEmpty()) {
possibilities.add(current);
}

for (int i = 0; i < remaining.length(); i++) {

String newCurrent = current + remaining.charAt(i);
String newRemaining = remaining.substring(0, i) + remaining.substring(i + 1);
backtrack(newCurrent, newRemaining, possibilities);
}
}
}
Time Conversion
import java.util.Scanner;

public class Main {

public static void main(String[] args) {

Scanner input = new Scanner(System.in);

String time12Hour = input.nextLine();

String convertedTime = convertTo24HourFormat(time12Hour);

System.out.println(convertedTime);
}

public static String convertTo24HourFormat(String time12Hour) {

String[] parts = time12Hour.split(":");
int hour = Integer.parseInt(parts[0]);
String minute = parts[1];
String second = parts[2].substring(0, 2);
String amPm = parts[2].substring(2);

if (amPm.equals("PM") && hour != 12) {

hour += 12;
} else if (amPm.equals("AM") && hour == 12) {
hour = 0;
}

return String.format("%02d:%s:%s", hour, minute, second);

}
}
Module 4 contest
Sum of two integers
import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;

public class Main {

public static void main(String[] args) {

Scanner input = new Scanner(System.in);
int a = input.nextInt();
int b = input.nextInt();
int ret = doSomething(a,b);
System.out.println(ret);
}

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

//Do Something
while (y != 0) {
int carry = x & y;
x = x ^ y;
y = carry << 1;
}
return x;

}
}
Distance of elements :
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

public class Main {

public static void main(String[] args) {

Scanner input = new Scanner(System.in);
String[] strArray = input.nextLine().split("\\s+");
int[] array = new int[strArray.length];

for (int i = 0; i < strArray.length; i++) {

array[i] = Integer.parseInt(strArray[i]);
}

int k = input.nextInt();

String result = doSomething(array, k);

System.out.println(result);
}

public static String doSomething(int[] array, int k) {

Map<Integer, Integer> lastIndexMap = new HashMap<>();

for (int i = 0; i < array.length; i++) {

if (lastIndexMap.containsKey(array[i]) && i - lastIndexMap.get(array[i]) <= k) {
return "Yes";
}
lastIndexMap.put(array[i], i);
}

return "No";
}
}