


Écrivez un code en C++ pour trouver le nombre de sous-tableaux avec des sommes impaires
Un sous-tableau est une partie contiguë d'un tableau. Par exemple, on considère un tableau [5, 6, 7, 8], alors il y a dix sous-tableaux non vides, tels que (5), (6), (7), (8), (5, 6 ), (6, 7), (7,8), (5,6,7), (6,7,8) et (5,6,7,8).
Dans ce guide, nous expliquerons toutes les informations possibles pour trouver le nombre de sous-tableaux à sommes impaires en C++. Pour trouver le nombre de sous-tableaux avec des sommes impaires, nous pouvons utiliser différentes méthodes, voici donc un exemple simple -
Input : array = {9,8,7,6,5} Output : 9 Explanation : Sum of subarray - {9} = 9 {7} = 7 {5} = 5 {9,8} = 17 {8,7} = 15 {7,6} = 13 {6,5} = 11 {8,7,6} = 21 {9,8,7,6,5} = 35
Méthode de la force brute
Par cette méthode, nous pouvons simplement vérifier que la somme des éléments dans tous les sous-tableaux est paire ou impair, si c'est pair nous rejetterons le sous-tableau et calculerons le sous-tableau dont la somme est impaire, ce n'est pas un moyen efficace car la complexité de ce code est O(n2).
Exemple
#include <bits/stdc++.h> using namespace std; int main(){ int n=5, temp = 0; int a[n-1] = { 9,8,7,6,5 } ; // declaring our array. int cnt = 0; // counter variable. for(int i = 0; i < n; i++){ temp = 0; // refreshing our temp sum. for(int j = i; j < n; j++){ // this loop will make our subarrays starting from i till n-1. temp = temp + a[j]; if( temp % 2 == 1 ) cnt++; } } cout << "Number of subarrays with odd sum : " << cnt << "\n"; return 0; }
Sortie
Number of subarrays with odd sum : 9
La description du code ci-dessus
Une boucle imbriquée est utilisée dans ce code, où la boucle externe est utilisée pour incrémenter la valeur de I, et I pointe vers chaque valeur du tableau depuis le début ; la boucle interne est utilisée pour trouver un sous-tableau avec une somme impaire commençant à la position " i " .
Méthode efficace
Dans cette méthode, nous traitons chaque élément à partir de la 0ème position du tableau. Si l'élément actuel est impair, incrémentez un compteur impair et incrémentez un compteur pair pour chaque nombre pair. Si nous trouvons un nombre impair, les valeurs de Pair et impair sont inversées, car l'ajout d'un nombre impair au sous-tableau modifie sa parité, et enfin un décompte est ajouté au résultat. La complexité de ce code est O(n) puisque nous traitons chaque élément.
Exemple
#include <bits/stdc++.h> using namespace std; int main(){ int odd = 0, even = 0, result = 0,n=5,i,temp; int arr[ n-1 ] = { 9,8,7,6,5}; // initialising the array // for loop for processing every element of array for ( i = 0 ; i < n ; i ++ ) { if ( arr[ i ] % 2 == 0 ) { even++; } else { // swapping even odd values temp = even; even = odd; odd = temp + 1; } result += odd; } cout << "Number of subarrays with odd sum : " << result; }
Sortie
Number of subarrays with odd sum : 9
Explication du code ci-dessus
Dans ce code, nous vérifions le nombre pair/impair de chaque élément et incrémentons le compteur pair pour pair et le compteur impair pour impair. De plus, si un nombre impair est trouvé, nous échangerons les valeurs du compteur de parité ; sinon, cela modifiera la parité du sous-tableau. Ajoutez ensuite la valeur du compteur impair à la variable résultat après chaque itération.
Conclusion
Dans cet article, nous avons expliqué comment trouver la méthode de coercition numérique de Brute pour les sous-tableaux avec une somme impaire, générer chaque sous-tableau avec une somme impaire et incrémenter le nombre. La complexité temporelle de ce code est O(n2). Un moyen efficace de procéder consiste à parcourir chaque élément du tableau et à incrémenter la variable compteur impair/pair avec chaque nombre impair/pair trouvé, en échangeant les compteurs si un nombre impair est trouvé, la complexité temporelle de ce code est O( n). J'espère que vous avez trouvé cet article utile pour comprendre le problème et la solution.
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!

Outils d'IA chauds

Undresser.AI Undress
Application basée sur l'IA pour créer des photos de nu réalistes

AI Clothes Remover
Outil d'IA en ligne pour supprimer les vêtements des photos.

Undress AI Tool
Images de déshabillage gratuites

Clothoff.io
Dissolvant de vêtements AI

AI Hentai Generator
Générez AI Hentai gratuitement.

Article chaud

Outils chauds

Bloc-notes++7.3.1
Éditeur de code facile à utiliser et gratuit

SublimeText3 version chinoise
Version chinoise, très simple à utiliser

Envoyer Studio 13.0.1
Puissant environnement de développement intégré PHP

Dreamweaver CS6
Outils de développement Web visuel

SublimeText3 version Mac
Logiciel d'édition de code au niveau de Dieu (SublimeText3)

La détection hors distribution (OOD) est cruciale pour le fonctionnement fiable des systèmes intelligents en monde ouvert, mais les méthodes actuelles de détection orientée objet souffrent d'« incohérences d'évaluation » (incohérences d'évaluation). Travaux antérieurs OpenOODv1 unifie l'évaluation de la détection OOD, mais présente toujours des limites en termes d'évolutivité et de convivialité. Récemment, l'équipe de développement a de nouveau proposé OpenOODv1.5. Par rapport à la version précédente, la nouvelle évaluation de la méthode de détection OOD a été considérablement améliorée pour garantir la précision, la standardisation et la convivialité. Document d'image : https://arxiv.org/abs/2306.09301OpenOODCodebase:htt

Sur la courbe précision-rappel, les mêmes points sont tracés avec des axes différents. Attention : Le premier point rouge à gauche (0% de rappel, 100% de précision) correspond à 0 règle. Le deuxième point à gauche est la première règle, et ainsi de suite. Skope-rules utilise un modèle d'arborescence pour générer des règles candidates. Créez d’abord des arbres de décision et considérez les chemins allant du nœud racine aux nœuds internes ou aux nœuds feuilles comme candidats aux règles. Ces règles candidates sont ensuite filtrées selon certains critères prédéfinis tels que la précision et le rappel. Seuls ceux dont la précision et le rappel sont supérieurs à leurs seuils sont retenus. Enfin, un filtrage de similarité est appliqué pour sélectionner des règles présentant une diversité suffisante. En général, les règles Skope sont appliquées pour connaître la cause profonde de chaque problème.

En Java, une façon de transmettre des paramètres au moment de l'exécution consiste à utiliser la ligne de commande ou le terminal. Lors de la récupération de ces valeurs pour les paramètres de ligne de commande, nous devrons peut-être trouver le nombre de paramètres fournis par l'utilisateur au moment de l'exécution, ce qui peut être obtenu à l'aide de l'attribut length. Cet article vise à expliquer le processus de transmission et d'obtention d'un certain nombre de paramètres fournis par l'utilisateur à l'aide d'un exemple de programme. Obtenir le nombre d'arguments fournis par l'utilisateur au moment de l'exécution Avant de trouver le nombre d'arguments de ligne de commande, notre première étape consiste à créer un programme qui permet à l'utilisateur de transmettre des arguments au moment de l'exécution. Paramètre String[] Lors de l'écriture de programmes Java, nous rencontrons souvent la méthode main(). Lorsque la JVM appelle cette méthode, l'application Java commence à s'exécuter. Il est utilisé avec un argument appelé String[]args

Les commandes Linux sont l'un des outils indispensables dans le travail quotidien des administrateurs système. Elles peuvent nous aider à accomplir diverses tâches de gestion du système. Lors des travaux d'exploitation et de maintenance, il est parfois nécessaire de vérifier le numéro d'un certain processus dans le système afin de détecter les problèmes et de procéder à des ajustements à temps. Cet article explique comment utiliser les commandes Linux pour vérifier le nombre de processus telnet, apprenons ensemble. Dans les systèmes Linux, nous pouvons utiliser la commande ps combinée avec la commande grep pour afficher le nombre de processus telnet. Tout d'abord, nous devons ouvrir un terminal,

Nous avons deux tableaux d'entiers, l'un avec les éléments calculés et l'autre avec les points de division nécessaires pour diviser le tableau afin de générer des sous-ensembles, nous devons calculer la somme de chaque sous-ensemble dans chaque division et renvoyer le sous-ensemble maximum. Passons en revue l'exemple Comprendre : - input −intarr[]=intarr[]={9,4,5,6,7}intsplitPoints[]={0,2,3,1} ; sortie−la somme maximale du sous-tableau après chaque division [ 22, 13,9,9] Explication - Ici, nous décomposons le tableau en fonction de ses points de division et obtenons le sous-ensemble maximum après chaque division et après la première division → {9} et {4,5,6,7 }>> La somme maximale des sous-tableaux est de -22 après la deuxième division →{9},{4

Obtenir la somme d’une série est l’une des tâches pratiques les plus simples lorsque nous apprenons la programmation et la construction logique. En mathématiques, il existe des moyens de trouver la somme des séries présentes dans différentes séries. En programmation, nous les générons un par un en implémentant la logique et les ajoutons à plusieurs reprises pour obtenir la somme ou bien faisons autre chose selon les besoins. Dans cet article, nous présenterons la technique permettant d'obtenir la somme de tous les nombres impairs jusqu'à N en utilisant C++. Il existe deux manières possibles d’obtenir cette somme, mais avec une particularité. Examinons ces méthodes une par une. L'algorithme est plafonné au nombre N. Initialisez la somme à 0. i va de 1 à N. Si i est un nombre impair, alors. Somme :=somme+i. Si ça se termine. Affichez la somme. Exemple#include<iostre

Dans cet article, nous utiliserons C++ pour résoudre le problème de trouver le nombre de sous-tableaux dont les valeurs maximales et minimales sont les mêmes. Voici un exemple du problème −Input:array={2,3,6,6,2,4,4,4}Output:12Explication :{2},{3},{6},{6}, {2 },{4},{4},{4},{6,6},{4,4},{4,4}et{4,4,4}sont les sous-tableaux qui peuvent être formés avec les mêmes éléments maximum et minimum. Entrée : tableau = {3, 3, 1,5,

Étant donné un arbre N-aire, notre tâche est de trouver le nombre total de façons de parcourir l'arbre, par exemple - Pour l'arbre ci-dessus, notre résultat sera de 192. Pour ce problème, nous avons besoin de connaissances en combinatoire. Maintenant, dans ce problème, il nous suffit de vérifier toutes les combinaisons possibles de chaque chemin et cela nous donnera la réponse. Méthode pour trouver la solution Dans cette méthode, il nous suffit d'effectuer un parcours hiérarchique, de vérifier le nombre d'enfants de chaque nœud, puis de le multiplier factoriellement par la réponse. Exemple de code C++ de la méthode ci-dessus #include<bits/stdc++.h>usingnamespacestd;structNode{//s
