Fallenyasha

Используйте метод Seek

var stream = new FileStream("file.exe", FileMode.Open, FileAccess.Read);
byte[] test1 = new byte[2048];
stream.Seek(2048, SeekOrigin.Begin);
stream.Read(test1, 0, 2048);

Здесь могут быть более сложные варианты, например { a, b }, { b, c }, { c ,d }, { d ,e }, должен ли такой набор объектов схлопнуться в один { a, b, c, d, e }?

Опишу идею алгоритма:
0. на входе имеем
[ { a, b }, { b, c }, { c ,d }, { d ,e } ]
1. строим словарь из ключей и списка содержащих их объектов, т. е. должно получиться такое:
a: [ { a, b } ],
b: [ { a, b }, { b, c } ]
c: [ { b, c }, { c, d } ]
d: [ { c, d }, { d, e } ]
e: [ { d, e } ]
и строим второй словарь статусов
{ a, b }: 0
{ b, c }: 0
{ c ,d }: 0
{ d ,e }: 0
2. пробегаем в цикле по словарю и объединяем все объекты для каждого ключа, берем любой из объектов в каждом массиве и расширяем его, остальные удаляем из массива
a: [ { a, b } ], при изменении объекта при проходе b, он будет расширен до { a, b, c }
b: [ { a, b, c } ], например берем за основу { a, b } и расширяем до { a, b, c }, второй удаляем
c: [ { b, c, d } ], например берем за основу { b, c } и расширяем до { b, c, d }, второй удаляем
d: [ { c, d, e } ], например берем за основу { c, d } и расширяем до { c, d, e }, второй удаляем
e: [ { d, e } ], останется без изменений
в словаре статусов проснавляем для объединенных объектов признак объединения (1), для удаленных признак удаления (2), при этом правило выставления статуса должно быть 0->1, 0->2, 2->1
3. берем полученный набор значений как первоначальный массив объектов, при этом фильтруем по статусу, он не должен быть 2
[ { a, b, c }, { b, c, d }, { c, d, e } ]
4. в случае если на 2-м шаге объединять было нечего, то выходим, иначе переходим к шагу 1

Для оптимизации выполнения можно на 3-м шаге не просто фильтровать по статусу 2, но еще и отделять объекты со статусом 0, они в ходе прохода ни с чем не объединились, а значит больше их можно не трогать, перекладывать их в результирующий массив, а в следующий цикл входить только с объектами со статусом 1, и если таковых нет, то все

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

Напишу схематично:

var data = concat(array1, array2).sort(e => e.startTime);
for (var i = 0; i < data.length-1;)
{
  if (data[i].endTime >= data[i+1].startTime)
  {
    data[i].endTime = max(data[i].endTime, data[i+1].endTime);
    remove(data[i+1]);
  }
  else
    i++;
}

А оно точно работает?
Потому что вроде как при отрицательной степени должно быть return myRecursion(1/$x, -$n);
Для положительной степени работает так:
myRecursion (5, 5) =
5 * myRecursion (5, 4) =
5 * 5 * myRecursion (5, 3) =
5 * 5 * 5 * myRecursion (5, 2) =
5 * 5 * 5 * 5 * myRecursion (5, 1) =
5 * 5 * 5 * 5 * 5 * myRecursion (5, 0) =
5 * 5 * 5 * 5 * 5 * 1

1. x/5 внутри косинуса
2. p заменить на Math.PI
3. 5/3 вычисляется в типе данных int, надо изменить запись на 5d/3

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

using System;
using System.Linq;
					
public class Program
{
	private static char[] Filter = new [] { 'A', 'E', 'I', 'O' ,'U', 'Y' };
	
	public static void Main()
	{
		var data = new char[10];
		var s = 'A';
		
		for(var i = 0; i < data.Length; s++)
			if(!Filter.Contains(s))
				data[i++] = s;
		
		Console.WriteLine(string.Join(", ", data));
	}
}

Оформление радиокнопки можно менять при помощи только CSS, без подмены классов, почитайте про :checked

Сделать его Enabled=false

Int32.TryParse(textBox1.Text, out var text);
Int32.TryParse(textBox2.Text, out var text2);
Int32.TryParse(textBox3.Text, out var text3);

isWait == false;
заменить на
isWait = false;