Khoá học lập trình C# (.NET Core) [Video] In dãy số chẵn & lẻ từ mảng số nguyên - Lập trình C# - Loop trong C#

[Video] Giải Thuật & Lập Trình C# - Bài mở đầu C# - In dãy số chẵn & lẻ từ mảng số nguyên - Lập trình C#

Mở bài

Xử lý mảng và in ra dãy số chẵn & lẻ là bài tập cơ bản nhưng vô cùng quan trọng trong hành trình học lập trình C#. Việc biết cách in dãy số chẵn & lẻ từ mảng số nguyên không chỉ giúp bạn nắm vững cú pháp ngôn ngữ mà còn rèn luyện tư duy thuật toán, tối ưu vòng lặp và xử lý dữ liệu thực tế. Từ các ứng dụng nhỏ như lọc số để thống kê, đến các hệ thống lớn cần phân loại dữ liệu nhanh chóng, kỹ năng này luôn xuất hiện trong phỏng vấn, bài tập và trong sản phẩm thực tế.

Bài viết này hướng dẫn chi tiết cách in dãy số chẵn & lẻ từ mảng số nguyên bằng nhiều cách tiếp cận trong C#: sử dụng for, foreach, while, LINQ, và tối ưu khi mảng lớn. Mỗi phần đều kèm ví dụ mã nguồn, giải thích logic từng bước, các lỗi thường gặp và lời khuyên để viết code sạch, hiệu năng tốt. Nếu bạn muốn hiểu rõ cách phân tách mảng theo tính chẵn lẻ, áp dụng vào dữ liệu thực tế và viết mã theo chuẩn — bài viết này là hướng dẫn toàn diện, dễ hiểu và thực dụng.

Hiểu về bài toán: in dãy số chẵn & lẻ từ mảng số nguyên

Trước khi vào code, hãy mô tả bài toán bằng ngôn ngữ tự nhiên: bạn có một mảng số nguyên (ví dụ int[] numbers) và muốn tách, sau đó in 2 dãy: một dãy chứa tất cả số chẵn, một dãy chứa tất cả số lẻ. Yêu cầu bổ sung có thể là:

• Giữ nguyên thứ tự xuất hiện ban đầu.

• Loại bỏ số âm hoặc không tùy chọn.

• In ra theo định dạng một hàng hoặc nhiều dòng.

• Trả về hai mảng hoặc hai danh sách (List<int>).

Mấu chốt: kiểm tra tính chẵn/lẻ của từng phần tử bằng phép toán n % 2 == 0 (chẵn) hoặc n % 2 != 0 (lẻ). Khi bạn thực hiện đủ nhiều lần, cụm từ “in dãy số chẵn & lẻ từ mảng số nguyên” sẽ là hành động lặp đi lặp lại, và việc lựa chọn vòng lặp phù hợp sẽ quyết định hiệu năng.

Cấu trúc dữ liệu: mảng số nguyên và List<int>

Trong C#, bạn có thể dùng mảng int[] hoặc bộ sưu tập động List<int>:

• int[] numbers = { 1, 2, 3, 4 }; — mảng cố định kích thước.

• List<int> list = new List<int> { 1, 2, 3, 4 }; — thêm/xóa dễ dàng.

Khi in dãy số chẵn & lẻ từ mảng số nguyên, List<int> thường thuận tiện nếu bạn muốn thu thập kết quả trước rồi in. Với mảng cố định, bạn có thể đếm trước số phần tử chẵn/lẻ để cấp phát mảng mới. Tuy nhiên, List<int> sẽ đơn giản hơn cho người mới.

Ví dụ khai báo:

int[] numbers = { 10, 21, 4, 45, 66, 93 };
List<int> evens = new List<int>();
List<int> odds = new List<int>();

Sau đó, bạn lặp qua numbers, kiểm tra chẵn/lẻ và Add vào danh sách tương ứng.

Cách 1 — Sử dụng for để in dãy số chẵn & lẻ từ mảng số nguyên

for thích hợp khi bạn cần truy cập chỉ số và biết kích thước mảng.

Ví dụ đầy đủ:

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        int[] numbers = { 10, 21, 4, 45, 66, 93, 0, -2 };
        List<int> evens = new List<int>();
        List<int> odds = new List<int>();

        for (int i = 0; i < numbers.Length; i++)
        {
            int n = numbers[i];
            if (n % 2 == 0)
                evens.Add(n);
            else
                odds.Add(n);
        }

        Console.WriteLine("Even numbers: " + string.Join(", ", evens));
        Console.WriteLine("Odd numbers: " + string.Join(", ", odds));
    }
}

Giải thích:

• Duyệt từng phần tử với chỉ số i.

• Dùng n % 2 == 0 để kiểm tra chẵn.

• string.Join in danh sách đẹp, gọn.

Ưu điểm: rõ ràng, kiểm soát chỉ số. Nhược điểm: khi mảng rất lớn, vẫn phải quét toàn bộ mảng (nhưng bắt buộc để phân loại).

Cách 2 — Sử dụng foreach cho code ngắn gọn

foreach gọn hơn khi không cần chỉ số:

foreach (int n in numbers)
{
    if (n % 2 == 0)
        evens.Add(n);
    else
        odds.Add(n);
}

foreach an toàn: không vô tình thay đổi chỉ số, giảm lỗi. Tuy nhiên, không thể dùng continue để thay đổi thứ tự truy cập — nhưng continue vẫn dùng được để bỏ qua phần tử hiện tại.

Cách 3 — Sử dụng LINQ để in dãy số chẵn & lẻ từ mảng số nguyên

LINQ cho phép lọc mảng bằng biểu thức ngắn gọn:

using System.Linq;

var evens = numbers.Where(n => n % 2 == 0).ToArray();
var odds = numbers.Where(n => n % 2 != 0).ToArray();

Hoặc nếu muốn List<int>:

var evensList = numbers.Where(n => n % 2 == 0).ToList();

Ưu điểm: code ngắn, cao cấp, dễ đọc. Nhược điểm: có thể sinh overhead nhỏ do deferred execution và phương thức extension — nhưng với hầu hết ứng dụng thì hiệu quả đủ tốt.

Cách 4 — Sử dụng while / do-while (khi cần điều kiện đặc biệt)

while hữu ích nếu bạn có điều kiện dừng phức tạp hoặc muốn xử lý từng phần tử theo luồng:

int i = 0;
while (i < numbers.Length)
{
    int n = numbers[i];
    if (n % 2 == 0) evens.Add(n);
    else odds.Add(n);
    i++;
}

do-while đảm bảo xử lý ít nhất một lần (ít khi cần cho mảng trống), nhưng vẫn có thể dùng.

Xử lý trường hợp đặc biệt và ràng buộc đầu vào

Khi in dãy số chẵn & lẻ từ mảng số nguyên, cần lưu ý:

• Mảng rỗng: nếu numbers.Length == 0, in thông báo "No numbers".

• Số âm: phép n % 2 vẫn đúng cho số âm (-3 % 2 == -1), nên dùng Math.Abs(n) % 2 nếu muốn tránh số âm ảnh hưởng — thực tế n % 2 != 0 cho biết lẻ đúng cả với số âm.

• Số 0: 0 là số chẵn (0 % 2 == 0).

• Null input: nếu dùng int[] numbers = null, kiểm tra if (numbers == null) để tránh NullReferenceException.

Ví dụ kiểm tra an toàn:

if (numbers == null || numbers.Length == 0)
{
    Console.WriteLine("Array is empty or null.");
    return;
}

Định dạng in: một hàng, nhiều hàng, theo cột

Bạn có thể in dãy chẵn & lẻ theo nhiều cách:

• Một dòng: Even numbers: 2, 4, 6

• Mỗi số một dòng: tốt khi dữ liệu nhiều.

• Theo cột (2 cột: chẵn bên trái, lẻ bên phải): dễ quan sát.

Ví dụ in theo cột:

int max = Math.Max(evens.Count, odds.Count);
for (int i = 0; i < max; i++)
{
    string e = i < evens.Count ? evens[i].ToString() : "";
    string o = i < odds.Count ? odds[i].ToString() : "";
    Console.WriteLine($"{e,-10} {o,-10}");
}

Tối ưu hiệu năng khi mảng lớn

Khi numbers có hàng triệu phần tử, một số lưu ý:

1. Duyệt một lần: tránh duyệt mảng nhiều lần — thu thập cả chẵn và lẻ trong cùng một vòng lặp.

2. Sử dụng List với capacity: nếu ước lượng trước số phần tử chẵn/lẻ, dùng new List<int>(estimatedCapacity) để giảm reallocation.

3. Parralel processing: có thể dùng Parallel.ForEach để phân loại song song, nhưng cần đồng bộ khi thêm vào danh sách (sử dụng concurrent collections như ConcurrentBag<int>).

4. Tránh boxing/unboxing: giữ nguyên kiểu int, không chuyển sang object.

5. LINQ: tiện nhưng có overhead — với dữ liệu cực lớn, manual loop có thể nhanh hơn.

Ví dụ tối ưu cơ bản:

List<int> evens = new List<int>(numbers.Length / 2 + 1);
List<int> odds = new List<int>(numbers.Length / 2 + 1);
for (int i = 0; i < numbers.Length; i++)
{
    int n = numbers[i];
    if ((n & 1) == 0) evens.Add(n); // bitwise check
    else odds.Add(n);
}

Sử dụng (n & 1) == 0 thay vì n % 2 == 0 là kiểm tra bit thấp, có thể nhanh hơn một chút.

Những lỗi thường gặp và cách khắc phục

• Quên kiểm tra null → NullReferenceException.

  • Fix: kiểm tra numbers == null.

• Sử dụng n % 2 sai với số âm (nhầm lẫn)

  • Nhận biết: -3 % 2 trả về -1 nhưng -1 != 0 vẫn nghĩa là lẻ. Dùng Math.Abs(n) % 2 nếu muốn kiểm tra theo giá trị tuyệt đối.

• In theo thứ tự không mong muốn

  • Giữ nguyên thứ tự bằng cách thu thập theo thứ tự duyệt. Nếu muốn sắp xếp tăng dần, gọi Sort() trước khi in.

• Race condition khi dùng song song

  • Dùng ConcurrentBag<int> hoặc lock khi thêm phần tử vào collection chia sẻ.

Ví dụ thực tế: chương trình hoàn chỉnh

Dưới đây là một ví dụ hoàn chỉnh, an toàn, cho phép người dùng nhập dãy số và chương trình sẽ in dãy số chẵn & lẻ:

using System;
using System.Collections.Generic;
using System.Linq;

class Program
{
    static void Main()
    {
        Console.WriteLine("Enter integers separated by space:");
        var input = Console.ReadLine();
        if (string.IsNullOrWhiteSpace(input))
        {
            Console.WriteLine("No input provided.");
            return;
        }

        int[] numbers;
        try
        {
            numbers = input.Split(' ')
                           .Where(s => !string.IsNullOrWhiteSpace(s))
                           .Select(int.Parse)
                           .ToArray();
        }
        catch
        {
            Console.WriteLine("Invalid input. Please enter integers only.");
            return;
        }

        var evens = new List<int>();
        var odds = new List<int>();

        foreach (var n in numbers)
        {
            if ((n & 1) == 0) evens.Add(n);
            else odds.Add(n);
        }

        Console.WriteLine("Even numbers: " + (evens.Count > 0 ? string.Join(", ", evens) : "None"));
        Console.WriteLine("Odd numbers: " + (odds.Count > 0 ? string.Join(", ", odds) : "None"));
    }
}

LSI keywords và ứng dụng liên quan

Khi viết nội dung về in dãy số chẵn & lẻ từ mảng số nguyên, bạn sẽ thấy các thuật ngữ liên quan hữu ích để SEO và mở rộng kiến thức:

• mảng số nguyên C#

• kiểm tra chẵn lẻ C#

• vòng lặp for foreach while C#

• LINQ Where ToList

• List<int> và Array

• bitwise operator & for odd/even

• tối ưu performance C#

• ConcurrentBag và Parallel.ForEach

Sử dụng LSI keywords này trong phần mô tả, chú thích code và tài liệu giúp bài viết tự nhiên, phong phú và thân thiện với bộ máy tìm kiếm.

Kết luận

In dãy số chẵn & lẻ từ mảng số nguyên là bài toán đơn giản nhưng giàu giá trị giáo dục: nó giúp bạn luyện tập vòng lặp, điều kiện, xử lý dữ liệu và cân nhắc hiệu năng. Trong bài viết này, bạn đã được hướng dẫn nhiều cách tiếp cận: for, foreach, while, LINQ, cùng các kỹ thuật tối ưu và xử lý tình huống thực tế như input lỗi, mảng rỗng, số âm và in định dạng.

Lời khuyên thực tế: bắt đầu với for hoặc foreach để hiểu rõ luồng, chuyển sang LINQ khi muốn code ngắn gọn; dùng bitwise (n & 1) khi cần tối ưu; và luôn kiểm tra null/empty để code an toàn. Nếu cần xử lý dữ liệu lớn, cân nhắc dự đoán kích thước danh sách, dùng collection có capacity phù hợp hoặc xử lý song song kèm concurrent collection.

Bây giờ hãy thử tự viết một chương trình nhỏ: tạo mảng ngẫu nhiên 1000 số, in dãy số chẵn & lẻ từ mảng số nguyên, đo thời gian thực hiện và so sánh hiệu năng giữa for và LINQ. Thực hành sẽ giúp bạn hiểu sâu hơn và làm chủ vòng lặp trong C#. Nếu bạn muốn, tôi có thể chuẩn bị bộ bài tập, hay mẫu code kiểm tra hiệu năng để bạn so sánh và học nhanh hơn — bạn muốn bắt đầu từ phần nào?