user10429306

user10429306

На Пикабу
583 рейтинг 30 подписчиков 1 подписка 28 постов 0 в горячем
4

Двумерные массивы и вложенные циклы. Синтаксис C#

Двумерные массивы представляют собой таблицу. Поэтому доступ к значению, хранимому в двумерном массиве, осуществляется с указанием двух индексов, индекса строки и индекса столбца. Нумерация индексов начинается с нуля.

static void Main(string[] args)

{

string[,] arr = { { "A", "B" }, { "C", "D" } };

Console.WriteLine(arr[1,0]);

}

Здесь, инициализирован двумерный массив из двух строк, в каждой из которых два значения. Значения A и B принадлежать первой строке с индексом 0, значения С и D, находятся на второй строке, с индексом 1. С помощью arr[1,0] был получен доступ к значению «С» расположенному на второй строке в первом столбце.

Количество строк и столбцов можно указать явно. Для этого, вместо фигурных скобок, используются квадратные.

Первым параметром указывается количество строк, вторым— столбцов. Количество строк и столбцов называется размерностью массива.

static void Main(string[] args)

{

int[,] arr = new int [ 2, 3 ];

arr[0, 0] = 1;

arr[0, 1] = 2;

arr[0, 2] = 3;

arr[1, 0] = 4;

arr[1, 1] = 5;

arr[1, 2] = 6;

Console.WriteLine(arr[1,0]);

}

Здесь, инициализирован массив из двух строк и трех столбцов. Присвоение значения происходит по двум индексам. Индексу строки и индексу столбца. Доступ получен к находящемуся во второй строке первому элементу.

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

Так же, как и в одномерном массиве, для перебора в цикле нужно знать размерность массива, но в отличии от одномерного, в двумерном, размерности две. Одна — количество строк, вторая количество — столбцов. Свойство Length для этих целей не подходит, так как предназначено для подсчета количества всех элементов массива вне зависимости от того, как они хранятся.

static void Main(string[] args)

{

int[,] arr = new int[2, 3];

arr[0, 0] = 1;

arr[0, 1] = 2;

arr[0, 2] = 3;

arr[1, 0] = 4;

arr[1, 1] = 5;

arr[1, 2] = 6;

Console.WriteLine(arr.Length);

}

Для нахождения размерностей строк и столбцов используется метод — GetLength(), в скобки которого помещают значения размерности, для строк это число 0, для столбцов 1.

static void Main(string[] args)

{

int[,] arr = new int[2, 3];

arr[0, 0] = 1;

arr[0, 1] = 2;

arr[0, 2] = 3;

arr[1, 0] = 4;

arr[1, 1] = 5;

arr[1, 2] = 6;

// Перебор строк:

for (int i = 0; i < arr.GetLength(0); i++)

{

// Перебор столбцов в строке:

for (int j = 0; j < arr.GetLength(1); j++)

{


Console.Write(arr[i, j] + " ");

}

// Переход к новой строке:

Console.WriteLine();

}

}

Общепринято для внешнего цикла использовать переменную «i», для внутреннего «j»

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

static void Main(string[] args)

{

int[,] arr = new int[2, 3];

Random rnd = new Random();

int value = rnd.Next(0, 10);


for (int i = 0; i < arr.GetLength(0); i++)

{

// Перебор столбцов в строке:

for (int j = 0; j < arr.GetLength(1); j++)

{

arr[i,j] = rnd.Next(0, 10);

Console.Write(arr[i, j] + " ");

}

// Переход к новой строке:

Console.WriteLine();

}

}

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

К примеру, таблица умножения

static void Main(string[] args)

{

for (int i = 1; i < 10; i++)

{

for (int j = 1; j < 10; j++)

{

Console.Write($"{i * j} \t");

}

Console.WriteLine();

}

}

Здесь, « \t » управляющий символ, литерал, аналог клавиши Tab, используемый для выравнивания текста.

В заключении.

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

Для обработки всех значений двумерного массива используется конструкция вложенного цикла, где внешний цикл производит итерации надстройками, а внутренний над столбцами Конечное значение счетчика размерности строки и столбца определяется методом GetLength().

На этом занятие закончено.

Вы можете самостоятельно найти задачи для закрепления теоретического материала или для получения задач с ответами отправьте письмо на basicprog@mail.ru

Удачи в выполнении практических заданий!

Показать полностью
4

Операции над массивом. Синтаксис C#

Операции над массивом включают в себя

  • Присвоение значения элементу массива

  • Изменение элемента массива

  • Поиск элемента массива

  • Сортировка элементов массива. Данная операция относится к учебному курсу «Алгоритмы и структуры данных» и в данной лекции рассмотрена не будет.

Присвоение значения элементу массива.

Присвоить значения элементам массива можно при инициализации массива

int[] arr = {10, 5, 6, 3, 4};

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

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

static void Main(string[] args)

{

Random rnd = new Random();

int value = rnd.Next(0, 10);

Console.WriteLine("Сгенерированное число " + value);

}

Здесь — rnd, объект класса Random. Классы не входят в рамки этого курса и не будут рассмотрены.

Строка int value = rnd.Next(0, 10); — операция инициализации целочисленной переменной целочисленным значением, которое является результатом вычисления операции rnd.Next(0, 10), где метод— Next(0, 10) определяет диапазон числового ряда.

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

static void Main(string[] args)

{

Random rnd = new Random();

int[] arr = new int[5];

for (int i = 0; i < arr.Length; i++)

{

arr[i] = rnd.Next(0, 10);

Console.WriteLine($"Индекс элемента {i}, значение {arr[i]}");

}

}

Переменная « i » последовательно принимает значения числового ряда в диапазоне от нуля до четырех. Изменяясь каждую итерацию, переменная « i », изменяет каждую итерации индекс в выражении arr[i], при первой итерации выражение arr[i] будет заменено на arr[0], а при последнем на arr[4]. Таким образом, в строке arr[i] = rnd.Next(0, 10); происходит три операции

  • Генерация случайного значения в диапазоне от 0 до 10

  • Получение доступа к элементу массива по индексу

  • Присвоение сгенерированного значения элементу массива

В случае, когда значений не много, элементы массива можно случайными значениями с клавиатуры. Напишем программу для хранения названий трех самых высоких гор

static void Main(string[] args)

{

Console.WriteLine("Введите названия трех самых высоких гор");

string[] arr = new string[3];

for (int i = 0; i < arr.Length; i++)

{

Console.WriteLine("Введите название горы ");

arr[i] = Console.ReadLine();

}

Console.Clear();

Console.WriteLine("Названия трех самых высоких гор");

for (int i = 0; i < arr.Length; i++)

{

Console.WriteLine(arr[i]);

}

}

Здесь, в первом цикле значения записываются в элементы массива, второй цикл выводит содержимое массива на экран.  

Изменение значений в элементах массива

Изменения значений в элементах ничем не отличаются от операции присвоения, и по аналогии с операцией присвоения нового значения переменной, происходит замещение одного значения другим.

static void Main(string[] args)

{

int[] arr = { 1, 2, 3, 4, 5 };

Random rnd = new Random();

for (int i = 0; i < arr.Length; i++)

{

arr[i] = rnd.Next(10, 20);

Console.WriteLine($"Индекс элемента {i}, значение {arr[i]}");

}

}

Самая распространенная операция над элементами массива — поиск значения.

Данная операция нашла широкое применение при сортировке, но сортировка структуры данных — это отдельный учебный курс и не будет рассмотрена.

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

static void Main(string[] args)

{

int[] arr = { 1, 2, 3, 4, 5, 6, 7, 8 };

for (int i = 0; i < arr.Length; i++)

{

if (arr[i] % 2 == 0)

{

Console.WriteLine(arr[i]);

}

}

}

Здесь переменная « i » будет принимать значения от нуля до значения ограниченное логическим выражением «arr.Length», т.е. конечное значение массива. Меняясь, переменная « i », будет изменять индекс элемента arr[i]  и проверять его в отношении «arr[i] % 2 == 0» , тем самым вызывая для проверки, каждую итерацию, значение из нового элемента.

Часто требуется подсчитать вхождения в массив определенного значения.

static void Main(string[] args)

{

int count = 0;

Console.WriteLine("Введите искомое число");

int number = int.Parse(Console.ReadLine());

int[] arr = { 1, 2, 4, 4, 5, -1, 7, 8, 9, 7 };

for (int i = 0; i < arr.Length; i++)

{

if (arr[i] == number)

{

count++;

}

}

Console.WriteLine($"Количество вхождений числа {number} = {count}");

}

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

Ниже код программы, выводящий значения пока, не встретится значение с определенным характеристиками. В данном случае — отрицательное число.

static void Main(string[] args)

{

int[] arr = { 1, 2, 4, 4, 5, -1, 7, 8, 9, 7 };

for (int i = 0; i < arr.Length; i++)

{

if (arr[i] > 0)

{

Console.WriteLine( arr[i]);

}

else

{

break;

}

}

}

В заключении.

При работе с массивами важным условием является понимание, о том, что доступ к значению возможен лишь только по индексу элемента. Поэтому в операциях над значениями массива, необходимо знать его индекс в формате — имя массива [индекс элемента]

На этом занятие закончено.

Вы можете самостоятельно найти задачи для закрепления теоретического материала или для получения задач с ответами отправьте письмо на basicprog@mail.ru

Удачи в выполнении практических заданий!

Показать полностью
1

Структуры данных. Массив. Синтаксис C#

До этой лекции, для решения задач, использовалось единственное значение, хранимое в переменной. Но для большинства задач, требующих автоматизации, характерна обработка большого количества значений. Количество необходимых для получения результата вычисления может достигать несколько тысяч значений. Возникает вопрос. Как хранить и обрабатывать большое количество значений? Применение метода «одна переменная — одно значение» в данном случае неприемлемо. Представьте программный код с одной тысячей переменных. Удобочитаемость, имена переменных, сам набор символов для инициализации или объявления переменной, создадут огромные трудности для программиста. Здесь, даже не стоит говорить об эффективности программного кода с точки зрения аппаратной части вычислительной системы.

Для устранения проблемы по хранению большого количества значений, логично было бы создать некую конструкцию, в котором значения хранились бы единым блоком, в виде множества переменных с единственным значением. К примеру, как строковое значение, с той разницей, что элемент строкового значения хранит один символ, а элемент этой конструкции хранил бы переменную с единственным значением. Такая конструкция была создана, вернее целое семейство таких конструкций под общим названием — структуры данных.

Но лекция не об структурах данных. Структуры данных — большой объем информации, для изучения которого существует специализированный учебный курс “Структуры и алгоритмы обработки данных”.

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

Массив в C# имеет некоторые ограничения

1.  Массив хранит значения с одним типом данных.

2.  Размер массива определяется сразу и не меняется.

В случае необходимости хранить значения с разными типами данных или когда размер массива нельзя предсказать заранее, применяются другие структуры данных, о которых вы можете узнать из курса “Структуры и алгоритмы обработки данных”.

При объявлении массива указывается тип хранимых данных и имя, по которому будет осуществляется доступ к элементам массива, а также указывается размер массива, т.е. количество элементов. Элементы можно представить как отдельные мини переменные объединенный в один блок.

Нижеприведенный массив состоит из двух элементов, каждый из которых хранит единственное значение типа данных int.

int[] arr = new int[2];

Отдельно нужно пояснить про оператор « new », который используется для указания на создание объекта некоторого класса. Классы не будут рассмотрены, поэтому примите оператор « new » как обязательный параметр при объявлении массива.

Заполним массив значениями. Для этого обратимся к элементам по соответствующим индексам и присвоим им значения, как обычным переменным. Нумерация индексов начинается с нуля.

static void Main(string[] args)

{

int[] arr = new int[2];

arr[0] = 5;

arr[1] = 3;

}

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

Структуры данных. Массив. Синтаксис C#

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

string[] text = { "Hello", ", ", "world ", "!"};
int[] arr = { 10, 5, 6, 3, 4 };

Доступ к единичному элементу массива осуществляется по имени массива с указанием индекса

static void Main(string[] args)

{

int[] arr = { 10, 5, 6, 3, 4 };

Console.WriteLine("Первое значение массива: " + arr[0]);

Console.WriteLine("Второе значение массива: " + arr[1]);

Console.WriteLine("Третье значение массива: " + arr[2]);

Console.WriteLine("Четвертое значение массива: " + arr[3]);

Console.WriteLine("Пятое значение массива: " + arr[4]);

}

Так как нумерация индексов элементов массива начинается с нуля, то для доступа к первому значению массива, нужно обратится к элементу с индексом « ноль ».

Но самым важным отличием массива от строкового значения является возможность изменения хранимых в элементах массива значений.

static void Main(string[] args)

{

string []text = { "А","Р","Т","К" };


text[2] = "M";

Console.WriteLine(text[2]);

}

Доступ ко всем элементам массива осуществляется через цикл используя тот же алгоритм, что и для обработки элементов строкового значения. А именно создается счетчик, где переменная, принимая каждую итерацию новое значение, изменяет индекс элемента. Таким образом каждую итерацию программа обращается к новому элементу массива.

Для работы с массивами создана специальная конструкция повторения с оператором foreach, но использовать мы ее не будем, а получим доступ к элементам массива с помощью конструкцией с оператором for

static void Main(string[] args)

{

int[] arr = new int[5] { 10, 5, 6, 3, 4 };

for(int i=0; i < arr.Length; i++ )

{

Console.Write(arr[i] + " ");

}

}

Или while

static void Main(string[] args)

{

string[] arr = new string[5] { "10", "5", "6", "3", "4" };

int i = 0;

while (i < arr.Length)

{

Console.Write(arr[i] + " ");

i++;

}

}

Где,

  • Выражение int i=0— начальное значение счетчика

  • Выражение i < arr.Length — логическое выражение со свойством Length, которое определяет размер массива. В случае результата true в операции отношения, выполняется итерация цикла, результат — false, заканчивает цикл.

  • Унарная операция i++ — операция по изменению счетчика.

В заключении.

Хранение большого количества значений в переменных не эффективно, как с точки информативности и удобочитаемости программного кода, так и с точки эффективности использования аппаратной части вычислительной системы. Для хранения некоторого количества значений используются более сложные структуры данных. Одной из таких структур является — массив. Массив переназначен для хранения однотипных значений, в области памяти компьютера под названием — куча. Доступ к элементу, хранимому значение,  осуществляется по его индексу. Первый индекс элемента равен нулю. Для доступа к массиву в стеке записывается ссылка в виде имени массива, указывающая, где находится массив.

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

На этом занятие закончено.

Вы можете самостоятельно найти задачи для закрепления теоретического материала или для получения задач с ответами отправьте письмо на basicprog@mail.ru

Удачи в выполнении практических заданий!

Показать полностью 1
2

Операции над строковым значением с помощью цикла. Синтаксис C#

Самой распространенной операцией над строковым значением является поиск. Поиск может осуществляется как одного элемента, так и цепочки из элементов. К примеру, зная, что инструкция в программном коде заканчивается на знак «;», можно подсчитать количество инструкций даже если некоторые из них написаны в одну строку. Поиск, цепочек из элементов, позволяют определить стратегию продажи товара. Для этого, в отзывах ищут цепочки из символов «хорошо» или «плохо».

Для таких операций, как это не банально звучит, необходимо получить доступ к массиву элементов значения.

Давайте вспомним, что для доступа к элементу значения строкового типа используется конструкция — имя переменной [индекс элемента], где индекс элемента — целое число, изменяя который, можно получить доступ к любому элементу значения.

Изменение номера индекса — повторяющаяся задача, поэтому применим для этой операции операцию повторения.

Для написания цикла, нам необходимо знать начальное, конечное значение цикла, а также изменение начального значения.

  1. Так как нумерация индексов начинается с нуля, то и начальное значение будет начинаться с нуля.

  2. Конечное значение определим с помощью свойства— Length.Свойство — Length. Свойства, так же, как и методы, вызываются через точку после имени, с той разницей, что в формате вызова метода используются круглые скобки после имени метода, а формат свойства их не использует.

static void Main(string[] args)

{

string text = "Hello!";

int sizeText =  text.Length;

Console.WriteLine($"Размер значения: {sizeText} символов");

}

  1. Изменение значения будем осуществлять по нижеприведенному алгоритму:

  • Представим индекс элемента в виде переменной

  • В цикле будем изменять значение переменной. Изменяя значение переменной, каждую итерацию, в конструкции — имя переменной [индекс элемента], вместо индекса элемента будет подставляться новое значение.

    Напишем программу вывода элементов через пробел переменной text.

    static void Main(string[] args)

    {

    string text = "Hello!";

    for(int i=0; i < text.Length; i++)

    {

    Console.Write(text[i] + " ");

    }

    }

    Здесь,

    1. Внесено изменение в конструкцию — имя переменной [индекс элемента] и представляет собой следующий вид  — text[i].

    2. Изменяясь каждую итерацию, переменная «i» будет принимать значение от нуля до пяти. При первой итерации, конструкция text [i], получит от переменной « i » значение в виде числа « 0 » и метод вывода примет следующий вид Console.Write(text[0] + " "); а при последней — Console.Write(text[5] + ","). 


    Выведем на экран символы значение из предыдущей программы в обратном порядке


    static void Main(string[] args)

    {

    string text = "Hello!";

    for (int i = text.Length; i > 0; i--)

    {

    Console.Write(text[i] + " ");

    }

    }

    При запуске программы произойдет ошибка, указывающая на обращении к несуществующему индексу.

Операции над строковым значением с помощью цикла. Синтаксис C#

Все дело в свойстве Length. Вернее, в том, что, нумерация индексов начинается с нуля и последний индекс значения будет — пять, а нумерация в свойстве Length, начинается с единицы и заканчивается числом шесть. Так как, начальным значением счетчика установлено значение от свойства Length, то произошло обращение к несуществующему индексу с номером шесть, что и привело к ошибке.

Исправить ошибку достаточно легко. Достаточно уменьшить значение свойства Length на единицу. Еще одной ошибкой в данном коде является конечное значение счетчика определенное операцией «i > 0». Здесь «i» не достигнет числа « 0 » и элемент с таким индексом не будет задействован в цикле.

Исправим обе ошибки

static void Main(string[] args)

{

string text = "Hello!";

for (int i = text.Length - 1; i >= 0; i--)

{

Console.Write(text[i] + " ");

}

}

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

Практический пример для подсчета предложений

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

static void Main(string[] args)

{

string text = "Эрнест Хемингуэй! Старик и море. Жанр. Роман?";

int count = 0;

int i = 0;

while (i < text.Length)

{

if ((text[i] == '.') || (text[i] == '!') || (text[i] == '?'))

{

count++;

}

i++;

}

Console.WriteLine("Количество предложений: " + count);

}

Здесь переменная «i» не только считает количество итераций, но и изменяет каждую итерацию индекс массива символов. Таким образом в цикле просматриваются все символы от первого до последнего. В случае совпадения символа значения с символом сравнения, информация об этом записывается в переменную count.

В заключении.

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

На этом занятие закончено.

Вы можете самостоятельно найти задачи для закрепления теоретического материала или для получения задач с ответами отправьте письмо на basicprog@mail.ru

Удачи в выполнении практических заданий!

Показать полностью 1
3

О string и char. Синтаксис C#

Из этой лекции вы узнаете о ссылочном типе данных — string и примитивном — char.

Переменные с ссылочным типом данных string — это переменные, предназначенные для хранения значений в виде строк. Строкой считается любое значение, с форматом представления в виде любых символов заключенных между двойными кавычками, даже если это один символ.

Объявление и инициализация переменной с типом данных string ничем ни отличается от тех же операций с другими типами данных.

Так выглядит инициализация переменной с строковым значением

static void Main(string[] args)

{

string text = "Bill";

}

В отличии от числовых значений, строковое значение, не является набором цифр, и поэтому не может хранится как числовое значение.

Для хранения строгого значения используется следующая схема. Строковое значение разбивается на отдельные символы, в том числе, знаки препинания, пробелы и т.д., и каждый символ преобразуется в число. После преобразования получается массив из чисел, которые записываются в специальную область памяти — куча. Соответствие символа и его десятичного, числового представления указаны в таблице символов ASCII(1 байт) или UNICODE(2 байта).

Для доступа к строковому значению, в стеке, создается объект-ссылка с именем, в котором указано, где, в куче, находятся символы.

Ссылка приведена для визуального оформления

Само хранение строкового значения можно представить как блок из мини переменных, где каждая мини переменная, в виде числа, хранит один символ. Такая мини переменная называется — элемент строкового значения. Доступ к элементу осуществляется по индексу, который представляет собой порядковый номер элемента в значении. Нумерация индексов начинается с нуля.

Строковое значение «Bill», в памяти компьютера будет представлено следующим набором числовых значений — 66 105 108 108.

Для доступа к отдельному элементу указывается имя значения и соответствующий индекс, в формате записи — имя переменной [индекс элемента]

static void Main(string[] args)

{

string text = "Bill";

Console.WriteLine($"Имя строка - {text[0]},{text[1]},{text[2]},{text[3]}");

}

Здесь, для вывода строки применена интерполяции.

Элемент строкового значения хранится в виде значения с символьным типом данных — char. Таким образом, значение с типом данных string — это массив элементов с типом данных char.

static void Main(string[] args)

{

string text = "Bill";

Console.WriteLine("Тип данных: " + text[0].GetTypeCode());

}

Здесь, метод GetTypeCode(), указывает на тип данных значения, хранимого в элементе с индексом 0.

Символьный тип —char, является очень интересным типом данных. Значения этого типа данных хранится как числовое значение, но на экран выводится — его графическое представление. Другими словами, для компьютера значение типа данных —char, является числом, но пользователь на экране видит символ.  Это некий мостик, между строковыми и числовыми значениями.

Значения с типом данных char относятся к примитивным типам данных и хранятся в стеке. Формат записи —  единственный символ, обрамленный одинарными кавычками. Размер выделяемой памяти составляет один или два байта.

Инициализация переменной

static void Main(string[] args)

{

char symbolA = 'A';

}

Соответствие символа и его числового значения

static void Main(string[] args)

{

char symbolA = 'A';

Console.WriteLine("Переменная символа 'A' = " + symbolA);

int number = symbolA;

Console.WriteLine("Числовое значение переменной symbolA = " + number);

}

При изменении числового значение меняется символ.

static void Main(string[] args)

{

char symbolA = 'A';

Console.WriteLine("Переменная символа 'A' = " + symbolA);

int number = symbolA + 1;

char value = (char)number;

Console.WriteLine("Символ 'A' + 1 = " + value);

}

Здесь, переменная number инициализирована числом, соответствующим символу 'A' — 65, добавим к этому значению единицу. Результатом такой операции станет число 66, которое соответствует символу 'B'. Для преобразования числового значения в значение с типом данных char используется явное привидение типов

Для обработки строкового значения зачастую необходимо знать количество содержащихся в нем элементов, размер значения. Для этого используется свойство — Length.

static void Main(string[] args)

{

string text = "Bill";

Console.WriteLine($"Размер значения - {text.Length}");

}

Зная, что строковое значение — массив значений символьного типа, а также размер массива, можно производить некоторые действия над строковым значением. В C# такие действия ограничены, но, к примеру в языке С++, можно заменять один символ другим. Возможности обработка строки, на различных языках программирования существенно отличается, иначе зачем столько языков программирования.

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

Примем, что строковое значение состоит из одного предложение, заканчивающееся на один из вышеперечисленных знаков.

Последний символ предложения хранится в последнем элементе значения. Для получения доступа к этому элементу нам необходимо знать его индекс. В этом нам поможет свойство Length, в виде конструкции «Length-1». Дело в том, что нумерация в Length начинается не с нуля, как у индексов элементов, а с единицы. Дабы привести в соответствие числовые ряды, Length уменьшается на единицу.

Полученный индекс последнего элемента запишем в отдельную переменную «int idx = text.Length-1;». Таким образом в операции отношения сравнивается последний элемент строкового значения с символами окончания предложения.

static void Main(string[] args)

{

string text = "Hello, world!";

int idx = text.Length - 1;

if (text[idx] == '.')

{

Console.WriteLine("Предложение повествовательное");

}

if (text[idx] == '!')

{

Console.WriteLine("Предложение побудительное");

}

if (text[idx] == '?')

{

Console.WriteLine("Предложение вопросительное");

}

}

В заключении.

Строковое значение — набор отдельных элементов. Каждый элемент строкового значения имеет свой порядковый номер —индекс, по которому можно получить доступ к содержимому элемента. Нумерация начинается с нуля. Формат записи значения — любые символы заключенные в двойные кавычки. Количество элементов равно размер значения.

Значения с типом данных char, представляет собой значение в графическом виде, отображающее символ, но хранимое как число. Символы и соответствующие им числовые значения приведены в таблице ASCII. Формат записи — единственный символ, заключенный в одинарные кавычки.

На этом занятие закончено.

Вы можете самостоятельно найти задачи для закрепления теоретического материала или для получения задач с ответами отправьте письмо на basicprog@mail.ru

Удачи в выполнении практических заданий!

Показать полностью 3
2

Конструкции повторения. Синтаксис C#

В 1969 году Эдсгер Дейкстра доказал, что для решения любой логической задачи необходимо три алгоритмических структуры: следование, ветвление и повторение.

Следование и ветвление вам уже известны. Переходим к рассмотрению алгоритмической структуры — повторение.

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

При выполнении операций повторения используются управляющие конструкции с операторами — while, do…while и for.

Основой алгоритма цикла является проверка некоторого условия, представляющего собой логическое выражение. Алгоритм цикла схож м алгоритмом операции ветвления.

Если результатом вычисления логического выражения является значение true, выполняется итерация цикла, если false, цикл завершается. Таким образом, выходом из цикла, является изменение, с true на false, результата вычисления логического выражения в операторе цикла

Конструкция повторения состоит из

  • Оператор цикла, с логическим выражением выполнения условия итераций

  • Тело цикла

  • Счетчик количества итераций или оператор — break.

Счетчик итераций применяется, когда количество итераций известно, оператор break, в случаях, когда количество итераций неизвестно.

Счетчик итераций имеет обязательные параметры.

  • Начальное значение. Целое число.

  • Операция изменения начального значения. Выбор, с определенным шагом, значения из числового ряда в диапазоне ограниченным начальным и конечным значением.

  • Конечное значение. Логическая операция. В основном, операция отношения с числом или переменной с примитивным типом данных.

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

Унарная операция — операция с одним операндом, имеет конструкцию вида « х++ »  и заменяет запись « х = х + 1». Приращение на единицу называется операцией инкремент — « х++ »  , уменьшение« х-- »  — декремент. Унарные операции делятся на префиксную и постфиксную.

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

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

Отличие результатов применения префиксной и постфиксной записи инкремента.

static void Main(string[] args)

{

int x = 3;

Console.WriteLine(x);  // Результат: 3

Console.WriteLine(x++); // Результат: 3

Console.WriteLine(x);  // Результат: 4

Console.WriteLine();

int y = 3;

Console.WriteLine(y);  // Результат: 3

Console.WriteLine(++y); // Результат: 4

Console.WriteLine(y);  // Результат: 4

}

Вернемся к операциям повторения и рассмотрим конструкцию с оператором — for, вида:

static void Main(string[] args)

{

for (int variable = 0; variable < 3; variable++)

{

Console.WriteLine("Итерация ");

}

}

Где, for (int variable = 0; variable < 3; variable++) — конструкция с оператором «for » с счетчиком.

  • Выражение int variable = 0 — начальное значение счетчика

  • Выражение variable < 3 — логическое выражение. В случае истинности выполняется итерация цикла, результат — false, заканчивает цикл.

  • Унарная операция variable++ — операция по изменению счетчика.

Здесь, каждую итерацию, значение переменной variable изменяется на единицу, в диапазоне от нуля до трех.

При достижении числа три, логической выражение вернет в программный код результат «false», итерация не будет выполнена и  цикл будет завершен. Начальным значением может быть любое число, но диапазон чисел должен соответствовать необходимому количеству итераций. К примеру, 1 <= 3 или 5  <  8

Эту же задачу можно решить с помощью конструкции повторения с операторам « while »

static void Main(string[] args)

{

int i = 0;

while(i<3)

{

Console.WriteLine("Итерация ");

i++;

}

}

Отличие конструкции с операторам « while » от конструкции с оператором « for » в расположении элементов счетчика. Начальное значение инициализируется перед циклом, а операция по изменению начального значения происходит каждую итерацию в теле цикла.

Счетчик может как приращиваться, так и уменьшаться.

Выведем числа от десяти до нуля в одну строку через запятую. Изменяя начальное или логическое выражение на экран, можно выводить любой числовой ряд. Выражение в виде Console.WriteLine(i);  часто используют для вывода нумерации строк.

static void Main(string[] args)

{

int i = 10;

while (i > 0)

{

Console.Write(i + ", ");

i--;

}

}

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

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

Для этого, оператору while в качестве параметра передается значение true, а для выхода из цикла применяется операция ветвления, которая может принять либо true либо false. Один из блоков операции ветвления содержит оператор — break.

Напишем программу проверки ввода логина. Логин — строчное значение 123.

static void Main(string[] args)

{

Console.WriteLine("Введите логин. Для отказа нажмите пробел");

while (true)

{

string value = Console.ReadLine();

if(value == " ")

{

break;

}

if (value != "123")

{

Console.WriteLine("Неверно. Введите логин");

}

else

{

Console.WriteLine("Логин принят");

Console.ReadKey();

break;

}

}

Заключение.

Алгоритмическая структура повторение используется при решении задач с неоднократно повторяющимися операциями вычисления. Наиболее известными конструкциями структуры повторения являются конструкции с операторами while и for. Циклы делятся на две группы. Циклы с известным количеством итераций, для которых предпочтительно использовать конструкцию с оператором for, и с неизвестным количеством итераций, в том числе и бесконечные циклы, для которых лучше подходит конструкция с оператором while.

На этом занятие закончено.

Вы можете самостоятельно найти задачи для закрепления теоретического материала или для получения задач с ответами отправьте письмо на basicprog@mail.ru

Удачи в выполнении практических заданий!

Показать полностью
2

Конструкция с оператором множественного выбора. Синтаксис C#

Из этой лекции вы узнаете о конструкции с оператором множественного выбора switch…case.

Помимо широко используемой конструкции с оператором условного перехода «if», в ветвлении применяется конструкция с оператором множественного выбора switch…case. По своему функционалу, Switch…case, похож на расширенную форму конструкции с условным оператором «if», if…else if…else, но в отличии от оператора «if», оператор switch не производит вычисления логического выражения, а сравнивает полученное значение с константой в операторе «case».

Так как операция сравнения возможна только между одинаковыми типами данных, то и тип данных в переменной и константе должен быть одинаковыми.

Тип данных константы, определяется неявно, по формату записи. Целочисленные — тип данных int, с плавающей точкой — double, набор символов заключенных в двойные кавычки — string, true или false — bool.

Получив на вход значение, оператор switch сравнивает его с константами оператора case. Найдя совпадения, переходит к выполнению программного кода в соответствующем блоке. После того как программный код выполнен, оператор — break прекращает работу оператора switch и выполнение возвращается следованию. Для случаев, когда не найдено ни одно соответствие константы сравниваемому значению, применяется блок— default. Если такой блок отсутствует, выполнение возвращается следованию.

Конструкция Switch…case имеет следующий вид

switch(variable) — Сравниваемая с константами переменная

{

case 1:  — Оператор case с константой 1

Блок кода, выполняемый в случае, если переменная равна 1

break;

case 2: — Оператор case с константой 2

Блок кода, в случае если переменная равна 2

break; 

default:

Блок кода, выполняемый если переменная отлична от всех констант

break;

}

Как видите конструкция множественного выбора switch…case достаточна проста и в отличие от if…else if…else нет необходимости строить конструкцию с множеством ветвлений, что сокращает количество ошибок и повышает удобочитаемость текста.

Напишем программу, производящую арифметические действия над двумя числами

static void Main(string[] args)

{

int a = 5;

int b = 3;

Console.WriteLine("Для операции сложения нажмите +, для вычитания -");

string variable = Console.ReadLine();

switch (variable)

{

case "+":

Console.WriteLine("Сумма чисел: " + (a + b));

break;

case "-":

Console.WriteLine("Разница чисел: " + (a - b));

break;

default:

Console.WriteLine("Операция указана не верно");

break;

}

}

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

В таких случаях, применяется подмена значения неоднозначной трактовки, числовым значением.

К примеру, программа, показывающая блюда меню на завтрак, обед, ужин

static void Main(string[] args)

{

Console.Write("Посмотреть блюда на завтрак — нажмите 1,");

Console.Write(" на обед — нажмите 2,");

Console.WriteLine(" на ужин — нажмите 3");

int variable = int.Parse(Console.ReadLine());

switch (variable)

{

case 1:

Console.WriteLine("Омлет");

break;

case 2:

Console.WriteLine("Курица");

break;

case 3:

Console.WriteLine("Рыба");

break;

default:

Console.WriteLine("Операция указана не верно");

break;

}

}

В блоках конструкции swith…case, так же как и в блоках конструкции с оператором if, можно размещать блоки программного кода.

Программа переводящая значение температуры по Цельсию в значение по Фаренгейту и Кельвину.

static void Main(string[] args)

{

double c = 25;

Console.Write("Температура по Фаренгейту — нажмите 1,");

Console.WriteLine(" по Кельвину — нажмите 2");

int variable = int.Parse(Console.ReadLine());

switch (variable)

{

case 1:

double f=c * 9 / 5 + 32;

Console.WriteLine("Температура по Фаренгейту — " + f);

break;

case 2:

double k = c  + 273.15;

Console.WriteLine("Температура по Кельвину — " + k);

break;

default:

Console.WriteLine("Операция указана не верно");

break;

}

}

В заключении.

Конструкция ветвления swith…case удобна своей простотой и удобочитаемостью, поэтому нашла применения в виде различных меню консольных программ или при выборе значения из некоторого списка. Во избежание ввода неверного значения сравниваемой переменной, рекомендуется приводить неоднозначно трактуемые значение к более упрощенной форме. К примеру, подмену строкового значения числовым.

На этом занятие закончено.

Вы можете самостоятельно найти задачи для закрепления теоретического материала или для получения задач с ответами отправьте письмо на basicprog@mail.ru

Удачи в выполнении практических заданий!

Показать полностью
4

Тернарная операция и логические операторы. Синтаксис C#

Из этой лекции вы узнаете о логических операторах, тернарной операции, познакомитесь с сокращенной формой конструкции ветвления с оператором «if».

Классическую и расширенную форму конструкции ветвления с оператором «if», удобно использовать при написании информативного кода, когда один из блоков содержит справочную информацию о выполнение или невыполнение операции. За такую информативность ветвления приходится платить нагрузкой на аппаратную часть вычислительной системы, так как увеличивается количество операций. Страдает удобочитаемостью кода. К примеру, классическая формы if…else занимает восемь строк программного кода, поэтому каждая операция вложения одной формы в другую, будет увеличивать программный код на восемь строк.

В случае отсутствия необходимости в информативности, операции отношения укрупняют. Для этого используют цепочки из операций отношения, связанных логическими операторами. В данной связка операции отношения являются операндами, а логический оператор выступает в роли оператора связки.

Нам для учебных целей понадобятся нижеследующие логические операторы

Логический оператор— И —&&. Результатом связки двух операций отношений будет true, если результат в обоих операндах (операциях отношения)) будет true, в остальных случаях — false. Заменяет операцию вложения в конструкции ветвления.

Логический оператор — ИЛИ —||. Результатом связки двух операций отношений будет true, если результат в одном из операндов будет true, в остальных случаях — false. Заменяет расширенную конструкцию if…else if…else.

Логическая инверсия (отрицание)—НЕ —!= (отрицание). Используется для изменения результата вычисления операции отношения с true на false или наоборот.

Нижеприведенная таблица помогает правильно составить логические выражения. Где, 0 — ложь, а 1 — истина.

Напишем программу, определяющую принадлежность точки отрезку с координатами [0, 5].

Для получения результата о принадлежности точки заданному отрезку, составим логическое выражение, состоящее из отношения 0 < = point и point <= 5 соединенное логическим оператором &&.

static void Main(string[] args)

{

int point = -2;

if ((0 <= point) && (point <= 5))

{


{

Console.WriteLine("Точка принадлежит отрезку");

}

}

else

{

Console.WriteLine("Точка не принадлежит отрезку");

}

}

Логическое выражение —(0 <= point) && (point <= 5) вычисляет результат двух операций отношения, а оператор && (логическое И) заменяет собой операцию вложения классической формы конструкции ветвления с оператором if.

Усложним задачу и проверим принадлежность точки двум отрезкам с координатами [0, 5]  и [6, 9]

Для этого добавим в предыдущий код проверку принадлежности второму отрезку.

static void Main(string[] args)

{

int point = 8;

if (((0 <= point) && (point <= 5)) || ((6 <= point) && (point <= 9)))

{


{

Console.WriteLine("Точка принадлежит одному из отрезков");

}

}

else

{

Console.WriteLine("Точка не принадлежит ни одному из отрезков");

}

}

Здесь, в качестве операндов выступают логические выражения с оператором &&, а оператором связкой является логический оператор —||.

Логический оператор « | | — ИЛИ» заменяет расширенную форму  if…else if…else. Таким образом, получился компактный, но малоинформативный программный код, который не может сообщить, какому именно отрезку принадлежит точка.

Ну и уж если мы начали писать компактный, но малоинформативный программный код, познакомимся с неполной(сокращенной) формой оператора if и тернарной операцией.

Неполная форма конструкции с оператором if  — это форма без блока else. Тем не менее, даже неполная форма может менять ход выполнения программы. 

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

static void Main(string[] args)

{

int job = 0;

double rate = 15;

if(job==0)

{

rate = rate * 1.1;

}

Console.WriteLine("Ставка по кредиту = " + rate);

}

Тот же самый результат можно получить, используя тернарную операцию.

Тернарная операция, это операция над тремя операндами (это повлияло на название). Тернарная операция представляет собой конструкцию, где переменная инициализируется значением второго или третьего операнда.

string result = 0 < 1? "Истина" : "Ложь";

Первый операнд — это логическое выражение 0 <1, после оператора «?», через двоеточие, перечисляются значения второго «Истина»  и третьего операнда «Ложь».

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

Пример программы с тернарной операцией по проверке положительности числа.

static void Main(string[] args)

{

int number = 2;

string result = 0 < number ? "Положительное" : "Отрицательное";

Console.WriteLine("Число " + number + " " + result);

}

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

Решим задачу по проверке принадлежности точки двум отрезкам с координатами [0, 5]  и [6, 9]

static void Main(string[] args)

{

int point = -8;

bool compare = (((0 <= point) && (point <= 5)) || ((6 <= point) && (point <= 9)));

string textTrue = "Точка принадлежит одному из отрезков";

string textFalse = "Точка не принадлежит ни одному из отрезков";

string result = compare ? textTrue : textFalse;

Console.WriteLine(result);

}

В заключении.

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

На этом занятие закончено.

Вы можете самостоятельно найти задачи для закрепления теоретического материала или для получения задач с ответами отправьте письмо на basicprog@mail.ru

Удачи в выполнении практических заданий!

Показать полностью 2
Отличная работа, все прочитано!