# Basic Algorithms Course for Beginners : CodeNCode(1 Aug 2020 : New problem added)

Hello Codechef Community , this is CodeNCode.

This is going to be a course where I will be teaching most of the algorithms(like binary search , coordinate compression etc) which are essential and important to start competitive programming.

Here is the list of lectures made till now.
L001 : why you should learn Binary Search

E001 : Koko Eating bananas | Leetcode | Binary Search

More lectures will be added soon , any suggestion / query / criticism is welcome.
Thank you for your valuable time.
CodeNCode

33 Likes

In this Monk’s encounter question, why do we need to use binary search? I solved it using quadratic equation solving formula. I get it, that there are different ways of solving one question, but with binary search it will take log(n) time and with the quadratic formula, I guess, it’ll take constant time. Do correct me, if I am wrong. Is there any reason for using binary search? bcz the problem tag also says binary search.

Thanks;

Code:

``````import java.io.Writer;
import java.io.BufferedWriter;
import java.io.OutputStreamWriter;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.IOException;
import java.io.InputStream;
import java.math.BigInteger;
import java.util.Arrays;
import java.util.ArrayList;
import java.util.InputMismatchException;
import java.util.*;
import java.io.*;
import java.math.*;

class Solution{
static class ProblemSolver{
public void solveTheProblem(InputReader in,OutputWriter out, NumberTheory nt){
int test=in.nextInt();
while(test-- >0){
Long a=in.nextLong();
Long b=in.nextLong();
Long c=in.nextLong();
Long k=in.nextLong();
c=c-k;
// System.out.println("=== "+(((b*b)-(4*a*c))));
double d1= (-1*b)+Math.sqrt((b*b)-(4*a*c));
d1/=2*a;
double d2= -b-Math.sqrt((b*b)-(4*a*c));
d2/=2*a;
double min=1;
// System.out.println("d1: "+d1+"   d2: "+d2);
if(d1<0)  min=d2;
if(d2<0)  min=d1;
if(new Double(d1).isNaN() && new Double(d2).isNaN()){
System.out.println(0);
continue;
}
if(d1<0 && d2<0){
System.out.println(0);
continue;
}
if(d1>=0 && d2>=0)
min=Math.min(d1, d2);
if(min%1==0){
System.out.println((int)min);
}
else{
System.out.println((int)Math.ceil(min));
}
}
}
}

public static void main(String[] args){
InputStream inputStream=System.in;
OutputStream outputStream=System.out;
OutputWriter out=new OutputWriter(outputStream);
NumberTheory nt= new NumberTheory();
ProblemSolver problemSolver=new ProblemSolver();
problemSolver.solveTheProblem(in,out, nt);
out.flush();
out.close();
}

private boolean finished = false;

private InputStream stream;
private byte[] buf = new byte[1024];
private int curChar;
private int numChars;
private SpaceCharFilter filter;

this.stream = stream;
}

if (numChars == -1) {
throw new InputMismatchException();
}
if (curChar >= numChars) {
curChar = 0;
try {
} catch (IOException e) {
throw new InputMismatchException();
}
if (numChars <= 0) {
return -1;
}
}
return buf[curChar++];
}

public int peek() {
if (numChars == -1) {
return -1;
}
if (curChar >= numChars) {
curChar = 0;
try {
} catch (IOException e) {
return -1;
}
if (numChars <= 0) {
return -1;
}
}
return buf[curChar];
}

public int nextInt() {
while (isSpaceChar(c)) {
}
int sgn = 1;
if (c == '-') {
sgn = -1;
}
int res = 0;
do {
if (c < '0' || c > '9') {
throw new InputMismatchException();
}
res *= 10;
res += c - '0';
} while (!isSpaceChar(c));
return res * sgn;
}

public long nextLong() {
while (isSpaceChar(c)) {
}
int sgn = 1;
if (c == '-') {
sgn = -1;
}
long res = 0;
do {
if (c < '0' || c > '9') {
throw new InputMismatchException();
}
res *= 10;
res += c - '0';
} while (!isSpaceChar(c));
return res * sgn;
}

public String nextLine() {
while (isSpaceChar(c)) {
}
StringBuilder res = new StringBuilder();
do {
if (Character.isValidCodePoint(c)) {
res.appendCodePoint(c);
}
} while (!isSpaceChar(c));
return res.toString();
}

public boolean isSpaceChar(int c) {
if (filter != null) {
return filter.isSpaceChar(c);
}
return isWhitespace(c);
}

public static boolean isWhitespace(int c) {
return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}

StringBuilder buf = new StringBuilder();
while (c != '\n' && c != -1) {
if (c != '\r') {
buf.appendCodePoint(c);
}
}
return buf.toString();
}

while (s.trim().length() == 0) {
}
return s;
}

if (ignoreEmptyLines) {
} else {
}
}

try {
return new BigInteger(nextLine());
} catch (NumberFormatException e) {
throw new InputMismatchException();
}
}

public char nextCharacter() {
while (isSpaceChar(c)) {
}
return (char) c;
}

public double nextDouble() {
while (isSpaceChar(c)) {
}
int sgn = 1;
if (c == '-') {
sgn = -1;
}
double res = 0;
while (!isSpaceChar(c) && c != '.') {
if (c == 'e' || c == 'E') {
return res * Math.pow(10, nextInt());
}
if (c < '0' || c > '9') {
throw new InputMismatchException();
}
res *= 10;
res += c - '0';
}
if (c == '.') {
double m = 1;
while (!isSpaceChar(c)) {
if (c == 'e' || c == 'E') {
return res * Math.pow(10, nextInt());
}
if (c < '0' || c > '9') {
throw new InputMismatchException();
}
m /= 10;
res += (c - '0') * m;
}
}
return res * sgn;
}

public boolean isExhausted() {
int value;
while (isSpaceChar(value = peek()) && value != -1) {
}
return value == -1;
}

public String next() {
return nextLine();
}

public SpaceCharFilter getFilter() {
return filter;
}

public void setFilter(SpaceCharFilter filter) {
this.filter = filter;
}

public interface SpaceCharFilter {
public boolean isSpaceChar(int ch);
}
public int[] nextIntArray(int n){
int[] array=new int[n];
for(int i=0;i<n;++i)array[i]=nextInt();
return array;
}
public int[] nextSortedIntArray(int n){
int array[]=nextIntArray(n);
Arrays.sort(array);
return array;
}
public ArrayList<Integer> nextIntArrayList(int n){
ArrayList<Integer> ar= new ArrayList<>();
for(int i=0;i<n;i++)
return ar;
}
public ArrayList<Long> nextLongArrayList(int n){
ArrayList<Long> ar= new ArrayList<>();
for(int i=0;i<n;i++)
return ar;
}

public int[] nextSumIntArray(int n){
int[] array=new int[n];
array[0]=nextInt();
for(int i=1;i<n;++i)array[i]=array[i-1]+nextInt();
return array;
}
public long[] nextLongArray(int n){
long[] array=new long[n];
for(int i=0;i<n;++i)array[i]=nextLong();
return array;
}
public long[] nextSumLongArray(int n){
long[] array=new long[n];
array[0]=nextInt();
for(int i=1;i<n;++i)array[i]=array[i-1]+nextInt();
return array;
}
public long[] nextSortedLongArray(int n){
long array[]=nextLongArray(n);
Arrays.sort(array);
return array;
}
public int[][] nextIntMatrix(int n,int m){
int[][] matrix=new int[n][m];
for(int i=0;i<n;++i)
for(int j=0;j<m;++j)
matrix[i][j]=nextInt();
return matrix;
}

public int[][] nextIntMatrix(int n){
return nextIntMatrix(n,n);
}

public long[][] nextLongMatrix(int n,int m){
long[][] matrix=new long[n][m];
for(int i=0;i<n;++i)
for(int j=0;j<m;++j)
matrix[i][j]=nextLong();
return matrix;
}

public long[][] nextLongMatrix(int n){
return nextLongMatrix(n,n);
}

public char[][] nextCharMatrix(int n,int m){
char[][] matrix=new char[n][m];
for(int i=0;i<n;++i)
matrix[i]=next().toCharArray();
return matrix;
}

public char[][] nextCharMatrix(int n){
return nextCharMatrix(n,n);
}
}

static class OutputWriter {
private final PrintWriter writer;

public OutputWriter(OutputStream outputStream) {
writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
}

public OutputWriter(Writer writer) {
this.writer = new PrintWriter(writer);
}

// public void print(char[] array) {
//     writer.print(array);
// }

public void print(Object... objects) {
for (int i = 0; i < objects.length; i++) {
if (i != 0) {
writer.print(' ');
}
writer.print(objects[i]);
}
}

public void print(int[] array) {
for (int i = 0; i < array.length; i++) {
if (i != 0) {
writer.print(' ');
}
writer.print(array[i]);
}
}

public void print(double[] array) {
for (int i = 0; i < array.length; i++) {
if (i != 0) {
writer.print(' ');
}
writer.print(array[i]);
}
}

public void print(long[] array) {
for (int i = 0; i < array.length; i++) {
if (i != 0) {
writer.print(' ');
}
writer.print(array[i]);
}
}

public void print(char[] array) {
for (int i = 0; i < array.length; i++) {
if (i != 0) {
writer.print(' ');
}
writer.print(array[i]);
}
}

public void print(String[] array) {
for (int i = 0; i < array.length; i++) {
if (i != 0) {
writer.print(' ');
}
writer.print(array[i]);
}
}

public void print(int[][] matrix){
for(int i=0;i<matrix.length;++i){
println(matrix[i]);
}
}

public void print(double[][] matrix){
for(int i=0;i<matrix.length;++i){
println(matrix[i]);
}
}

public void print(long[][] matrix){
for(int i=0;i<matrix.length;++i){
println(matrix[i]);
}
}

public void print(char[][] matrix){
for(int i=0;i<matrix.length;++i){
println(matrix[i]);
}
}

public void print(String[][] matrix){
for(int i=0;i<matrix.length;++i){
println(matrix[i]);
}
}

public void println(int[] array) {
print(array);
writer.println();
}

public void println(double[] array) {
print(array);
writer.println();
}

public void println(long[] array) {
print(array);
writer.println();
}

// public void println(char[] array) {
//     print(array);
//     writer.println();
// }

public void println(String[] array) {
print(array);
writer.println();
}

public void println() {
writer.println();
}

public void println(Object... objects) {
print(objects);
writer.println();
}

public void print(char i) {
writer.print(i);
}

public void println(char i) {
writer.println(i);
}

public void println(char[] array) {
writer.println(array);
}

public void printf(String format, Object... objects) {
writer.printf(format, objects);
}

public void close() {
writer.close();
}

public void flush() {
writer.flush();
}

public void print(long i) {
writer.print(i);
}

public void println(long i) {
writer.println(i);
}

public void print(int i) {
writer.print(i);
}

public void println(int i) {
writer.println(i);
}

public void separateLines(int[] array) {
for (int i : array) {
println(i);
}
}
}
static class NumberTheory{

/**
* Modular Arithmetic:
*  1. (a+b)%c=(a%c+b%c)%c
*  2. (a*b)%c=(a%c*b%c)%c
*  3. (a-b)%c=(a%c-b%c+c)%c
*  4. (a/b)%c=(a%c*(b^-1)%c)%c -- (b^-1 is multiplicative modulo inverse)
*/
public int modularAddition(int a,int b,int MOD){
return (a%MOD+b%MOD)%MOD;
}
public long modularAddition(long a,long b,long MOD){
return (a%MOD+b%MOD)%MOD;
}
//Modular Multiplication
public int modularMultiplication(int a,int b,int MOD){
return ((a%MOD)*(b%MOD))%MOD;
}
public long modularMultiplication(long a,long b,long MOD){
return ((a%MOD)*(b%MOD))%MOD;
}
//Modular Subtraction
public int modularSubtraction(int a,int b,int MOD){
return (a%MOD-b%MOD+MOD)%MOD;
}
public long modularSubtraction(long a,long b,long MOD){
return (a%MOD-b%MOD+MOD)%MOD;
}

/**
* Binary Exponentiation
*/
public int binaryExponentiation(int x,int n){
if(n==0)return 1;
else if(n%2==0)return binaryExponentiation(x*x,n/2);
else return x*binaryExponentiation(x*x,(n-1)/2);
}
public long binaryExponentiation(long x,long n){
long result=1;
while(n>0){
if(n%2==1)result*=x;
x=x*x;
n/=2;
}
return result;
}

/**
* Modular Exponentiation
*/
public int modularExponentiation(int x,int n,int MOD){
if(n==0)return 1%MOD;
else if(n%2==0)return modularExponentiation(modularMultiplication(x,x,MOD),n/2,MOD);
else return modularMultiplication(x,modularExponentiation(modularMultiplication(x,x,MOD),(n-1)/2,MOD),MOD);
}
public long modularExponentiation(long x,long n,long MOD){
long result=1;
while(n>0){
if(n%2==1)result=modularMultiplication(result,x,MOD);
x=modularMultiplication(x,x,MOD);
n/=2;
}
return result;
}

/**
* Factorial of a number
*/
public long factorials(long n){
if(n==0)return 1;
return n*factorials(n-1);
}

/**
* Prime factors of a number
*/
public ArrayList<Integer> distinctPrimeFactors(int n){
ArrayList<Integer> factorials=new ArrayList<>();
int limit=(int)Math.sqrt(n);
if(n%2==0){
while(n%2==0)n/=2;
}
for(int i=3;i<=limit;i+=2){
if(n%i==0){
while(n%i==0)n/=i;
}
}
return factorials;
}

public ArrayList<Long> distinctPrimeFactors(long n){
ArrayList<Long> factorials=new ArrayList<>();
long limit=(long)Math.sqrt(n);
if(n%2==0){
while(n%2==0)n/=2;
}
for(long i=3;i<=limit;i+=2){
if(n%i==0){
while(n%i==0)n/=i;
}
}
return factorials;
}

public ArrayList<Integer> primeFactors(int n){
ArrayList<Integer> factorials=new ArrayList<>();
int limit=(int)Math.sqrt(n);
if(n%2==0){
while(n%2==0)n/=2;
}
for(int i=3;i<=limit;i+=2){
if(n%i==0){
while(n%i==0)n/=i;
}
}
return factorials;
}

public ArrayList<Long> primeFactors(long n){
ArrayList<Long> factorials=new ArrayList<>();
long limit=(long)Math.sqrt(n);
if(n%2==0){
while(n%2==0)n/=2;
}
for(long i=3;i<=limit;i+=2){
if(n%i==0){
while(n%i==0)n/=i;
}
}
return factorials;
}

/**
* Combination: nCr
*/
//Naive version
//(n,r)=(n-1,r-1)+(n-1,r) for r!=0 or r!=n
//(n,0)=(n,n)=1
public int binomialCoefficientRecursive(int n,int k){
if(k==0 || k==n)return 1;//base case
return binomialCoefficientRecursive(n-1,k-1)+binomialCoefficientRecursive(n-1,k);//recursion
}

//Dynamic Programming version(Uses bottom up approach to fill the table)
//Time complexity: O(n*k)
//Space complexity: O(n*k)
public long binomialCoefficientIterative(int n,int k){
long[][] C=new long[n+1][k+1];
for(int i=0;i<=n;++i){
for(int j=0;j<=Math.min(n,k);++j){
if(j==0 || j==i)C[i][j]=1;
else C[i][j]=C[i-1][j-1]+C[i-1][j];
}
}
return C[n][k];
}

//Pascal's Triangle version(Space efficient program)
//Time complexity: O(n*k)
//Space complexity: O(k)
public long nCr(int n,int r){
int[] C=new int[r+1];
C[0]=1;//nC0=1
for(int i=1;i<=n;++i)
for(int j=Math.min(i,r);j>0;--j)
C[j]=C[j]+C[j-1];
return C[r];
}

/**
* Catlan number:
*  - Time complexity: O(n*n)
*  - Auxiliary space: O(n)
*
*  NOTE: Time complexity could be reduced to O(n) but it is
*        possible if and only if n is small or else there is
*        a chance of getting an overflow. To decrease the time
*        complexity to O(n) just remember nCr=nCn-r
*/
public long catlanNumber(int n){
long[] catlan=new long[n+1];
catlan[0]=catlan[1]=1;
for(int i=2;i<=n;++i)
for(int j=0;j<i;++j)
catlan[i]+=catlan[j]*catlan[i-1-j];

return catlan[n];
}

/**
* Greatest Common Divisor(GCD)
*  - It is also known as Highest Common Factor(HCF)
*  - Time complexity: log(min(a,b))
*  - Auxiliary Space: O(1)
*/
public int gcd(int a,int b){
if(b==0)return a;
return gcd(b,a %b);
}

public long gcd(long a,long b){
if(b==0)return a;
return gcd(b,a%b);
}

/**
* Extended Euclid's Algorithm:
*  - ax+by=gcd(a,b)
*  - Time complexity:
*  -
*/

/**
* Least Common Multiple(LCM):
*  - Time complexity: log(min(a,b))
*  - Auxiliary Space: O(1)
*/
public long lcm(long a,long b){
return (a*b)/gcd(a,b);
}

}
}
//
//                       "8,        .m8"
//                        I8Im    ,mI8"
//                        ,8I""I8,mI8m
//             "I8mm,    ,I8    I8 "I8,          ,m"
//                "I88I88I8m ,I8"   "I8""==mm ,mI8"
//        ___    ,mI8"    "8I8"      I8,  ,mI8I8"
//   .,mI8I8I8I8I88,      ,m8"      ,I8I8I8I888"
// "I8Im,       "I88,    ,8"      ,II8"     "88,
//    `"I8,        "I8, ,8"     ,I8"         "I8,
//       "I8m       "I888      ,I8"           "I8,
//         "8m        "I8      88"              "I8,
//          I8,        I8      88                 "I8,
//           88,       I8,     "I8                 "I8
//           "I8,      "I8,     "I8,                I8;.
//            "I8,      "I8,      "I8        .,mmmI8888888m,.
//              I8,      "I8,      I8,  .mI8I88"""". .. "I8888
//              "I8,      "I8      mI8I88"". . . . . .,m8"   "8
//               I8m,  __ ;I8   ,II88" . . . . .,;miI88"
//               "I88I8I88I88,,I88" . . . ,mmiiI8888"
//                ,I8". . ."I8I8". . . mi888888888"
//              ,I8 . . . .,I88I. . .i88888888888"
//             I8. . . .,mII88Ima. .i88888888888"
//            ,8"..,mI88I88I88I8Imi888888888888"
//            I8.,I8I"""        ""II88888888888
//           ;I8I8"                  ""I8888888
//           ""                         "I88888
//                                        "I888
//                                         "I88,
//                                          "I88
//                                           "88,
//                                            I88,              ______   __
//                           ______           "I88__        .mI88I88I88I88I88,
//                      .,mI88I88I88, ,mI88,   I88"""     ,mI8". . . . "I8,..8,
//                    ,I888' . . . "I88.\ "8,  I88      ,I8". . . .  / :;I8 \ 8,
//                  .mI8' . . .  / .:"I8.\ 88  "88,    ,8". . .  / .;mI8I8I8,\ 8
//                 ,I8'. . .  / . .:;,I8I8I888  I88   ,8". .  / .:mI8"'   "I8,:8
//                ,I8'. . . / . .:;,mI8"  `"I88 I88   I8. .  / .m8"         "I8I
//               ,I8 . .  / . .:;,mI8"      "I88888   88,.  / ,m8            "8'
//               I8'. .  / . .;,mI8"          "II888 ,I8I8,.,I8"
//               I8 . . / . .,mI8"              I8888888' """
//               `I8,.  / ;,mI8"                 II888
//                "I8I, /,mI8"                 __I888
//                  "I8888"                   """I88
//                    ""                         I88
//                                               I88__
//                                               I88"""
//                                               I88
//                                               I88
//                                             __I88
//                                            """I88
//                                               I88
//                                               I88
//                                               I88__
//                                               I88"""
//                                               I88
//                                        BITSY  ___  CHUCK

``````

I have solved this problem using binary search because I want to teach students that binary search is not bound to finding element in a sorted array but it can be used to do much more.

and the approach I discussed to solve this problem can be used to solve problem with any degree , so that students know different approach.

using the approach i discussed you can solve the problem with degree 10 as well.

8 Likes

18 may 2020 : 1 video added
E001 : Ternary String | Codeforces | Ed. Round 87 B

I am confused on how to move the bounds and choosing mid for a problem.
if for a predicate this is the case .
FFFFFFFFTTTTTTTTTTT (F=false for f(x),T=true for f(x)) and and I take the code as such:
lo=1,hi=size
while(lo<hi){
mid=lo+(hi-lo)/2
if(F(mid)==T)
hi=mid
else
lo=mid+1
}
return lo

instead of while(lo < hi) you should go for while (lo <= hi)

reason :
suppose string is 123
FFT (function f(x))
lo = 1 , hi = 3 , mid = 2;
since f(2) = false , lo = 3 , hi = 3 , now your while loop will terminate if you go with while(lo < hi) without checking for length 3.

so update that.

second thing
since F(mid) == T
instead of setting hi = mid , set hi = mid - 1 because you have already tested mid , so reduce range to mid - 1 otherwise there will be an infinite loop in the case which i explained earlier (example with input 123)

1 Like

@waqar_ahmad224 So do we need to check for each problem whether to go with low < high or low <= high? And what is the general pattern to figure out whether mid = low + (high-low)/2 will be alright, or should we use mid = low + (high-low+1)/2? (By the way, I have watched some of your videos, they are really good. Thanks for this initiative.)

1 Like

you should always write low <= high.
I have solved many problems and always calculated mid as (L + H) / 2.

I think sticking with low + (high - low) / 2 should be enough.

1 Like

many i know what is the reason for decreasing the count of numbers in ternary strings problem
idx=s[i-k+1]
a[idx]–

we need to find frequency array of all subarray of size k.

in first for loop we add k-1 elements in frequency array.

now the second for loop comes in.

in second for loop we add kth element in the frequency array , now frequency array(ar[ ] ) contains frequency of first k elements (from 0 to k-1 character)

now in the next iteration we need to find frequency of elements from 1 to k , for that you need to remove 0th index element from the frequency array , that is why we are decreasing frequency.

3 Likes

Hey can you explain why are we decreasing the count of numbers
idx=s[i-k+1]
a[idx]–

Not able to understand properly

here is the reason

``````we need to find frequency array of all subarray of size k.

in first for loop we add k-1 elements in frequency array.

now the second for loop comes in.

in second for loop we add kth element in the frequency array , now frequency array(ar[ ] ) contains frequency of first k elements (from 0 to k-1 character)

now in the next iteration we need to find frequency of elements from 1 to k , for that you need to remove 0th index element from the frequency array , that is why we are decreasing frequency.``````

@waqar_ahmad224 Why do we need the frequency of elements from 1 to k? if the sub array we were searching for was not found in range 0 to k-1 how are we supposed to find it in range 1 to k-1? Please make me understand this. Thanks!

I think you didn’t understand the purpose of isValid( ) function.

isValid(int k) checks if there exist a sub array of size k such that 1 , 2 and 3 appear at least 1 time in it.

so if string size is say 10 and k is 4 then we have to check for subarray
0 - 3 , 1 - 4 , 2 - 5 , . . . , 6 - 9 , if any of these subarray contains all 1 , 2 and 3 we will return true otherwise false.

the second for loop starts from i = k-1 , in this example at 3 , so we are checking for sub array 0 - 3 , if this contains all 1 , 2 and 3 we can directly return true , otherwise we have to check for subarray 1 - 4.
we already have elements 0 - 3 in our frequency array , so to check for sub array 1 - 4 we need to remove 0 , that is why we are removing (i - k + 1)th element from frequency array.

I hope you got the idea , if not try taking a small example , dry run the code , if still have any doubt let me know.

19 May 2020 : new video added.
E001 : Aggressive Cows | Spoj | Binary Search

1 Like

Foo and Exams
Please look at my code. It passes only one test case.

``````#include<bits/stdc++.h>
using namespace std;
#define ll long long
ll a,b,c,d;
ll f(ll n)
{
return (a*n*n*n)+(b*n*n)+c*n+d;
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll t;
cin>>t;
while(t--)
{
ll k;
cin>>a>>b>>c>>d>>k;
if(d>k)
{
cout<<"0\n";
}
else
{
ll l=1;
ll r=1000000;
ll ans=-1;
while(l<=r)
{
ll mid=l+(r-l)/2;
if(f(mid)<=k && f(mid+1)>k)
{
ans=mid;
break;
}
else if(f(mid)<k)
{
l=mid+1;
}
else
{
r=mid-1;
}
}
cout<<ans<<"\n";
}
}
}``````

I can tell you the answer but I want you to learn it yourself.

try setting r as 10^5 instead of 10^6 , keep the rest code same.

then try to figure out what is the problem.

after you figure out the problem do let me know in comment here so others (if any in future) have the same problem can learn from your experience.

2 Likes

Just a Slight Change
All test cases passed.
There was a problem of data overflow. I used unsigned long long int instead
of long long int. I took r(upper bound)=10^6

Code

``````#include<bits/stdc++.h>
using namespace std;
#define ll unsigned long long int
ll a,b,c,d;
ll f(ll n)
{
return (a*n*n*n)+(b*n*n)+c*n+d;
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll t;
cin>>t;
while(t--)
{
ll k;
cin>>a>>b>>c>>d>>k;
if(d>=k)
{
cout<<"0\n";
}
else
{
ll l=0;
ll r=1000000;
ll ans=0;
while(l<=r)
{
ll mid=l+(r-l)/2;
if(f(mid)<=k && f(mid+1)>k)
{
ans=mid;
break;
}
else if(f(mid)<=k)
{
l=mid+1;
}
else
{
r=mid-1;
}
}
cout<<ans<<"\n";
}
}
}``````

Thank you so much for your guidance and tutorials. Your videos are the best. You are a great human being…

1 Like

That’s what I wanted you to learn , great job man.

3 Likes