Как делить нацело в си шарп

Арифметические операторы (справочник по C#)

Следующие операторы выполняют арифметические операции с операндами числовых типов:

• унарные — ++ (приращение), — (уменьшение), + (плюс) и — (минус);
• бинарные — * (умножение), / (деление), % (остаток от деления), + (сложение) и — (вычитание).

Эти операторы поддерживаются всеми целочисленными типами и типами с плавающей запятой.

В случае целочисленных типов эти операторы (за исключением операторов ++ и — ) определяются для типов int , uint , long и ulong . Если операнды принадлежат к другим целочисленным типам ( sbyte , byte , short , ushort или char ), их значения преобразуются в тип int , который также является типом результата операции. Если операнды принадлежат к разным целочисленным типам или типам с плавающей запятой, их значения преобразуются в ближайший содержащий тип, если такой тип существует. Дополнительные сведения см. в разделе Числовые повышения уровня в статье Спецификации языка C#. Операторы ++ и — определяются для всех целочисленных числовых типов и числовых типов с плавающей запятой, а также типа char. Тип результата выражения сложного назначения является типом левого операнда.

Оператор инкремента ++

Оператор инкремента ++ увеличивает операнд на 1. Операндом должна быть переменная, свойство или индексатор.

Оператор инкремента поддерживается в двух формах: постфиксный оператор инкремента ( x++ ) и префиксный оператор инкремента ( ++x ).

Постфиксный оператор приращения

Результатом x++ является значение x перед выполнением операции, как показано в следующем примере:

int i = 3; Console.WriteLine(i); // output: 3 Console.WriteLine(i++); // output: 3 Console.WriteLine(i); // output: 4 

Префиксный оператор инкремента

Результатом ++x является значение x после выполнения операции, как показано в следующем примере:

double a = 1.5; Console.WriteLine(a); // output: 1.5 Console.WriteLine(++a); // output: 2.5 Console.WriteLine(a); // output: 2.5 

Оператор декремента —

Унарный оператор декремента — уменьшает операнд на 1. Операндом должна быть переменная, свойство или индексатор.

Оператор декремента поддерживается в двух формах: постфиксный оператор декремента ( x— ) и префиксный оператор декремента ( —x ).

Постфиксный оператор уменьшения

Результатом x— является значение x перед выполнением операции, как показано в следующем примере:

int i = 3; Console.WriteLine(i); // output: 3 Console.WriteLine(i--); // output: 3 Console.WriteLine(i); // output: 2 

Префиксный оператор декремента

Результатом —x является значение x после выполнения операции, как показано в следующем примере:

double a = 1.5; Console.WriteLine(a); // output: 1.5 Console.WriteLine(--a); // output: 0.5 Console.WriteLine(a); // output: 0.5 

Операторы унарного плюса и минуса

Унарный оператор + возвращает значение полученного операнда. Унарный оператор — изменяет знак операнда на противоположный.

Console.WriteLine(+4); // output: 4 Console.WriteLine(-4); // output: -4 Console.WriteLine(-(-4)); // output: 4 uint a = 5; var b = -a; Console.WriteLine(b); // output: -5 Console.WriteLine(b.GetType()); // output: System.Int64 Console.WriteLine(-double.NaN); // output: NaN 

Тип ulong не поддерживает унарный оператор — .

Оператор умножения *

Оператор умножения * вычисляет произведение операндов:

Console.WriteLine(5 * 2); // output: 10 Console.WriteLine(0.5 * 2.5); // output: 1.25 Console.WriteLine(0.1m * 23.4m); // output: 2.34 

Оператор деления /

Оператор деления / делит левый операнд на правый.

Деление целых чисел

Для операндов цельночисленных типов результат оператора / является целочисленным типом, который равен частному двух операндов, округленному в сторону нуля:

Console.WriteLine(13 / 5); // output: 2 Console.WriteLine(-13 / 5); // output: -2 Console.WriteLine(13 / -5); // output: -2 Console.WriteLine(-13 / -5); // output: 2 

Чтобы получить частное двух операндов в виде числа с плавающей запятой, используйте тип float , double или decimal :

Console.WriteLine(13 / 5.0); // output: 2.6 int a = 13; int b = 5; Console.WriteLine((double)a / b); // output: 2.6 

Деление чисел с плавающей запятой

Для типов float , double и decimal результатом оператора / является частное двух операндов:

Console.WriteLine(16.8f / 4.1f); // output: 4.097561 Console.WriteLine(16.8d / 4.1d); // output: 4.09756097560976 Console.WriteLine(16.8m / 4.1m); // output: 4.0975609756097560975609756098 

Если один из операндов — это decimal , второй операнд не может быть ни float , ни double , так как ни float , ни double не преобразуется неявно в тип decimal . Необходимо явным образом преобразовать операнд float или double в тип decimal . Дополнительные сведения о числовых преобразованиях см. в разделе Встроенные числовые преобразования.

Оператор остатка %

Оператор остатка % вычисляет остаток от деления левого операнда на правый.

Целочисленный остаток

Для целочисленных операндов результатом a % b является значение, произведенное a — (a / b) * b . Знак ненулевого остатка такой же, как и у левого операнда, как показано в следующем примере:

Console.WriteLine(5 % 4); // output: 1 Console.WriteLine(5 % -4); // output: 1 Console.WriteLine(-5 % 4); // output: -1 Console.WriteLine(-5 % -4); // output: -1 

Используйте метод Math.DivRem для вычисления результатов как целочисленного деления, так и определения остатка.

Остаток с плавающей запятой

Для операндов типа float и double результатом x % y для конечных x и y будет значение z , так что:

• знак z , если отлично от нуля, совпадает со знаком x ;
• абсолютное значение z является значением, произведенным |x| — n * |y| , где n — это наибольшее возможное целое число, которое меньше или равно |x| / |y| , а |x| и |y| являются абсолютными значениями x и y , соответственно.

Этот метод вычисления остатка аналогичен тому, который использовался для целочисленных операндов, но отличается от спецификации IEEE 754. Если вам нужна операция вычисления остатка, которая соответствует спецификации IEEE 754, используйте метод Math.IEEERemainder.

Сведения о поведение оператора % в случае неконечных операндов см. в разделе Оператор остаткаспецификации языка C#.

Для операндов decimal оператор остатка % эквивалентен оператору остатка типа System.Decimal.

В следующем примере показано поведение оператора остатка для операндов с плавающей запятой:

Console.WriteLine(-5.2f % 2.0f); // output: -1.2 Console.WriteLine(5.9 % 3.1); // output: 2.8 Console.WriteLine(5.9m % 3.1m); // output: 2.8 

Оператор сложения +

Оператор сложения + вычисляет сумму своих операндов:

Console.WriteLine(5 + 4); // output: 9 Console.WriteLine(5 + 4.3); // output: 9.3 Console.WriteLine(5.1m + 4.2m); // output: 9.3 

Кроме того, оператор + можно использовать для объединения строк и делегатов. Дополнительные сведения см. в статье Операторы + и += .

Оператор вычитания —

Оператор вычитания — вычитает правый операнд из левого:

Console.WriteLine(47 - 3); // output: 44 Console.WriteLine(5 - 4.3); // output: 0.7 Console.WriteLine(7.5m - 2.3m); // output: 5.2 

Кроме того, оператор — можно использовать для удаления делегатов. Дополнительные сведения см. в статье Операторы — и -= .

Составное присваивание

Для бинарного оператора op выражение составного присваивания в форме

x op= y 

x = x op y 

за исключением того, что x вычисляется только один раз.

Следующий пример иллюстрирует использование составного присваивания с арифметическими операторами:

int a = 5; a += 9; Console.WriteLine(a); // output: 14 a -= 4; Console.WriteLine(a); // output: 10 a *= 2; Console.WriteLine(a); // output: 20 a /= 4; Console.WriteLine(a); // output: 5 a %= 3; Console.WriteLine(a); // output: 2 

Из-за восходящих приведений результат операции op может быть невозможно неявно преобразовать в тип T из x . В этом случае, если op является предопределенным оператором, и результат операции является явно преобразуемым в тип T x , выражение составного присваивания формы x op= y эквивалентно x = (T)(x op y) , за исключением того, что x вычисляется только один раз. В следующем примере продемонстрировано такое поведение.

byte a = 200; byte b = 100; var c = a + b; Console.WriteLine(c.GetType()); // output: System.Int32 Console.WriteLine(c); // output: 300 a += b; Console.WriteLine(a); // output: 44 

В предыдущем примере значение 44 является результатом преобразования значения 300 в byte тип .

Вы также можете использовать операторы += и -= для подписки и отмены подписки на события соответственно. Дополнительные сведения см. в разделе Практическое руководство. Подписка и отмена подписки на события.

Приоритет и ассоциативность операторов

В следующем списке перечислены арифметические операторы в порядке убывания приоритета:

• Постфиксный инкремент x++ и декремент x—
• Префиксный инкремент ++x и декремент —x , унарные операторы + и —
• Мультипликативные операторы * , / , и %
• Аддитивные операторы + и —

Бинарные арифметические операторы имеют левую ассоциативность. То есть операторы с одинаковым приоритетом вычисляются в направлении слева направо.

Порядок вычисления, определяемый приоритетом и ассоциативностью операторов, можно изменить с помощью скобок ( () ).

Console.WriteLine(2 + 2 * 2); // output: 6 Console.WriteLine((2 + 2) * 2); // output: 8 Console.WriteLine(9 / 5 / 2); // output: 0 Console.WriteLine(9 / (5 / 2)); // output: 4 

Полный список операторов C#, упорядоченный по уровню приоритета, можно найти в разделе Приоритет операторов статьи Операторы C#.

Арифметическое переполнение и деление на нуль

Если результат арифметической операции выходит за пределы диапазона возможных конечных значений соответствующего числового типа, поведение арифметического оператора зависит от типа его операндов.

Целочисленное арифметическое переполнение

Деление целого числа на ноль всегда вызывает исключение DivideByZeroException.

В случае целочисленного арифметического переполнения итоговое поведение определяется проверяемым или непроверяемым контекстом проверки переполнения:

• Если в проверяемом контексте переполнение возникает в константном выражении, происходит ошибка времени компиляции. В противном случае, если операция производится во время выполнения, возникает исключение OverflowException.
• В непроверяемом контексте результат усекается путем удаления старших разрядов, которые не помещаются в целевой тип данных.

Вместе с проверяемыми и непроверяемыми операторами можно использовать операторы checked и unchecked , чтобы управлять контекстом проверки переполнения, в котором вычисляется выражение:

int a = int.MaxValue; int b = 3; Console.WriteLine(unchecked(a + b)); // output: -2147483646 try < int d = checked(a + b); >catch(OverflowException) < Console.WriteLine($"Overflow occurred when adding to ."); > 

По умолчанию арифметические операции выполняются в непроверяемом контексте.

Арифметическое переполнение с плавающей запятой

Арифметические операции с типами float и double никогда не вызывают исключение. Результатом арифметических операций с этими типами может быть одно из специальных значений, представляющих бесконечность и объект, не являющийся числовым:

double a = 1.0 / 0.0; Console.WriteLine(a); // output: Infinity Console.WriteLine(double.IsInfinity(a)); // output: True Console.WriteLine(double.MaxValue + double.MaxValue); // output: Infinity double b = 0.0 / 0.0; Console.WriteLine(b); // output: NaN Console.WriteLine(double.IsNaN(b)); // output: True 

Для операндов типа decimal арифметическое переполнение всегда выдает исключение OverflowException, а деление на нуль — DivideByZeroException.

Ошибки округления

Из-за общих ограничений, касающихся представления вещественных чисел в форме с плавающей запятой и арифметических операций с плавающей запятой, при вычислениях с использованием типов с плавающей запятой могут возникать ошибки округления. То есть полученный результат выражения может отличаться от ожидаемого математического результата. В следующем примере показано несколько таких случаев:

Console.WriteLine(.41f % .2f); // output: 0.00999999 double a = 0.1; double b = 3 * a; Console.WriteLine(b == 0.3); // output: False Console.WriteLine(b - 0.3); // output: 5.55111512312578E-17 decimal c = 1 / 3.0m; decimal d = 3 * c; Console.WriteLine(d == 1.0m); // output: False Console.WriteLine(d); // output: 0.9999999999999999999999999999 

См. заметки в справочной документации по System.Double, System.Single и System.Decimal.

Возможность перегрузки оператора

Определяемый пользователем тип может перегружать унарные ( ++ , — , + и — ) и бинарные ( * , / , % , + и — ) арифметические операторы. При перегрузке бинарного оператора соответствующий оператор составного присваивания также неявно перегружается. Явная перегрузка составного оператора присваивания для пользовательского типа невозможна.

Проверенные операторы, определяемые пользователем

Начиная с C# 11 при перегрузке арифметического оператора можно использовать ключевое слово checked , чтобы определить проверенную версию этого оператора. Следующий пример показывает, как это сделать:

public record struct Point(int X, int Y) < public static Point operator checked +(Point left, Point right) < checked < return new Point(left.X + right.X, left.Y + right.Y); >> public static Point operator +(Point left, Point right) < return new Point(left.X + right.X, left.Y + right.Y); >> 

При определении проверенного оператора следует также определить соответствующий оператор без модификатора checked . Проверенный оператор вызывается в проверенном контексте. Оператор без модификатора checked вызывается в непроверенном контексте. Если указать только оператора без модификатора checked , он будет вызываться как в контексте checked , так и в unchecked .

При определении обеих версий оператора их поведение будет различаться только в том случае, если результат операции слишком велик, чтобы представить его тип следующим образом:

• Проверенный оператор вызывает OverflowException.
• Оператор без модификатора checked возвращает экземпляр, который представляет усеченный результат.

Сведения о разнице в поведении встроенных арифметических операторов см. в разделе Арифметическое переполнение и деление на ноль.

Модификатор checked можно использовать только при перегрузке следующих операторов:

• Унарные операторы ++ , — и —
• Бинарные операторы * , / , + и —
• Операторы явного преобразования

Контекст проверки переполнения в теле проверенного оператора не изменяется при наличии модификатора checked . Контекст по умолчанию определяется значением параметра компилятора CheckForOverflowUnderflow. С помощью операторов checked и unchecked можно явно указать контекст проверки переполнения, как показано в примере в начале этого раздела.

Спецификация языка C#

Дополнительные сведения см. в следующих разделах статьи Спецификация языка C#:

• Постфиксные операторы инкремента и декремента
• Префиксные операторы инкремента и декремента
• Оператор унарного плюса
• Оператор унарного минуса
• Оператор умножения
• Оператор деления
• Оператор остатка
• Оператор сложения
• Оператор вычитания
• Составное присваивание
• Операторы checked и unchecked
• Восходящие приведения числовых типов

См. также раздел

• справочник по C#
• Операторы и выражения C#
• System.Math
• System.MathF
• Числовые значения в .NET

Совместная работа с нами на GitHub

Источник этого содержимого можно найти на GitHub, где также можно создавать и просматривать проблемы и запросы на вытягивание. Дополнительные сведения см. в нашем руководстве для участников.

The .NET documentation is open source. Provide feedback here.

Обратная связь

Отправить и просмотреть отзыв по

Как разделить без остатка на C#?

И вообще, нет никакого смысла использовать дробные числа для времени. Используй целые секунды или миллисекунды, как везде.

Отслеживать
ответ дан 30 сен 2017 в 22:27
122k 24 24 золотых знака 124 124 серебряных знака 299 299 бронзовых знаков

Извините, для меня здесь пока слишком много магии) вы не могли бы пояснить? 1e11 это 1 * 10^11 (один умножить на 10 в степени 11)? (long) — Это некий «целочисленный тип данных» (зачем он здесь)? Math.Floor — округление? Судя по ссылке насколько я понимаю в обоих случаях вывод в консоль = 1666666666 — что это дает? И как задавать время для таймера в этом варианте?

30 сен 2017 в 22:51

1. Да. 2. Да, 64 битный. У double только 53 значащих бита, т. е. только целые числа до 5^53 представляются точно. У long получается 63, т. е. ни переполнения, ни потери точности не будет (при условии, что число не превосходило 2^53). 3. Это два условно эквивалентных способа. Точнее, они эквивалентны при x in 0 to 2^53. При других гарантировать не могу. А результат деления имеет 6 в периоде и обычное округление дало бы последнюю цифру 7, а не 6.

30 сен 2017 в 22:54

почему floor то, а не truncate ?, для -7.1 получите -8 , что явно не «отрезание» дробной части. По условию, конечно, у автора вряд ли будут отрицательные значения, но все же, имхо метод не тот.

Как делить нацело в си шарп

В C# используется большинство операций, которые применяются и в других языках программирования. Операции представляют определенные действия над операндами — участниками операции. В качестве операнда может выступать переменной или какое-либо значение (например, число). Операции бывают унарными (выполняются над одним операндом), бинарными — над двумя операндами и тернарными — выполняются над тремя операндами. Рассмотрим все виды операций.

Бинарные арифметические операции:

+ Операция сложения двух чисел:

int x = 10; int z = x + 12; // 22

int x = 10; int z = x - 6; // 4

int x = 10; int z = x * 5; // 50

int x = 10; int z = x / 5; // 2 double a = 10; double b = 3; double c = a / b; // 3.33333333

При делении стоит учитывать, что если оба операнда представляют целые числа, то результат также будет округляться до целого числа:

double z = 10 / 4; //результат равен 2

Несмотря на то, что результат операции в итоге помещается в переменную типа double, которая позволяет сохранить дробную часть, но в самой операции участвуют два литерала, которые по умолчанию рассматриваются как объекты int, то есть целые числа, и результат то же будет целочисленный. Для выхода из этой ситуации необходимо определять литералы или переменные, участвующие в операции, именно как типы double или float:

double z = 10.0 / 4.0; //результат равен 2.5

double x = 10.0; double z = x % 4.0; //результат равен 2

Также есть ряд унарных операций, в которых принимает участие один операнд:

++ Операция инкремента Инкремент бывает префиксным: ++x — сначала значение переменной x увеличивается на 1, а потом ее значение возвращается в качестве результата операции.

И также существует постфиксный инкремент: x++ — сначала значение переменной x возвращается в качестве результата операции, а затем к нему прибавляется 1.

int x1 = 5; int z1 = ++x1; // z1=6; x1=6 Console.WriteLine($" - "); int x2 = 5; int z2 = x2++; // z2=5; x2=6 Console.WriteLine($" - ");

int x1 = 5; int z1 = --x1; // z1=4; x1=4 Console.WriteLine($" - "); int x2 = 5; int z2 = x2--; // z2=5; x2=4 Console.WriteLine($" - ");

При выполнении сразу нескольких арифметических операций следует учитывать порядок их выполнения. Приоритет операций от наивысшего к низшему:

1. Инкремент, декремент
2. Умножение, деление, получение остатка
3. Сложение, вычитание

Для изменения порядка следования операций применяются скобки.

Рассмотрим набор операций:

int a = 3; int b = 5; int c = 40; int d = c---b*a; // a=3 b=5 c=39 d=25 Console.WriteLine($"a= b= c= d=");

Здесь мы имеем дело с тремя операциями: декремент, вычитание и умножение. Сначала выполняется декремент переменной c, затем умножение b*a, и в конце вычитание. То есть фактически набор операций выглядел так:

int d = (c--)-(b*a);

Но с помощью скобок мы могли бы изменить порядок операций, например, следующим образом:

int a = 3; int b = 5; int c = 40; int d = (c-(--b))*a; // a=3 b=4 c=40 d=108 Console.WriteLine($"a= b= c= d=");

Ассоциативность операторов

Как выше было отмечено, операции умножения и деления имеют один и тот же приоритет, но какой тогда результат будет в выражении:

int x = 10 / 5 * 2;

Стоит нам трактовать это выражение как (10 / 5) * 2 или как 10 / (5 * 2) ? Ведь в зависимости от трактовки мы получим разные результаты.

Когда операции имеют один и тот же приоритет, порядок вычисления определяется ассоциативностью операторов. В зависимости от ассоциативности есть два типа операторов:

• Левоассоциативные операторы, которые выполняются слева направо
• Правоассоциативные операторы, которые выполняются справа налево

Все арифметические операторы являются левоассоциативными, то есть выполняются слева направо. Поэтому выражение 10 / 5 * 2 необходимо трактовать как (10 / 5) * 2 , то есть результатом будет 4.

Как узнать, делится ли первое число нацело на втрое

Извините может быть за тупой вопрос. Я не так давно начал программировать на с#, еще не читал не каких материалов, так что кроме школьных знаний по qBasik, у меня не чего нет, но уже написал две программки, первая из них простой консольный калькулятор, а вторая это тренажер устного счета. Вот со второй программой у меня и появились сложности.
Когда первое число получается меньше второго а знак деление, то ответе получается 0 или же когда первое число нацело не делиться на втрое то тоже косяк.
Пример: (67/98 = 0 или же 67 /56 = 1)
Во-первых как узнать делиться ли первое число нацело на втрое в с#( в qBasik это было так

Кликните здесь для просмотра всего текста

IF a / b <> a \ b

, можно ли так и тут?
Во-вторых хотелось что бы программа при знаке деления подбирало второе число так что бы оно делило первое нацело, может у кого есть какие идеи и он поможет.
В-третьих как находить общий делитель у двух цифр?
P.s. За такое кривое изложение вопросов, я пытался как можно удобней и понятней.
Вот исходники.

Кликните здесь для просмотра всего текста

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101

using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace TrainerMentalArithmetic { class Program { static void Main(string[] args) { bool repeat = true; while (repeat == true) { TMA c = new TMA(); c.randomas(); c.Operation1(); c.resulting(); c.compare(); /*if (c.fail == false)*/ continue; } } } class TMA { int a; int b; public bool fail = true; public void randomas() { Random rnd1 = new Random(); Random rnd2 = new Random(); a = rnd1.Next(101); b = rnd2.Next(-101, 101); //Console.WriteLine(a); //Console.Read(); } int c; int result; string operetion; public void Operation1() { Random opr = new Random(); c = opr.Next(4); switch (c) { case 0: result = a + b; break; case 1: result = a - b; break; case 2: result = a * b; break; case 3: result = a / b; break; } switch (c) { case 0: operetion = "+"; break; case 1: operetion = "-"; break; case 2: operetion = "*"; break; case 3: operetion = "/"; break; } //Console.WriteLine(c); //Console.Read(); } int result1; public void resulting() { Console.WriteLine("Ведите ответ"); Console.WriteLine(a + operetion + b + "="); input(Console.ReadLine(), out result1); } public void compare() { if (result == result1) { Console.WriteLine("Правильнo"); //fail = false; } else { Console.WriteLine("Неправильно"); } Console.WriteLine(Environment.NewLine); } public void input(string str, out int number) { number = 0; try { number = Convert.ToInt32(str); } catch (Exception) { Console.WriteLine("Неверный ввод"); } //fail = true; } } }

Добавлено через 2 часа 0 минут
Не,неужели такой сложный вопрос? Не кто не знает как сделать? Или я не коректно задал вопросы?

94731 / 64177 / 26122
Регистрация: 12.04.2006
Сообщений: 116,782
Ответы с готовыми решениями:

Делится ли нацело первое число на второе
пиши программу, которая запрашивает у пользователя два числа и проверяет, делится ли нацело первое.

Проверить условие, что число а: четное, делится нацело на 3, нечетное, не делится нацело на 3
запишите условие того, что число а есть: парное, делится нацело на 3, нечетное, не делится нацело.

Найти числа А и В, если известно, что первое четырехзначное число нацело делится на 99
Даны два двузначных числа А и В. Из этих чисел составили два четырехзначных числа: первое число.

Найти числа А и В, если известно, что первое четырехзначное число нацело делится на 99, а второе – на 49.
Даны два двузначных числа А и В. Из этих чисел составили два четырехзначных числа: первое число.

34 / 34 / 16
Регистрация: 07.04.2011
Сообщений: 103
1. Остаток от деления в c# проверяется с помощью оператора «%», то есть

1 2 3 4

int a = 10; int b = 20; if(b%a == 0) Console.WriteLine("Число b делится нацело на число a"); else Console.WriteLine("..не делится..")

P.S. Четность-нечетность числа можно узнать проверив его остаток от деления на 2.

2. Эм, не совсем понял, но вот таким вот способом можно получить все числа меньше заданного, которые делят его нацело

1 2 3 4 5

int a = 10; for(int n = a;n>0;n--) { if(a%n==0)Console.WriteLine(string.Format("Число делит число нацело", n,a)); }

3. Наибольший общий делитель (НОД) двух чисел можно найти с помощью алгоритма Евклида. Реализация на шарпе + использование (взял с данного форума):

1 2 3 4 5 6 7 8 9 10 11 12

private static int Gcd(int a, int b) { return a > 0 ? Gcd(b % a, a) : b; } private static void Main() { int a = 10; int b = 15; int gcd = Gcd(a,b); Console.WriteLine(gcd); Console.Read(); }