Merge pull request #1 from adityabisoi/main

Update

Author: suhas142

Algorithms/Apple and Orange/solution.py

@@ -0,0 +1,29 @@
+
+def countApplesAndOranges(s,t,a,b,apples,oranges):
+ app=0 # app denotes apples falling on house
+ ora=0 # ora denotes oranges falling on house
+
+ for i in apples:
+ if i + a <= t and i + a >= s:
+ app+=1 # app increment
+ for i in oranges:
+ if i + b <= t and i + b >= s:
+ ora+=1 # ora increment
+ print(app)
+ print(ora)
+
+def main():
+ s,t = map(int,input().split(' ')) # s=start location t=end location
+
+ a,b = map(int,input().split(' ')) # a=apple tree location b=orange tree location
+
+ m,n = map(int,input().split(' ')) # m=apple count n=orange count
+
+ apples = list(map(int,input().split(' ')))
+ oranges = list(map(int,input().split(' ')))
+
+ countApplesAndOranges(s,t,a,b,apples,oranges) # Function call
+
+# Code Execution
+if __name__ == '__main__':
+ main()

Algorithms/Breaking the Records/solution.cpp

@@ -0,0 +1,100 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+vector<string> split_string(string);
+
+// Implemented Part
+vector<int> breakingRecords(vector<int> scores) {
+ 
+ // Initialize highestScore and lowestScore to first value of scores
+ // number of times she breaks her record i.e initialize 0 to countLow and countHigh 
+ int high = scores[0], low = scores[0], countHigh = 0, countLow = 0;
+ vector<int> result;
+ 
+ for(int i = 1; i < scores.size(); i++){
+ // compare current score with lowest score
+ // if condition satisfies then do changes as given 
+ if(scores[i] < low){
+ countLow++;
+ low = scores[i];
+ }else if(scores[i] > high){
+ // compare current score with highest score
+ // if above condition satisfies then update the values
+ countHigh++;
+ high = scores[i];
+ }
+ }
+ 
+ // then push countHigh and countLow in returning vector i.e result
+ result.push_back(countHigh);
+ result.push_back(countLow);
+ return result;
+}
+
+int main()
+{
+ ofstream fout(getenv("OUTPUT_PATH"));
+
+ int n;
+ cin >> n;
+ cin.ignore(numeric_limits<streamsize>::max(), '\n');
+
+ string scores_temp_temp;
+ getline(cin, scores_temp_temp);
+
+ vector<string> scores_temp = split_string(scores_temp_temp);
+
+ vector<int> scores(n);
+
+ for (int i = 0; i < n; i++) {
+ int scores_item = stoi(scores_temp[i]);
+
+ scores[i] = scores_item;
+ }
+
+ vector<int> result = breakingRecords(scores);
+
+ for (int i = 0; i < result.size(); i++) {
+ fout << result[i];
+
+ if (i != result.size() - 1) {
+ fout << " ";
+ }
+ }
+
+ fout << "\n";
+
+ fout.close();
+
+ return 0;
+}
+
+vector<string> split_string(string input_string) {
+ string::iterator new_end = unique(input_string.begin(), input_string.end(), [] (const char &x, const char &y) {
+ return x == y and x == ' ';
+ });
+
+ input_string.erase(new_end, input_string.end());
+
+ while (input_string[input_string.length() - 1] == ' ') {
+ input_string.pop_back();
+ }
+
+ vector<string> splits;
+ char delimiter = ' ';
+
+ size_t i = 0;
+ size_t pos = input_string.find(delimiter);
+
+ while (pos != string::npos) {
+ splits.push_back(input_string.substr(i, pos - i));
+
+ i = pos + 1;
+ pos = input_string.find(delimiter, i);
+ }
+
+ splits.push_back(input_string.substr(i, min(pos, input_string.length()) - i + 1));
+
+ return splits;
+}
+

Algorithms/Breaking the Records/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 {
+
+ //This method will compute the number of times
+ //BestScore was broke and WorstScore was broke
+ static int[] breakingRecords(int[] scores) {
+ //Set bestScore and worstScore to first value of scores array
+ int bestScore = scores[0], worstScore = scores[0];
+ //Set count of bestScoreinc and worstscoredec to zero 
+ int countBestScoreInc = 0, countWorstScoreDec = 0;
+ //Traverse throught the remaining array
+ for(int i = 1; i < scores.length; i ++) {
+ //if bestScore is broken
+ //Update bestScore and increase count by 1
+ if(scores[i] > bestScore) {
+ bestScore = scores[i];
+ countBestScoreInc ++;
+ }
+ //if worstScore is broken 
+ //Update worstScore and decrease count by 1
+ if(scores[i] < worstScore) {
+ worstScore = scores[i];
+ countWorstScoreDec ++;
+ }
+ }
+ //Finally return the count of bestScoreInc and worstScoreDec
+ return new int[]{countBestScoreInc, countWorstScoreDec};
+ }
+
+ private static final Scanner scanner = new Scanner(System.in);
+
+ public static void main(String[] args) throws IOException {
+ BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(System.getenv("OUTPUT_PATH")));
+
+ int n = scanner.nextInt();
+ scanner.skip("(\r\n|[\n\r\u2028\u2029\u0085])?");
+
+ int[] scores = new int[n];
+
+ String[] scoresItems = scanner.nextLine().split(" ");
+ scanner.skip("(\r\n|[\n\r\u2028\u2029\u0085])?");
+
+ for (int i = 0; i < n; i++) {
+ int scoresItem = Integer.parseInt(scoresItems[i]);
+ scores[i] = scoresItem;
+ }
+
+ int[] result = breakingRecords(scores);
+
+ for (int i = 0; i < result.length; i++) {
+ bufferedWriter.write(String.valueOf(result[i]));
+
+ if (i != result.length - 1) {
+ bufferedWriter.write(" ");
+ }
+ }
+
+ bufferedWriter.newLine();
+
+ bufferedWriter.close();
+
+ scanner.close();
+ }
+}

Algorithms/Breaking the Records/solution.py

@@ -0,0 +1,37 @@
+#!/bin/python3
+
+import math
+import os
+import random
+import re
+import sys
+
+# Complete the breakingRecords function below.
+
+def breakingRecords(scores):
+ r = [0,0] # record breaks list - first element for highest score & second for lowest score
+ # both initially set to 0
+ maxm = scores[0]
+ minm = scores[0]
+ for i in range(len(scores)):
+ if scores[i]>maxm:
+ maxm = scores[i] # updating the greatest score
+ r[0]+=1 # incrementing by 1
+ if scores[i]<minm:
+ minm = scores[i] # updating the lowest score
+ r[1]+=1 # incrementing by 1
+ return r
+
+if __name__ == '__main__':
+ fptr = open(os.environ['OUTPUT_PATH'], 'w')
+
+ n = int(input())
+
+ scores = list(map(int, input().rstrip().split()))
+
+ result = breakingRecords(scores)
+
+ fptr.write(' '.join(map(str, result)))
+ fptr.write('\n')
+
+ fptr.close()

Algorithms/Climbing the Leaderboard/solution.java

@@ -0,0 +1,45 @@
+import java.util.Scanner;
+
+// Time Complexity: O(n + m)
+// Space Complexity: O(1) (other than storing input)
+public class Solution {
+ public static void main(String[] args) {
+ /* Save input - discard duplicates in leaderboard */
+ Scanner scan = new Scanner(System.in);
+ int n = scan.nextInt();
+ int lastScore = -1;
+ int[] scores = new int[n];
+ int index = 0;
+ 
+while (n-- > 0) {
+ int currScore = scan.nextInt();
+ if (currScore != lastScore) {
+ scores[index] = currScore;
+ index++;
+ }
+ lastScore = currScore;
+ }
+ 
+int m = scan.nextInt();
+ int[] alice = new int[m];
+ for (int i = 0; i < m; i++) {
+ alice[i] = scan.nextInt();
+ }
+ scan.close();
+
+ /* Print ranks */
+ int i = index - 1;
+ for (int aliceScore : alice) {
+ while (i >= 0) {
+ if (aliceScore < scores[i]) {
+ System.out.println(i + 2); // add 2 to get correct rank
+ break;
+ }
+ i--;
+ }
+ if (i < 0) { // if true, each remaining aliceScore is highest score
+ System.out.println(1);
+ }
+ }
+ }
+}

Algorithms/Diagonal Difference/Solution.java

@@ -0,0 +1,23 @@
+import java.util.Scanner;
+
+public class Solution {
+
+ public static void main(String[] args) {
+ Scanner scan = new Scanner(System.in);
+ int n = Integer.parseInt(scan.nextLine());
+ // sumOne variable computes the sum for the primary diagonal whereas
+ // sumTwo variable computers the sum for the secondary diagonal
+ int sumOne = 0;
+ int sumTwo = 0;
+
+ for(int currentOne = 0, currentTwo = n - 1; currentOne < n; currentOne ++, currentTwo--) {
+ // Split the numbers in a row of the 2D matrix
+ String[] inputLine = scan.nextLine().split(" ");
+ sumOne += Integer.parseInt(inputLine[currentOne]);
+ sumTwo += Integer.parseInt(inputLine[currentTwo]);
+ }
+ 
+ // Output the absolute difference of the sums of both diagonals
+ System.out.println(Math.abs(sumOne - sumTwo));
+ }
+}

Algorithms/Diagonal Difference/solution.cpp

@@ -0,0 +1,62 @@
+#include <bits/stdc++.h>
+
+using namespace std;
+
+/*
+ * the 'diagonalDifference' function below.
+ *
+ * The function is expected to return an INTEGER.
+ * The function accepts 2D_INTEGER_ARRAY arr as parameter.
+ * 
+ * Complexity: BigO(n);
+ * 
+ * What we do is traversing one diagonal at a time, because traversin 2 diagonals in onemay complicate things
+ * 
+ * In first loop, we traverse from left top to right bottom whereas 
+ * in 2nd loop we will traverse from right top to bottom left
+ */
+
+int diagonalDifference(vector<vector<int>> arr) {
+ int s1=0; //sum of diagonal from left top to right bottom
+ int n=arr[0].size(); //size of square matrix
+ int i=0;
+ //loop 1
+ while(i<n){
+ s1=s1+arr[i][i];
+ i++;
+ }
+ //loop 2
+ int s2=0,j=n-1; //sum of diagonal from right top to left bottom
+ i=0;
+ while(i<n){
+ s2=s2+arr[i][j];
+ i++;
+ j--;
+ }
+ return abs(s2-s1); //difference of solution;
+}
+
+int main()
+{
+ int n;
+ cin>>n;
+
+ vector<vector<int>> arr(n);
+
+ for (int i = 0; i < n; i++) {
+ arr[i].resize(n);
+
+ for (int j = 0; j < n; j++) {
+ int a;
+ cin>>a;
+
+ arr[i][j] = a;
+ }
+ }
+
+ int result = diagonalDifference(arr);
+
+ cout << result << "\n";
+
+ return 0;
+}