Numéro 30: Formation informatique - problèmes et défis actuels des grandes entreprises

Des questions

100 prisonniers en prison sont debout dans une file d'attente face à une direction. Chaque prisonnier porte un chapeau de couleur noire ou rouge. Un prisonnier peut voir les chapeaux de tous les prisonniers devant lui dans la file d'attente, mais ne peut pas voir son chapeau et les chapeaux des prisonniers debout derrière lui.
Le geôlier va demander la couleur du chapeau de chaque prisonnier à partir du dernier prisonnier en file d'attente. Si un prisonnier dit la bonne couleur, il est sauvé, sinon exécuté. Combien de prisonniers peuvent être sauvés au maximum s'ils sont autorisés à discuter d'une stratégie avant que le geôlier ne commence à demander la couleur de leur chapeau.

Dans un pays, toutes les familles veulent un garçon. Ils continuent d'avoir des bébés jusqu'à la naissance d'un garçon. Quel est le ratio attendu de garçons et de filles dans le pays?

Tâches

Étant donné un entier N , indiquant le nombre de coupes qui peuvent être faites sur une crêpe, trouvez le nombre maximum de morceaux qui peuvent être formés en faisant N coupes.

Entrée:
La première ligne d'entrée contient un seul entier T indiquant le nombre de cas de test. Ensuite, les cas de test T suivent. Chaque cas de test se compose d'une ligne. La première ligne de chaque cas de test se compose d'un entier N.

Sortie:
correspondant à chaque cas de test, sur une nouvelle ligne, imprimez le nombre maximal de pièces pouvant être formées en effectuant N coupes.

Contraintes: Exemple: entrée sortie

1 ≤ T ≤ 100
1 ≤ N ≤ 106



2
5
3

16
7

Given an array A of N integers. The task is to find a peak element in it.
An array element is peak if it is not smaller than its neighbours. For corner elements, we need to consider only one neighbour.

Note: There may be multiple peak element possible, in that case you may return any valid index.

Input Format:
The first line of input contains an integer T denoting the number of test cases. Then T test cases follow. Each test case contains an integer N. Then in the next line are N space separated values of the array.

Output Format:
For each test case output will be 1 if the index returned by the function is an index with peak element.

User Task:
Vous n'avez pas besoin de prendre de contribution. Complétez simplement la fonction peakElement () fournie et retournez l'index valide.

Contraintes: Exemple: Entrée: Sortie: Explication: Testcase 1: Dans le tableau donné, 3 est l'élément de crête. Le testcase 2: 4 est l'élément de pointe.
1 <= T <= 100
1 <= N <= 100
1 <= A[] <= 1000



2
3
1 2 3
2
3 4

3
4

Consider a big party where a log register for guest’s entry and exit times is maintained. Find the time at which there are maximum guests in the party. Note that entries in register are not in any order.

Input:
The first line of input contains an integer T denoting the number of test cases. Then T test cases follow. Each test case contains an integer n denoting the size of the entry and exit array. Then the next two line contains the entry and exit array respectively.

Output:
Print the maximum no of guests and the time at which there are maximum guests in the party.

Constraints:
1<=T<=10^5
1<=N<=10^5
1<=entry[i],exit[i]<=10^5

Example:
Input:
2
5
1 2 10 5 5
4 5 12 9 12
7
13 28 29 14 40 17 3
107 95 111 105 70 127 74

Output:
3 5
7 40

int main() {
	int t,n,final;
	cin>>t;
	while(t--){
	   cin>>n;
	   final=(n+(n*n)+2)/2;
	   cout<<final<<endl;
	}
	return 0;
}

// arr: input array
// n: size of array
int peakElement(int a[], int n)
{
    int i;
    for(i=1;i<n-1;i++){
        if(a[i]>a[i-1] && a[i]>a[i+1]){
            return i;
        }
    }
    if(n>1 && a[0]>a[1])
        return a[0];
    if(n-2>=0 && a[n-1]>a[n-2])
    return a[n-1];
}

/*package whatever //do not write package name here */

import java.util.*;
import java.lang.*;
import java.io.*;

class GFG {
	public static void main (String[] args) {
		Scanner sc = new Scanner(System.in);
		int T = sc.nextInt();
		
		while (T > 0) {
		    int N = sc.nextInt();
		    int[] entry = new int[N];
		    int[] exit = new int[N];
		    for (int i = 0; i < N; i++) {
		        entry[i] = sc.nextInt();
		    }
		    
		    for (int i = 0; i < N; i++) {
		        exit[i] = sc.nextInt();
		    }
		    
		    Arrays.sort(entry);
		    Arrays.sort(exit);
		    //System.out.println(Arrays.toString(entry));
		    //System.out.println(Arrays.toString(exit));
		    
		    int counter = 0;
		    int maxCounter = -1;
		    int maxTime = -1;
		    
		    int entryIdx = 0;
		    int exitIdx = 0;
		    
		    while (entryIdx < N && exitIdx < N) {
		        if (entry[entryIdx] <= exit[exitIdx]) {
		            counter++;
		            if (counter > maxCounter) {
		                maxCounter = counter;
		                maxTime = entry[entryIdx];
		            }
		            entryIdx++;
		        } else {
		            counter--;
		            exitIdx++;
		        }
		    }
		    
		    System.out.println(maxCounter + " " + maxTime);   
		    T--;
		}
	}
}