Wie wird "GERADE" für gerade Zahlen zwischen 1 und 100 ausgegeben?

Question

Wie schreibt man C# -Code, der den Objektarray-Wert int 1-100 auflistet und den String-Text "EVEN" ausgibt, wenn er feststellt, dass das in int konvertierte Objekt durch 2 teilbar ist?

class Program 
{ 
    static void Main(string[] args) 
    { 
     object[] numbers = new object[100]; 

     numbers = Enumerable.Range(1, 100).Cast<object>().ToArray(); 


     foreach (object number in numbers) 
     { 
      if(Convert.ToInt32(number) % 2 == 0) 
      { 
       number.ToString().Equals("Even"); 
      } 
      Console.WriteLine(number); 
     } 
     Console.Read(); 
    } 
} 

Answer 1

Das Problem, das Sie haben, ist hier lösen könnte:

number.ToString().Equals("Even"); 

Dies wird die Stringdarstellung number bekommen und vergleichen es dann für die Gleichstellung gegen die Zeichenfolge Even, und nichts mit dem Ergebnis zu tun. Wenn Sie einen Schritt zurück machen und darüber nachdenken, ergibt das keinen Sinn, denn Sie möchten Even drucken, wenn number gerade ist.

Mit Ihrem aktuellen Programm können Sie das wie folgt tun:

if (Convert.ToInt32(number) % 2 == 0) 
{ 
    Console.WriteLine("{0} is even", number); 
} 

Das heißt, es gibt ein paar Dinge mit Ihrem Programm sind die verbessert werden könnten, wie es scheint nicht, als ob Sie haben hat den C# -Typus schon kennengelernt.

Zunächst Sie ein Array von 100 Objekten wie so erklärt:

object[] numbers = new object[100]; 

Sie bereits wissen, dass Sie mit ganzen Zahlen arbeiten wollen, so, anstatt object verwenden, sollten Sie int verwenden:

int[] numbers = new int[100]; 

Als nächstes sind Erzeugen Sie eine Sequenz von ganzen Zahlen 1-100:

numbers = Enumerable.Range(1, 100).Cast<object>().ToArray(); 

Enumerable.Range() gibt eine Sammlung von Ganzzahlen zurück, und .ToArray() konvertiert das in ein Array von ganzen Zahlen. Da wir jetzt eine Reihe von ganzen Zahlen verwenden, gibt es keine Notwendigkeit, sie zu object zu werfen, so kann dies zu vereinfachen:

numbers = Enumerable.Range(1, 100).ToArray(); 

Es ist eine weitere Vereinfachung, die dies gemacht werden kann. Enumerable.Range() gibt eine IEnumerable<int> zurück, die eine Sammlung von ganzen Zahlen darstellt.Dies bedeutet, dass anstelle eine Anordnung von 100 ganzen Zahlen zu erklären, eine Sammlung von Zahlen zu erzeugen, die nicht auf eine Array umzuwandeln und sie zu numbers Zuweisung wir diese stattdessen tun können:

IEnumerable<int> numbers = Enumerable.Range(1, 100); 

Es ist eine weitere Änderung, die sein kann, gemacht hier, aber ich werde am Ende dieser Antwort beschreiben die an der Schleife aussehen lassen:

foreach (object number in numbers) 
{ 
    if (Convert.ToInt32(number) % 2 == 0) 
    { 
     Console.WriteLine(number); 
    } 
} 

Wie wir den Code geändert haben IEnumerable<int> statt object[] zu verwenden, können wir nun die Erklärung der Änderung Schleife zu:

foreach (int number in numbers) 

Dies ist möglich, weil ein Typ, der IEnumerable implementiert, die Verwendung von foreach ermöglicht. Als weiteres Beispiel hatten, wenn wir eine Sammlung von Studenten:

IEnumerable<Student> students = GetStudents(); 

Wir könnten jene Schleife über wie folgt aus:

foreach (Student student in students) 

zurück zu Ihrer Schleife gehen, jetzt, wo number ist ein int, wir don‘ Ich muss es von einem object zu einem int konvertieren, bevor wir überprüfen können, ob es gerade ist oder nicht. Also der Code der Schleife kann vereinfacht werden:

foreach (int number in numbers) 
{ 
    if (number % 2 == 0) 
    { 
     Console.WriteLine("{0} is even", number); 
    } 
} 

Die wichtigste Sache zu verstehen ist, dass, wenn Sie bereits wissen, welche Art Sie verwenden möchten, sollten Sie es immer verwenden, wann immer Sie können, wie es immer vereinfachen der Code, den du schreibst. Das komplette Programm aussehen würde nun wie folgt aus:

class Program 
{ 
    static void Main(string[] args) 
    { 
     IEnumerable<int> numbers = Enumerable.Range(1, 100); 

     foreach (int number in numbers) 
     { 
      if (number % 2 == 0) 
      { 
       Console.WriteLine("{0} is even", number); 
      } 
     } 
     Console.Read(); 
    } 
} 

Was die andere Änderung, die ich erwähnt, könnte Ihre ganze Zahl Generation Code zu vereinfachen:

var numbers = Enumerable.Range(1, 100); 

Das var Schlüsselwort wird die Nutzung von implicit type inference zu bestimmen numbers Typ. In ähnlicher Weise könnte die Schleife auch geändert werden:

foreach (var number in numbers) 

würde ich im Moment nicht über implizite Typinferenz kümmern. Ich erwähne der Vollständigkeit halber mehr, aber Sie sollten zuerst lernen, das Typsystem richtig zu benutzen.

Answer 2

Ihr Code ist fast richtig (mit Ausnahme des .Equals("Even") Teil).

dieser Code-Schnipsel

 Console.WriteLine(number.ToString() + ((Convert.ToInt32(number) % 2) == 0 ? " is even" : "")); 

}

Answer 3

Check: Ihr Code innerhalb des foreach kann vereinfacht werden.

class Program 
    { 
     static void Main(string[] args) 
     { 
     var stringBuilder = new StringBuilder(); 

     var numbers = new List<object>(); 
     numbers = Enumerable.Range(0, 100).Cast<object>  ().ToList();    
     foreach (var number in numbers) 
     { 
      if (Convert.ToInt32(number) % 2 == 0)    
       stringBuilder.Append("EVEN");     
      else 
       stringBuilder.Append(number); 
     } 

     Console.WriteLine(stringBuilder.ToString()); 
    } 
} 

Bitte lassen Sie mich wissen, ob diese Schnipsel Ihre Probleme