Infosys SP DSE Previous Year Questions

31 January 2023

Q1.

You are given an integer N.

You have to choose a set of integers S from the range [1, N-1] such that the product of integers in S is 1 modulo N. This means that if N=5, we can choose set S = [1,2,3] as the product is 6 and 6 modulo 5 is 1.

Find the length of the biggest set S you can choose.

Input Format

The first line contains an integer N, denoting the given integer.

Constraints

1<=N<= 5 * 10^5

Sample Input 1

7

Sample Output 1

5

Explanation:

We can choose set (1,2,3,4,5). Here product = 120 which mod 7 is 1

Sample Input 2

5

Sample Output 2

3

Explanation:

Here we can choose set (1,2,3) where product is 6 and 6 mod 5 =1

Sample Input 3

4

Sample Output 3

1

Explanation

Here we choose only (1)

 

C Solution

#include <stdio.h>

int fact(int num)

{

    if(num>0)

    return num * fact(num-1);

    else

    return 1;

}

int main()

{

    int N,i;

    scanf("%d",&N);

    int a[N-1];

    for(i=0;i<N;i++ )

    {

        a[i]=i+1;

    }

    for(int x =N-1;x>=1;x--)

    {

        int y = fact(x);

        if (y%N == 1)

        {

            printf("%d",x);

            break;

        }

    }

    return 0;

}

 

 

C++ Solution

#include <iostream>

using namespace std;

int fact(int num)

{

    if(num>0)

    return num * fact(num-1);

    else

    return 1;

}

int main()

{

    int N,i;

    cin>>N;

    int a[N-1];

    for(i=0;i<N;i++ )

    {

        a[i]=i+1;

    }

    for(int x =N-1;x>=1;x--)

    {

        int y = fact(x);

        if (y%N == 1)

        {

            cout<<x;

            break;

        }

    }

    return 0;

}

 

Java

import java.util.Scanner;

public class Main

{

    public static int fact(int num)

    {

        if(num>0)

        return num * fact(num-1);

        else

        return 1;

    }

 

public static void main(String[] args)

{

Scanner sc = new Scanner(System.in);

int N,i;

N = sc.nextInt();

int a[] = new int[N];

for(i=0;i<N;i++)

   {

     a[i]=i+1;

   }

for(int x =N-1;x>=1;x--)

        {

            int y = fact(x);

            if (y%N == 1)

            {

                System.out.print(x);

                break;

            }

        }                            

   }

}

 

Python

N=int(input())

a=[]

 

def fact(num):

    if num>0:

        return num * fact(num-1)

    else:

        return 1

 

for i in range (0,N-1):

    a.append(i+1)

for x in range (N-1,0,-1):

    y=fact(x)

    if(y%N)==1:

        print(x)

        break



Q2.

You are given an array of size N.

An array A is considered a summer array if all the even values in A are on one side and odd values are on the other side.

You are allowed to swap two adjacent elements in A in one operation. Find the minimum swap operations required to change A into a summer array.

Input Format

The first line contains an integer N, denoting the number of elements in A. Each line i of the N subsequent lines (where 0 <= i <= N) contains an integer describing A[i].

Constraints

1<= N <= 10^5

1 <= A[i] <= 10^5

Sample Input 1

3

1

2

2

Sample Output 1

0

Explanation:

Here N=3 A= [1,2,2]. 0 swaps are required here as the odd number is already on the left and all the even number are already on the right

 

Sample Input 2

3

1

2

1

Sample Output 2

1

Explanation:

Here N =3 A=[1,2,1]. We can swap 2 at 1st index with 1 at  0th index after which A becomes [2,1,1] satisfying the condition.

 

Sample Input 3

6

1

2

3

4

5

6

Sample Output 3

3

Explanation:

Here N =6 A= [1,2,3,4,5,6] We have to swap 4 one time to right and 2 two times to right making A = [1,3,5,2,4,6]

 

C Solution

#include <stdio.h>

int main()

{

    int N,swap=0,i;

    scanf("%d",&N);

    int a[N];

    for(int i=0;i<N;i++)

    {

        scanf("%d",&a[i]);

    }

    for(i=0;i<N;i++)

    {

        for(int j=i;j<N-1;j++)

        {

            if (((a[j])%2==0) && (a[j+1]%2==1))

            {

                int temp = a[j];

                a[j] = a[j+1];

                a[j+1] = temp;

                swap++;

                break;

            }

        }

    }

    printf("%d",swap);

    return 0;

}

 

C++ Solution

#include <iostream>

using namespace std;

int main()

{

    int N,swap=0,i;

    cin>>N;

    int a[N];

    for(int i=0;i<N;i++)

    {

        cin>>a[i];

    }

    for(i=0;i<N;i++)

    {

        for(int j=i;j<N-1;j++)

        {

            if (((a[j])%2==0) && (a[j+1]%2==1))

            {

                int temp = a[j];

                a[j] = a[j+1];

                a[j+1] = temp;

                swap++;

                break;

            }

        }

    }

    cout<<swap;

    return 0;

}

 

Java

import java.util.Scanner;

public class Main

{

                public static void main(String[] args) {

                                Scanner sc = new Scanner(System.in);

                                int i,swap=0;

                                int N = sc.nextInt();

                                int a[] = new int[N];

        for(i=0;i<N;i++)

        {

            a[i]=sc.nextInt();

        }

        for(i=0;i<N;i++)

        {

            for(int j=i;j<N-1;j++)

            {

                if (((a[j])%2==0) && (a[j+1]%2==1))

                {

                int temp = a[j];

                a[j] = a[j+1];

                a[j+1] = temp;

                swap++;

                break;

                }

            }

        }

        System.out.println(swap);

 

                }

}

 

Python

N=int(input())

swap=0

a=[]

for i in range(0,N):

    a.append(int(input()))

for i in range(0,N):

    for j in range(i,N-1):

        if ((a[j]%2==0) and (a[j+1]%2==1)):

            temp=a[j]

            a[j] = a[j+1]

            a[j+1] = temp

            swap=swap+1

            break

print(swap)



Q3.

There are N buckets numbered 11 through N. The buckets contain balls; each ball has a color between 11 and K. Let's denote the number of balls with color j that are initially in bucket i by ,ai,j?.

For each i from 1 to N−1 (in this order), someone draws a ball uniformly at random from bucket i and puts it into bucket i+1, then continues to draw the next ball. After putting a ball in bucket N, this person draws a ball, again uniformly at random, from bucket N.

For each color from 1 to K, find the probability that the ball drawn from bucket N has this color.

Input

  • The first line of the input contains two space-separated integers N and K.
  • N lines follow. For each i (1≤ i N), the i-th of these lines contains K space-separated integers ai,1?,ai,2?,…,ai,K?.

Output

Print a single line containing K space-separated real numbers. For each valid i, the i-th of these numbers should denote the probability that the last drawn ball has color i. your answer will be considered correct if absolute or relative error does not exceed 10^6

Sample Input 1

2 2

0 1

1 1

Sample Output 1

0.333333 0.666667

 

C Solution

#include<stdio.h>

int main(){

  int N,K,i,j;

  scanf("%d%d",&N,&K);

  float a[N][K],sum[N],p[K];

  for(i=0;i<N;i++){

        sum[i]=0;

    for(j=0;j<K;j++){

        scanf("%f",&a[i][j]);

        sum[i]=sum[i]+a[i][j];

    }

  }

  for(j=0;j<K;j++){

    p[j]=a[0][j]/sum[0];

  }

   for(j=0;j<K;j++){

  for(i=1;i<N;i++){

        p[j]=p[j]*((a[i][j]+1)/(sum[i]+1))+((1-p[j])*(a[i][j]/(sum[i]+1)));

    }

  }

  for(i=0;i<K;i++)

    printf("%f ",p[i]);

 

  }

 

C++ Solution

#include<bits/stdc++.h>

using namespace std;

typedef long long ll;

const int N=1005,M=1e9+7;

int n,k,a[N][N],s[N],b[N];

double ans[N];

int ksm(int x,int y){

                int ans=1;

                for (;y;y>>=1,x=(ll)x*x%M)

                                if (y&1)ans=(ll)ans*x%M;

                return ans;

}

int main(){

                scanf("%d%d",&n,&k);

                for (int i=1;i<=n;i++)

                                for (int j=1;j<=k;j++)scanf("%d",&a[i][j]),s[i]+=a[i][j];

                for (int i=1;i<n;i++)b[i]=1;

                b[n]=1;double pre=1;

                for (int i=n;i;i--){

                                pre=pre/(s[i]+b[i-1])*b[i];

                                for (int j=1;j<=k;j++)ans[j]=ans[j]+pre*a[i][j];

                }

                for (int i=1;i<=n;i++)printf("%.10lf\n",ans[i]);

                return 0;

}

 

Java

import java.util.*;

import java.lang.*;

import java.io.*;

class Main

{

                public static void main (String[] args) throws java.lang.Exception

                {

                                BufferedReader in=new BufferedReader(new InputStreamReader(System.in));

                                String[] S1 = in.readLine().split(" ");

                                int N = Integer.parseInt(S1[0]);

                                int K = Integer.parseInt(S1[1]);

                                int[][]A = new int[N+1][K+1];

                                int[]B = new int[N+1];

                                for (int n=1;n<=N;n++) {

                                    String[] S2 = in.readLine().split(" ");

                                    for (int k=1;k<=K;k++) {

                                        A[n][k] = Integer.parseInt(S2[k-1]);

                                        B[n] += A[n][k];

                                    }

                                    if (n>1) B[n]++;

                                }

                                StringBuilder S = new StringBuilder("");

                                for (int k=1;k<=K;k++) {

                                    double P = 0;

                                    for (int n=1;n<=N;n++) {

                                        P = (P + A[n][k])/B[n];

                                    }

                                    S.append(P);

                                    S.append(" ");

                                }

                                System.out.println(S);

                }

}

 

Python

def modifyarr(n,k,l,sumi):

    dp=[[0 for i in range(k)] for i in range(n)]

    for j in range(k):

        dp[0][j]=l[0][j]/sumi[0]

    for i in range(1,n):

        for j in range(k):

            dp[i][j]=(dp[i-1][j]*(l[i][j]+1)/(sumi[i]+1))+((1-dp[i-1][j])*(l[i][j]/(sumi[i]+1)))

    for i in range(k):

        print(dp[n-1][i],end=" ")

    print()

   

l=input().split()

n=int(l[0])

k=int(l[1])

l=[]

sumi=[0 for i in range(n)]

for i in range(n):

    lo=input().split()

    li=[int(i) for i in lo]

    l.append(li)

    sumi[i]=sum(li)

modifyarr(n,k,l,sumi)



   Q4.

Khaled has an array A of N elements. It is guaranteed that N is even. He wants to choose at most N/2 elements from array A. It is not necessary to choose consecutive elements.  Khaled is interested in XOR of all the elements he chooses. Here, XOR denotes the bitwise XOR operation.

  • If A=[2,4,6,8], then Khaled can choose the subset [2,4,8] to achieve XOR=(2 XOR 4 XOR 8)=14.

Khaled wants to maximize the XOR of all the elements he chooses. Your task is to help Khaled to find the max XOR of a subset that he can achieve by choosing at most N/2 elements

Input format

  • The first line contains an integer, N, denoting the number of elements in A.
  • Each line i of the N subsequent lines(where 0<=i<=N) contains an integer describing Ai.

Sample Input 1

   2
   1
   2
Sample Output 1 
   2

Explanation:

N=2,  A=[1,2] Khaled can choose the subset[2]. The XOR of the elements in the subset is 2. And the number of elements in the subset is 1 which is less than N/2.

C++ Solution

#include<bits/stdc++.h>

using namespace std;

int main ()

{

  int num;

  cin >> num;

 

  int arr1[num];

  for (int i = 0; i < num; i++) cin >> arr1[i];

  int M = 1 << 20;

  int arr2[M];

  char res[M];

 

  for (int i = 1; i < M; i++)

    arr2[i] = INT_MAX;

 

  for (int i = 0; i < num; i++)

    {

      if (arr1[i] == 0)

                   continue;

     

      for (int j = 0; j < M; j++)

                    res[j] = 0;

     

      for (int k = 0; k < M; k++) { if (res[k] == 1) continue; if (arr2[k] > arr2[k ^ arr1[i]])

                       arr2[k] = arr2[k ^ arr1[i]] + 1;

                 

         else if (arr2[k ^ arr1[i]] > arr2[k])

                       arr2[k ^ arr1[i]] = arr2[k] + 1;

                     res[k ^ arr1[i]] = 1;

                    

                  }

    }

 int j = M - 1, k = num >> 1;

 

  while (arr2[j] > k)

    j--;

  cout << j;

  return 0;

}

 

Java

import java.util.*;

class Main

{

  public static void main (String[]args)

  {

    final int N = 120, M = 1 << 20;

    int arr2[] = new int[M];

    char res[] = new char[M];

 

    Scanner sc = new Scanner (System.in);

    int num = sc.nextInt ();

    int arr1[] = new int[num];

 

    for (int i = 0; i < num; i++)

        arr1[i] = sc.nextInt ();

 

    for (int i = 1; i < M; i++)

        arr2[i] = Integer.MAX_VALUE;

 

    for (int i = 0; i < num; ++i)

      {

                if (arr1[i] == 0)

                  continue;

                for (int j = 0; j < M; ++j)

                  res[j] = 0;

 

                for (int k = 0; k < M; ++k) { if (res[k] == 1) continue; if (arr2[k] > arr2[k ^ arr1[i]])

                      arr2[k] = arr2[k ^ arr1[i]] + 1;

                     

                    else if (arr2[k ^ arr1[i]] > arr2[k])

                      arr2[k ^ arr1[i]] = arr2[k] + 1;

 

                    res[k ^ arr1[i]] = 1;

                  }

      }

    int j = M - 1, k = num >> 1;

    while (arr2[j] > k)

      --j;

    System.out.println (j);

  }

}



Q5.

You have an array of integers A1 A2 .. An. Find the longest increasing subsequence Ai1 Ai2 .. Ak
(1 <= k <= N) that satisfies the following condition:
For every adjacent pair of numbers of the chosen subsequence Ai[x] and Ai[x+1] (1 < x < k), the expression( Ai[x] Ai[x+1] ) * 2 < ( Ai[x] Ai[x+1] ) is true

Note: ‘&’ is the bitwise AND operation, ‘ | ‘ is the bit-wise OR operation

Input Format

  1. The first line contains an integer, N, denoting the number of elements in A.
  2. Each line i of the N subsequent lines (where 0 ≤ i < N) contains an integer describing Ai.

Sample Input 1

5
15
6
5
12
1

Sample Output 1

2

Explanation:

One possible subsequence is: 5 12

C ++

#include<bits/stdc++.h>

using namespace std;

int Sequence(int arr[], int i, int n, int prev){

    if(i == n)

       return 0;

    int x = Sequence(arr, i + 1, n, prev);

    int y = 0;

    if (arr[i] > prev)

       y = 1 + Sequence(arr, i + 1, n, arr[i]);

  

    return max(y, x);

}

 

int main(){

   

    int n;

    cin>>n;

   

    int arr[n];

   

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

    cin>>arr[i];

   

    int res = Sequence(arr, 0, n, 0);

    cout<< res;

}

 

Java

import java.util.Scanner;

class Main

{

    public static int Sequence(int[] arr, int i, int n, int prev)

    {

        if (i == n) {

            return 0;

        }

        int x = Sequence(arr, i + 1, n, prev);

 

        int y = 0;

        if (arr[i] > prev) {

            y = 1 + Sequence(arr, i + 1, n, arr[i]);

        }

 

        return Integer.max(y, x);

    }

 

    public static void main(String[] args)

    {

        Scanner sc = new Scanner(System.in);

        int n = sc.nextInt();

       

        int[] arr = new int[n];

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

        {

            arr[i] = sc.nextInt();

        }

        System.out.print(Sequence(arr, 0, arr.length, Integer.MIN_VALUE));

    }

}

 

Python

def Sequence(arr, i, n, prev=0):

   if i == n:

       return 0

   x = Sequence(arr, i + 1, n, prev)

   y = 0

   if arr[i] > prev:

       y = 1 + Sequence(arr, i + 1, n, arr[i])

   return max(y, x)

 

 

n = int(input())

arr = []

for i in range(n):

   arr.append(int(input()))

print(Sequence(arr, 0, len(arr)))


Q6.

Khaled has an array A of N elements. It is guaranteed that N is even. He wants to choose at most N/2 elements from array A. It is not necessary to choose consecutive elements.  Khaled is interested in XOR of all the elements he chooses. Here, XOR denotes the bitwise XOR operation. 

   For example:

  • If A=[2,4,6,8], then khaled can choose the subset [2,4,8] to achieve XOR=(2 XOR 4 XOR 8)=14.

Khaled wants to maximize the XOR of all the elements he chooses. Your task is to help khaled to find the max XOR of a subset that he can achieve by choosing at most N/2 elements?

   Input format:

  • The first line contains an integer, N, denoting the number of elements in A.
  • Each line i of the N subsequent lines(where 0<=i<=N) contains an integer describing Ai.

   Constraints 

  • 1<=N<=120
  • 1<=A[i]<=10^6

   Sample Input 1

   2
   1
   2
   Sample Output 1 
   2

Explanation:

N=2,  A=[1,2] khaled can choose the subset[2]. The xor of the elements in the subset is 2. And the number of elements in the subset is 1 which is less than N/2.

Sample Input 2
4
1
2

7

Sample Output 2

7

Explanation:

N=4,  A=[1,2,4,7] Khaled can choose the subset [7]. The xor of the elements in the subset is 7, and the number of elements in the subset is 1 which is less than N/2.

 

CPP

#include<bits/stdc++.h>

using namespace std

int main ()

{

  int n;

  cin >> n;

  int arr[n];

 

  for (int i = 0; i < n; i++) cin >> arr[i];

 

  int M = 1 << 20;

  int dp[M];

  char res[M];

 

  for (int i = 1; i < M; i++)

    dp[i] = INT_MAX;

 

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

    {

      if (arr[i] == 0)

                   continue;

     

      for (int j = 0; j < M; j++)

                    res[j] = 0;

     

      for (int k = 0; k < M; k++) { if (res[k] == 1) continue; if (dp[k] > dp[k ^ arr[i]])

                       dp[k] = dp[k ^ arr[i]] + 1;

                 

         else if (dp[k ^ arr[i]] > dp[k])

                       dp[k ^ arr[i]] = dp[k] + 1;

                    

                     res[k ^ arr[i]] = 1;

                     

                  }

    }

 

 int j = M - 1, k = n >> 1;

 

  while (dp[j] > k)

    j--;

 

  cout << j;

  return 0;

}

 

Java

import java.util.*;

class Main

{

  public static void main (String[]args)

  {

    final int N = 120, M = 1 << 20;

    int dp[] = new int[M];

    char res[] = new char[M];

 

    Scanner sc = new Scanner (System.in);

    int n = sc.nextInt ();

    int arr[] = new int[n];

 

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

        arr[i] = sc.nextInt ();

 

    for (int i = 1; i < M; i++)

        dp[i] = Integer.MAX_VALUE;

 

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

      {

                if (arr[i] == 0)

                  continue;

                for (int j = 0; j < M; ++j)

                  res[j] = 0;

 

                for (int k = 0; k < M; ++k) { if (res[k] == 1) continue; if (dp[k] > dp[k ^ arr[i]])

                      dp[k] = dp[k ^ arr[i]] + 1;

                     

                    else if (dp[k ^ arr[i]] > dp[k])

                      dp[k ^ arr[i]] = dp[k] + 1;

 

                    res[k ^ arr[i]] = 1;

                  }

      }

 

    int j = M - 1, k = n >> 1;

    while (dp[j] > k)

      --j;

    System.out.println (j);

  }

}

 

Python

from itertools import combinations

def fun(arr, N):

   sub = []

   max_xor = max(arr)

   for i in range(1, N // 2):

       comb = combinations(arr, i + 1)

       for i in comb:

           sub.append(list(i))

   for a in sub:

       z = 0

       for b in a:

           z = z ^ b

       if z > max_xor:

           max_xor = z

   return max_xor

 

 

N = int(input("Enter Length : "))

arr = []

for i in range(N):

   arr.append(int(input(f"Enter {i+1} Element : ")))

if N < 3:

   print("Output :", max(arr))

else:

   print("Output :", fun(arr, N))


Q7.

Your birthday is coming soon and one of your friends, Alex, is thinking about a gift for you. He knows that you really like integer arrays with interesting properties.

He selected two numbers, and and decided to write down on paper all integer arrays of length (in form a[1], a[2], …, a[K]), where every number a[i] is in range from to N, and, moreover, a[i+1] is divisible by a[i] (where 1 < <= K), and give you this paper as a birthday present.

Alex is very patient, so he managed to do this. Now you’re wondering, how many different arrays are written down on this paper?

Since the answer can be really large, print it modulo 10000.

Input:

The first line contains an integer, n, denoting the maximum possible value in the arrays.

The next line contains an integer, k, denoting the length of the arrays.

Input

Output

Output Description

2
1

2

The required length is 1, so there are only two possible arrays: [1] and [2].

2
2

3

All possible arrays are [1, 1], [1, 2], [2, 2].[2, 1] is invalid because 1 is not divisible by 2.

3
2

5

All possible arrays are [1, 1], [1, 2], [1, 3], [2, 2], [3, 3].

 

Java

import java.util.*;

class Main {

    public static void main(String args[]) {

        Scanner sc = new Scanner(System.in);

        int k, n;

        n = sc.nextInt();

        k = sc.nextInt();

        System.out.println(countt(n, k));

    }

 

    static int counter(int n, int k) {

        int count = 0;

        if (k == 1)

            return n;

        else {

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

                for (int j = 1; j <= n; j++) {

                    if (j % i == 0)

                        count++;

                }

            }

        }

        return count;

    }

 

    static int countt(int n, int k) {

        if (k == 1)

            return n;

        if (k == 2) {

            return counter(n, k);

        }

        int mid = k / 2;

        int x = countt(n, k - mid);

        int y = counter(n, mid);

        return x + y - 1;

    }

}

 

Python

def counter(n, k):

   num = 0

   if k == 1:

       return n

   else:

       for i in range(1, n + 1):

           for j in range(1, n + 1):

               if j % i == 0:

                   num += 1

   return num

 

def count(n, k):

   if k == 1:

       return n

   if k == 2:

       return counter(n, k)

   mid = k // 2

   x = count(n, k - mid)

   y = counter(n, mid)

   return x + y - 1

 

n = int(input())

k = int(input())

print(count(n, k))


Q8.

While playing an RPG game, you were assigned to complete one of the hardest quests in this game. There are n monsters you’ll need to defeat in this quest. Each monster i is described with two integer numbers – poweri and bonusi. To defeat this monster, you’ll need at least poweri experience points. If you try fighting this monster without having enough experience points, you lose immediately. You will also gain bonusi experience points if you defeat this monster. You can defeat monsters in any order.

The quest turned out to be very hard – you try to defeat the monsters but keep losing repeatedly. Your friend told you that this quest is impossible to complete. Knowing that, you’re interested, what is the maximum possible number of monsters you can defeat?

Input:

The first line contains an integer, n, denoting the number of monsters. The next line contains an integer, e, denoting your initial experience.

Each line i of the n subsequent lines (where 0 ≤ i < n) contains an integer, poweri, which represents power of the corresponding monster.

Each line i of the n subsequent lines (where 0 ≤ i < n) contains an integer, bonusi, which represents bonus for defeating the corresponding monster.

Input

Output

Output Description

2
123
78
130
10
0

2

Initial experience level is 123 points.

Defeat the first monster having power of 78 and bonus of 10. Experience level is now 123+10=133.

Defeat the second monster.

3
100
101
100
304
100
1
524

2

Initial experience level is 100 points.

Defeat the second monster having power of 100 and bonus of 1. Experience level is now 100+1=101.

Defeat the first monster having power of 101 and bonus of 100. Experience level is now 101+100=201.

The third monster can’t be defeated.

 

Java

import java.util.Arrays;

import java.util.Comparator;

import java.util.Scanner;

 

class Main

{

    public static void main(String[] args) {

        Scanner s = new Scanner(System.in);

        int n = s.nextInt();

        int exp = s.nextInt();

 

        int monst[] = new int[n];

        int bonus[] = new int[n];

 

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

            monst[i] = s.nextInt();

        }

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

            bonus[i] = s.nextInt();

        }

 

        class Monster {

            private final int power, bonus;

            public Monster(int power, int bonus){

                this.power = power;

                this.bonus = bonus;

            }

        }

 

        Monster[] monsters = new Monster[n];

 

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

            monsters[i] = new Monster(monst[i], bonus[i]);

 

        Arrays.sort(monsters, Comparator.comparingInt(m -> m.power));

 

        int count = 0;

 

        for(Monster m: monsters){

            if(exp < m.power) break;

            exp += m.bonus;

            ++count;

        }

        System.out.println(count);

    }

}

 

Python

n = int(input())

lev = int(input())

p = []

b = []

a = []

ans = 0

for i in range(n):

   p.append(int(input()))

for j in range(n):

   b.append(int(input()))

for k in range(n):

   a.append([p[k], b[k]])

a.sort()

for z in a:

   if z[0] > lev:

       break

   lev += z[1]

   ans += 1

print(ans)

 

CPP

#include<iostream>

#include<map>

using namespace std;

int main(){

int nMon,nExp;

cin>>nMon;

cin>>nExp;

map<int,int> monster;

int arr[nMon],monBon;

for(int i=0; i<nMon; i++){ cin>>arr[i];

}

for(int i=0; i<nMon; i++){ cin>>monBon;

    monster[arr[i]]=monBon;

}

 

map<int,int> :: iterator iter;

int value,valBon,counter=0;;

 

for(iter=monster.begin(); iter!= monster.end(); iter++){

    value=(*iter).first;

    valBon=(*iter).second;

     if(nExp>=value){

        nExp=nExp+valBon;

        counter++;

     }else{

 

        break;

     }

}

cout<<"OUTPUT : "<< counter<<endl;

}


Q9.

You have an array of integers A1 A2 .. An. Find the longest increasing subsequence Ai1 Ai2 .. Ak
(1 <= k <= N) that satisfies the following condition:
For every adjacent pair of numbers of the chosen subsequence Ai[x] and Ai[x+1] (1 < x < k), the expression( Ai[x] Ai[x+1] ) * 2 < ( Ai[x] Ai[x+1] ) is true

Note: ‘&’ is the bitwise AND operation, ‘ | ‘ is the bit-wise OR operation

Input:

The first line contains an integer, N, denoting the number of elements in A.

Each line i of the N subsequent lines (where 0 ≤ i < N) contains an integer describing Ai.

Sample cases:

Input

Output

Output Description

5
15
6
5
12
1

2

One possible subsequence is: 5 12

6
9
17
2
15
5
2

2

One possible subsequence is: 2 15

7
17
16
12
2
8
17
17

3

One possible subsequence is: 2 8 17

 

CPP

#include<bits/stdc++.h>

using namespace std;

int sub(int arr[], int i, int n, int prev){

    if(i == n)

       return 0;

    int a = sub(arr, i + 1, n, prev);

    int b = 0;

    if (arr[i] > prev)

       b = 1 + sub(arr, i + 1, n, arr[i]);

  

    return max(b, a);

}

 

int main(){

   

    int n;

    cin>>n;

   

    int arr[n];

   

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

    cin>>arr[i];

   

    int res = sub(arr, 0, n, 0);

    cout<< res;

}

 

Java

class Main

{

    public static int LIS(int[] arr, int i, int n, int prev)

    {

        if (i == n) {

            return 0;

        }

        int excl = LIS(arr, i + 1, n, prev);

 

        int incl = 0;

        if (arr[i] > prev) {

            incl = 1 + LIS(arr, i + 1, n, arr[i]);

        }

 

        return Integer.max(incl, excl);

    }

 

    public static void main(String[] args)

    {

        int[] arr = { 15, 6, 5, 12, 1 };

 

        System.out.print("The length of the LIS is "

                        + LIS(arr, 0, arr.length, Integer.MIN_VALUE));

    }

}

 

 

Python

def sub(arr, i, n, prev=0):

   if i == n:

       return 0

   a = sub(arr, i + 1, n, prev)

   b = 0

   if arr[i] > prev:

       b = 1 + sub(arr, i + 1, n, arr[i])

   return max(b, a)

 

 

n = int(input())

arr = []

for i in range(n):

   arr.append(int(input()))

print("Length of Bitwise subsequence will be", sub(arr, 0, len(arr)))


Q10.

You have been given a string S of length N. The given string is a binary string which consists of only 0’s and ‘1’s. Ugliness of a string is defined as the decimal   number that this binary string represents.

 Example:

“101” represents 5.

“0000” represents 0.

“01010” represents 10.

 There are two types of operations that can be performed on the given string.

Swap any two characters by paying a cost of A coins.

Flip any character by paying a cost of B coins

flipping a character means converting a ‘1’to a ‘0’or converting a ‘0’ to a ‘1’.

Initially, you have been given coins equal to the value defined in CASH. Your task is to minimize the ugliness of the string by performing the above mentioned operations on it. Since the answer can be very large, return the answer modulo 10^9+7.

Note:

You can perform an operation only if you have enough number of coins to perform it.

After every operation the number of coins get deducted by the cost for that operation.

Input Format

The first line contains an integer, N, denoting the number of character in the string 

The next line contains a string, S, denoting the the binary string

The next line contains an integer, CASH, denoting the total number of coins present initially

Next will contains an integer, A, denoting the cost to swap two characters.

Then the next line contains an integer, B, denoting the cost to flip a character.

Constraints

1 <= N <= 10^5

1< len(S)<= 10^5

1<=CASH <=10^5

1<=A<=10^5

1<=B<=10^5

Sample Input 1 :

4
1111
7
1
2

Sample Output 1 :

  1

Explanation:

   3 flips can be used to create “0001” which represents 1.

Sample Input 2:

  6
  111011
  7
  1
  3

Sample Output 2:

  7

Explanation:

  First swap 0 with the most significant 1, then use flip twice first on index one and then on index two “111011”=>”0111111″=>”001111″=>”000111″ the value represented is 7.

Sample Input 3:

  6
  111011
  7
  3
  2

Sample Output 3:

  3

Explanation:

 Flip the 3 most significant characters to get “000011” : the value represented by this string is 3.

CPP

#include<bits/stdc++.h>

using namespace std;

string s;

int n, cash, a, b;

void swapf ()

{

  int i;

  for (int a = 0; a < s.length (); a++)

  if (s[a] == '1')

  {

      i = a;

      break;

  }

  int j = s.length () - 1;

  while (j > i)

    {

      if (cash < a)

                break;

 

      if (s[j] == '0')

                {

                  if (s[i] == '0')

                    i++;

 

                  else

                    {

                      swap (s[i], s[j]);

                      cash -= a;

                      j--;

                    }

                }

      else

                j--;

    }

}

void flipf ()

{

  int i;

  for (int a = 0; a < s.length (); a++)

  if (s[a] == '1')

  {

      i = a; break;

  }

  while (cash >= b)

    {

      if (i == s.length ())

      break;

 

      if (s[i] == '1')

                {

                  s[i] = '0';

                  i++;

                  cash -= b;

                }

    }

}

int main ()

{

  cin >> n >> s >> cash >> a >> b;

  if (a < b)

    {

      swapf ();

      flipf ();

    }

  else

    {

      flipf ();

      swapf ();

    }

  cout << stoull (s, 0, 2);

}

 

Java

import java.util.*;

class Main

{

  static String str;

  static int cash, n, a, b;

  static void swapf ()

  {

    char s[] = str.toCharArray ();

    int i = 0;

    for (int a = 0; a < s.length; a++)

      if (s[a] == '1')

                {

                  i = a;

                  break;

                }

    int j = s.length - 1;

    while (j > i)

      {

                if (cash < a)

                  break;

                if (s[j] == '0')

                  {

                    if (s[i] == '0')

                      i++;

                    else

                      {

                                char temp = s[i];

                                s[i] = s[j];

                                s[j] = temp;

                                cash -= a;

                                j--;

                      }

                  }

                else

                  j--;

      }

    str = new String (s);

  }

  static void flipf ()

  {

    char s[] = str.toCharArray ();

    int i = 0;

 

    for (int a = 0; a < s.length; a++)

      if (s[a] == '1')

                {

                  i = a;

                  break;

                }

    while (cash >= b)

      {

                if (i == s.length)

                  break;

                if (s[i] == '1')

                  {

                    s[i] = '0';

                    i++;

                    cash -= b;

                  }

      }

    str = new String (s);

  }

 

  public static void main (String[]args)

  {

    Scanner sc = new Scanner (System.in);

    n = sc.nextInt ();

    str = sc.next ();

    cash = sc.nextInt ();

    a = sc.nextInt ();

    b = sc.nextInt ();

 

    if (a < b)

      {

                swapf ();

                flipf ();

      }

    else

      {

                flipf ();

                swapf ();

      }

    System.out.println (Integer.parseInt (str, 2));

  }

}

 

 
Python

# N = int(input())

# S = list(input())

# Cash = int(input())

# A = int(input())

# B = int(input())

N = 6

S = list("111011")

Cash = 7

A = 1

B = 3

 

 

def swap():

   global Cash

   Rs = S.copy()

   S[S.index('1')], S[''.join(S).rindex('0')] = S[''.join(S).rindex('0')], S[S.index('1')]

   if Rs == S:

       flip()

   else:

       Cash -= A

 

 

def flip():

   global Cash

   S[S.index('1')] = '0'

   Cash -= B

 

 

while Cash > A or Cash > B:

   if A < B and '0' in S:

       swap()

   else:

       flip()

print(int(''.join(S), 2))



FAQ

Any Questions?
Look Here.

Related Articles

Accenture Abstract Reasoning Previous Year Questions

Accenture Critical Reasoning and Problem Solving Questions

Accenture English Ability Previous Year Questions

Accenture MS Office Questions

Accenture Network Security & Cloud Computing Questions

Accenture Pseudocode Questions

Capgemini Game Based Aptitude Previous Year Questions

Capgemini Technical MCQ's Previous Year Questions

Cisco Aptitude Previous Year Questions

Cognizant Gen C Quantitative Ability Previous Year Questions

Dell Quantitative Aptitude Previous Year Questions

Dell Verbal Ability Previous Year Questions

Deloitte Quantitative Aptitude Previous Year Questions

DXC Technology Automata Fix Questions

DXC Technology Computer Programming Questions

DXC Technology Logical Ability Questions

DXC Technology Quantitative Ability Previous Year Questions

DXC Technology Verbal Ability Questions

Goldman Sachs Numerical Computation Previous Year Questions

Hexaware Logical Ability Previous Year Questions

Hexaware Numerical Ability Previous Year Questions

Hexaware Verbal Ability Previous Year Questions

Infosys Mathematical Ability Previous Year Questions

Infosys Pseudocode Questions

Infosys Puzzle Solving Previous Year Questions

Infosys Reasoning Ability Previous Year Questions

Infosys Verbal Ability Previous Year Questions

InfyTQ DBMS Questions

InfyTQ Java Questions

LTI Logical Reasoning Previous Year Questions

LTI Quantitative Ability Previous Year Questions

LTI Verbal Ability Previous Year Questions

Mindtree Previous Year Questions

TCS NQT Numerical Ability Questions

TCS NQT Previous Year Coding Questions

TCS NQT Verbal Ability Questions

Tech Mahindra Logical Ability Previous Year Questions

Tech Mahindra Quantitative Ability Previous Year Questions

Top 14 Capgemini Pseudocode Questions

Top 15 LTI Coding Questions

Top 15 TCS NQT Reasoning Questions

Wipro Logical Ability Questions

Wipro Quantitative Ability Previous Year Questions

Wipro Verbal Ability Questions