1-Masala. Nuqta bilan tugaydigan belgilar ketma-ketligi berilgan

double result = 1;
for (int i = 0, j = numbers.Length - 1; i < numbers.Length; i++, j--)
{
double num1 = double.Parse(numbers[i]);
double num2 = double.Parse(numbers[j]);
result *= (num1 + num2);
}

Console.WriteLine("Natija: " + result);

Console.ReadKey();

}
}
}

в) ( x₁ + x₂ + 2*x_n )* ( x₂ + x₃ + 2*x_n-1 ) . . . ( x_n-1 + x_n + 2*x₂ )
Algoritmi:
Berilgan sonlar orasidagi ifodani hisoblash uchun quyidagi algoritmni amalga oshirish mumkin:

1. ifoda = 1 # boshlang'ich qiymati

2. for i in range(1, n): # sonlar orasida yurish
ifoda *= (x[i-1] + x[i] + 2*x[n-i])
3. print(ifoda)

Shunday qilib, berilgan sonlar orasidagi ifoda quyidagi Python funksiyasi yordamida hisoblanishi mumkin:

```
def calculate_expression(x):
n = len(x)
res = 1
for i in range(1, n):
res *= (x[i-1] + x[i] + 2*x[n-i])
return res
```

Funksiya sinfdosh parametr sifatida berilgan sonlardan foydalanadi va hisoblangan ifodani natija sifatida qaytaradi.

Dasturning C#dagi matni:
using System;
using System.Text;
using System.Collections.Generic;
using System.Linq;

namespace MirzashokirovOraliq
{
class Program
{
public static void Main(string[] args)
{

Console.Write("Massiv elementlari sonini kiriting: ");

int n = Convert.ToInt32(Console.ReadLine());

int[] arr = new int[n];
for (int i = 0; i < n; i++)
{
Console.Write("{0}. elementni kiriting: ", i+1);
arr[i] = Convert.ToInt32(Console.ReadLine());
}

int result = 1;
for (int i = 0; i < n/2; i++)
{
result *= (arr[i] + arr[n-1-i] + 2*arr[n/2]);
}
if (n % 2 != 0)
{
result *= arr[n/2];
}
Console.WriteLine("Natija: " + result);

Console.ReadKey();

}
}
} 

3-Masala.Berilgan haqiqiy sonlar a₁ , a₂ , . . . , a_2n (n >= 2 va oldindan ma'lum emas).
Hisoblang, topshiriqlarning blok sxemasini, algoritmini va dasturini tuzing
а) a₁* a_2n + a₂*a_2n-1 + . . . + a_n*a_n+1 ;
Algoritmi:
1. Berilgan haqiqiy sonlar ro'yxatini a o'zgaruvchiga yuklang.
2. n-burchaklar uchun for tsikli yaratiladi, misol uchun:

for i in range(n):

3. ifoda a[i] * a[n+i] ni hisoblagan shaklda for tsikliga qo'shiladi.
4. Natijani saqlash uchun bir o'zgaruvchiga qo'shish davom ettiriladi, misol uchun:

result = 0

5. For tsikli tugagandan so'ng, result o'zgaruvchiga ifoda natijasi yuklanadi.
6. Natijani qaytarish uchun:

return result

Dasturning C#dagi matni:
using System;
using System.Linq;

class Program

{
static void Main()
{
double[] sonlar = { 1.2, 3.4, 5.6, 7.8 }; // haqiqiy sonlar uchun misol
int n = sonlar.Length / 2;
double natija = 0;
for (int i = 0; i < n; i++)
{
natija += sonlar[i] * sonlar[2 * n - 1 - i];
} 
Console.WriteLine(natija);
Console.ReadKey();
}
}
Natija:

б) min ( a₁ + a_n+1 , a₂ + a_n+2 , . . . , a_n + a_2n ) ;
Algoritmi:
1. Berilgan sonlar to'plamini ikki to'g'ridan bo'lmaydigan bo'limga ajratamiz.
2. Kiritilgan sonlardan birinci yarimni a va ikkinchi yarimni b deb nomlashamiz.
3. Birinchi yarimning oxirgi sonini a_oxirgi qilib, ikkinchi yarimning b_1 sonini e'lon qilamiz.
4. Birinchi yarimning oxirgi soni bilan, ikkinchi yarimning birinchi sonini qo'shib, olishimiz kerak:
c = a_oxirgi + b_1
5. Natijada, ikkinchi yarimning oxirgi sonini b_oxirgi deb, ularni ham qo'shib natija b_ravno = a_oxirgi + b_1 bo'ladigan sonlarni topamiz.
6. Agar n == 2 bo'lsa, b_ravno ni qaytarib, boshqa holda quyidagi holda tarang:

A = (a_1 , a_2 , . . . , a_n) va B = (a_n+1 , a_n+2 , . . . , a_2n)

A va B to'plamlarini qo'shib qolgan natijaga X ni deb nomlashamiz:
X = min ( a_1 + a_n+1 , a_2 + a_n+2 , . . . , a_n + a_2n )
7. Quyidagi holda tarang:
Y = minimum topqinchi - 1 elementlari sonlar to'plami A va B yorliq.
8. quyidagi algoritmni tartib qilib yuborish: b_ravno + min(X, Y) shamncha.
9. Harmonik o'qitish avvalgi elementlarni turli tartibda izlashni mahsulot qiladi. Shundan, Qavatlash Avvalgi elementlarni bir-biridan ajratilgan holda o'qitishga qarab majburiy harakatlarni aniqlovchi tasnifda ishlatiladi (avvalgi yarimni, ikkinchi yarimni va natijani ajratish).
Algoritm:
1. Sonlarni kiritish.
2. Sonlarni ikki to'g'ridan bo'lmaydigan bo'limga ajratish va ikkita yarim to'plamini tuzish:
a = []
b = []
n = len(arr)
for i in range(n // 2):
a.append(arr[i])
b.append(arr[n // 2 + i])
if n % 2 != 0:
a[n // 2] = arr[n - 1]
3. To'plamlarni topish:
c = b[0] + a[-1]
for i in range(1, n // 2):
if b[i] + a[n // 2 - i - 1] < c:
c = b[i] + a[n // 2 - i - 1]
4. Yarimlardan olinmagan to'plamlarni topish:
d = a[0] + b[0]
for i in range(1, n // 2):
if a[i] + b[i] < d:
d = a[i] + b[i]
5. Natijani hisoblash:
if n <= 2:
return c
else:
return c + min(c, d)