Wie kann ich den Inhalt eines Arrays horizontal drucken?

Warum druckt das Konsolenfenster den Array-Inhalt nicht horizontal, sondern vertikal?

Gibt es eine Möglichkeit, das zu ändern?

Wie kann ich den Inhalt meines Arrays horizontal statt vertikal mit einem anzeigen Console.WriteLine()?

Zum Beispiel:

int[] numbers = new int[100]
for(int i; i < 100; i++)
{
    numbers[i] = i;
}

for (int i; i < 100; i++)
{
    Console.WriteLine(numbers[i]);
}

Sie verwenden wahrscheinlich Console.WriteLinezum Drucken des Arrays.

int[] array = new int[] { 1, 2, 3 };
foreach(var item in array)
{
    Console.WriteLine(item.ToString());
}

Wenn Sie nicht jeden Artikel in einer separaten Zeile haben möchten, verwenden Sie Console.Write:

int[] array = new int[] { 1, 2, 3 };
foreach(var item in array)
{
    Console.Write(item.ToString());
}

oder string.Join<T>(in .NET Framework 4 oder höher):

int[] array = new int[] { 1, 2, 3 };
Console.WriteLine(string.Join(",", array));

Ich würde vorschlagen:

foreach(var item in array)
  Console.Write("{0}", item);

Wie oben beschrieben, außer es wird keine Ausnahme ausgelöst, wenn es sich um ein Element handelt null.

Console.Write(string.Join(" ", array));

wäre perfekt, wenn das Array a ist string[].

Durchlaufen Sie einfach das Array und schreiben Sie die Elemente in die Konsole, indem Sie Writeanstelle von WriteLine:

foreach(var item in array)
    Console.Write(item.ToString() + " ");

Solange Ihre Artikel keine Zeilenumbrüche haben, wird eine einzelne Zeile erstellt.

... oder, wie Jon Skeet sagte, geben Sie Ihrer Frage etwas mehr Kontext.

Wenn Sie ein Array von Arrays hübsch drucken müssen, könnte Folgendes funktionieren: Pretty Print Array von Arrays in .NET C #

public string PrettyPrintArrayOfArrays(int[][] arrayOfArrays)
{
  if (arrayOfArrays == null)
    return "";

  var prettyArrays = new string[arrayOfArrays.Length];

  for (int i = 0; i < arrayOfArrays.Length; i++)
  {
    prettyArrays[i] = "[" + String.Join(",", arrayOfArrays[i]) + "]";
  }

  return "[" + String.Join(",", prettyArrays) + "]";
}

Beispielausgabe:

[[2,3]]

[[2,3],[5,4,3]]

[[2,3],[5,4,3],[8,9]]

foreach(var item in array)
Console.Write(item.ToString() + "\t");

namespace ReverseString
{
    class Program
    {
        static void Main(string[] args)
        {
            string stat = "This is an example of code" +
                          "This code has written in C#\n\n";

            Console.Write(stat);

            char[] myArrayofChar = stat.ToCharArray();

            Array.Reverse(myArrayofChar);

            foreach (char myNewChar in myArrayofChar)
                Console.Write(myNewChar); // You just need to write the function
                                          // Write instead of WriteLine
            Console.ReadKey();
        }
    }
}

Dies ist die Ausgabe:

#C ni nettirw sah edoc sihTedoc fo elpmaxe na si sihT

Die folgende Lösung ist die einfachste:

Console.WriteLine("[{0}]", string.Join(", ", array));

Ausgabe: [1, 2, 3, 4, 5]

Eine weitere kurze Lösung:

Array.ForEach(array,  val => Console.Write("{0} ", val));

Ausgabe : 1 2 3 4 5. Oder wenn Sie hinzufügen müssen ,, verwenden Sie Folgendes:

int i = 0;
Array.ForEach(array,  val => Console.Write(i == array.Length -1) ? "{0}" : "{0}, ", val));

Ausgabe: 1, 2, 3, 4, 5

int[] n=new int[5];

for (int i = 0; i < 5; i++)
{
    n[i] = i + 100;
}

foreach (int j in n)
{
    int i = j - 100;

    Console.WriteLine("Element [{0}]={1}", i, j);
    i++;
}

public static void Main(string[] args)
{
    int[] numbers = new int[10];

    Console.Write("index ");

    for (int i = 0; i < numbers.Length; i++)
    {
        numbers[i] = i;
        Console.Write(numbers[i] + " ");
    }

    Console.WriteLine("");
    Console.WriteLine("");
    Console.Write("value ");

    for (int i = 0; i < numbers.Length; i++)
    {
        numbers[i] = numbers.Length - i;
        Console.Write(numbers[i] + " ");
    }

    Console.ReadKey();
}

Die Verwendung von Console.Write funktioniert nur, wenn der Thread der einzige Thread ist, der in die Konsole schreibt. Andernfalls wird Ihre Ausgabe möglicherweise mit anderen Ausgaben, die möglicherweise Zeilenumbrüche einfügen oder nicht, sowie anderen unerwünschten Zeichen durchsetzt. Verwenden Sie Console.WriteLine, um sicherzustellen, dass Ihr Array intakt gedruckt wird, um eine Zeichenfolge zu schreiben. Fast jedes Array von Objekten kann horizontal gedruckt werden (abhängig von der ToString () -Methode des Typs), indem der nicht generische Join verwendet wird, der vor .NET 4.0 verfügbar ist:

        int[] numbers = new int[100];
        for(int i= 0; i < 100; i++)
        {
            numbers[i] = i;
        }

        //For clarity
        IEnumerable strings = numbers.Select<int, string>(j=>j.ToString());
        string[] stringArray = strings.ToArray<string>();
        string output = string.Join(", ", stringArray);
        Console.WriteLine(output);

        //OR 

        //For brevity
        Console.WriteLine(string.Join(", ", numbers.Select<int, string>(j => j.ToString()).ToArray<string>()));

Ich habe einige Erweiterungen geschrieben, um fast jedem Bedarf gerecht zu werden.
Es gibt Erweiterungsüberladungen, die mit Separator , String.Format und IFormatProvider gespeist werden müssen .

Beispiel:

var array1 = new byte[] { 50, 51, 52, 53 };
var array2 = new double[] { 1.1111, 2.2222, 3.3333 };
var culture = CultureInfo.GetCultureInfo("ja-JP");

Console.WriteLine("Byte Array");
//Normal print 
Console.WriteLine(array1.StringJoin());
//Format to hex values
Console.WriteLine(array1.StringJoin("-", "0x{0:X2}"));
//Comma separated 
Console.WriteLine(array1.StringJoin(", "));
Console.WriteLine();

Console.WriteLine("Double Array");
//Normal print 
Console.WriteLine(array2.StringJoin());
//Format to Japanese culture
Console.WriteLine(array2.StringJoin(culture));
//Format to three decimals 
Console.WriteLine(array2.StringJoin(" ", "{0:F3}"));
//Format to Japanese culture and two decimals
Console.WriteLine(array2.StringJoin(" ", "{0:F2}", culture));
Console.WriteLine();

Console.ReadLine();

Erweiterungen:

using System;
using System.Collections;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Extensions
{
    /// <summary>
    /// IEnumerable Utilities. 
    /// </summary>
    public static partial class IEnumerableUtilities
    {
        /// <summary>
        /// String.Join collection of items using custom Separator, String.Format and FormatProvider. 
        /// </summary>
        public static string StringJoin<T>(this IEnumerable<T> Source)
        {
            return Source.StringJoin(" ", string.Empty, null);
        }

        /// <summary>
        /// String.Join collection of items using custom Separator, String.Format and FormatProvider. 
        /// </summary>
        public static string StrinJoin<T>(this IEnumerable<T> Source, string Separator)
        {
            return Source.StringJoin(Separator, string.Empty, null);
        }

        /// <summary>
        /// String.Join collection of items using custom Separator, String.Format and FormatProvider. 
        /// </summary>
        public static string StringJoin<T>(this IEnumerable<T> Source, string Separator, string StringFormat)
        {
            return Source.StringJoin(Separator, StringFormat, null);
        }

        /// <summary>
        /// String.Join collection of items using custom Separator, String.Format and FormatProvider. 
        /// </summary>
        public static string StringJoin<T>(this IEnumerable<T> Source, string Separator, IFormatProvider FormatProvider)
        {
            return Source.StringJoin(Separator, string.Empty, FormatProvider);
        }

        /// <summary>
        /// String.Join collection of items using custom Separator, String.Format and FormatProvider. 
        /// </summary>
        public static string StringJoin<T>(this IEnumerable<T> Source, IFormatProvider FormatProvider)
        {
            return Source.StringJoin(" ", string.Empty, FormatProvider);
        }

        /// <summary>
        /// String.Join collection of items using custom Separator, String.Format and FormatProvider. 
        /// </summary>
        public static string StringJoin<T>(this IEnumerable<T> Source, string Separator, string StringFormat, IFormatProvider FormatProvider)
        {
            //Validate Source
            if (Source == null)
                return string.Empty;
            else if (Source.Count() == 0)
                return string.Empty;

            //Validate Separator
            if (Separator.IsNullOrEmpty())
                Separator = " ";

            //Validate StringFormat
            if (StringFormat.IsNullOrWhitespace())
                StringFormat = "{0}";

            //Validate FormatProvider 
            if (FormatProvider == null)
                FormatProvider = CultureInfo.CurrentCulture;

            //Convert items 
            var convertedItems = Source.Select(i => String.Format(FormatProvider, StringFormat, i));

            //Return 
            return String.Join(Separator, convertedItems);
        }
    }
}

private int[,] MirrorH(int[,] matrix)               //the method will return mirror horizintal of matrix
{
    int[,] MirrorHorizintal = new int[4, 4];
    for (int i = 0; i < 4; i++)
    {
        for (int j = 0; j < 4; j ++)
        {
            MirrorHorizintal[i, j] = matrix[i, 3 - j];
        }
    }
    return MirrorHorizintal;
}