C# Load entiers et affichage pair / impair

Bonjour demandais si il ya un moyen plus facile pour afficher pair /impair de chiffres.
Je sais que je pourrais faire une boucle for et de charger une liste. Ensuite, je peux écrire un autre pour la boucle
pour parcourir la liste et de vérifier si une valeur est pair /impair:

for(i=0; i<100; i++)
 if(myList[i]%2==0) //even
    //do something
 else
    //odd do something

Mais est-il possible de raccourcir ce simplement que je peux facilement obtenir une liste de les nombres pairs ou impairs. Pas de devoirs demandais juste.

OriginalL'auteur oJM86o | 2010-03-02

11

Pourriez-vous utiliser une sorte de lambdas:
```
//load a list, t, with 100 integers
List<int> t = Enumerable.Range(1, 100).ToList();

//find odd numbers
var oddNumbers = t.Where(num => num%2 != 0);

//find even numbers
var evenNumbers = t.Where(num => num%2 == 0);

//print odd numbers
foreach (int i in oddNumbers)
    Console.WriteLine(i);

//print even numbers
    foreach(int i in evenNumbers)
        Console.WriteLine(i);
```
L'Énumérable juste des charges de la liste avec les 1 à 100, et ensuite, j'ai simplement arracher toutes les chances /evens et de les imprimer ensuite. Tout cela peut être réduit à:
```
var e = Enumerable.Range(1, 100).Where(num => num%2==0); //for even numbers
var o = Enumerable.Range(1, 100).Where(num => num%2!=0); //for odd numbers
```
e,o disposer d'un implicite de type var. Le compilateur peut déterminer son type de sorte que ces deux lignes sont équivalentes à:
```
List<int> eo = Enumerable.Range(1, 100).ToList(); //must tell it its a list
```
Alors pour trouver la cote /evens directement à un type de liste:
```
List<int> o = eo.Where(num => num%2!=0).ToList();
List<int> e = eo.Where(num => num%2==0).ToList();
```
Et que l'impression qu'il est répertorié dans mon code initial.

Votre prédicat pour les nombres impairs contient un méchant bug. Voir si vous pouvez le trouver. (Astuce: vous avez besoin de plus de cas de test.)
Lippert peut-être num % 2==1 était un mauvais choix...comme 2==1 retourne false :). Éditer...laissez-moi savoir si je me suis trompé.
Bonne estimation, de corriger corriger, mais pas de cigare parce que vous n'avez pas réellement diagnostiquer le problème. Tentez votre code d'origine avec une gamme qui va de -100 à +100.
le comte ne peut pas être < 0.
Correct. Juste pour être clair pour les autres lecteurs:%2 est -1 si A est négatif d'un nombre impair. Donc A%2==1 n'est pas un test pour "bizarre", c'est un test pour "est à la fois positif et impair". '%2!=0 est un test pour "bizarre".

OriginalL'auteur JonH
15

LINQ façon... Étrange et Même un nombre entre 1 et 100.
```
var even = Enumerable.Range(1,100).Where(i => i % 2 == 0);
var odd = Enumerable.Range(1,100).Where(i => i % 2 != 0);
```
C'est plus rapide pour remplacer i%2 avec i&1 dans votre exemple
Lonli-Lokli mais ensuite, il y a deux tête de commutateurs de comprendre ce qui se passe. La lisibilité est plus important pour une telle quantité insignifiante de l'épargne.
Bon point, mais je pense que les gens devraient être encouragés à écrire des choses dans un performant, expliquent-ils. par exemple: // i & 1 == 0 is faster than i % 2 == 0

OriginalL'auteur Jesper Palm
3

Vous pouvez utiliser LINQ pour sortir seulement la pair ou impair, et puis processus:
```
var even = myList.Where(i => i%2==0);
foreach(var number in even)
     //do something
```
OriginalL'auteur Reed Copsey
3
```
var t = Enumerable.Range(1, 100).ToList();
var oddNumbers = t.Where(n => (n & 1) != 0).ToList();
var evenNumbers = t.Where(n => (n & 1) == 0).ToList();
```
Comment est-ce utile, lorsqu'un 12 upvotes réponse dit déjà il y a 2 ans?
Je comprends que vous travaillez pour débloquer certaines fonctionnalités, peut-être essayer quelques nouvelles / questions sans réponse bien 🙂

OriginalL'auteur Ashot
1

Je ne pense pas que vous ayez à créer la première boucle. Vous pourriez tout simplement:
```
for (i=1; i < 101; i++)
{
   if (i % 2 != 0)
   {
      //do something
   }
}
```
Ou encore:
```
for (i=1, i < 101, i+=2)
{
   //do something
}
```
Le problème n'est pas de choisir l'impair ou même des indices, c'est le choix de l'impair ou même des éléments de la liste d'entiers.
Lippert -- Ah, je vois. Merci.

OriginalL'auteur davecoulter
0

Remplir votre liste en fonction de ces formules
```
Odds[0->N] = 2*i+1
Evens[0->N] = 2*i
```
OriginalL'auteur Ian Jacobs
0

Si vous avez uniquement besoin de la moitié des numéros, il vous suffit de créer la moitié des numéros ( .. ; .. ; i = i + 2)

Si vous avez besoin de tous les chiffres, mais veulent éviter une boucle supplémentaire, vous pouvez les marquer ou de processus lors de la phase initiale de la boucle.

Ou, lors de la création, de faire jusqu'à trois listes/tableaux - un pour tous les nombres, l'autre pour la cote, et la troisième pour les evens.

Est-il une application spécifique?

Le problème est de ne pas regarder les même indices, le problème est de regarder les même éléments.

OriginalL'auteur Jason Kleban

Vous devez vous connecter pour publier un commentaire.