Модул 16

Оператори, приоритет и класът Math

Как C# изчислява изразите: аритметични оператори, целочислено деление и остатък (включително с отрицателни числа), оператори за сравнение и логически оператори със съкратено изчисляване, пълна таблица на приоритета и асоциативността, `++`/`--` и съставните оператори за присвояване. Класът `Math` с `Abs`, `Pow`, `Sqrt`, `Round`, `Floor`, `Ceiling`, `Truncate`, `Min`, `Max` и `PI`, плюс капанът на банковото закръгляне и `MidpointRounding`. Завършва със задачи с изрази по модела на училищната практика.

Теория

Всяко изчисление в C# е израз (expression): комбинация от стойности, променливи и оператори, която се свежда до една стойност. Стойностите, върху които операторът действа, се наричат операнди — в a + b операндите са a и b. Аритметичните оператори са пет: +, -, *, / и % (остатък от деление). Типът на резултата се определя от типовете на операндите, а не от променливата, в която го записвате: int с int дава int, а щом поне единият операнд е double, целият резултат е double. Оттук идва най-известният капан: 7 / 2 е целочислено деление и дава 3, докато 7 / 2.0 дава 3.5. Делението на цяло число на нула спира програмата с DivideByZeroException, а при double резултатът е специалната стойност Infinity (или NaN за 0.0 / 0).

Операторът % връща остатъка от целочисленото деление: 7 % 2 е 1, 17 % 5 е 2, а 10 % 5 е 0 — затова n % 2 == 0 проверява за четност, а n % 10 дава последната цифра. При отрицателни числа трябва да сте нащрек: C# отрязва дробната част към нулата, така че -7 / 2 е -3 (не -4), а знакът на остатъка следва делимото: -7 % 2 е -1, докато 7 % -2 е 1. Двете операции са свързани с равенството (a / b) * b + a % b == a, което важи винаги. Практическо следствие: проверката n % 2 == 1 за нечетност е грешна за отрицателни числа — пишете n % 2 != 0, а при работа с цифри първо вземете Math.Abs(n). Остатък може да се взема и от дробни числа: 7.5 % 2 е 1.5.

Операторите за сравнение ==, !=, <, >, <=, >= сравняват два операнда и винаги връщат bool — true или false: 5 > 3 е true, а 5 == 3 е false. Внимавайте с двойния знак: == сравнява, а единичното = присвоява. Логическите оператори свързват булеви стойности: && (И) е true само ако двете страни са true, || (ИЛИ) — ако поне една е true, а ! (НЕ) обръща стойността. && и || използват съкратено изчисляване (short-circuit): ако лявата страна вече определя резултата, дясната не се изчислява изобщо, затова count != 0 && sum / count > 5 е безопасно и при count == 0. Пълните варианти &, | и ^ (изключващо ИЛИ) изчисляват винаги и двете страни. Още една клопка: дробните числа не се сравняват с ==, защото 0.1 + 0.2 == 0.3 е false заради двоичното представяне — сравнявайте разликата: Math.Abs(a - b) < 0.000001.

Когато в един израз има няколко оператора, редът им се определя от приоритета (precedence): 2 + 3 * 4 е 14, защото умножението се изпълнява преди събирането. Пълният ред отгоре надолу е: първични (x++, извикване на метод), унарни (-x, !x, ++x, преобразуване (double)x), мултипликативни (*, /, %), адитивни (+, -), сравнение (<, >, <=, >=), равенство (==, !=), &&, || и накрая присвояването. При еднакъв приоритет решава асоциативността (associativity): аритметичните и логическите оператори се изчисляват отляво надясно, затова 10 - 4 - 3 е 3, а 7 / 2 * 2.0 е 6, а не 7 — първо се изпълнява целочисленото 7 / 2. Присвояването е отдясно наляво: a = b = 0 първо дава 0 на b, после на a. Скобите имат най-висок приоритет и са безплатни: (2 + 3) * 4 е 20, а изразът за високосна година (year % 4 == 0 && year % 100 != 0) || year % 400 == 0 работи и без скоби, но със скоби се чете веднага.

Операторите ++ и -- увеличават или намаляват променлива с единица, но имат две форми с различен резултат в израз. Постфиксният i++ връща старата стойност и чак след това променя i, а префиксният ++i първо променя и връща новата: при int i = 5; изразът Console.WriteLine(i++) печата 5, а Console.WriteLine(++i) веднага след него — 7. На самостоятелен ред (i++;) двете форми са еднакви, а изрази като a++ + ++a имат точно определен резултат в C#, но никой не трябва да ги разгадава — използвайте по един ++ на ред. Съставните оператори за присвояване +=, -=, *=, /= и %= съкращават записа: score += 5 е същото като score = score + 5, а score /= 4 при int отново е целочислено деление. Компилаторът пази типа: int x = 10; x += 2.5; е грешка, защото double не се побира в int без изрично преобразуване.

Класът Math от пространството System събира математическите функции като статични методи — извикват се направо върху класа, без обект: Math.Sqrt(16). Най-често ще ви трябват Math.Abs(x) (абсолютна стойност), Math.Pow(x, y) (степен), Math.Sqrt(x) (квадратен корен), Math.Min(a, b) и Math.Max(a, b), както и константата Math.PI за окръжности: Math.PI * r * r. Запомнете типовете: Math.Pow и Math.Sqrt връщат винаги double, затова за цяло число пишете (int)Math.Pow(2, 10), а Math.Abs връща типа на аргумента. За премахване на дробната част има три различни метода: Math.Floor закръгля надолу (Math.Floor(-3.7) е -4), Math.Ceiling — нагоре (Math.Ceiling(-3.2) е -3), а Math.Truncate просто отрязва към нулата (Math.Truncate(-3.7) е -3, точно както (int)-3.7). И трите връщат double, макар стойността да е цяла. При положителни числа Floor и Truncate съвпадат — разликата се вижда само при отрицателни.

Math.Round(x) закръгля до най-близкото цяло, а Math.Round(x, 2) — до два знака: Math.Round(3.14159, 2) е 3.14. Изненадата идва точно по средата: по подразбиране .NET използва банково закръгляне (MidpointRounding.ToEven), при което .5 отива към четния съсед — Math.Round(2.5) е 2, а Math.Round(3.5) е 4. За училищното правило „5 и нагоре се закръгля нагоре“ подайте MidpointRounding.AwayFromZero: Math.Round(2.5, MidpointRounding.AwayFromZero) дава 3, а с брой знаци — Math.Round(x, 2, MidpointRounding.AwayFromZero). Форматът {x:F2} при извеждане само показва два знака, без да променя стойността в променливата. Задачите с изрази (включително практиката с аритметични изрази и Math) се решават по една и съща схема: запишете формулата на хартия, оградете със скоби всяка дроб и всеки сбор под корен, решете кои стойности са int и кои double, заменете степените и корените с Math.Pow и Math.Sqrt и накрая проверете програмата с данни, за които знаете отговора — например страни 3, 4, 5 за триъгълник или 212 °F за температура. Ако резултатът е грешен, изведете междинните стойности с Console.WriteLine и ще откриете къде целочисленото деление или липсващата скоба са променили сметката.

Златни правила

Скобите са безплатни, грешките — не

Щом в израза има повече от два оператора или дроб, сложете скоби дори когато приоритетът би свършил работа. (f - 32) * 5 / 9 се чете веднага; f - 32 * 5 / 9 е съвсем друга формула.

`int / int` е винаги `int`

Типът на резултата се решава от операндите, не от променливата отляво. За дробен резултат направете поне единия операнд double още преди делението: (double)sum / count или sum / 2.0.

Остатъкът носи знака на делимото

-7 % 2 е -1, а не 1. Проверявайте нечетност с n % 2 != 0, а цифрите на число вземайте от Math.Abs(n).

Защитното условие стои отляво

&& и || спират, щом резултатът е ясен. Пишете count != 0 && sum / count > 5, никога обратното — иначе делението се изпълнява преди проверката.

`Math.Round` закръгля към четно

При точно .5 резултатът е четният съсед: Math.Round(2.5) е 2. Когато ви трябва училищното правило, подайте MidpointRounding.AwayFromZero.

Бърз справочник

Приоритет на операторите (от най-висок към най-нисък)

НивоОператориАсоциативностПример
Първичниx++, x--, f(x), a[i], x.yотляво надясноMath.Abs(n) % 10 — първо методът
Унарни+x, -x, !x, ++x, --x, (T)xотдясно наляво(double)sum / count — първо преобразуването
Мултипликативни*, /, %отляво надясно7 / 2 * 2.0 → 6
Адитивни+, -отляво надясно10 - 4 - 3 → 3
Сравнение<, >, <=, >=отляво надясноa + 1 < b * 2 — аритметиката е първа
Равенство==, !=отляво надясноn % 2 == 0
Условно И&&отляво надясноx > 0 && x < 10
Условно ИЛИ||отляво надясноa || b && c → a || (b && c)
Присвояване=, +=, -=, *=, /=, %=отдясно налявоa = b = 0 — първо b, после a

Най-полезните методи на класа Math

МетодКакво правиПример → резултатБележка
Math.Abs(x)Абсолютна стойностMath.Abs(-7) → 7Връща типа на аргумента (int, double...)
Math.Pow(x, y)x на степен yMath.Pow(2, 10) → 1024Винаги double; за цяло число: (int)Math.Pow(2, 10)
Math.Sqrt(x)Квадратен коренMath.Sqrt(144) → 12Отрицателен аргумент дава NaN
Math.Round(x), Math.Round(x, n)Закръгля до цяло / до n знакаMath.Round(3.14159, 2) → 3.14При точно .5 закръгля към четно: Math.Round(2.5) → 2
Math.Round(x, MidpointRounding.AwayFromZero)Училищно закръгляне на .5Math.Round(2.5, MidpointRounding.AwayFromZero) → 3С брой знаци: Math.Round(x, 2, MidpointRounding.AwayFromZero)
Math.Floor(x)Най-голямото цяло ≤ x (надолу)Math.Floor(-3.7) → -4Връща double
Math.Ceiling(x)Най-малкото цяло ≥ x (нагоре)Math.Ceiling(3.2) → 4Math.Ceiling(-3.2) → -3
Math.Truncate(x)Отрязва дробната част към нулатаMath.Truncate(-3.7) → -3Същият резултат като (int)x, но от тип double
Math.Min(a, b), Math.Max(a, b), Math.PIПо-малкото / по-голямото от две числа; числото πMath.Max(3, 8) → 8; Math.PI → 3.14159...За три числа: Math.Max(a, Math.Max(b, c)); Math.Clamp(x, 2, 6) ограничава в интервал

Код за анализ и пренаписване

Приоритет, целочислено деление и ++ на практика

Program.cs
using System;

namespace OperatorsDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            // 1. Приоритет и асоциативност
            int a = 2 + 3 * 4;          // 14 - умножението е първо
            int b = (2 + 3) * 4;        // 20 - скобите променят реда
            int c = 10 - 4 - 3;         // 3  - отляво надясно: (10 - 4) - 3
            double d = 7 / 2 * 2.0;     // 6  - 7 / 2 е 3 (int), после 3 * 2.0
            Console.WriteLine($"a={a}, b={b}, c={c}, d={d}");

            // 2. Целочислено деление и остатък с отрицателни числа
            Console.WriteLine($"7 / 2 = {7 / 2}, 7 % 2 = {7 % 2}");       // 3, 1
            Console.WriteLine($"-7 / 2 = {-7 / 2}, -7 % 2 = {-7 % 2}");   // -3, -1
            Console.WriteLine($"7 / -2 = {7 / -2}, 7 % -2 = {7 % -2}");   // -3, 1
            Console.WriteLine($"7.5 % 2 = {7.5 % 2}");                     // 1.5

            // 3. Цифри на число
            int n = -457;
            int abs = Math.Abs(n);
            int ones = abs % 10;        // 7
            int tens = abs / 10 % 10;   // 5
            int hundreds = abs / 100;   // 4
            Console.WriteLine($"Цифри на {n}: {hundreds} {tens} {ones}, сбор {hundreds + tens + ones}");

            // 4. Инкремент: префиксен срещу постфиксен
            int i = 5;
            Console.WriteLine(i++);     // 5 - връща старата стойност, после увеличава
            Console.WriteLine(i);       // 6
            Console.WriteLine(++i);     // 7 - първо увеличава, после връща новата стойност

            // 5. Съставни оператори за присвояване
            int score = 10;
            score += 5;     // 15
            score *= 2;     // 30
            score -= 4;     // 26
            score /= 4;     // 6 - целочислено!
            score %= 4;     // 2
            Console.WriteLine($"score = {score}");
        }
    }
}

Какво се случва тук?

  • a = 2 + 3 * 4 дава 14, защото * има по-висок приоритет от +; в b скобите го променят и резултатът е 20.
  • 10 - 4 - 3 е 3: при еднакъв приоритет изчислението върви отляво надясно, т.е. (10 - 4) - 3, а не 10 - (4 - 3).
  • 7 / 2 * 2.0 изненадва с 6: / и * са на едно ниво, затова първо се изпълнява целочисленото 7 / 2, което дава 3, и чак после 3 * 2.0. Ако искахме 7, трябваше 7 * 2.0 / 2 или 7 / 2.0 * 2.
  • Отрицателните числа показват правилото: резултатът от / се отрязва към нулата (-7 / 2 е -3), а знакът на % е знакът на делимото (-7 % 2 е -1, но 7 % -2 е 1). % работи и с double: 7.5 % 2 е 1.5.
  • За цифрите на n първо взимаме Math.Abs(n), иначе -457 % 10 би дало -7. Изразът abs / 10 % 10 се чете отляво надясно: 457 / 10 е 45, после 45 % 10 е 5 — десетиците.
  • Console.WriteLine(i++) печата 5, защото постфиксната форма връща старата стойност и чак после увеличава; следващият ред показва вече 6, а ++i увеличава преди да върне и печата 7.
  • Съставните оператори променят променливата на място: score /= 4 при 26 дава 6, защото и тук делението е целочислено, а score %= 4 оставя остатъка 2.

Класът Math в действие: геометрия и закръгляне

Program.cs
using System;

namespace MathDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            // 1. Разстояние между две точки и триъгълник по три върха
            double x1 = 0, y1 = 0, x2 = 4, y2 = 0, x3 = 0, y3 = 3;
            double a = Math.Sqrt(Math.Pow(x2 - x1, 2) + Math.Pow(y2 - y1, 2)); // 4
            double b = Math.Sqrt(Math.Pow(x3 - x2, 2) + Math.Pow(y3 - y2, 2)); // 5
            double c = Math.Sqrt(Math.Pow(x1 - x3, 2) + Math.Pow(y1 - y3, 2)); // 3
            double p = (a + b + c) / 2;                                        // 6
            double area = Math.Sqrt(p * (p - a) * (p - b) * (p - c));          // 6 (формула на Херон)
            Console.WriteLine($"Страни: {a}, {b}, {c}; лице: {area}");

            // 2. Окръжност и степени
            double r = 2.5;
            double circleArea = Math.PI * r * r;
            double circumference = 2 * Math.PI * r;
            Console.WriteLine($"Лице на кръга: {circleArea:F2}, обиколка: {circumference:F2}"); // 19.63, 15.71
            int kilobyte = (int)Math.Pow(2, 10);  // Pow връща double, затова (int)
            Console.WriteLine($"2 на степен 10 = {kilobyte}");

            // 3. Floor, Ceiling, Truncate и Round с отрицателно число
            double v = -3.7;
            Console.WriteLine($"Floor: {Math.Floor(v)}, Ceiling: {Math.Ceiling(v)}, Truncate: {Math.Truncate(v)}, Round: {Math.Round(v)}");
            // Floor: -4, Ceiling: -3, Truncate: -3, Round: -4

            // 4. Банково закръгляне срещу училищно
            Console.WriteLine($"Round(2.5) = {Math.Round(2.5)}, Round(3.5) = {Math.Round(3.5)}");   // 2, 4
            Console.WriteLine($"AwayFromZero: {Math.Round(2.5, MidpointRounding.AwayFromZero)}");  // 3
            Console.WriteLine($"Round(3.14159, 2) = {Math.Round(3.14159, 2)}");                    // 3.14

            // 5. Min, Max, Abs и ограничаване в интервал
            int grade = 7;
            int clamped = Math.Max(2, Math.Min(grade, 6));   // 6 - оценката остава в [2, 6]
            int diff = Math.Abs(3 - 8);                       // 5
            Console.WriteLine($"Ограничена оценка: {clamped}, разлика: {diff}, Clamp: {Math.Clamp(-1, 2, 6)}");
        }
    }
}

Какво се случва тук?

  • Разстоянието между две точки е корен от сбора на квадратите на разликите: Math.Sqrt(Math.Pow(x2 - x1, 2) + Math.Pow(y2 - y1, 2)). Скобите около x2 - x1 са задължителни — Math.Pow получава вече изчислената разлика. Трите върха (0,0), (4,0) и (0,3) дават страни 4, 5 и 3.
  • Формулата на Херон Math.Sqrt(p * (p - a) * (p - b) * (p - c)) изисква скоби около всяка разлика; с полупериметър p = 6 изразът под корена е 6 * 2 * 1 * 3 = 36 и лицето е 6.
  • Math.PI * r * r е лицето на кръг, а {circleArea:F2} показва резултата с два знака, без да променя стойността. Math.Pow(2, 10) връща double 1024, затова има изрично преобразуване (int), за да го запишем в int.
  • За -3.7 трите метода дават различни отговори: Math.Floor отива надолу към -4, Math.Ceiling нагоре към -3, а Math.Truncate отрязва дробната част и също дава -3. Math.Round(-3.7) е -4, защото числото не е точно по средата — банковото правило изобщо не се намесва.
  • Math.Round(2.5) дава 2, а Math.Round(3.5) — 4: по подразбиране .5 се закръгля към четния съсед. С MidpointRounding.AwayFromZero получаваме училищното 3, а Math.Round(3.14159, 2) закръгля до два знака — 3.14.
  • Math.Max(2, Math.Min(grade, 6)) ограничава стойността в интервала [2, 6]: вътрешният Min реже отгоре, външният Max — отдолу. Същото прави готовият Math.Clamp(x, 2, 6), а Math.Abs(3 - 8) дава разстоянието 5 между две числа независимо от реда им.

Внимавай! Чести грешки

Грешките, които почти всеки прави в тази тема — виж разликата между грешния и правилния код.

Средна стойност с целочислено деление

Грешно

int sum = 17;
int count = 3;
double average = sum / count;
Console.WriteLine(average); // 5, а не 5.666...

Правилно

int sum = 17;
int count = 3;
double average = (double)sum / count;
Console.WriteLine(average); // 5.666666666666667

Типът на променливата отляво не влияе на деленето: sum / count вече е int със стойност 5, преди да стигне до average. Преобразувайте единия операнд в double преди деленето; (double)(sum / count) не помага, защото отрязването вече е станало.

Формула без скоби и дроб от цели числа

Грешно

double f = 212;
double celsius = 5 / 9 * (f - 32);
Console.WriteLine(celsius); // 0 - защото 5 / 9 е 0

Правилно

double f = 212;
double celsius = (f - 32) * 5 / 9;
Console.WriteLine(celsius); // 100

5 / 9 са две цели числа и дават 0, а всичко, умножено по нула, е нула. В правилния вариант (f - 32) е double, затова и умножението, и делението след него са дробни; същото постига и 5.0 / 9 * (f - 32).

Проверка за нечетно число с `== 1`

Грешно

int n = -3;
bool isOdd = n % 2 == 1;
Console.WriteLine(isOdd); // False, а -3 е нечетно!

Правилно

int n = -3;
bool isOdd = n % 2 != 0;
Console.WriteLine(isOdd); // True

-3 % 2 е -1, не 1 — знакът на остатъка следва делимото. Проверката != 0 работи и за положителни, и за отрицателни числа.

Закръгляне на `.5` с `Math.Round`

Грешно

double price = 2.5;
double rounded = Math.Round(price);
Console.WriteLine(rounded); // 2 - очаквахме 3

Правилно

double price = 2.5;
double rounded = Math.Round(price, MidpointRounding.AwayFromZero);
Console.WriteLine(rounded); // 3

По подразбиране Math.Round закръгля към четно (MidpointRounding.ToEven): 0.5 → 0, 1.5 → 2, 2.5 → 2, 3.5 → 4. За училищното правило подайте MidpointRounding.AwayFromZero, при брой знаци — Math.Round(x, 2, MidpointRounding.AwayFromZero).

Задачи за самостоятелна работа

Опитай първо сам — подсказката е там само ако наистина закъсаш.

Секунди в часове, минути и секунди

Прочетете от конзолата цяло число — брой секунди (например 3725). Изведете го като часове, минути и секунди във формат 1:02:05. Минутите и секундите винаги са с две цифри. Използвайте само / и %, без if.

Проверки без if

Прочетете цяло число year (година) и цяло число n. Без да използвате if, изведете четири реда с True или False: дали year е високосна (дели се на 4, но не на 100, освен ако се дели на 400); дали n е нечетно (трябва да работи и за отрицателни числа); дали n е трицифрено (по абсолютна стойност между 100 и 999); дали n завършва на 0 или 5. Проверете с 2024, 1900, 2000 и с n = -125.

Сметка за поръчка

Прочетете единична цена (double), брой (int) и процент отстъпка (int). Изчислете и изведете с два знака след десетичния знак: сумата преди отстъпка; приложената отстъпка в проценти, която не може да надвишава 50 (Math.Min) и не може да е отрицателна (Math.Max); сумата след отстъпката; крайната сума с 20% ДДС, закръглена до стотинка по училищното правило (MidpointRounding.AwayFromZero). Накрая изведете колко кашона по 12 броя са нужни, за да се опаковат всички бройки (Math.Ceiling). Проверете с цена 19.99, брой 7 и отстъпка 60: крайната сума трябва да е 83.96, а кашоните — 1.

Мини-тест за проверка

Отговори си наум (или на глас!) и чак тогава разкрий отговора.

1. Какво извежда кодът `int i = 5; Console.WriteLine(i++); Console.WriteLine(++i);`?

2. Какво дават `-7 / 2` и `-7 % 2` в C# и защо?

3. Защо `count != 0 && sum / count > 5` не гърми при `count == 0`, а същият израз с `&` вместо `&&` хвърля `DivideByZeroException`?

4. `Math.Round(2.5)` връща `2`, а `Math.Round(3.5)` — `4`. Грешка ли е това и как да получим `3` от `2.5`?

Речник на термините

Виж пълния речник на курса
Оператор и операнд (operator, operand)
Операторът е знак за действие (+, %, &&), а операндите са стойностите, върху които той действа. В a % b операторът е %, операндите са a и b.
Израз (expression)
Комбинация от стойности, променливи, оператори и извиквания на методи, която се изчислява до една стойност от определен тип, например Math.Sqrt(a * a + b * b).
Приоритет (precedence)
Редът, по който се изпълняват операторите в израз без скоби: умножението и делението са преди събирането, сравненията — преди &&, а && — преди ||.
Асоциативност (associativity)
Посоката на изчисление при оператори с еднакъв приоритет. Аритметичните са отляво надясно (10 - 4 - 3 е 3), присвояването — отдясно наляво (a = b = 0).
Целочислено деление (integer division)
Деление на две цели числа, при което дробната част се отрязва към нулата: 7 / 2 е 3, -7 / 2 е -3.
Остатък (modulo, `%`)
Остатъкът от целочислено деление; знакът му съвпада със знака на делимото. 7 % 3 е 1, -7 % 3 е -1.
Инкремент и декремент (increment, decrement)
Операторите ++ и --, които променят променлива с единица. Префиксната форма (++i) връща новата стойност, постфиксната (i++) — старата.
Съкратено изчисляване (short-circuit evaluation)
Поведение на && и ||, при което дясната страна не се изчислява, ако лявата вече определя резултата. Позволява защитни проверки като x != 0 && 10 / x > 1.
Банково закръгляне (banker's rounding)
Правилото по подразбиране на Math.Round: стойност точно по средата (.5) се закръгля към четния съсед — 2.5 става 2, 3.5 става 4. Задава се с MidpointRounding.ToEven; алтернативата е MidpointRounding.AwayFromZero.

Провери знанията

Бърз тест с избор от отговори върху термините на модула — с точки и моментална обратна връзка.

Провери знанията си

9 въпроса върху термините от модула. Показваме определение — ти избираш правилния термин.

Материали от часовете

Задачи и тестове, давани в клас по тази тема.

Препоръки за този модул

  • Преди да напишете формула в кода, препишете я на хартия с всички скоби и отбележете до всяка променлива дали е int или double. Деленето на две цели числа маркирайте веднага — точно там ще ви трябва 2.0 или (double).
  • Проверявайте програмата с данни, за които знаете отговора наизуст: страни 3, 4, 5 за триъгълник, 100 °C = 212 °F, 3600 секунди = 1 час. Ако отговорът е грешен, печатайте междинните стойности ред по ред, вместо да се взирате в крайната формула.
  • Дръжте таблицата с приоритета на операторите подръка, но пишете код, който не я изисква: по един ++ на ред, скоби около всяка смесена група от && и ||, междинни променливи с ясни имена вместо един израз на три реда.
  • Ако изходът показва 3,5 вместо 3.5, Windows е с български регионални настройки — тогава и double.Parse очаква запетая при въвеждане. Това не е грешка в кода; за красив изход използвайте формат {x:F2}, а за закръгляне на самата стойност — Math.Round.

Учебен наръчник — теория, примери, задачи и тестове по предметите от учебния план.

Натисни Ctrl K или / отвсякъде, за да търсиш.