{
CreditDate = creditDate;
CreditAmount = creditAmount;
InterestRate = interestRate;
RemainingDebt = remainingDebt;
}
public override void DisplayInfo()
{
Console.WriteLine($"Кредитополучатель: {Name}, Дата выдачи кредита: {CreditDate.ToShortDateString()}, Размер кредита: {CreditAmount}, Процент по кредиту: {InterestRate}%, Остаток долга: {RemainingDebt}");
}
public override bool MatchesCriteria(DateTime date)
{
return CreditDate >= date;
}
}
public class Organization : Client
{
public DateTime AccountOpenDate { get; set; }
public string AccountNumber { get; set; }
public decimal AccountBalance { get; set; }
public Organization(string name, DateTime accountOpenDate, string accountNumber, decimal accountBalance)
: base(name)
{
AccountOpenDate = accountOpenDate;
AccountNumber = accountNumber;
AccountBalance = accountBalance;
}
public override void DisplayInfo()
{
Console.WriteLine($"Организация: {Name}, Дата открытия счета: {AccountOpenDate.ToShortDateString()}, Номер счета: {AccountNumber}, Сумма на счету: {AccountBalance}");
}
public override bool MatchesCriteria(DateTime date)
{
return AccountOpenDate >= date;
}
}
class Program
{
static void Main(string[] args)
{
List<Client> clients = new List<Client>
{
new Depositor("Иванов", new DateTime(2022, 1, 15), 10000m, 5.5),
new Credited("Петров", new DateTime(2023, 3, 10), 50000m, 15, 25000m),
new Organization("TechCorp", new DateTime(2021, 5, 5), "1234567890", 200000m)
};
Console.WriteLine("Все клиенты:");
foreach (var client in clients)
{
client.DisplayInfo();
}
DateTime searchDate = new DateTime(2022, 1, 1);
Console.WriteLine($"\nКлиенты, начавшие сотрудничество после {searchDate.ToShortDateString()}:");
foreach (var client in clients.Where(c => c.MatchesCriteria(searchDate)))
{
client.DisplayInfo();
}
var richestOrganization = clients.OfType<Organization>().OrderByDescending(o => o.AccountBalance).FirstOrDefault();
if (richestOrganization != null)
{
Console.WriteLine("\nОрганизация с наибольшей суммой на счету:");
richestOrganization.DisplayInfo();
}
else
{
Console.WriteLine("\nОрганизаций не найдено.");
}
}
}
VI. В одномерном массиве, состоящем из n вещественных элементов (предусмотреть ввод значения переменной n с клавиатуры), вычислить:
- сумму отрицательных элементов массива;
- произведение элементов массива, расположенных между максимальным и минимальным элементами.
Элементы массива сгенерировать случайным образом. Реализовать вывод элементов массива на консоль и в текстовый файл. Нахождение суммы и произведения оформить в виде отдельных методов, выполняющихся в разных потоках. Результаты работы программы вывести на консоль и в текстовый файл. Реализовать обработку исключительных ситуаций, возникающих во время выполнения программы.
using System;
using System.IO;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
class Program
{
static void Main(string[] args)
{
try
{
Console.Write("Введите количество элементов массива (n): ");
int n = int.Parse(Console.ReadLine());
double[] array = GenerateRandomArray(n);
Console.WriteLine("Сгенерированный массив:");
foreach (var item in array)
{
Console.WriteLine(item);
}
string filePath = "array.txt";
File.WriteAllLines(filePath, array.Select(x => x.ToString()));

Task<double> sumTask = Task.Run(() => SumNegativeElements(array));
Task<double> productTask = Task.Run(() => ProductBetweenMaxMin(array));

Task.WaitAll(sumTask, productTask);

double sumOfNegatives = sumTask.Result;
double productBetweenMaxMin = productTask.Result;

Console.WriteLine($"Сумма отрицательных элементов: {sumOfNegatives}");
Console.WriteLine($"Произведение элементов между максимальным и минимальным элементами: {productBetweenMaxMin}");

string resultFilePath = "results.txt";
File.WriteAllText(resultFilePath,
$"Сумма отрицательных элементов: {sumOfNegatives}\n" +
$"Произведение элементов между максимальным и минимальным элементами: {productBetweenMaxMin}");
}
catch (Exception ex)
{
Console.WriteLine($"Ошибка: {ex.Message}");
}
}
static double[] GenerateRandomArray(int n)
{
Random rand = new Random();
double[] array = new double[n];
for (int i = 0; i < n; i++)
{
array[i] = rand.NextDouble() * 200 - 100;
}
return array;
}
static double SumNegativeElements(double[] array)
{
return array.Where(x => x < 0).Sum();
}
static double ProductBetweenMaxMin(double[] array)
{
if (array.Length < 2) return 0;

int maxIndex = Array.IndexOf(array, array.Max());
int minIndex = Array.IndexOf(array, array.Min());
if (maxIndex > minIndex)
{
var temp = maxIndex;
maxIndex = minIndex;
minIndex = temp;
}
double product = 1;
for (int i = maxIndex + 1; i < minIndex; i++)
{
product *= array[i];
}
return product;
}
}
VII. В одномерном массиве, состоящем из n целочисленных элементов (предусмотреть ввод значения переменной n с клавиатуры), вычислить:
- сумму положительных элементов массива;
- произведение элементов массива, расположенных между максимальным по модулю и минимальным по модулю элементами.
Элементы массива сгенерировать случайным образом. Реализовать вывод элементов массива на консоль и в текстовый файл. Нахождение суммы и произведения оформить в виде отдельных методов, выполняющихся в разных потоках. Результаты работы программы вывести на консоль и в текстовый файл. Реализовать обработку исключительных ситуаций, возникающих во время выполнения программы.
using System;
using System.IO;
using System.Linq;
using System.Threading;
class Program
{
static int[] array;
static int sumPositive;
static long productBetweenMaxMin;
static void Main()
{
try
{
Console.Write("Введите размер массива n: ");
int n = int.Parse(Console.ReadLine());
array = new int[n];
Random rand = new Random();
for (int i = 0; i < n; i++)
{
array[i] = rand.Next(-100, 101);
}
Console.WriteLine("Сгенерированный массив:");
Console.WriteLine(string.Join(", ", array));
File.WriteAllText("array.txt", string.Join(", ", array));
Thread sumThread = new Thread(ComputeSumPositive);
Thread productThread = new Thread(ComputeProductBetweenMaxMin);
sumThread.Start();
productThread.Start();
sumThread.Join();
productThread.Join();
Console.WriteLine($"Сумма положительных элементов: {sumPositive}");
Console.WriteLine($"Произведение элементов между максимальным и минимальным по модулю элементами: {productBetweenMaxMin}");
using (StreamWriter writer = new StreamWriter("results.txt"))
{
writer.WriteLine($"Сумма положительных элементов: {sumPositive}");
writer.WriteLine($"Произведение элементов между максимальным и минимальным по модулю элементами: {productBetweenMaxMin}");
}
}
catch (Exception ex)
{
Console.WriteLine($"Произошла ошибка: {ex.Message}");
}
}
static void ComputeSumPositive()
{
sumPositive = array.Where(x => x > 0).Sum();
}
static void ComputeProductBetweenMaxMin()
{

int maxAbs = array.Select((value, index) => new { value, index })
.OrderByDescending(x => Math.Abs(x.value))
.First().index;

int minAbs = array.Select((value, index) => new { value, index })
.OrderBy(x => Math.Abs(x.value))
.First().index;
if (maxAbs > minAbs)
{
int temp = maxAbs;
maxAbs = minAbs;
minAbs = temp;
}
productBetweenMaxMin = 1;
for (int i = maxAbs + 1; i < minAbs; i++)
{
productBetweenMaxMin *= array[i];
}
if (maxAbs + 1 == minAbs)
{
productBetweenMaxMin = 0;
}
}
}
VIII. В одномерном массиве, состоящем из n целочисленных элементов (предусмотреть ввод значения переменной n с клавиатуры), вычислить:
- произведение элементов массива с четными номерами;
- сумму элементов массива, расположенных между первым и последним нулевыми элементами.
Элементы массива сгенерировать случайным образом. Реализовать вывод элементов массива на консоль и в текстовый файл. Нахождение произведения и суммы оформить в виде отдельных методов, выполняющихся в разных потоках. Результаты работы программы вывести на консоль и в текстовый файл. Реализовать обработку исключительных ситуаций, возникающих во время выполнения программы.
using System;
using System.IO;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
class Program
{
static void Main(string[] args)
{
try
{
Console.Write("Введите количество элементов массива (n): ");
int n = int.Parse(Console.ReadLine());
int[] array = GenerateRandomArray(n);
PrintArray(array);
WriteArrayToFile(array, "array.txt");
Task<long> productTask = Task.Run(() => CalculateProductOfEvenIndexedElements(array));
Task<int> sumTask = Task.Run(() => CalculateSumBetweenFirstAndLastZeros(array));
Task.WaitAll(productTask, sumTask);
long product = productTask.Result;
int sum = sumTask.Result;
Console.WriteLine($"Произведение элементов массива с четными номерами: {product}");
Console.WriteLine($"Сумма элементов массива между первым и последним нулевыми элементами: {sum}");

WriteResultsToFile(product, sum, "results.txt");
}
catch (FormatException ex)
{
Console.WriteLine("Ошибка: введено некорректное значение. " + ex.Message);
}
catch (Exception ex)
{
Console.WriteLine("Произошла ошибка: " + ex.Message);
}
}
static int[] GenerateRandomArray(int n)
{
Random rand = new Random();
int[] array = new int[n];
for (int i = 0; i < n; i++)
{
array[i] = rand.Next(-10, 10);
}
return array;
}
static void PrintArray(int[] array)
{
Console.WriteLine("Массив:");
foreach (int element in array)
{
Console.Write(element + " ");
}
Console.WriteLine();
}
static void WriteArrayToFile(int[] array, string fileName)
{
using (StreamWriter writer = new StreamWriter(fileName))
{
foreach (int element in array)
{
writer.Write(element + " ");
}
}
}
static long CalculateProductOfEvenIndexedElements(int[] array)
{
long product = 1;
for (int i = 0; i < array.Length; i += 2)
{
product *= array[i];
}
return product;
}
static int CalculateSumBetweenFirstAndLastZeros(int[] array)
{
int firstZeroIndex = Array.IndexOf(array, 0);
int lastZeroIndex = Array.LastIndexOf(array, 0);
if (firstZeroIndex == -1 lastZeroIndex == -1 firstZeroIndex == lastZeroIndex)
{
return 0;
}
int sum = 0;
for (int i = firstZeroIndex + 1; i < lastZeroIndex; i++)
{
sum += array[i];
}
return sum;
}
static void WriteResultsToFile(long product, int sum, string fileName)
{
using (StreamWriter writer = new StreamWriter(fileName))
{
writer.WriteLine($"Произведение элементов массива с четными номерами: {product}");
writer.WriteLine($"Сумма элементов массива между первым и последним нулевыми элементами: {sum}");
}
}
}
IX. В одномерном массиве, состоящем из n вещественных элементов (предусмотреть ввод значения переменной n с клавиатуры), вычислить:
- сумму элементов массива с нечетными номерами;
- сумму элементов массива, расположенных между первым и последним отрицательными элементами.
Элементы массива сгенерировать случайным образом. Реализовать вывод элементов массива на консоль и в текстовый файл. Нахождение суммы и произведения оформить в виде отдельных методов, выполняющихся в разных потоках. Результаты работы программы вывести на консоль и в текстовый файл. Реализовать обработку исключительных ситуаций, возникающих во время выполнения программы.
using System;
using System.IO;
using System.Linq;
using System.Threading;
class Program
{
static void Main()
{
try
{
Console.Write("Введите количество элементов в массиве: ");
int n = int.Parse(Console.ReadLine());
double[] array = GenerateRandomArray(n);
Console.WriteLine("Сгенерированный массив:");
PrintArray(array);
// Создание потоков для вычислений
Thread oddIndexSumThread = new Thread(() => {
double sumOddIndexes = SumOddIndexes(array);
Console.WriteLine($"Сумма элементов массива с нечетными номерами: {sumOddIndexes}");
WriteToFile($"Сумма элементов массива с нечетными номерами: {sumOddIndexes}");
});
Thread betweenNegativesSumThread = new Thread(() => {
double sumBetweenNegatives = SumBetweenFirstAndLastNegative(array);
Console.WriteLine($"Сумма элементов между первым и последним отрицательными элементами: {sumBetweenNegatives}");
WriteToFile($"Сумма элементов между первым и последним отрицательными элементами: {sumBetweenNegatives}");
});
// Запуск потоков
oddIndexSumThread.Start();

betweenNegativesSumThread.Start();
// Ожидание завершения потоков
oddIndexSumThread.Join();
betweenNegativesSumThread.Join();
}
catch (Exception ex)
{
Console.WriteLine($"Произошла ошибка: {ex.Message}");
WriteToFile($"Произошла ошибка: {ex.Message}");
}
}
static double[] GenerateRandomArray(int n)
{
Random random = new Random();
double[] array = new double[n];
for (int i = 0; i < n; i++)
{
array[i] = random.NextDouble() * 200 - 100;
}
return array;
}
static void PrintArray(double[] array)
{
foreach (var item in array)
{
Console.Write($"{item:F2} ");
}
Console.WriteLine();
WriteToFile("Сгенерированный массив: " + string.Join(" ", array.Select(x => x.ToString("F2"))));
}
static double SumOddIndexes(double[] array)
{
double sum = 0;
for (int i = 1; i < array.Length; i += 2)
{
sum += array[i];
}
return sum;
}
static double SumBetweenFirstAndLastNegative(double[] array)
{
int firstNegativeIndex = -1;
int lastNegativeIndex = -1;
for (int i = 0; i < array.Length; i++)
{
if (array[i] < 0)
{
if (firstNegativeIndex == -1)
{
firstNegativeIndex = i;
}
lastNegativeIndex = i;
}
}
if (firstNegativeIndex == -1 firstNegativeIndex == lastNegativeIndex)
{
return 0; // Если нет отрицательных элементов или только один отрицательный элемент
}

double sum = 0;
for (int i = firstNegativeIndex + 1; i < lastNegativeIndex; i++)
{
sum += array[i];
}
return sum;
}
static void WriteToFile(string text)
{
using (StreamWriter writer = new StreamWriter("output.txt", true))
{
writer.WriteLine(text);
}
}
}
X. В одномерном массиве, состоящем из n вещественных элементов (предусмотреть ввод значения переменной n с клавиатуры), вычислить:
- номера максимальных элементов массива;
- сумму элементов массива, расположенных до последнего положительного элемента.
Элементы массива сгенерировать случайным образом. Реализовать вывод элементов массива на консоль и в текстовый файл. Нахождение номеров и суммы оформить в виде отдельных методов, выполняющихся в разных потоках. Результаты работы программы вывести на консоль и в текстовый файл. Реализовать обработку исключительных ситуаций, возникающих во время выполнения программы.
using System;
using System.IO;
using System.Linq;
using System.Threading;
class Program
{
static void Main()
{
try
{
Console.Write("Введите значение n: ");
int n = int.Parse(Console.ReadLine());
Random rand = new Random();
double[] array = new double[n];
for (int i = 0; i < n; i++)
{
array[i] = rand.NextDouble() * 200 - 100;
}
string filePath = "output.txt";
using (StreamWriter writer = new StreamWriter(filePath))
{
Console.WriteLine("Массив:");
writer.WriteLine("Массив:");
foreach (double elem in array)
{
Console.WriteLine(elem);
writer.WriteLine(elem);
}
}
Thread maxElementsThread = new Thread(() => FindMaxElements(array, filePath));
Thread sumBeforeLastPositiveThread = new Thread(() => SumBeforeLastPositive(array, filePath));
maxElementsThread.Start();
sumBeforeLastPositiveThread.Start();
maxElementsThread.Join();
sumBeforeLastPositiveThread.Join();
Console.WriteLine("Результаты сохранены в файл " + filePath);
}
catch (Exception ex)
{

Console.WriteLine("Произошла ошибка: " + ex.Message);
}
}
static void FindMaxElements(double[] array, string filePath)
{
try
{
double max = array.Max();
var maxIndexes = array.Select((value, index) => new { value, index })
.Where(x => x.value == max)
.Select(x => x.index)
.ToArray();

using (StreamWriter writer = new StreamWriter(filePath, true))
{
Console.WriteLine("Индексы максимальных элементов:");
writer.WriteLine("Индексы максимальных элементов:");
foreach (int index in maxIndexes)
{
Console.WriteLine(index);
writer.WriteLine(index);
}
}
}
catch (Exception ex)
{
Console.WriteLine("Ошибка при нахождении максимальных элементов: " + ex.Message);
}
}
static void SumBeforeLastPositive(double[] array, string filePath)
{
try
{
int lastPositiveIndex = Array.FindLastIndex(array, x => x > 0);
double sum = array.Take(lastPositiveIndex).Sum();

using (StreamWriter writer = new StreamWriter(filePath, true))
{
Console.WriteLine("Сумма элементов до последнего положительного элемента: " + sum);
writer.WriteLine("Сумма элементов до последнего положительного элемента: " + sum);
}
}
catch (Exception ex)
{
Console.WriteLine("Ошибка при вычислении суммы: " + ex.Message);
}
}
}
XI. В одномерном массиве, состоящем из n вещественных элементов (предусмотреть ввод значения переменной n с клавиатуры), вычислить:
- номера минимальных элементов массива;
- сумму элементов массива, расположенных между первым и последним положительными элементами.
Элементы массива сгенерировать случайным образом. Реализовать вывод элементов массива на консоль и в текстовый файл. Нахождение номеров и суммы оформить в виде отдельных методов, выполняющихся в разных потоках. Результаты работы программы вывести на консоль и в текстовый файл. Реализовать обработку исключительных ситуаций, возникающих во время выполнения программы.
using System;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
class Program
{
static void Main()
{
try
{
Console.WriteLine("Введите количество элементов массива:");
int n = int.Parse(Console.ReadLine());
if (n <= 0)
{
throw new ArgumentException("Количество элементов должно быть положительным числом.");
}
double[] array = GenerateRandomArray(n);
Console.WriteLine("Массив:");
PrintArray(array);
Task<int[]> findMinIndicesTask = Task.Run(() => FindMinElementIndices(array));
Task<int> sumBetweenPositivesTask = Task.Run(() => SumBetweenFirstAndLastPositives(array));
Task.WaitAll(findMinIndicesTask, sumBetweenPositivesTask);
int[] minIndices = findMinIndicesTask.Result;
int sumBetweenPositives = sumBetweenPositivesTask.Result;
Console.WriteLine("\nРезультаты:");
Console.WriteLine($"Номера минимальных элементов: {string.Join(", ", minIndices)}");
Console.WriteLine($"Сумма элементов между первым и последним положительными элементами: {sumBetweenPositives}");
WriteResultsToFile(array, minIndices, sumBetweenPositives, "output.txt");
Console.WriteLine("\nРезультаты записаны в файл output.txt");
}
catch (Exception ex)
{
Console.WriteLine($"Произошла ошибка: {ex.Message}");
}
}
static double[] GenerateRandomArray(int n)
{
Random random = new Random();
double[] array = new double[n];
for (int i = 0; i < n; i++)
{
array[i] = random.NextDouble() * 100;
}
re

turn array;
}
static void PrintArray(double[] array)
{
foreach (var element in array)
{
Console.Write($"{element:F2} ");
}
Console.WriteLine();
}
static int[] FindMinElementIndices(double[] array)
{
double minValue = array.Min();
return Enumerable.Range(0, array.Length)
.Where(i => array[i] == minValue)
.ToArray();
}
static int SumBetweenFirstAndLastPositives(double[] array)
{
int firstPositiveIndex = -1;
int lastPositiveIndex = -1;
for (int i = 0; i < array.Length; i++)
{
if (array[i] > 0)
{
if (firstPositiveIndex == -1)
firstPositiveIndex = i;
lastPositiveIndex = i;
}
}
if (firstPositiveIndex == -1 lastPositiveIndex == -1)
{
throw new InvalidOperationException("В массиве отсутствуют положительные элементы.");
}
int sum = 0;
for (int i = firstPositiveIndex + 1; i < lastPositiveIndex; i++)
{
sum += (int)array[i];
}
return sum;
}
static void WriteResultsToFile(double[] array, int[] minIndices, int sumBetweenPositives, string filename)
{
using (StreamWriter writer = new StreamWriter(filename))
{
writer.WriteLine("Массив:");
for (int i = 0; i < array.Length; i++)
{
writer.Write($"{array[i]:F2} ");
}
writer.WriteLine();
writer.WriteLine($"Номера минимальных элементов: {string.Join(", ", minIndices)}");
writer.WriteLine($"Сумма элементов между первым и последним положительными элементами: {sumBetweenPositives}");
}
}
}
XII. В одномерном массиве, состоящем из n вещественных элементов (предусмотреть ввод значения переменной n с клавиатуры), вычислить:
- максимальный по модулю элемент массива;
- сумму элементов массива, расположенных между первым и вторым положительными элементами.
Элементы массива сгенерировать случайным образом. Реализовать вывод элементов массива на консоль и в текстовый файл. Нахождение элемента и суммы оформить в виде отдельных методов, выполняющихся в разных потоках. Результаты работы программы вывести на консоль и в текстовый файл. Реализовать обработку исключительных ситуаций, возникающих во время выполнения программы.
using System;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
class Program
{
static void Main(string[] args)
{
try
{
Console.WriteLine("Введите размер массива n:");
int n = int.Parse(Console.ReadLine());
double[] array = GenerateRandomArray(n);
Console.WriteLine("Массив:");
PrintArray(array);
Task<double> maxAbsValueTask = Task.Run(() => FindMaxAbsoluteValue(array));
Task<int> sumBetweenPositivesTask = Task.Run(() => SumBetweenFirstAndSecondPositive(array));
Task.WaitAll(maxAbsValueTask, sumBetweenPositivesTask);
double maxAbsValue = maxAbsValueTask.Result;
int sumBetweenPositives = sumBetweenPositivesTask.Result;
Console.WriteLine($"\nМаксимальный по модулю элемент: {maxAbsValue}");
Console.WriteLine($"Сумма элементов между первым и вторым положительными: {sumBetweenPositives}");
WriteResultsToFile(array, maxAbsValue, sumBetweenPositives);
Console.WriteLine("\nРезультаты записаны в файл output.txt.");
}
catch (FormatException)
{
Console.WriteLine("Ошибка: неверный формат ввода.");
}
catch (OverflowException)
{
Console.WriteLine("Ошибка: введено слишком большое число для размера массива.");
}
catch (Exception ex)
{
Console.WriteLine($"Произошла ошибка: {ex.Message}");
}
}
static double[] GenerateRandomArray(int n)
{
Random random = new Random();

double[] array = new double[n];
for (int i = 0; i < n; i++)
{
array[i] = random.NextDouble() * random.Next(-100, 100);
}
return array;
}
static void PrintArray(double[] array)
{
foreach (var element in array)
{
Console.Write($"{element:F2} ");
}
Console.WriteLine();
}
static double FindMaxAbsoluteValue(double[] array)
{
double maxAbsValue = array.Max(x => Math.Abs(x));
return maxAbsValue;
}
static int SumBetweenFirstAndSecondPositive(double[] array)
{
int firstPositiveIndex = -1;
int secondPositiveIndex = -1;
int sum = 0;
for (int i = 0; i < array.Length; i++)
{
if (array[i] > 0)
{
if (firstPositiveIndex == -1)
firstPositiveIndex = i;
else
{
secondPositiveIndex = i;
break;
}
}
}
if (firstPositiveIndex != -1 && secondPositiveIndex != -1)
{
for (int i = firstPositiveIndex + 1; i < secondPositiveIndex; i++)
{
sum += (int)array[i]; // суммируем целую часть элементов
}
}
return sum;
}
static void WriteResultsToFile(double[] array, double maxAbsValue, int sumBetweenPositives)
{
using (StreamWriter writer = new StreamWriter("output.txt"))
{
writer.WriteLine("Массив:");
foreach (var element in array)
{
writer.Write($"{element:F2} ");
}
writer.WriteLine();
writer.WriteLine($"Максимальный по модулю элемент: {maxAbsValue}");
writer.WriteLine($"Сумма элементов между первым и вторым положительными: {sumBetweenPositives}");
}
}
}
XIII. В одномерном массиве, состоящем из n целочисленных элементов (предусмотреть ввод значения переменной n с клавиатуры), вычислить:
- минимальный по модулю элемент массива;
- сумму модулей элементов массива, расположенных после первого элемента, равного нулю.
Элементы массива сгенерировать случайным образом. Реализовать вывод элементов массива на консоль и в текстовый файл. Нахождение элемента и суммы оформить в виде отдельных методов, выполняющихся в разных потоках. Результаты работы программы вывести на консоль и в текстовый файл. Реализовать обработку исключительных ситуаций, возникающих во время выполнения программы.
using System;
using System.IO;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
class Program
{
static void Main()
{
Console.Write("Введите размер массива n: ");
if (!int.TryParse(Console.ReadLine(), out int n) n <= 0)
{
Console.WriteLine("Неверный ввод размера массива.");
return;
}
int[] array = GenerateRandomArray(n);
Console.WriteLine("Элементы массива:");
PrintArray(array);
Task<int> minAbsTask = Task.Run(() => FindMinAbs(array));
Task<int> sumAfterZeroTask = Task.Run(() => SumOfModAfterFirstZero(array));
try
{
Task.WaitAll(minAbsTask, sumAfterZeroTask);
int minAbs = minAbsTask.Result;
int sumAfterZero = sumAfterZeroTask.Result;
Console.WriteLine($"Минимальный по модулю элемент массива: {minAbs}");
Console.WriteLine($"Сумма модулей элементов после первого нулевого элемента: {sumAfterZero}");
using (StreamWriter writer = new StreamWriter("output.txt"))
{
writer.WriteLine($"Минимальный по модулю элемент массива: {minAbs}");
writer.WriteLine($"Сумма модулей элементов после первого нулевого элемента: {sumAfterZero}");
}
Console.WriteLine("Результаты записаны в файл output.txt.");
}
catch (AggregateException ex)
{
Console.WriteLine("Произошла ошибка при выполнении задач:");

foreach (var innerEx in ex.InnerExceptions)
{
Console.WriteLine(innerEx.Message);
}
}
catch (Exception ex)
{
Console.WriteLine($"Произошла ошибка: {ex.Message}");
}
}
static int[] GenerateRandomArray(int n)
{
Random random = new Random();
int[] array = new int[n];
for (int i = 0; i < n; i++)
{
array[i] = random.Next(-100, 101);
}
return array;
}
static void PrintArray(int[] array)
{
foreach (var num in array)
{
Console.Write(num + " ");
}
Console.WriteLine();

using (StreamWriter writer = new StreamWriter("output.txt", true))
{
foreach (var num in array)
{
writer.Write(num + " ");
}
writer.WriteLine();
}
}
static int FindMinAbs(int[] array)
{
if (array == null array.Length == 0)
throw new ArgumentException("Массив не должен быть пустым.");

int minAbs = Math.Abs(array[0]);
for (int i = 1; i < array.Length; i++)
{
int absValue = Math.Abs(array[i]);
if (absValue < minAbs)
minAbs = absValue;
}
return minAbs;
}
static int SumOfModAfterFirstZero(int[] array)
{
if (array == null array.Length == 0)
throw new ArgumentException("Массив не должен быть пустым.");
bool foundZero = false;
int sum = 0;
foreach (var num in array)
{
if (foundZero)
{
sum += Math.Abs(num);
}
if (num == 0)
{
foundZero = true;
}
}
if (!foundZero)
throw new InvalidOperationException("В массиве нет нулевых элементов.");
return sum;
}
}
XIV. В одномерном массиве, состоящем из n вещественных элементов (предусмотреть ввод значения переменной n с клавиатуры), вычислить:
- количество элементов массива, лежащих в диапазоне от 10 до 20;
- сумму элементов массива, расположенных после максимального элемента.
Элементы массива сгенерировать случайным образом. Реализовать вывод элементов массива на консоль и в текстовый файл. Нахождение количества и суммы оформить в виде отдельных методов, выполняющихся в разных потоках. Результаты работы программы вывести на консоль и в текстовый файл. Реализовать обработку исключительных ситуаций, возникающих во время выполнения программы.
using System;
using System.IO;
using System.Threading.Tasks;
class Program
{
static Random random = new Random();
static void Main(string[] args)
{
try
{
Console.WriteLine("Введите размер массива n:");
if (!int.TryParse(Console.ReadLine(), out int n) n <= 0)
{
throw new ArgumentException("Некорректный ввод. Ожидалось положительное целое число.");
}
double[] array = GenerateRandomArray(n);
Console.WriteLine("Элементы массива:");
PrintArray(array);
string filePath = "output.txt";
PrintArrayToFile(array, filePath);
Console.WriteLine($"Массив записан в файл {filePath}");
// Асинхронно находим количество элементов в диапазоне [10, 20]
Task<int> countTask = CountElementsInRangeAsync(array, 10, 20);
// Асинхронно находим сумму элементов после максимального значения
Task<double> sumTask = SumElementsAfterMaxAsync(array);
Task.WaitAll(countTask, sumTask);
Console.WriteLine($"Количество элементов в диапазоне [10, 20]: {countTask.Result}");
Console.WriteLine($"Сумма элементов после максимального значения: {sumTask.Result}");
Console.WriteLine("Работа программы завершена.");
}
catch (Exception ex)
{
Console.WriteLine($"Произошла ошибка: {ex.Message}");
}
}

static double[] GenerateRandomArray(int n)
{
double[] array = new double[n];
for (int i = 0; i < n; i++)
{
array[i] = random.NextDouble() * 100;
}
return array;
}
static void PrintArray(double[] array)
{
foreach (var element in array)
{
Console.Write($"{element:F2} ");
}
Console.WriteLine();
}
static void PrintArrayToFile(double[] array, string filePath)
{
using (StreamWriter writer = new StreamWriter(filePath))
{
foreach (var element in array)
{
writer.Write($"{element:F2} ");
}
}
}
static async Task<int> CountElementsInRangeAsync(double[] array, double min, double max)
{
await Task.Delay(100);
int count = 0;
foreach (var element in array)
{
if (element >= min && element <= max)
{
count++;
}
}
return count;
}
static async Task<double> SumElementsAfterMaxAsync(double[] array)
{
await Task.Delay(100);
double sum = 0;
if (array.Length == 0)
{
return sum;
}
// Находим индекс максимального элемента
int maxIndex = 0;
double max = array[0];
for (int i = 1; i < array.Length; i++)
{
if (array[i] > max)
{
max = array[i];
maxIndex = i;
}
}
// Считаем сумму элементов после максимального элемента
for (int i = maxIndex + 1; i < array.Length; i++)
{
sum += array[i];
}
return sum;
}
}
XV. В одномерном массиве, состоящем из n вещественных элементов (предусмотреть ввод значения переменной n с клавиатуры), вычислить:
- количество элементов массива, равных нулю;
- сумму элементов массива, расположенных после минимального элемента.
Элементы массива сгенерировать случайным образом. Реализовать вывод элементов массива на консоль и в текстовый файл. Нахождение количества и суммы оформить в виде отдельных методов, выполняющихся в разных потоках. Результаты работы программы вывести на консоль и в текстовый файл. Реализовать обработку исключительных ситуаций, возникающих во время выполнения программы.
using System;
using System.IO;
using System.Threading;
using System.Threading.Tasks;
class Program
{
static void Main()
{
try
{
Console.WriteLine("Введите количество элементов массива:");
int n = int.Parse(Console.ReadLine());
double[] array = GenerateRandomArray(n);
PrintArray(array);
int zeroCount = CountZeros(array);
Console.WriteLine($"Количество элементов массива, равных нулю: {zeroCount}");

Task<double> sumTask = Task.Run(() => SumAfterMinElement(array));
double sumAfterMin = sumTask.Result;
Console.WriteLine($"Сумма элементов массива после минимального элемента: {sumAfterMin}");
PrintResultsToFile(array, zeroCount, sumAfterMin);
Console.WriteLine("Результаты записаны в файл output.txt");
}
catch (FormatException)
{
Console.WriteLine("Ошибка: неверный формат ввода.");
}
catch (Exception ex)
{
Console.WriteLine($"Произошла ошибка: {ex.Message}");
}
}
static double[] GenerateRandomArray(int n)
{
Random rand = new Random();
double[] array = new double[n];
for (int i = 0; i < n; i++)
{
array[i] = rand.NextDouble() * 100 - 50;
}
return array;
}
static void PrintArray(double[] array)
{
Console.WriteLine("Элементы массива:");
foreach (var element in array)
{
Console.Write($"{element:F2} ");
}
Console.WriteLine();
}
static int CountZeros(double[] array)
{
int count = 0;
foreach (var element in array)
{
if (Math.Abs(element) < 1e-6) // учитываем погрешность для вещественных чисел
count++;
}
return count;
}
static double SumAfterMinElement(double[] array)
{
if (array.Length == 0)
return 0;

double minElement = array[0];
int minIndex = 0;

for (int i = 1; i < array.Length; i++)
{
if (array[i] < minElement)
{
minElement = array[i];
minIndex = i;
}
}
double sum = 0;
for (int i = minIndex + 1; i < array.Length; i++)
{
sum += array[i];
}
return sum;
}
static void PrintResultsToFile(double[] array, int zeroCount, double sumAfterMin)
{
using (StreamWriter writer = new StreamWriter("output.txt"))
{
writer.WriteLine("Элементы массива:");
foreach (var element in array)
{
writer.Write($"{element:F2} ");
}
writer.WriteLine();
writer.WriteLine($"Количество элементов массива, равных нулю: {zeroCount}");
writer.WriteLine($"Сумма элементов массива после минимального элемента: {sumAfterMin:F2}");
}
}
}