adding codes

Author: sauravjaiswalsj

Codechef/contest/2020/janLong/brkbks.java

@@ -0,0 +1,41 @@
+/*
+ * @author: sauravjaiswalsj
+ */
+import java.util.*;
+public class brkbks{
+	public static void main(String[] args){
+                final Scanner cin = new Scanner(System.in);
+                int test=cin.nextInt();
+                while(test-->0){
+                        int s = cin.nextInt();
+                        int w1 = cin.nextInt();
+                        int w2 = cin.nextInt();
+                        int w3 = cin.nextInt();
+                        System.out.println(BreakingBricks(s,w1,w2,w3));
+                }
+	}
+	/*
+	 * @params takes the strength and widths
+	 * @return the number of hits needed to break the bricks
+	 */
+	public static int BreakingBricks(int s,int w1,int w2,int w3){
+		int step=0;
+		if(s>=(w1+w2+w3)){
+			return 1;
+		}
+		else if(s>=w1+w2 && s>=w3){
+			System.out.println("1");
+			return 2;
+		}
+		else {
+			int sum=w1+w3;
+			if(s==sum){
+				step++;
+			}
+			if(s>=w2){
+				step++;
+			}
+		}
+		return step;
+	}
+}

Leetcode/2.add-two-numbers.java

@@ -0,0 +1,22 @@
+/*
+ * @lc app=leetcode id=2 lang=java
+ *
+ * [2] Add Two Numbers
+ */
+
+// @lc code=start
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
+        
+    }
+}
+// @lc code=end
+

Leetcode/34.find-first-and-last-position-of-element-in-sorted-array.java

@@ -0,0 +1,23 @@
+/*
+ * @lc app=leetcode id=34 lang=java
+ *
+ * [34] Find First and Last Position of Element in Sorted Array
+ */
+
+// @lc code=start
+class Solution {
+    public int[] searchRange(int[] nums, int target) {
+            int[] arr= new int[2];
+            int low=0;
+            int high=nums.length;
+            while(low<high){
+                int mid=(low+high)/2;
+                if(mid==target){
+                    arr[0]=mid;
+                }
+                if(mid<target)
+            }
+    }
+}
+// @lc code=end
+

atcoder/8-March/Station.java

@@ -0,0 +1,15 @@
+import java.util.*;
+import java.io.*;
+public class Station{
+	public static void main(String[] args)throws IOException{
+		final BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		String S=br.readLine();
+		System.out.println(getStationPair(S));
+	}
+	public static String getStationPair(String S){
+		if(S.charAt(0).equals(S.charAt(1))&&(S.charAt(1).equals(S.charAt(2)))){
+			return "No";
+		}	
+		return "YES";	
+	}
+}

codeforces/636/candies

@@ -0,0 +1,22 @@
+#include<bits/stdc++.h>
+
+void findX(int n){
+	double x;
+	for(int k=1;k<=n;k++){
+		double p=pow(2,k);
+		x=n*((1-k)/(1-p));
+		std::cout<<x<<" ";
+	}
+	
+	//std::cout<<x<<"\n";
+}
+int main(void){
+	int t,n;
+	std::cin>>t;
+	while(t!=0){
+		std::cin>>n;
+		findX(n);
+		t--;	
+	}
+	return 0;
+}

codeforces/636/candies.cpp

@@ -0,0 +1,28 @@
+import java.util.*;
+public class NextRound{
+	public static void main(String[] args){
+		final Scanner cin=new Scanner(System.in);
+		int n=cin.nextInt();
+		int k=cin.nextInt();
+		int[] arr = new int[n];
+		for(int i=0;i<n;i++){
+			arr[i]=cin.nextInt();
+		}
+		System.out.print(countWinner(n,k,arr));
+	}
+	//10 9 8 7 7 7 5 5
+	public static int countWinner(int n,int k,int[] arr){
+		int count=0,diffcount=0;
+		for(int i=k;i<n;i++){
+			if(arr[i]>k){
+				count++;
+			}
+		}
+		for(int i=0;i<k+1;i++){
+			if(arr[i]>=k){
+				diffcount++;
+			}
+		}
+		return diffcount+count;
+	}
+}

codeforces/Practice/maths/NextRound.java

@@ -0,0 +1,13 @@
+import java.util.io;
+public class merge{
+	public static void main(String[] args){
+		int[] arr=[1,4,5,8,10];
+		int[] arr2=[0,2,3,6,7,9];
+		merge(arr,arr2);
+	}
+	public static merge(int[] arr,int[] arr2){
+		int[] newArray=new int[arr.length+arr2.length];
+		int i=0;
+		int n=newArray.length;
+		while(i<n){
+			

practice/algorithms/merge.java

@@ -0,0 +1,25 @@
+#include<bits/stdc++.h>
+
+int main(){
+	int n;
+	std::cin>>n;
+	int temp=n;
+	do{
+		std::cout<<n<<"a ";
+		if(n>0){
+			n=n-5;
+			std::cout<<n<<"b ";
+		}
+		else{
+			 std::cout<<n<<"c ";
+			n=n+5;
+		}
+		if(n==temp){
+			 std::cout<<n<<"d ";
+ 			 break;
+		
+		}
+		std::cout<<n<<" ";
+	}while(n==temp);
+	return 0;
+}

practice/bruteforce/printMicrosoft.cpp

@@ -0,0 +1,22 @@
+#include<bits/stdc++.h>
+static int summ=0;
+static int id=0;
+int sum(int array[],int n){
+	if(id>n){
+		return 0;
+	}
+	id++;
+	std::cout<<summ<<" ";
+	summ=summ+array[id];
+	sum(array,n);
+	return summ;
+}
+int main(){
+	int n;
+	std::cin>>n;
+	int *arr= new int[n];
+	for(int i=0;i<n;i++){
+		std::cin>>arr[i];
+	}
+	std::cout<<sum(arr,n);
+}

practice/recursion/.addArray.cpp.swp

@@ -0,0 +1,20 @@
+import java.util.Scanner;
+public class arraySum{
+	public static void main(String[] args){
+		Scanner cin=new Scanner(System.in);
+		//int n=cin.nextInt();
+		int[] arr={1,2,3,4,5};
+		System.out.println(sum(arr));
+	}
+	public static int add=0,id=0;
+	public static int sum(int[] arr){
+		if(id>arr.length){
+        	    return 0;
+  	     	 }
+		if(id<arr.length)
+	         	add+=arr[id];
+       		 id+=1;
+       		 sum(arr);
+    		 return add;
+	}
+}

practice/recursion/addArray.cpp

@@ -0,0 +1,17 @@
+#include<iostream>
+int counter=0;
+int count(int n) 
+{
+	if(n==0)
+		return 1;
+	count(n/10);
+	std::cout<<n<<" ";
+	++counter;
+	std::cout<<std::endl;
+	return counter;
+}
+int main(){
+	int n;
+	std::cin>>n;
+	std::cout<<count(n);
+}

practice/recursion/arraySum.class

@@ -0,0 +1,15 @@
+#include<bits/stdc++.h>
+bool check(int arr[],int n,int x){
+	if(n==0)
+		return 1;
+	std::cout<<arr[n-1]<<" ";
+	bool ck=check(arr,n-1,x);
+	if(x==arr[n-1])
+		return true;
+	return ck;
+}
+int main(){
+	int arr[] ={1,2,3,4,5};
+	std::cout<<check(arr,5,2);
+}
+

practice/recursion/arraySum.java

@@ -0,0 +1,14 @@
+import java.util.*;
+public class headRec{
+        public static void main(String[] args){
+                Scanner cin=new Scanner(System.in);
+        	int n=cin.nextInt();
+		HeadRec(n);
+	}
+	public static void HeadRec(int n){
+		if( n==0) return;
+		HeadRec(n-1);
+		System.out.println(n);
+	}
+}
+

practice/recursion/countDigit.cpp

@@ -0,0 +1,20 @@
+#include<bits/stdc++.h>
+int id=1;
+bool is_sorted(int *arr ,int size){
+	if(id>size){
+		return false;
+	}
+	if(arr[id-1]>arr[id]){return false;}
+	id++;
+	is_sorted(arr,size);
+	return true;
+}
+int main(){
+	int n;
+	std::cin>>n;
+	int *arr=new int[n];
+	for(int i=0;i<n;i++){
+		std::cin>>arr[i];
+	}
+	std::cout<<is_sorted(arr,n);
+}

practice/recursion/findelement.cpp

@@ -0,0 +1,12 @@
+import java.util.*;
+public class power{
+public static int power(int n,int x){
+	if(x==0) return 1;
+	return n*power(n,x-1);
+}
+	public static void main(String[] args){
+		Scanner cin=new Scanner(System.in);
+		int n=cin.nextInt();
+		System.out.println(power(n,4));
+	}
+}