C#, Load Integer-und Anzeige-ungerade / gerade

Hallo Frage mich, ob es ist ein einfacher Weg, um gerade /ungerade zahlen.
Ich weiß, ich könnte tun, eine for-Schleife und laden Sie eine Liste. Dann kann ich schreiben Sie eine weitere for-Schleife
um eine Schleife durch die Liste und überprüfen Sie, ob ein Wert gerade /ungerade:

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

Aber gibt es eine Möglichkeit, diese kürzen sich nur damit, dass ich kann leicht eine Liste von geraden oder ungeraden zahlen. Keine Hausaufgaben, einfach Fragen.

InformationsquelleAutor oJM86o | 2010-03-02

11

Könnte, Sie verwenden irgendeine Art von 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);
```
Aufzählbare nur lädt die Liste mit 1-100, und dann habe ich einfach entreißen all odds /evens, und dann drucken. Dies alles kann verkürzt werden zu:
```
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 haben eine implizite Typ-var. Der compiler kann bestimmen, Ihren Typ, so dass diese beiden Zeilen sind äquivalent:
```
List<int> eo = Enumerable.Range(1, 100).ToList(); //must tell it its a list
```
Dann finden die odds /evens direkt auf eine Liste Typ:
```
List<int> o = eo.Where(num => num%2!=0).ToList();
List<int> e = eo.Where(num => num%2==0).ToList();
```
Und zu drucken, ist es in meinem ursprünglichen code.
- Ihr Prädikat für ungerade zahlen enthält einen fiesen bug. Sehen Sie, wenn Sie es finden können. (Tipp: Sie benötigen mehr Testfälle.)
- Lippert vielleicht num % 2==1 war eine schlechte Wahl...wie 2==1 liefert false :). Bearbeiten...lassen Sie mich wissen, wenn ich mich nicht Irre.
- Gut erraten, richtig fix, aber keine Zigarre, weil Sie nicht tatsächlich das problem zu diagnostizieren. Versuchen Sie Ihre original-code mit einem Bereich von -100 bis +100.
- zählen kippe < 0.
- Sie wurde nur der Schild auf deinen Kommentar, den Sie ursprünglich hatte, -100 bis -10 was nicht möglich ist.
- aufgrund der negativen zahlen, ich gebe zu, es war eine schöne fangen :). Wer erfand negative zahlen und imaginären zahlen, das Leben schwer :-p. Beste, was zu verwenden ist != um zu vermeiden, dass.
- Richtig. Nur klar zu sein, für andere Leser: Ein%2 den Wert -1, wenn A eine negative ungerade Zahl ist. Also Ein%2==1 ist nicht ein test für "ungerade", es ist ein test für "ist positiv und ungerade". A%2!=0 ist ein test für "ungerade".
- Beachten Sie, dass dies eindeutig in der Spezifikation definiert in Abschnitt 7.7.3: "Das Ergebnis von x % y ist der Wert, produziert von x – (x / y) * y" So versuchen -3%2-das ist (-3) - (-3 / 2) * 2, die -3 - (-2), das ist -1.
- danke für die information, kann nicht glauben, dass Sie haben, dass in der spec auch!
- Es ist eine gute übung und guten Geschmack der code hier. Check this : github.com/garora/TDD-Katas/blob/master/TDD-Katas-project/... auch einen erklärenden code
InformationsquelleAutor JonH
15

LINQ Weg... gerade und Ungerade zahlen zwischen 1 und 100.
```
var even = Enumerable.Range(1,100).Where(i => i % 2 == 0);
var odd = Enumerable.Range(1,100).Where(i => i % 2 != 0);
```
- Es ist schneller zu ersetzen i%2 mit i&1 in deinem Beispiel
- Lonli-Lokli aber dann dauert es zwei Kopf-Schalter, um zu verstehen, was Los ist. Die Lesbarkeit ist wichtiger für eine so unbedeutende Menge von Einsparungen.
- Guter Punkt, aber ich denke, die Menschen sollten ermutigt werden, zu schreiben, Dinge in einer performanten Art und Weise, vorausgesetzt, Sie erklären. eg: // i & 1 == 0 is faster than i % 2 == 0
InformationsquelleAutor Jesper Palm
3

Können Sie die Verwendung von LINQ to ziehen Sie Sie heraus, nur die ungeraden oder geraden, und dann Prozess:
```
var even = myList.Where(i => i%2==0);
foreach(var number in even)
     //do something
```
InformationsquelleAutor 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();
```
- Wie ist das nützlich, wenn ein 12 upvotes Antwort sagte dies schon vor 2 Jahren?
- Ich verstehe, dass Sie arbeiten, um zu entsperren einige Funktionen, vielleicht versuchen Sie, einige neuen / unbeantworteten Fragen 🙂
InformationsquelleAutor Ashot
1

Ich glaube nicht, dass Sie haben, um die erste Schlaufe. Sie konnte nur:
```
for (i=1; i < 101; i++)
{
   if (i % 2 != 0)
   {
      //do something
   }
}
```
Oder auch:
```
for (i=1, i < 101, i+=2)
{
   //do something
}
```
- Das problem ist nicht die Wahl der geraden oder ungeraden Indizes, es ist die Wahl der ungeraden oder geraden Elementen der Liste von Ganzzahlen.
- Lippert -- Ah, ich sehe. Danke.
InformationsquelleAutor davecoulter
0

Füllen Sie Ihre Liste nach diesen Formeln
```
Odds[0->N] = 2*i+1
Evens[0->N] = 2*i
```
InformationsquelleAutor Ian Jacobs
0

Wenn Sie nur die Hälfte der zahlen, generieren Sie einfach die Hälfte der Zahl ( .. ; .. ; i = i + 2)

Wenn Sie müssen alle die zahlen wollen aber vermeiden, dass eine zusätzliche öse haben, können Sie markieren Sie Sie oder Bearbeiten Sie während der ersten Schleife.

Bzw. während der Schöpfung, machen bis zu drei Listen/arrays - eines für alle zahlen, ein anderes für die Verschiedenheit und die Dritte für evens.

Gibt es eine spezielle Anwendung?
- Das problem ist nicht, zu sehen an den geraden Indizes, das problem ist der Blick auf die geraden Elemente.
InformationsquelleAutor Jason Kleban

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.