Merge https://github.com/adityabisoi/ds-algo-solutions into main

Author: anushkasinghal11

Algorithms/Luck Balance/solution.java

@@ -0,0 +1,45 @@
+import java.io.*;
+import java.util.*;
+import java.text.*;
+import java.math.*;
+import java.util.regex.*;
+
+public class Solution { 
+ 
+ public static void main(String[] args) {
+ Scanner input = new Scanner(System.in);
+ ///////Variables//////
+ int n = input.nextInt();
+ int k = input.nextInt();
+ int maxLuck = 0;
+ ArrayList<Integer> importantContests = new ArrayList<>();
+ //////////////////////
+ 
+ //Build list of important contests
+ for(int i = 0; i < n; i++){
+ int luck = input.nextInt();
+ int important = input.nextInt();
+ 
+ if(important != 1)
+ {
+ maxLuck += luck;
+ } 
+ 
+ else
+ importantContests.add(luck);
+ }
+ 
+ //Sort the important contests in descending order
+ Collections.sort(importantContests, Collections.reverseOrder());
+ 
+ //Lose the k largest contests and win the rest
+ for(int i = 0; i < importantContests.size(); i++){
+ if(i < k)
+ maxLuck += importantContests.get(i); 
+ else
+ maxLuck -= importantContests.get(i); 
+ }
+ 
+ System.out.println(maxLuck);
+ }
+}

Algorithms/Sorting/Lily's Homework/solution.java

@@ -0,0 +1,75 @@
+/*
+Here, We can compare a sorted array to the original
+and just keep track of the differences. As we
+go we will need to perform the swaps, becasue we
+re not guranteed 1 swap will fix both elements.
+ We will do this on both a ascending sort and a
+descending sort as both meet the minimal 
+requirement
+ 
+Time Complexity: O(n log(n)) //We must sort the input
+Space Complexity: O(n) //We store the input in an array
+*/
+
+import java.io.*;
+import java.util.*;
+
+public class solution {
+
+ public static void main(String[] args) {
+ Scanner input = new Scanner(System.in);
+ int n = input.nextInt();
+ 
+ int sortedSwaps = 0;
+ int[] homework = new int[n];
+ Integer[] homeworkSorted = new Integer[n];
+ Map<Integer,Integer> original = new HashMap<>();
+ 
+ int sortedReverseSwaps = 0; 
+ int[] homework2ndCopy = new int[n]; 
+ Map<Integer,Integer> original2ndCopy = new HashMap<>();
+ 
+ //Initialize our arrays and maps
+ for(int i = 0; i < n; i++)
+ {
+ homeworkSorted[i] = input.nextInt();
+ homework[i] = homeworkSorted[i];
+ homework2ndCopy[i] = homeworkSorted[i];
+ original.put(homework[i],i);
+ original2ndCopy.put(homework2ndCopy[i],i);
+ }
+ 
+ Arrays.sort(homeworkSorted);//Sort the input ascending
+ 
+ for(int i = 0; i < n; i++)
+ {
+ if(homework[i] != homeworkSorted[i])
+ {
+ //swap the element from homework to the right position
+ int tmp = homework[i];
+ homework[i] = homework[original.get(homeworkSorted[i])];
+ homework[original.get(homeworkSorted[i])] = tmp;
+ //Update index after swap
+ original.put(tmp,original.get(homeworkSorted[i]));
+ sortedSwaps++; 
+ }
+ }
+ 
+ Arrays.sort(homeworkSorted, Collections.reverseOrder());//Sort the input descending
+ 
+ for(int i = 0; i < n; i++)
+ {
+ if(homework2ndCopy[i] != homeworkSorted[i])
+ {
+ //swap the element from homework to the right position
+ int tmp = homework2ndCopy[i];
+ homework2ndCopy[i] = homework2ndCopy[original.get(homeworkSorted[i])];
+ homework2ndCopy[original2ndCopy.get(homeworkSorted[i])] = tmp;
+ //Update index after swap
+ original2ndCopy.put(tmp, original2ndCopy.get(homeworkSorted[i]));
+ sortedReverseSwaps++;
+ }
+ }
+ System.out.println(Math.min(sortedSwaps,sortedReverseSwaps));//Choose the smallest of the two possible smallest
+ }
+}

Algorithms/Sorting/Lily's Homework/solution.py

@@ -0,0 +1,29 @@
+ 
+def homework(n, arr):
+
+ pos = dict()
+ for i, num in enumerate(arr):
+ pos[num] = i
+
+ cnt = 0
+ sorted_arr = sorted(arr)
+
+ for i in range(len(arr)):
+ if arr[i] != sorted_arr[i]:
+ cnt += 1
+
+ new_idx = pos[sorted_arr[i]]
+ pos[arr[i]] = new_idx
+ arr[i], arr[new_idx] = arr[new_idx], arr[i]
+
+ return cnt
+
+# input the number of elements of the array
+n = int(input().strip())
+# input elements of array
+arr = list(map(int, input().strip().split()))
+
+asc = homework(n, arr)
+desc = homework(n, list(reversed(arr)))
+# print the minimum number of swaps needed to make the array beautiful
+print(min(asc, desc))

Algorithms/Strings/Beautiful Binary String/solution.cpp

@@ -0,0 +1,49 @@
+#include <bits/stdc++.h>
+
+using namespace std;
+
+// Implementation Part
+int beautifulBinaryString(string b) {
+ 
+ int count = 0;
+ /*
+ * if we found 010 then if will be efficient,
+ * to change last 0 ---> 1
+ * so that it can prevent 010 
+ */
+ 
+ // traversing string b
+ for(int i = 2; i < b.size(); ){
+ 
+ // checking whether substring 010 is present or not
+ // based on that increment index i
+ if(b[i - 2] == '0' && b[i - 1] == '1' && b[i] == '0'){
+ count++;
+ i = i + 3;
+ }else{
+ i++;
+ } 
+ }
+ return count;
+}
+
+int main()
+{
+ ofstream fout(getenv("OUTPUT_PATH"));
+
+ int n;
+ cin >> n;
+ cin.ignore(numeric_limits<streamsize>::max(), '\n');
+
+ string b;
+ getline(cin, b);
+
+ int result = beautifulBinaryString(b);
+
+ fout << result << "\n";
+
+ fout.close();
+
+ return 0;
+}
+

Algorithms/Strings/Beautiful Binary String/solution.java

@@ -0,0 +1,31 @@
+/*
+We could use a greedy approach and starting from the
+left everytime we see a 010 replace the last 0 with a 1
+and continue
+*/
+
+import java.io.*;
+import java.util.*;
+
+public class Solution {
+
+ public static void main(String[] args) {
+ // Read input from STDIN and Print output to STDOUT
+ Scanner input = new Scanner(System.in);
+ int n = input.nextInt(); // length of binary string
+ input.nextLine();
+ String s = input.nextLine(); // single binary string of length n
+ int switches = 0;
+ 
+ for(int i = 0; i < s.length()-2; i++) // left to right character of binary string
+ {
+ if(s.charAt(i) == '0' && s.charAt(i+1) == '1' && s.charAt(i+2) == '0')
+ {
+ switches++;
+ i += 2;
+ }
+ }
+ // minimum number of steps needed to make the string beautiful
+ System.out.println(switches);
+ }
+}

Algorithms/Strings/Highest Value Palindrome/solution.java

@@ -0,0 +1,71 @@
+import java.io.*;
+import java.math.*;
+import java.security.*;
+import java.text.*;
+import java.util.*;
+import java.util.concurrent.*;
+import java.util.regex.*;
+
+public class solution {
+
+ private static String largestPalindrome(String number, int k) {
+ char[] chars = number.toCharArray();
+ int minChange = 0;
+ for (int i = 0, j = chars.length - 1; i < j; i++, j--) {
+ if (chars[i] != chars[j]) {
+ minChange++;
+ }
+ }
+ if (minChange > k) {
+ return "-1";
+ }
+ int changeBoth = k - minChange;
+ 
+ // Iinitialize l and r by leftmost and 
+ // rightmost ends 
+ int i = 0;
+ int j = chars.length - 1;
+ for (; i <= j; i++, j--) {
+ if (chars[i] != chars[j]) {
+ // Replace left and right character by 
+ // maximum of both 
+ char maxChar = (char) Math.max(chars[i], chars[j]);
+ if (maxChar != '9' && changeBoth - 1 >= 0) {
+ /* If characters at ith or rth (one of them) is changed in the previous 
+ loop then subtract 1 from K (1 more is 
+ subtracted already) and make them 9 */ 
+ chars[i] = '9';
+ chars[j] = '9';
+ changeBoth--;
+ } else {
+ chars[i] = maxChar;
+ chars[j] = maxChar;
+ minChange--;
+ }
+ } else {
+ char maxChar = (char) Math.max(chars[i], chars[j]);
+ /* If none of them is changed in the 
+ previous loop then subtract 2 from changeboth
+ and convert both to 9 */
+ if (maxChar != '9' && changeBoth - 2 >= 0) {
+ chars[i] = '9';
+ chars[j] = '9';
+ changeBoth -= 2;
+ }
+ }
+ }
+ if (changeBoth != 0 && i - 1 == j + 1) {
+ chars[i - 1] = '9';
+ }
+ String palindrome = new String(chars);
+ return palindrome;
+ }
+
+ public static void main(String[] args) {
+ Scanner in = new Scanner(System.in);
+ int n = in.nextInt();
+ int k = in.nextInt();
+ String number = in.next();
+ System.out.println(largestPalindrome(number, k));
+ }
+}

Algorithms/Strings/Highest Value Palindrome/solution.py

@@ -0,0 +1,35 @@
+# input the number of digits and the maximum number of changes allowed
+n,k=map(int,input().split(' '))
+# input the n-digit string of numbers
+num=input()
+ss=list(num)
+ch=[False for i in range(n)]
+offset=0
+cc=0
+# print a string representation of the highest value achievable or -1
+for i in range(n>>1):
+ if ord(ss[i])>ord(ss[n-1-i]):
+ ss[n-1-i]=ss[i]
+ ch[n-1-i]=True
+ cc+=1
+ elif ord(ss[i])<ord(ss[n-1-i]):
+ ss[i] = ss[n-1-i]
+ ch[i]=True
+ cc+=1
+if cc>k:
+ print(-1)
+else:
+ k-=cc
+ i=0
+ while k and i<(n>>1):
+ if ss[i]!='9':
+ if ch[i] or ch[n-i-1]:
+ ss[i]=ss[n-1-i]='9'
+ k-=1
+ elif k>=2:
+ ss[i] = ss[n - 1 - i] = '9'
+ k -= 2
+ i+=1
+ if n&1 and k:
+ ss[(n>>1)]='9'
+ print(''.join(ss))

Algorithms/Strings/Making Anagrams/solution.cpp

@@ -0,0 +1,53 @@
+#include <bits/stdc++.h>
+
+using namespace std;
+
+// Implementation Part
+int makingAnagrams(string s1, string s2) {
+ 
+ // creating vector for finding frequency of letters
+ vector<int> freq(26, 0);
+ 
+ // Get the frequency of each letter in s1
+ for(int i = 0; i < s1.size(); i++){
+ int index = (int)s1[i] - 97;
+ freq[index]++;
+ }
+ 
+ // getting difference of frequency of letters in s1 and s2
+ for(int i = 0; i < s2.size(); i++){
+ int index = (int)s2[i] - 97;
+ freq[index]--;
+ }
+ 
+ /*
+ * So if frequency is 0 thet means letter has same frequency in s1 and s2
+ * no need to delete
+ * if frequency is not zero...we need to delete that element
+ */
+ int count = 0;
+ for(int i = 0; i < 26; i++)
+ count += abs(freq[i]);
+ 
+ return count;
+}
+
+int main()
+{
+ ofstream fout(getenv("OUTPUT_PATH"));
+
+ string s1;
+ getline(cin, s1);
+
+ string s2;
+ getline(cin, s2);
+
+ int result = makingAnagrams(s1, s2);
+
+ fout << result << "\n";
+
+ fout.close();
+
+ return 0;
+}
+