Bucla for în C#: numărare și acumulare

Bucla for repetă un bloc de instrucțiuni folosind de obicei un contor. Contorul spune ce pas sau ce valoare prelucrăm. Este potrivită când putem descrie clar începutul, condiția de continuare și schimbarea făcută după fiecare iterație.

O iterație înseamnă o executare a corpului buclei. În această lecție numărăm și adunăm numerele pare din intervalul 1..n. O valoare este pară dacă restul împărțirii la doi este zero; în C# restul se calculează cu operatorul %.

Ideea pe care o folosim

În forma for (int i = 1; i <= n; i++), inițializarea se execută o singură dată. Condiția este verificată înainte de fiecare intrare în corp. După corp, expresia i++ mărește contorul cu unu, apoi condiția este verificată din nou.

Avem două acumulatoare cu roluri diferite: count numără valorile acceptate, iar sum adună aceste valori. Când găsim un număr par, count crește cu unu și sum crește cu i. Nu confundăm numărul valorilor cu suma lor. La afișare, textul prefixat cu $ poate include expresii între acolade: în $"{count} {sum}", cele două nume sunt înlocuite cu valorile variabilelor. Această construcție se numește interpolare.

Intrare și rezultat

Citim un întreg n pe o linie, cu 0≤n≤100000. Afișăm numărul valorilor pare din 1..n și suma lor, separate printr-un spațiu. Pentru intrare neconvertibilă sau în afara limitelor afișăm INVALID. Cazul n=0 descrie un interval fără elemente și trebuie să producă 0 0. Folosim long pentru sumă.

Exemplu urmărit

Pentru n=6, bucla examinează 1, 2, 3, 4, 5 și 6. După 2 avem count=1 și sum=2; după 4 avem count=2 și sum=6; după 6 avem count=3 și sum=12. Valorile impare nu schimbă acumulatoarele. La următoarea verificare, i este 7 și condiția 7≤6 este falsă, deci execuția continuă după buclă.

După valorile pare 2, 4 și 6, numărătorul este 1, 2, 3, iar suma este 2, 6, 12.Mărește schema ↗

De ce obținem acest rezultat

Înaintea iterației pentru i, acumulatoarele descriu exact numerele pare din 1..i−1. Dacă i este impar, păstrăm valorile; dacă este par, îl includem o singură dată. Astfel proprietatea rămâne adevărată pentru pasul următor. La terminare am acoperit întregul interval. Această proprietate păstrată la fiecare pas se numește invariant și oferă o justificare a corectitudinii, nu doar o observație despre exemplu.

Program complet C#

using System;

class Program
{
    static void Main()
    {
        if (!int.TryParse(Console.ReadLine(), out int n) || n < 0 || n > 100000)
        {
            Console.WriteLine("INVALID");
            return;
        }

        int count = 0;
        long sum = 0;
        for (int i = 1; i <= n; i++)
        {
            if (i % 2 == 0)
            {
                count++;
                sum += i;
            }
        }

        Console.WriteLine($"{count} {sum}");
    }
}

Greșeli de evitat

Nu scrie punct și virgulă imediat după antetul for, deoarece ai crea un corp gol. Nu reseta sum sau count în interiorul buclei: ai pierde rezultatele pașilor anteriori. La n=100000, suma este 2500050000, mai mare decât maximul int; tipul long este necesar chiar dacă fiecare valoare citită și contorul încap în int. Timpul este O(n), iar memoria suplimentară O(1).

Exersează

1. Pentru n=1, rezultatul este 0 0.
2. Pentru n=5, rezultatul este 2 6, deoarece alegem 2 și 4.
3. Ce se schimbă dacă scriem i<n? Valoarea n nu mai este examinată. Diferența contează când n este par.

Continuă parcursul C#

Vezi Variabile și tipuri în C#: int, double și bool. Vezi Condiții în C#: if, else și operatori logici. Vezi Bucla while în C#: repetare până la o santinelă.

Documentație de referință: Microsoft Learn.

Întrebări frecvente

Care este ordinea pașilor unei bucle for?

Inițializare o singură dată, apoi condiție, corp, actualizare a contorului și repetarea verificării condiției.

Poate o buclă for să execute zero iterații?

Da. Dacă prima verificare a condiției este falsă, corpul nu se execută deloc, ca în exemplul n=0.

De ce suma folosește long și contorul int?

Suma multor valori poate depăși intervalul int chiar dacă fiecare valoare și numărul de iterații încap individual în int.