Пешгуфтор 
 Ҳамқадам бо асру бо даврон мебояд будан, 
 Бо хабар аз илму аз ирфон мебояд шудан. 
 Ҳеҷ роҳе нест бепоён бошад дар ҷаҳон, 
 Бо ирода бо ҳавас бо ҷон мебояд шудан. 
 (Муллошараф Арабов) 
 Барномасозӣ низ ҳунар буда, барои бартараф намудани баъзе 
 мушкилоти ҷомеа бо истифода аз ягон забони барноманависӣ барнома 
 навишта мешавад. Ҳангоме, ки шахс барнома менависад, метавонад ба 
 компютер ҳамчун раис (роҳбар) муомила кунад. Барои навиштани 
 барнома забонҳои барноманависии зиёде мавҷуданд, ки аз байни онҳо 
 якчанд забон маъмулу машҳур ва пурқудрат буда, мавриди писанди 
 барноманависон ва омӯзандагон гардидаанд. Ин зумра забонҳоро, 
 забонҳои барноманависии сатҳи олӣ (ЗБСО) мегӯянд. Забонҳои 
 PascalABC.Net, C++, C#, Python, Java ва GO аз зумраи чунин забонҳо 
 мебошанд. Забонҳои барноманависӣ бо гузашти замон такмилу 
 густариш меёбанд. Забонҳои PascalABC.Net, C++, C#, Python, Java ва GO 
 низ дар айни ҳол дар ҳолати рушд ва густариш мебошанд. 
 Забонҳои мазкур дорои қудрати зиёд буда, метавонанд ҳам дар 
 муҳити Windows ва ҳам дар муҳити дигар системаҳои омилӣ кор 
 кунанд. 
 Дар ин дастур операторҳои асосии забонҳои барномасозии 
 муосир PascalABC.Net, C++, C#, Python, Java ва GO бо мисол ва 
 масъалаҳо оварда шудаанд. Дар ҳар як мавзӯъ намунаи масъалаҳо ҳал 
 карда шудааст, ки бо таҳлил кардани онҳо донишҷӯ метавонад 
 масъалаҳои боқимондаро мустақилона ҳал кунад. 
 Дар охири дастур феҳристи адабиёт ҷой дода шудааст, ки барои 
 пурратар ва ҳаматарафа омӯхтани забонҳои мазкур кӯмак мекунад. 
 Инак, чопи нахустини дастур пешкаши хонандагон мегардад, ки 
 метавонад аз нуқсону ғалатҳо орӣ нест. Аз ин рӯ, муаллифон аз ҳамаи 
 хонандагон эҳтиромона хоҳиш менамоянд, ки ҳар гуна фикру 
 мулоҳизоти хешро оид ба ин дастур ба нишонаи электронии 
 cool.araby@mail.ru ва mashka@inbox.ru ирсол намоянд. 
 Мо умедворем, ки фикру дархости беғаразонаи Шумо барои 
 беҳтар шудани сифати дастур дар оянда кӯмак хоҳанд кард. 
 Муаллифон ба шахсоне, ки фикру мулоҳизаҳои худро оид ба 
 мазмуни китоб беғаразона ба онҳо мерасонанд, қаблан миннатдории 
 худро баён месозанд. 
 Муаллифон ба муқарризон _______________ ва шахсоне, ки дар 
 рафти навиштани китоб маслиҳатҳои муфид дода, таваҷҷуҳ зоҳир 
 намуданд, миннатдории худро баён месозанд. 
 Масъалаҳои гуруҳи Begin 
 функсияҳои математикӣ ва ифодаҳои забонҳои PascalABC.Net, C++, 
 C#, Python, Java ва GO-ро аз [-] азбар намоед. 
 Python, Java ва GO нависед. 
 Намунаи ҳалли масъалаҳо 
 𝑃 = ∙ 𝑎. 
 PascalABC.NET C++ 
 Var #include <iostream> 
 a, P: Integer; using namespace std; 
 int main() 
 begin { 
 WriteLn('a: '); int a,P; 
 ReadLn(a); cout<<"a: " 
 P:=*a; cin >> a; 
 WriteLn('P=',P); P=*a; 
 end. cout << P << endl; 
 return; 
 } 
 Python C# 
 a=int(input("a:")) static void Main(string[] args) 
 P=*a { 
 print("P=", P) int a, p; 
 Console.Write("a: "); 
 a=Convert.ToInt(Console.ReadLine()); 
 p=*a; 
 Console.Write("p="+p); 
 Console.ReadKey(); 
 } 
 Java GO 
 public static void main(String[]args) package main 
 { import "fmt" 
 int a,P; func main() { 
 Scanner pa=new Scanner(System.in); var a int 
 System.out.println("a:"); fmt.Println("a: ") 
 a=pa.nextInt(); fmt.Scanf("%d", &a) 
 P=*a; var p=*a 
 System.out.println("p="+P); fmt.Println("p=",P) 
 } } 
 Ба сифати 𝜋 қимати. – ро истифода баред. 
 PascalABC.NET C++ 
 Var #include <iostream> 
 d, L: Real; using namespace std; 
 int main() 
 begin { 
 WriteLn('d: '); double d,L; 
 ReadLn(d); cout<<"d: "; 
 L:=d*pi; cin >> d; 
 WriteLn('L=',L); L=d*. 
 ReadLn; cout<<"L="<<L<< endl; 
 end. return; 
 } 
 Python C# 
 d=float(input("d:")) static void Main(string[] args) 
 L=.*d { 
 print("L=",L) Double d, L, pi; 
 Console.Write("d: "); 
 d=Convert.ToDouble(Console.ReadLine()); 
 pi=Math.PI; 
 L=d*pi; 
 Console.Write("L="+L); 
 Console.ReadKey(); 
 } 
 Java Go 
 public static void main(String[]args) package main 
 { import ("fmt") 
 double L,d; func main() { 
 Scanner ld=new Scanner(System.in); var d float 
 System.out.println("d: "); fmt.Println("d: ") 
 d=ld.nextDouble(); fmt.Scanf("%v", &d) 
 L=Math.PI*d; var L=d*. 
 System.out.println("L="+ L); fmt.Println("L=", L) 
 } } 
 сатҳи он 𝑆 = ∙ 𝑎 ёфта шавад. 
 PascalABC.NET C++ 
 Var #include <iostream> 
 a, V, S: Real; using namespace std; 
 begin 
 WriteLn('a:'); int main() 
 ReadLn(a); { 
 V=a*a*a; double a,S,V; 
 S=*a*a; cout<<"a: "; 
 WriteLn('V=', V); cin >> a; 
 WriteLn('S=', S); V=a*a*a; 
 end. S=*a*a; 
 cout <<"V="<<V << endl; 
 cout <<"S="<<S << endl; 
 return; 
 } 
 Python C# 
 a=float(input("a:")) public static void Main(string[] args) 
 V=pow(a,) { 
 S=*a*a; double a, v, s; 
 print("V=",V,",S=",S) 
 Console.Write("a: "); 
 a=Convert.ToDouble(Console.ReadLine()); 
 v=Math.Pow(a, ); 
 s=*Math.Pow(a, ); 
 Console.Write("v="+v+ "s="+ s); 
 Console.ReadKey(true); 
 } 
 Java Go 
 public static void main(String[] package main 
 args) { import ("fmt" 
 double V, a, S; "math" 
 Scanner vs=new Scanner(System.in); ) 
 System.out.println("a: "); func main() { 
 a=vs.nextInt(); var a float 
 V=a*a*a; fmt.Println("a:") 
 S=*(a*a); fmt.Scanf("%v", &a) 
 System.out.println("V="+V+" S="+S); var V=math.Pow(a,) 
 } var S=*math.Pow(a,) 
 fmt.Println("V=",V) 
 fmt.Println("S=",S) 
 } 
 модули онҳо ёфта шавад. 
 PascalABC.NET C++ 
 Var #include <iostream> 
 a, b,s,m,z,t: Real; using namespace std; 
 int main(){ 
 begin double a, b,s,m,z,t; 
 WriteLn('a, b'); cout << "a: "; 
 ReadLn(a, b); cin >> a 
 s:=abs(a)+abs(b); cout << "b:"; 
 m:=abs(a)-abs(b); cin>> b; 
 z:=abs(a)*abs(b); s=abs(a)+abs(b); 
 t:=abs(a)/abs(b); m=abs(a)-abs(b); 
 WriteLn('s=',s,' m=', z=abs(a)*abs(b); 
 m,' z=',z, ' t=',t); t=abs(a)/abs(b); 
 end. cout << "s="<<s<< endl; 
 cout << "m="<<m << endl; 
 cout << "z="<< z<< endl; 
 cout << "t="<<t << endl; 
 return; 
 } 
 Python C# 
 a=float(input("a: ")) public static void Main(string[] args) 
 b=float(input("b: ")) { 
 float a, b, s, m, z, t; 
 p=abs(a)+abs(b) 
 Console.Write("a: "); 
 s=abs(a)-abs(b) 
 a=Convert.ToSingle(Console.ReadLine()); 
 t=abs(a)*abs(b) 
 Console.Write("b: "); 
 v=abs(a)/abs(b) 
 b=Convert.ToSingle(Console.ReadLine()); 
 print("p=",p," s=",s," s=Math.Abs(a)+Math.Abs(b); 
 v=", v," t=",t) m=Math.Abs(a)-Math.Abs(b); 
 z=Math.Abs(a)*Math.Abs(b); 
 t=Math.Abs(a)/Math.Abs(b); 
 Console.Write("s=",s, " m=",m, " 
 z=", z, " t=", t); 
 Console.ReadKey(true); 
 } 
 Java Go 
 public static void main( package main 
 String[] args) { import ("fmt" 
 int a, b,s,m,z,t; "math" 
 Scanner rd=new Scanner ) 
 (System.in); func main() { 
 a=rd.nextInt(); var a,b float 
 b=rd.nextInt(); fmt.Scanf("%v %v", &a, &b) 
 s=Math.abs(a)+Math.abs(b); var s=math.Abs(a)+ 
 m=Math.abs(a)-Math.abs(b); math.Abs(b); 
 z=Math.abs(a)/Math.abs(b); v ar m=math.Abs(a) – 
 t=Math.abs(a)*Math.abs(b); math.Abs(b); 
 System.out.println("s="+ var z=math.Abs(a)* 
 s+ " m="+m+ " z="+ z+ math.Abs(b); 
 " t="+ t); var t=math.Abs(a)/ 
 } math.Abs(b); 
 fmt.Println("s="+s+ " m="+m+ 
 " z="+z+" t="+t) 
 } 
 шудаанд. Масоҳатҳои ин ду доира 𝑆 ва 𝑆, инчунин масоҳати 𝑆 – 
 ҳалқае, ки радиуси дохилиаш ба 𝑅 баробар буда, радиуси берунаи 
 он ба 𝑅 баробар аст, ёфта шаванд 𝑆 = 𝜋𝑅, 𝑆 = 𝜋𝑅 ба сифати 𝜋 
 қимати. – ро истифода баред. 
 PascalABC.NET C++ 
 Var #define PI. 
 R, R, S, S, S: Real; #include <iostream> 
 using namespace std; 
 Begin int main() 
 WriteLn('R, R'); { 
 ReadLn(R, R); double R, R, S, S, S; 
 S:=pi*Sqr(R); cout<<"R, R"; 
 S:=pi*Sqr(R); cin >> R >> R; 
 S:=S-S; S=PI*R*R; 
 WriteLn('S=',S, ' S=', S=PI*R*R; 
 S, ' S=', S); S=S-S; 
 end. cout <<"S"<<S << "\nS=" 
 <<S << "\nS=" << S << endl; 
 system("pause"); 
 return; 
 } 
 Python C# 
 r=float(input("r:")) public static void Main(string[] args){ 
 r=float(input("r:")) 
 double r,r, s,s,s; 
 S=.*r*r 
 Console.Write("r: "); 
 S=.*r*r 
 r=Convert.ToDouble(Console.ReadLine());
 S=S-S 
 Console.Write("r: "); 
 print("S=",S) 
 r=Convert.ToDouble(Console.ReadLine());
 print("S=",S) s=Math.PI*r*r; 
 print("S=",S) s=Math.PI*r*r; 
 s=s-s; 
 Console.WriteLine("s=",s); 
 Console.WriteLine("s="+s); 
 Console.WriteLine("s="+s); 
 Console.ReadKey(true); 
 } 
 Java GO 
 public static void main( package main 
 String[] args) { import ("fmt" 
 Double S,S,S,R,R; "math" 
 Scanner ld=new Scanner ) 
 (System.in); f u n c main() { 
 System.out.println("R"); var R,R float 
 R=ld.nextDouble(); fmt.Println("R, R") 
 System.out.println("R"); fmt.Scanf("%v %v", &R, &R) 
 R=ld.nextDouble(); var S=.*math.Pow(R,); 
 S=Math.PI*(R*R); var S=.*math.Pow(R,); 
 S=Math.PI*(R*R); var S=S-S; 
 S=S-S; fmt.Println("S=",S,"\nS=",S, 
 System.out.println("S= "\nS=",S) 
 "+S); } 
 System.out.println(" S= 
 "+S); 
 System.out.println(" S=" 
 +S); 
 } 
 ёбед: 𝑟 = |𝑥 − 𝑥 |. 
 PascalABC.NET C++ 
 Var #define PI. 
 x,x,r: Real; #include <iostream> 
 using namespace std; 
 begin int main() 
 WriteLn('x,x'); { 
 ReadLn(x,x); double x,x,r; 
 r=abs(x-x); cout<<"x,x:"; 
 WriteLn('r=',r); cin >>x>>x; 
 end. r=abs(x-x); 
 cout<<"r="<<r<<endl; 
 system("pause"); 
 return; 
 } 
 Python C# 
 x=float(input()) public static void Main(string[] args) 
 x=float(input()) { 
 r=abs(x-x) float x, x, r; 
 print("r=",r) Console.Write("x,x:"); 
 x=Convert.ToSingle(Console.ReadLine()); 
 x=Convert.ToSingle(Console.ReadLine()); 
 r=Math.Abs(x-x); 
 Console.Write("r="+r); 
 Console.ReadKey(true); 
 } 
 Java Go 
 public static void main(String[] package main 
 args) { import ( 
 float x,x,r; "fmt" 
 Scanner cp=new Scanner "math") 
 (System.in); f u n c m a in() { 
 System.out.println("x,x:"); var x,x float 
 x=cp.nextFloat(); fmt.Println("x,x:") 
 x=cp.nextFloat(); fmt.Scanf("%v %v", &x, &x) 
 r=Math.abs(x-x); var r=math.Abs(x-x) 
 System.out.println("r="+r); fmt.Println("r=",r) 
 } } 
 додашуда ёфта шавад: 𝑠 = √(𝑥 − 𝑥 ) + (𝑦 − 𝑦 ). 
 PascalABC.NET C++ 
 Var #include <iostream> 
 x,y,x,y,S: Real; using namespace std; 
 int main(){ 
 begin double x, y, x, y,s; 
 RealLn(x, y); cin >> x >> y; 
 RealLn(x, y); cin >> x >> y; 
 S=sqrt(sqr(x- s=sqrt((y-y)*(x-x)+y-y)* 
 x)+sqr(y-y)); (y-y)); 
 WriteLn(S); cout<<"s="<<s<<endl; 
 end. system("pause"); 
 return; 
 } 
 Python C# 
 from math import sqrt public static void Main(string[] args) 
 x=float(input("x:")) { 
 x=float(input("x:")) double x, x, y, y, s; 
 y=float(input("y:")) Console.WriteLine("x,y,x,y:"); 
 y=float(input("y:")) x=Convert.ToDouble(Console. 
 S=sqrt((x-x)**+(y- ReadLine()); 
 y)**) y=Convert.ToDouble(Console. 
 print("S=",S) ReadLine()); 
 x=Convert.ToDouble(Console. 
 ReadLine()); 
 y=Convert.ToDouble(Console. 
 ReadLine()); 
 s=Math.Sqrt((x-x)*(x-x)+ 
 (y-y)*(y-y)); 
 Console.WriteLine("s="+s); 
 Console.ReadKey(true); 
 } 
 Java Go 
 public static void main( package main 
 String[] args) { import ("fmt" 
 double S,x, x, y, y; "math" 
 Scanner cp=new Scanner( ) 
 System.in); f u nc main() { 
 x=cp.nextDouble(); var x,x,y,y float 
 x=cp.nextDouble(); fmt.Println("x,x,y,y") 
 y=cp.nextDouble(); fmt.Scanf("%v %v %v %v", 
 y=cp.nextDouble(); &x, &x, &y, &y) 
 S=Math.sqrt((x-x)*(x-x)- var S=math.Sqrt((x-x)* 
 (y-y)*(y-y)); (x-x)-(y-y)*(y-y)); 
 System.out.println("S="+S); fmt.Println("S=",S) 
 } } 
 ба B ва B ба А. 
 PascalABC.NET C++ 
 Var #include <iostream> 
 A,B, Temp: Integer; using namespace std; 
 int main(){ 
 Begin int A, B, Temp; 
 WriteLn('A,B:'); cout <<"A,B:"; 
 RealLn(A, B); cin >> A >> B; 
 Temp:=A; Temp=A; 
 A:=B; A=B; 
 B:=Temp; B=Temp; 
 WriteLn('A:',A::, cout<<"A="<<A<<"\Nb="<<B<<endl; 
 ' B', B::); system("pause"); 
 end. return; 
 } 
 Python C# 
 a=int(input("a:")) public static void Main(string[] args) 
 b=int(input("b:")) { 
 (a, b)=(b,a); int a, b, Temp; 
 print("a=",a," b=", b) Console.WriteLine("a,b:"); 
 a=Convert.ToInt(Console.ReadLine()); 
 b=Convert.ToInt(Console.ReadLine()); 
 Temp=a; 
 a=b; 
 b=Temp; 
 Console.WriteLine("a="+a+" b="+b); 
 Console.ReadKey(true); 
 } 
 Java Go 
 public static void main( package main 
 String[] args) { import "fmt" 
 int a, b, Temp; func main() { 
 Scanner sc=new Scanner var A,B int 
 (System.in); fmt.Println("A,B:") 
 System.out.println("a,b:"); fmt.Scanf("%d %d", &A, &B) 
 a=sc.nextInt(); A,B=B,A; 
 b=sc.nextInt(); fmt.Println("A=",A,"\nB=",B) 
 Temp=a; } 
 a=b; 
 b=Temp; 
 System.out.println("a="+a+ 
 " b="+b); 
 } 
 𝑦 = (𝑥 − ) − (𝑥 − ) + – ро ёбед. 
 PascalABC.NET C++ 
 Var #include <cmath> 
 x, y: Real; #include <iostream> 
 using namespace std; 
 begin int main() 
 WriteLn('x:'); { 
 ReadLn(x); double x, y; 
 y:=*(sqr(x- cout <<"x:"; 
 )*sqr(x-)*sqr(x-))- cin>>x; 
 *sqr(x-)*(x-)+; y=*(pow((x-),.))-*(pow((x-), 
 WriteLn('y=',y);.))+; 
 end. cout <<"y="<<y; 
 system("pause"); 
 return; 
 } 
 Python C# 
 from math import pow public static void Main(string[] args) 
 x=float(input("x: ")) { 
 y=*pow((x-),)- double y, x; 
 *pow((x-),)+ 
 print("y=",y) Console.WriteLine("x:"); 
 x=Convert.ToInt(Console.ReadLine()); 
 y=*Math.Pow((x-),)-*Math. 
 Pow((x), )+; 
 Console.WriteLine("y="+y); 
 Console.ReadKey(true); 
 } 
 Java Go 
 public static void main(String[] package main 
 args) { import ("fmt" 
 double y,x; "math" 
 Scanner cp=new Scanner( ) 
 System.in); func main() { 
 System.out.println("x:"); var x float 
 x=cp.nextDouble(); fmt.Println("x:") 
 y=*Math.pow((x-),)-*Math. fmt.Scanf("%v", &x) 
 pow((x-),)+; var y=*math.Pow((x-),)- 
 System.out.println("y="+y); *math.Pow((x-),)+; 
 } fmt.Println("y=",y) 
 } 
 амали зарб, қимати 𝐴 ёфта шавад. Барои ин пайдарпайи 𝐴,𝐴,𝐴 
 чоп карда шавад. 
 PascalABC.NET C++ 
 Var #include <iostream> 
 A, Res: Real; using namespace std; 
 int main() 
 Begin { 
 Write('A: ') double A, Res; 
 ReadLn(A); cout<<"A:") 
 Res:=A*A; cin >> A; 
 WriteLn(Res); Res=A*A; 
 A:=Res*Res; cout<< Res; 
 WriteLn(A); A=Res*Res; 
 Res:=A*A; cout<< A; 
 WriteLn('Res=',Res); Res=A*A; 
 end. cout<<"Res="<<Res; 
 system("pause"); 
 return; 
 } 
 Python C# 
 a=float(input("a:")) public static void Main(string[] args) 
 Res=a*a { 
 double a, Res; 
 print(Res) 
 a=Convert.ToInt(Console.ReadLine()); 
 a=Res*Res 
 Res=a*a; 
 Res=a*a 
 Console.WriteLine(Res); 
 print("a=",a,"Res=",Res) 
 a=Res*Res; 
 Res=a*a; 
 Console.WriteLine("a="+a+" Res="+ Res); 
 Console.ReadKey(true); 
 } 
 Java Go 
 public static void package main 
 main(String[] args) { import "fmt" 
 double a, Res; func main() { 
 Scanner sc=new Scanner var a, Res float 
 (System.in); fmt.Println("a:") 
 System.out.println("a:"); fmt.Scanf("%v", &a) 
 a=sc.nextDouble(); Res=a*a 
 Res=a*a; fmt.Println(Res,"\t") 
 System.out.print(Res+" "); a=Res*Res 
 a=Res*Res; Res=a*a 
 Res=a*a; fmt.Println("a=",a, 
 System.out.println("a="+a+" " Res=", Res) 
 Res="+ Res); } 
 } 
 Бузургии қунҷи додашударо бо назардошти он ки о = 𝜋 радиан 
 аст, бо радиан муайян кунед. Ба сифати 𝜋 қимати. истифода 
 карда шавад. 
 PascalABC.NET C++ 
 Var #define PI. 
 alfa,x:Real; #include <iostream> 
 Begin using namespace std; 
 WriteLn('alfa'); int main() 
 ReadLn(alfa); { 
 x=alfa*pi/ Double x, alfa; 
 WriteLn('x=',x); cout<<"alfa"; 
 End. cin >> alfa; 
 x=(alfa*PI)/ 
 cout<<"x="<<x<<endl; 
 system("pause"); 
 return; 
 } 
 Python C# 
 a=float(input()) public static void Main(string[] args) 
 x=(a *.)/ { 
 print("x=",x) double x, alfa; 
 Console.WriteLine("alfa "); 
 alfa=Convert.ToSingle(Console.ReadLine()); 
 x=( alfa*.)/; 
 Console.WriteLine("x="+x); 
 Console.ReadKey(true); 
 } 
 Java Go 
 public static void package main 
 main(String[] args) { import "fmt" 
 double alfa,x; func main() { 
 Scanner sc=new Scanner var alfa float 
 fmt.Println("alfa") 
 (System.in); fmt.Scanf("%v", &alfa) 
 var x=(.*alfa)/; 
 System.out.println("alfa fmt.Println("x=",x) 
 "); } 
 alfa=sc.nextDouble(); 
 x=(Math.PI*alfa)/; 
 System.out.println("x="+x); 
 } 
 ва y кг ин гуна шириниро муаян кунед. 
 PascalABC.NET C++ 
 Var #include <iostream> 
 a, x, y,z,z: using namespace std; 
 Real; int main() 
 { 
 begin double a, x, y,z,z; 
 WriteLn('a,x,y:'); cout<<"a:"; cin>>a; 
 ReadLn(a); cout<<"x:"; cin>>x; 
 ReadLn(x); cout<<"y:";cin>>y; 
 ReadLn(y); z=a/x; 
 z:=a/x; z=z*y; 
 z:=z*y; cout<<"z="<<z<<"z="<<z<<endl; 
 WriteLn(z,' ',z); system("pause"); 
 end. return; 
 } 
 Python C# 
 a=float(input("a:")) public static void Main(string[] args) 
 x=float(input("x:")) { 
 y=float(input("y:")) double x, a, y; 
 z=a/x Console.Write("a,x,y:"); 
 z=z*y a=Convert.ToSingle(Console.ReadLine()); 
 print("z="z," x=Convert.ToSingle(Console.ReadLine()); 
 z=",z) y=Convert.ToSingle(Console.ReadLine()); 
 z=a/x; 
 z=z*y; 
 Console.WriteLine("z="+z+" z="+z); 
 Console.ReadKey(true); 
 } 
 Java Go 
 public static void main(String[] package main 
 args){ import ("fmt" 
 double x, a, z, y, z; ) 
 Scanner sc=new Scanner( func main() { 
 System.in); var a,x,y float 
 System.out.println("a,x,y"); fmt.Println("a,x,y:") 
 a=sc.nextDouble(); fmt.Scanf("%v %v %v", 
 x=sc.nextDouble(); &a,&x,&y) 
 y=sc.nextDouble(); var z=a/x; 
 z=a/x; var z=z*y; 
 z=z*y; fmt.Println("z="z, 
 System.out.println(" z="+z+" "\nz=",z) 
 z="+z); } 
 } 
 км/с (U<V) аст. Қаиқ дар оби ором 𝑇 соат ва муқобили ҷараёни дарё 
 Т соат ҳаракат кард. Роҳи тай кардаи қаиқ S -- ро муайян кунед 
 (роҳ = соат ∙ суръат). Маълум аст, ки суръати қаиқ ҳангоми ҳаракат 
 муқобили ҷараёни дарё ба андозаи суръати ҷараёни дарё кам 
 мешавад. 
 PascalABC.NET C++ 
 Var #include <iostream> 
 V, U, T, T, S: Real; using namespace std; 
 int main() 
 Begin { 
 WriteLn('V,U,T,T:'); double V, U, T, T, S; 
 ReadLn(V, U, T, T); cout<< "V, U, T, T:" 
 S:=T *V+T*(V-U); cin >> V >> U >> T >> T; 
 WriteLn('S=',S); S=T*V+T*(V-U); 
 end. cout<<"S="<<S<<endl; 
 system("pause"); 
 return; 
 } 
 Python C# 
 u=float(input("u:")) public static void Main(string[] args) 
 v=float(input("v:")) { 
 t=float(input("t:")) double v, u, t, t, s; 
 t=float(input("t:")) Console.Write("v, u, t, t"); 
 S=t*v+(v-u)*t; v=Convert.ToInt(Console.ReadLine()); 
 print("S",S) u=Convert.ToInt(Console.ReadLine()); 
 t=Convert.ToInt(Console.ReadLine()); 
 t=Convert.ToInt(Console.ReadLine()); 
 s=v*t+(v-u)*t; 
 Console.WriteLine(" s="+ s); 
 Console.ReadKey(true); 
 } 
 Java Go 
 public static void main( package main 
 String[] args) { import "fmt" 
 double u,v,t,t,S; func main() { 
 Scanner sc=new Scanner( var u,v,t,t float 
 System.in); fmt.Println("v,u,t,t") 
 System.out.println("v,u,t,t"); fmt.Scanf("%v %v %v %v", 
 v=sc.nextDouble(); &v, &u,&t,&t) 
 u=sc.nextDouble(); var S=t*v+(v-u)*t 
 t=sc.nextDouble(); fmt.Println("S=",S) 
 t=sc.nextDouble();; } 
 S=t*v+(v-u)*t; 
 System.out.println(" S="+S); 
 } 
 коэффитсиентҳои A, B, C (𝐴 ≠ ) муаян карда шаванд, агар маълум 
 бошад, ки дискриминанти муодила мусбат аст. Решаҳои муодилаи 
 −𝐵±√𝐷 
 квадратӣ аз рӯӣ формулаи зерин ёфта мешаванд: 𝑥 =, дар ин, 
 ∙𝐴 
 ҷо дискриминант D=𝐵 − ∙ 𝐴 ∙ 𝐶 аст. 
 PascalABC.NET C++ 
 Var #include <iostream> 
 d,a, b, c, x, x: real; using namespace std; 
 int main() 
 begin { 
 WriteLn('a, b, c'); double a, b, c, x, x,d; 
 readln(a, b, c); cout<<"a, b, c"; 
 d:=sqr(b)-*a*c; cin>>a>>b>>c; 
 x:=(-b-sqrt(d))/(*a); d=b*b-*a*c; 
 x:=(-b+sqrt(d))/(*a); x=(-b-sqrt(d))/(*a); 
 writeln('x=',x,' x=', x=(-b+sqrt(d))/(*a); 
 x); cout<<"x="<<x<<"\nx="<<x; 
 end. system("pause"); 
 return; 
 } 
 Python C# 
 from math import sqrt public static void Main(string[] args) 
 a=float(input("a:")) { 
 b=float(input("b:")) double a, b, c, x, x, d; 
 c=float(input("c:")) Console.Write("a, b, c"); 
 d=b*b-*a*c a=Convert.ToDouble(Console. 
 x=(-b+sqrt(d))/*a ReadLine()); 
 x=(-b-sqrt(d))/*a b=Convert.ToDouble(Console. 
 print("x=",x," ReadLine()); 
 x=",x) c=Convert.ToDouble(Console. 
 ReadLine()); 
 d=b*b-*a*c; 
 x=(-b*Math.Sqrt(d))/(*a); 
 x=(-b-Math.Sqrt(d))/(*a); 
 Console.WriteLine(" x="+x+ 
 " x="+ x); 
 Console.ReadKey(true); 
 } 
 Java Go 
 public static void main( package main 
 String[] args){ import ("fmt" 
 double a, b,c,d,x,x; "math" 
 Scanner cp=new Scanner( ) 
 System.in); func main() { 
 System.out.println("a, b, c"); v ar a,b,c float 
 a=cp.nextDouble(); fmt.Println("a, b, c") 
 b=cp.nextDouble(); fmt.Scanf("%v %v %v", &a, 
 c=cp.nextDouble(); &b,&c) 
 d=b*b-*a*c; var d=b*b-*a*c; 
 x=(-b+Math.sqrt(d))/*a; var x=(-b-math.Sqrt(d)) 
 x=(-b+Math.sqrt(d))/*a; /(*a); 
 System.out.println("x="+x+" var x=(-b+math.Sqrt(d)) 
 x="+x); /(*a); 
 } fmt.Println(" x=",x, 
 "\nx=",x) 
 } 
 Масъалаҳо барои кори мустақилона 
 периметри он 𝑃 = ∙ (𝑎 + 𝑏) ёфта шавад. 
 куб 𝑉 = 𝑎 ∙ 𝑏 ∙ 𝑐 ва масоҳати сатҳи он 𝑆 = ∙ (𝑎 ∙ 𝑏 + 𝑏 ∙ 𝑐 + 𝑎 ∙ 𝑐) ёфта
 шавад. 
 ёфта шавад: 𝐿 = ∙ 𝜋 ∙ 𝑅, 𝑆 = 𝜋 ∙ 𝑅. Ба сифати 𝜋 қимати. – ро
 истифода баред. 
 ёфта шавад: 𝑆 = (𝑎 + 𝑏)/. 
 геометрии онҳо ёфта шавад: 𝑆 = √𝑎 ∙ 𝑏. 
 с ва периметри он Р ёфта шавад: 𝑐 = √𝑎 + 𝑏, 𝑃 = 𝑎 + 𝑏 + 𝑐. 
 даврае, ки ин доираро иҳота мекунад, ёфта шавад. 𝐿 = 𝜋 ∙ 𝐷, 
 𝜋∙𝐷 √ 𝑆 
 𝑆 =, 𝐷 =, ба сифати 𝜋 қимати. – ро истифода баред. 
 √𝜋 
 порчаҳои AC ва BC ва суммаи онҳо ёфта шаванд: 𝑎 = |𝑥 − 𝑥 |, 
 𝑏 = |𝑥 − 𝑥 |,𝑐 = 𝑎 + 𝑏. 
 Нуқтаи С дар байни нуқтаҳои A ва B ҷойгир аст. Ҳосили зарби 
 дарозии порчаҳои AC ва BC ёфта шаванд: 
 𝑋 = |𝑥 − 𝑥 |,𝑌 = |𝑥 − 𝑥 |,𝑍 = 𝑋 ∙ 𝑌. 
 (𝑥,𝑦 ),(𝑥,𝑦 ). Тарафҳои росткунҷа бо тирҳои координатӣ 
 параллел мебошанд. Периметр ва масоҳати росткунҷа ёфта 
 шавад: 
 дода шудааст. Периметри секунҷа бо истифода аз формулаи 
 масофаи ду нуқта дар ҳамворӣ ва масоҳати он аз рӯи формулаи 
 𝑎+𝑏+𝑐 
 Герон 𝑆 = √𝑝(𝑝 − 𝑎)(𝑝 − 𝑏)(𝑝 − 𝑐), 𝑝 = ёфта шавад. Дар 
 ин ҷо: 𝑎 = √(𝑥 − 𝑥 ) + (𝑦 − 𝑦 ), 𝑏 = √(𝑥 − 𝑥 ) + (𝑦 − 𝑦 ), 
 𝑐 = √(𝑥 − 𝑥 ) + (𝑦 − 𝑦 ) аст. 
 дар b ва қимати b дар а қарор гирад), қимати нави онҳоро чоп 
 кунед. 
 – ро ба 𝑎 иваз намоед. Қиматҳои нави тағйирёбандаҳои 𝑎, 𝑏,𝑐-ро 
 хориҷ кунед. 
 – ро ба 𝑎 иваз намоед. Қиматҳои нави тағйирёбандаҳои 𝑎, b, c-ро 
 хориҷ кунед. 
 ро ёбед. 
 нав бо панҷ амали зарб ёфта шавад. Барои ин пай дар паии 
 𝐴,𝐴,𝐴,𝐴,𝐴 ҳисоб карда мешавад. Ҳамаи дараҷаҳои 
 ёфташудаи адади А чоп карда шавад. 
 қунҷи додашударо бо назардошти он ки о = 𝜋 радиан аст 
 муайян кунед (бо градус). Ба сифати 𝜋 қимати. – ро истифода 
 кунед. 
 ҳарорати додашударо бо градусҳои Селсия муайян кунед. 
 Ҳарорат бо Селсия 𝑇 ва ҳарорат бо Фаренгейт 𝑇 бо вобастагии 
 𝐶 𝐹 
 зерин бо ҳам алоқаманданд: 𝑇 = (𝑇 − )∙ /. 
 𝐶 𝐹 
 ҳарорати додашударо бо градусҳои Фаренгейт муайян кунед. 
 Ҳарорат бо Селсия 𝑇 ва ҳарорат бо Фаренгейт 𝑇 бо вобастагии 
 𝐶 𝐹 
 зерин бо ҳам алоқаманданд: 𝑇 = (𝑇 − )∙ /. 
 𝐶 𝐹 
 арзиш доранд. майян кунед, ки кг шоколад ва кг ирис чанд 
 сомонӣ арзиш доранд. Инчунин, маълум кунед, ки шоколад чанд 
 маротиба аз ирис қиматтар аст. 
 𝑉 км/с ва масофа байни онҳо ба S км баробар аст. Масофаи байни 
 онҳоро пас аз гузаштани Т соат муайян кунед, агар автомобилҳо 
 аз ҳам дур шуда истода бошанд. Масофаи додашуда ба суммаи 
 масофаи аввала ва роҳи умумии тай кардаи автомобилҳо баробар 
 аст: масофаи умумӣ = соат ∙ суръати умумӣ. 
 𝑉 км/с ва масофа байни онҳо ба S км баробар аст. Масофаи байни 
 онҳоро пас аз гузатани Т соат муайян кунед, агар автомобилҳо 
 муқобили ҳамдигар ҳаракат дошта бошанд. Масофаи додашуда 
 ба суммаи масофаи аввала ва роҳи умумии тай кардаи 
 автомобилҳо баробар аст: масофаи умумӣ = соат ∙ суръати умумӣ. 
 A ва B (𝐴 ≠ ) ҳал карда шавад. 
 𝐴 ∙ 𝑥 + 𝐵 ∙ 𝑦 = 𝐶, 
 { 
 𝐴 ∙ 𝑥 + 𝐵 ∙ 𝑦 = 𝐶. 
 бо коэффитсиентҳои додашуда 𝐴,𝐵,𝐶,𝐴,𝐵,𝐶 ёфта шавад, агар 
 маълум бошад, ки системаи додашуда ҳалли ягона дорад. 
 Формулаҳои зеринро истифода баред: 
 𝐶 ∙ 𝐵 − 𝐶 ∙ 𝐵 𝐴 ∙ 𝐶 − 𝐴 ∙ 𝐶 
 𝑥 =,𝑦 =, 
 𝐷 𝐷 
 ки дар ин ҷо 𝐷 = 𝐴 ∙ 𝐵 − 𝐴 ∙ 𝐵. 
 Масъалаҳои гуруҳи Integer 
 C#, Python, Java ва GO аз [-] азбар намоед. 
 Python, Java ва GO нависед. 
 Намунаи ҳалли масъалаҳо 
 тақсими бутун, миқдори пурраи метрҳо дар он ёфта шавад ( 
 метр= сантиметр). 
 PascalABC.NET C++ 
 Var #include <iostream> 
 L, M: integer; using namespace std; 
 int main() 
 begin { 
 read(L); int L,M; 
 M:=L div; cin>>L; 
 write(M); M=L/; 
 end. cout<<M<<endl; 
 system("pause"); 
 return; 
 } 
 Python C# 
 L=int(input()) static void Main(string[] args) 
 M=int(L/); { 
 print(M); int L,M; 
 L=Convert.ToInt(Console.ReadLine()); 
 M=L/; 
 Console.Write(M); 
 Console.ReadKey(); 
 } 
 Java Go 
 import java.util.Scanner; package main 
 public static void main(String[] args) import "fmt" 
 { func main() { 
 int L,M; var L,M int 
 Scanner sc=new Scanner(System.in); fmt.Scanf("%d", &L) 
 L=sc.nextInt(); M=L/ 
 M=L/; fmt.Println(M) 
 System.out.println(M); } 
 } 
 дарозиаш A, шумораи максималии порчаҳои дарозиаш B ҷой 
 дода шудааст (болои ҳам намехобанд). Бо истифода аз амали 
 тақсими бутун, миқдори порчаҳои B-ро, ки дар порчаи А 
 мехобанд, ёфта шавад. 
 PascalABC.NET C++ 
 Var #include <iostream> 
 A, B, Res: Integer; using namespace std; 
 int main() 
 begin { 
 Readln(A); int A, B, Res; 
 Readln(B); cin>>A>>B; 
 Res:=A div B; Res=A/B; 
 Writeln(Res); cout<< Res<<endl; 
 end. system("pause"); 
 return; 
 } 
 Python C# 
 a=int(input()) static void Main(string[] args){ 
 b=int(input()) int a, b, Res; 
 Res=a//b a=Convert.ToInt(Console.ReadLine()); 
 print(Res) b=Convert.ToInt(Console.ReadLine()); 
 Res=a/ b; 
 Console.WriteLine(Res); 
 Console.ReadKey(); 
 } 
 Java Go 
 public static void main(String[] package main 
 args) { import "fmt" 
 int B,A, Res; func main() { 
 Scanner sc=new Scanner( var a,b int 
 System.in); fmt.Scanf("%d %d", &a,&b) 
 A=sc.nextInt(); var Res=a/b 
 B=sc.nextInt(); fmt.Println(Res) 
 Res=A/B; } 
 System.out.println(Res); 
 } 
 сипас рақами тарафи рости он (воҳид) хориҷ карда шавад. Барои 
 ёфтани қисми даҳии адад, амали тақсими бутун ва барои ёфтани 
 қисми воҳид амали бақия аз тақсими бутунро истифода баред. 
 PascalABC.NET C++ 
 Var #include <iostream> 
 a, r, L: integer; using namespace std; 
 int main() 
 begin { 
 ReadLn(a); int a, r,L; 
 r:=a div; cin>>a; 
 L:=a mod; r=a/; 
 WriteLn(r); L=a%; 
 WriteLn(L); cout<<r<<" "<<L; 
 end. system("pause"); 
 return; 
 } 
 Python C# 
 a=int(input()) static void Main(string[] args){ 
 r=a// int a, r,L; 
 L=a% a=Convert.ToInt(Console.ReadLine()); 
 print(r,' ',L) r=a/; 
 L=a%; 
 Console.WriteLine(r+" "+L); 
 Console.ReadKey(); 
 } 
 Java Go 
 public static void main(String[] package main 
 args) { import "fmt" 
 int a, b,L; func main() { 
 Scanner sc=new Scanner(System.in); var n int 
 a=sc.nextInt(); fmt.Scanf("%d", &a) 
 r=a/; var r=a/; 
 L=a%; var L=a%; 
 System.out.println(r+" "+L); fmt.Println(r," ",L) 
 } } 
 бутун, рақами якуми ин ададро хориҷ кунед (садӣ). 
 PascalABC.NET C++ 
 Var #include <iostream> 
 a, r: integer; using namespace std; 
 int main(){ 
 begin int a,r; 
 readln(a); cin>>a; 
 r:=a div; r=a/; 
 Writeln(r); cout<<r<<endl; 
 end. system("pause"); 
 return; 
 } 
 Python C# 
 a=int(input()) static void Main(string[] args){ 
 r=a// int a, r; 
 print(r) a=Convert.ToInt(Console.ReadLine()); 
 r=a/; 
 Console.WriteLine(r); 
 Console.ReadKey(); 
 } 
 Java Go 
 public static void main(String[]args) { package main 
 int a,r; import "fmt" 
 Scanner sc=new Scanner(System.in); func main() { 
 a=sc.nextInt(); var a int 
 r=a/; fmt.Scanf("%d",&a) 
 System.out.println(r); var r=a/; 
 } fmt.Println(r) 
 } 
 хондани адади додашуда ҳосил мешавад, бароварда шавад. 
 PascalABC.NET C++ 
 Var #include <iostream> 
 x,a,b,c,p: integer; using namespace std; 
 int main(){ 
 begin int a, b,c,p,x 
 readln(x); cin>>x; 
 a:=x div; a=x/; 
 b:=(x div ) mod; b=(x %)/; 
 c:=x mod; c=x%; 
 p:=c*+b*+a; p=c*+b*+a 
 Writeln(p); cout<<p; 
 end. system("pause"); 
 return; 
 } 
 Python C# 
 x=int(input()) static void Main(string[] args){ 
 a=x// int a, b,c,x,p; 
 b=(x%)// x=Convert.ToInt(Console.ReadLine()); 
 c=x% a=x/; 
 p=c*+b*+a b=(x%)/; 
 print(S) c=x%; 
 p=*c+*b+a; 
 Console.WriteLine(p); 
 Console.ReadKey(); 
 } 
 Java Go 
 public static void main(String[] package main 
 args) { import ("fmt") 
 int a, b,c,p,x; func main() { 
 Scanner sc=new Scanner(System.in); var x int 
 x=sc.nextInt(); fmt.Scanf("%d", &x) 
 a=x/; var a=x/; 
 b=(x%)/; var b=(x%)/; 
 c=x%; var c=x%; 
 p=*c+*b+a; var p=*c+*b+a; 
 System.out.println(p); fmt.Println(p) 
 } } 
 тақсими бутун ва як амали бақия аз тақсими бутун, рақами 
 разряди садии ин адад ёфта шавад. 
 PascalABC.NET C++ 
 Var #include <iostream> 
 x, a: integer; using namespace std; 
 int main() 
 begin { 
 readln(x); int x, a; 
 a:=(x div ) mod; cin>>x; 
 writeln(a) a=(x%)/; 
 end. cout<<a; 
 system("pause"); 
 return; 
 } 
 Python C# 
 n=int(input()) static void Main(string[] args){ 
 a=(n%)// int x,a; 
 print(a) x=Convert.ToInt(Console.ReadLine()); 
 a=(x%)/; 
 Console.WriteLine(a); 
 Console.ReadKey(); 
 } 
 Java Go 
 public static void main(String[]args) package main 
 { import "fmt" 
 int a,x; func main() { 
 Scanner sc=new Scanner(System.in); var x int 
 x=sc.nextInt(); fmt.Scanf("%d", &x) 
 a=(x%)/; var a=(x%)/; 
 System.out.println(a); fmt.Println(a) 
 } } 
 дақиқаҳои бутуни аз оғози шабонарӯз гузаштаро ёбед. 
 PascalABC.NET C++ 
 Var #include <iostream> 
 s, m: integer; using namespace std; 
 int main() 
 begin { 
 readln(s); int s,m; 
 m:=s div; cin>>s; 
 writeln(m) m=s/; 
 end. cout<<m; 
 system("pause"); 
 return; 
 } 
 Python C# 
 s=int(input()) static void Main(string[] args){ 
 m=s// int m,s; 
 print(m) s=Convert.ToInt(Console.ReadLine()); 
 m=s/; 
 Console.WriteLine(m); 
 Console.ReadKey(); 
 } 
 Java Go 
 public static void main(String[] package main 
 args) { import "fmt" 
 int s,m; func main() { 
 Scanner sc=new Scanner(System.in); var s,m int 
 s=sc.nextInt(); fmt.Scanf("%d", &s) 
 m=s/; m=s/; 
 System.out.println(m); fmt.Println(m) 
 } } 
 якшанбе, – душанбе, – сешанбе, – панҷшанбе, – ҷумъа, – 
 шанбе. Адади бутуни К дар фосилаи аз то дода шудааст. 
 Рақами рӯзи ҳафтаи К- уми сол ёфта шавад, агар маълум бошад, 
 ки дар ин сол январ душанбе аст. 
 PascalABC.NET C++ 
 Var #include <iostream> 
 x, d: integer; using namespace std; 
 int main() 
 begin { 
 readln(x); int d,x; 
 d:=x mod; cin>>x; 
 writeln(d); d=x%; 
 end. cout<<d; 
 system("pause"); 
 return; 
 } 
 Python C# 
 x=int(input()) static void Main(string[] args){ 
 d=x% int d,x; 
 print(d) x=Convert.ToInt(Console.ReadLine()); 
 d=x%; 
 Console.WriteLine(d); 
 Console.ReadKey(); 
 } 
 Java Go 
 public static void main(String[] args) package main 
 { import "fmt" 
 int d,x; func main() { 
 Scanner lk=new Scanner(System.in); var x,d int 
 x=lk.nextInt(); fmt.Scanf("%d", &x) 
 d=x%; d=x%; 
 System.out.println(d); fmt.Println(L) 
 } } 
 тарафҳояш A ва B миқдори максималии квадратҳои тарафҳояш 
 ба С баробар ҷой дода шудаанд (ҳамдигарро намебуранд). 
 Миқдори квадратҳои дар росткунҷаи андозааш AxB ҷойгиршуда 
 ва масоҳати қисми холии он ёфта шавад. 
 PascalABC.NET C++ 
 Var #include <iostream> 
 a, b, c, s, p: integer; using namespace std; 
 Resulr: real; int main() 
 { 
 begin int a, b,c,p,s; 
 readln(a, b, c); cin>>a>>b>>c; 
 p:=(a div c)*(b div c); p=(a/c)*(b/c); 
 s:=b* a mod c)+(b mod s=b*(a%c)+(b%c)*(a-a%c); 
 c)*(a-a mod c); cout<<p<<" "<<s<<endl; 
 writeln(s, ' ', p); system("pause"); 
 end. return; 
 } 
 Python C# 
 a=int(input()) static void Main(string[] args){ 
 b=int(input()) int a, b,c,s,p; 
 c=int(input()) a=Convert.ToInt(Console.ReadLine()); 
 b=Convert.ToInt(Console.ReadLine()); 
 p=(a//c)*(b//c); 
 c=Convert.ToInt(Console.ReadLine()); 
 s=b*(a%c)+(b%c)*(a- 
 p=(a/c)*(b/c); 
 a%c); 
 s=b*(a%c)+(b%c)*(a-a%c); 
 print(p,' ',s ) 
 Console.WriteLine(p+" "+s); 
 Console.ReadKey(); 
 } 
 Java Go 
 public static void main( package main 
 String[] args) { import "fmt" 
 int a, b,c,p,s; func main() { 
 Scanner sc=new Scanner( var a,b,c,s,p int 
 System.in); fmt.Scanf("%d %d %d",&a,&b,&c) 
 a=sc.nextInt(); p=(a/c)*(b/c); 
 b=sc.nextInt(); s=b*(a%c)+(b%c)*(a-a%c); 
 c=sc.nextInt(); fmt.Println(p," ",s) 
 p=(a/c)*(b/c); } 
 s=b*(a%c)+(b%c)*(a-a%c); 
 System.out.println(p+" " 
 +s); 
 } 
 Масъалаҳо барои кори мустақилона 
 тақсими бутун, миқдори пурраи тоннаҳо дар он ёфта шавад ( 
 тонна= килограмм). 
 тақсими бутун, миқдори пурраи килобайтҳо дар он ёфта шавад ( 
 килобайт= байт). 
 дарозиаш A, шумораи максималии порчаҳои дарозиаш B ҷой 
 дода шудааст (ҳамдигарро намебуранд). Бо истифода аз амали 
 бақияи тақсими бутун, дарозии қисми холии порчаи А ёфта 
 шавад. 
 шавад. 
 рақамҳои адади додашуда ҳосилшударо хориҷ кунед. 
 (воҳид), сипас рақами мобайнии (даҳӣ) онро хориҷ кунед. 
 шавад. 
 хат зада, дар охир нависед. Адади ҳосилшуда хориҷ карда шавад. 
 Мисол дохилкунӣ, хориҷкунӣ. 
 зада, дар аввал нависед. Адади ҳосилшуда хориҷ карда шавад. 
 Мисол дохилкунӣ, хориҷкунӣ. 
 рақамҳои садӣ ва даҳии он ҳосилшударо хориҷ кунед (мисол - 
 ). 
 рақамҳои даҳӣ ва воҳиди он ҳосилшударо хориҷ кунед (мисол - 
 ). 
 тақсими бутун ва як амали бақия аз тақсими бутун, рақами 
 разряди ҳазории он адад ёфта шавад. 
 дақиқаҳои бутуни аз оғози шабонарӯз гузаштаро ёбед. 
 сонияи аз дақиқаҳои охирон гузаштаро ёбед. 
 сонияҳои аз соати охирон гузаштаро ёбед. 
 дақиқаҳои аз соати охирон гузаштаро ёбед. 
 якшанбе, – душанбе, – сешанбе, – панҷшанбе, – ҷумъа, – 
 шанбе. Адади бутуни К дар фосилаи аз то дода шудааст. 
 Рақами рӯзи ҳафтаи К- уми сол ёфта шавад, агар маълум бошад, 
 ки дар ин сол январ панҷшанбе аст. 
 якшанбе, – душанбе, – сешанбе, – панҷшанбе, – ҷумъа, – 
 шанбе. Адади бутуни К дар фосилаи аз то дода шудааст. 
 Рақами рӯзи ҳафтаи К- уми сол ёфта шавад, агар маълум бошад, 
 ки дар ин сол январ сешанбе аст. 
 якшанбе, – душанбе, – сешанбе, – панҷшанбе, – ҷумъа, – 
 шанбе. Адади бутуни К дар фосилаи аз то дода шудааст. 
 Рақами рӯзи ҳафтаи К- уми сол ёфта шавад, агар маълум бошад, 
 ки дар ин сол январ шанбе аст. 
 якшанбе, – душанбе, – сешанбе, – панҷшанбе, – ҷумъа, – 
 шанбе. Адади бутуни К дар фосилаи аз то адади бутуни N 
 дар фосилаи аз то дода шудааст. Рақами рӯзи ҳафтаи К- уми 
 сол ёфта шавад, агар маълум бошад, ки дар ин сол январ рӯзи 
 N бошад. 
 рақамгузорӣ шудаанд, ҳал карда шаванд. 
 асри (садсолаи) ба он мувофиқ ёфта шавад. Масалан соли 
 якуми асри – ум аст. 
 Масъалаҳои гуруҳи Boolean 
 PascalABC.Net, C++, C#, Python, Java ва GO-ро аз [-] азбар намоед. 
 Python, Java ва GO нависед. 
 Намунаи ҳалли масъалаҳо 
 мусбат аст”, муайян карда шавад. 
 PascalABC.NET C++ 
 Var #include <iostream> 
 a: Integer; using namespace std; 
 y: Boolean; int main() 
 begin { 
 ReadLn(a); int a; 
 y:=a >; boolean y; 
 WriteLn(y); cin >> a; 
 end. y=a >; 
 cout <<y; 
 system("pause"); 
 return; 
 } 
 Python C# 
 a=int(input()) static void Main(string[] args){ 
 y=a> int a; 
 print(y) bool y; 
 a=Convert.ToInt(Console.ReadLine()); 
 y=a >; 
 Console.WriteLine(y); 
 Console.ReadKey(); 
 } 
 Java Go 
 public static void main(String[]args) { package main 
 boolean y; import "fmt" 
 int a; func main() { 
 Scanner sc=new Scanner(System.in); var a int 
 a=sc.nextInt(); var y bool 
 y=a>; fmt.Scanf("%d",&a) 
 System.out.println(y); y=a> 
 } fmt.Println(y) 
 } 
 “Нобаробарии A ≥ ё B<- дуруст аст», муайян карда шавад. 
 PascalABC.NET C++ 
 Var #include <iostream> 
 A, B: integer; using namespace std; 
 y: boolean; int main() 
 { 
 begin int a,b; 
 ReadLn(A, B); boolean y; 
 y:=(A >=) And (B<-); cin >> a >> b; 
 WriteLn(y); y=((a >=) && (b <-)); 
 end. cout <<y; 
 system("pause"); 
 return; 
 } 
 Python C# 
 a=int(input()) static void Main(string[] args) 
 b=int(input()) { 
 y=(a>=) and (b<-) bool y; 
 print(y) int a, b; 
 a=Convert.ToInt(Console.ReadLine()); 
 b=Convert.ToInt(Console.ReadLine()); 
 y=((a>=) && (b<-)); 
 Console.WriteLine(y); 
 Console.ReadKey(); 
 } 
 Java Go 
 public static void main(String[] package main 
 args) { import "fmt" 
 boolean y; func main() 
 int A, B; { 
 Scanner sc=new Scanner(System.in); var a,b int 
 A=sc.nextInt(); var y bool 
 B=sc.nextInt(); fmt.Scanf("%d %d",&a,&b) 
 y=(A>=)&&(B<-); y=(a>=) && (b<-) 
 System.out.println(y); fmt.Println(y) 
 } } 
 яке аз ададҳои A ва B тоқ мебошад», муайян карда шавад. 
 PascalABC.NET C++ 
 Var #include <iostream> 
 a, b: Integer; using namespace std; 
 y: boolean; int main() 
 begin { 
 ReadLn(a, b); int a, b; 
 y:=Odd(a) And Odd(b); bool y; 
 WriteLn(y); cin >> a>>b; 
 end. y=((a%==)&&(b%==)); 
 cout << y; 
 system("pause"); 
 return; 
 } 
 Python C# 
 a=int(input()) static void Main(string[] args) { 
 b=int(input()) int a, b; 
 y=((a%==)) && bool y; 
 ((a%==)); a=Convert.ToInt(Console.ReadLine()); 
 print(y) b=Convert.ToInt(Console.ReadLine()); 
 y=((a%==)) && ((a%==)); 
 Console.WriteLine(y); 
 Console.ReadKey(); 
 } 
 Java Go 
 public static void main(String[] package main 
 args) { import ("fmt") 
 boolean y; func main() { 
 int a, b; var a,b int 
 Scanner sc=new Scanner( var y bool 
 System.in); fmt.Scanf("%d %d",&a,&b) 
 a=sc.nextInt(); y=((a%==)&&(b%==)); 
 b=sc.nextInt(); fmt.Println(y) 
 y=((a%==)&&(b%==)); } 
 System.out.println(y); 
 } 
 яке аз ададҳои A ва B тоқ мебошанд», муайян карда шавад. 
 PascalABC.NET C++ 
 Var #include <iostream> 
 a, b: Integer; using namespace std; 
 y: boolean; int main() 
 begin { 
 ReadLn(A, B); int a, b; 
 WriteLn(Odd(A) Xor Odd(B)); bool y; 
 end. cin >> a >> b; 
 y=((b%==) 
 &&(a%==))|| 
 ((a%==)&&(b%==)); 
 cout << y<<endl; 
 system("pause"); 
 return; 
 } 
 Python C# 
 a=int(input()) static void Main(string[] args){ 
 b=int(input()) int a, b; 
 y=(a%)+(b%)== bool y; 
 print(y) a=Convert.ToInt(Console.ReadLine()); 
 b=Convert.ToInt(Console.ReadLine()); 
 y=((b%==) &&(a%==))|| 
 ((a%==)&&(b%==)); 
 Console.WriteLine(y); 
 Console.ReadKey(); 
 } 
 Java Go 
 public static void main(String[] package main 
 args) { import "fmt" 
 boolean y; func main() { 
 int a, b; var a,b int 
 Scanner ab=new Scanner var y bool 
 (System.in); fmt.Scanf("%d %d",&a,&b) 
 a= ab.nextInt(); y=((a%==)&&(b%==))|| 
 b= ab.nextInt(); ((a%==)&&(b%==)); 
 y=((a%==)&&(b%==))|| fmt.Println(y) 
 ((a%==)&&(b%==)); } 
 System.out.println(y); 
 } 
 додашуда, адади дурақамаи ҷуфт аст”, муайян намоед. 
 PascalABC.NET C++ 
 Var #include <iostream> 
 A: Integer; using namespace std; 
 y: Boolean; int main() 
 { 
 begin int a; 
 ReadLn(a); cin >> a; 
 y:=((a>=) And (a<)) bool y; 
 And not Odd(a); y=(((a>)&&(a<))&&(a%==)); 
 WriteLn(y); cout <<y; 
 end. system("pause"); 
 return; 
 } 
 Python C# 
 a=int(input()) static void Main(string[] args){ 
 y=((a>) and (a<)) int a; 
 and (a%==) bool y; 
 print(y) a=Convert.ToInt(Console.ReadLine()); 
 y=((a > ) && (a < )) && (a%==); 
 Console.WriteLine(y); 
 Console.ReadKey(); 
 } 
 Java Go 
 public static void main( package main 
 String[] args) { import "fmt" 
 boolean y; func main() 
 int a; { 
 Scanner sc=new Scanner var a int 
 (System.in); var y bool 
 a=sc.nextInt(); fmt.Scanf("%d",&a) 
 y=(a>)&&(a<)&&(a%==); y=(a>)&&(a<)&&(a%==); 
 System.out.println(y); fmt.Println(y) 
 } } 
 аққалан дутои онҳо як хелаанд», муайян карда шавад. 
 PascalABC.NET C++ 
 Var #include <iostream> 
 a, b, c: Integer; using namespace std; 
 y: Boolean; int main() 
 { 
 begin int a, b, c; 
 ReadLn(a, b, c); cin >> a >> b >> c; 
 y:=(a=b) Or (b=c) Or bool y=((a==b)||(b==c)||(a==c)); 
 (a=c); cout <<y<<endl; 
 WriteLn(y); system("pause"); 
 end. return; 
 } 
 Python C# 
 a=int(input()) static void Main(string[] args){ 
 b=int(input()) int a, b, c; 
 c=int(input()) bool y; 
 y=(a==b) or (a==c) a=Convert.ToInt(Console.ReadLine()); 
 or (b==c) b=Convert.ToInt(Console.ReadLine()); 
 print(y) c=Convert.ToInt(Console.ReadLine()); 
 y=(a==b)||(a==c) || (b==c); 
 Console.WriteLine(y); 
 Console.ReadKey(); 
 } 
 Java Go 
 public static void package main 
 main(String[] args) { import "fmt" 
 boolean y; func main() { 
 int a, b,c; var a,b,c int 
 Scanner sc=new Scanner( var y bool 
 System.in); fmt.Scanf("%d %d %d",&a,&b,&c) 
 a=sc.nextInt(); y=(a==b)||(b==c)||(c==a); 
 b=sc.nextInt(); fmt.Println(y) 
 c=sc.nextInt(); } 
 y=(a==b)||(b==c)|| 
 (c==a); 
 System.out.println(y); 
 } 
 рақамҳои адади дода шуда гуногун мебошанд», муайян карда шавад. 
 PascalABC.NET C++ 
 Var #include <iostream> 
 a,b,c,n: Integer; using namespace std; 
 y: Boolean; int main() 
 begin { 
 ReadLn(n); int n,a, b,c; 
 a:=n Div; bool y; 
 b:=((n Mod ) Div ); cin >>n; 
 c:=(n Mod ); a=n/; 
 y:=(a<>b) And (b<>c) And b=(n%)/; 
 (a<>c); c=n%; 
 WriteLn(y); bool 
 end. y=(a!=b)&&(b!=c)&&(a!=c); 
 cout<<y<<endl; 
 system("pause"); 
 return; 
 } 
 Python C# 
 n=int(input()) static void Main(string[] args){ 
 a=n //; int n,a, b, c; 
 b=(n%)//; bool y; 
 c=n%; n=Convert.ToInt(Console.ReadLine()); 
 y=(a!=b) and (b!=c) a=n //; 
 and (a!=c); b=(n%)//; 
 print(y) c=n%; 
 y=(a!=b) and (b!=c); 
 Console.WriteLine(y); 
 Console.ReadKey(); 
 } 
 Java Go 
 public static void main(String[] package main 
 args) { import "fmt" 
 int a, b,c,n; func main() { 
 Scanner sc=new Scanner var a,b,c,n int 
 (System.in); var y bool 
 n=sc.nextint(); fmt.Scanf("%d",&n) 
 a=n/; a=n/; 
 b=(n%)/; b=(n%)/; 
 c=n%; c=n%; 
 y=(a!=b)&&(b!=c)&&(c!=a); y=(a!=b)&&(b!=c)&&(c!=a); 
 System.out.println(y); fmt.Println(y) 
 } } 
 дискриминанти 𝐷 = 𝑏 − 𝑎𝑐, мулоҳизаи зеринро санҷед: “Муодилаи 
 квадратии 𝐴𝑥 + 𝐵𝑥 + 𝐶 = ҳалли ҳақиқӣ дорад”. 
 PascalABC.NET C++ 
 Var #include <iostream> 
 a, b, c, d: real; using namespace std; 
 y: Boolean; int main() 
 begin { 
 ReadLn(a, b, c); double a, b, c, d; 
 d:=Sqr(b)-*a*c; bool y; 
 y:=(d>=); cin >> a >> b >> c; 
 WriteLn(y); d=b*b-*a*c; 
 end. y=(d>=); 
 cout <<y; 
 system("pause"); 
 return; 
 } 
 Python C# 
 a=float(input()) static void Main(string[] args){ 
 b=float(input()) bool y; 
 c=float(input()) double a, b, c, d; 
 d=b*b-*a*c a=Convert.ToSingle(Console.ReadLine()); 
 y=d>= b=Convert.ToSingle(Console.ReadLine()); 
 print(y) c=Convert.ToSingle(Console.ReadLine()); 
 d=b*b-*a*c; 
 y=(d >=); 
 Console.WriteLine(y); 
 Console.ReadKey(); 
 } 
 Java Go 
 public static void main(String[] package main 
 args) { import "fmt" 
 bool y; func main() { 
 var a,b,c int 
 double a, b, c, d; 
 Scanner sc=new Scanner (System.in); var y bool 
 a=sc.nextInt(); fmt.Scanf("%d %d %d", 
 b=sc.nextInt(); &a,&b,&c) 
 c=sc.nextInt(); var d=b*b-*a*c; 
 d=b*b-*a*c; y=(d >=); 
 y=(d >=); fmt.Println(y) 
 System.out.println(y); } 
 } 
 координатаҳояш (𝑥,𝑦) дар чоряки дуюми системаи ҳамвории 
 координатӣ мехобад”, муайян карда шавад. 
 PascalABC.NET C++ 
 Var #include <iostream> 
 x, y: Real; using namespace std; 
 z:Boolean; int main(){ 
 double x, y; 
 begin bool z; 
 ReadLn(x, y); cin >> x >> y; 
 z:=(x<=) And (y >=); z=((x <=) && (y >=)) 
 WriteLn(z); cout<<z; 
 end. system("pause"); 
 return; 
 } 
 Python C# 
 x=int(input("x:")) static void Main(string[] args){ 
 y=float(input("y:")) bool z; 
 z=(x<) and (y>) int x,y; 
 print(z) x=Convert.ToInt(Console.ReadLine()); 
 y=Convert.ToInt(Console.ReadLine()); 
 z=(x < ) && (y > ); 
 Console.WriteLine(z); 
 Console.ReadKey(); 
 } 
 Java Go 
 public static void main(String[] package main 
 args) { import "fmt" 
 boolean z; func main() { 
 double x,y; var x,y int 
 Scanner sc=new Scanner var z bool 
 (System.in); fmt.Scanf("%d %d",&x,&y) 
 x=sc.nextDouble(); z=(x<)&&(y>); 
 y=sc.nextDouble(); fmt.Println(z) 
 z=(x<)&&(y>); 
 System.out.println(z); 
 } 
 “Нуқтаи координатаҳояш (x,y) дар росткунҷае мехобад, ки 
 координатаҳои қуллаи болоии тарафи росташ (𝑥,𝑦 ), координатаҳои 
 қуллаи поёнии тарафи чапаш (𝑥,𝑦 ) мебошанд ва тарафҳояш ба 
 тирҳои координатӣ паралеланд”, муайян карда шавад. 
 PascalABC.NET C++ 
 Var #include <iostream> 
 x, y, x, y, x, y: using namespace std; 
 Real; int main() 
 z: Boolean; { 
 float x, y, x, y, x, y; 
 begin bool z; 
 ReadLn(x, y); cin >> x >> y; 
 ReadLn(x, y); cin >> x >> y; 
 ReadLn(x, y); cin >> x >> y; 
 z:=(y < y) And (y > y) z=((y < y) && (y > y) && 
 And (x > x) And (x < x); (x > x) && (x < x)); 
 WriteLn(z); cout <<z; 
 end. system("pause"); 
 return; 
 } 
 Python C# 
 x=float(input( )) static void Main(string[] args){ 
 y=float(input( )) bool z; 
 double x, x, x, y, y, y; 
 x=float(input( )) x=Convert.ToDouble(Console.ReadLine()); 
 y=float(input( )) x=Convert.ToDouble(Console.ReadLine()); 
 x=Convert.ToDouble(Console.ReadLine()); 
 x=float(input( )) 
 y=Convert.ToDouble(Console.ReadLine()); 
 x=float(input( )) 
 y=Convert.ToDouble(Console.ReadLine()); 
 z=((x<x) and (x<x) and y=Convert.ToDouble(Console.ReadLine()); 
 (y < y) and (y < y)) z=((x<x) && (x<x) && (y<y) && (y<y)); 
 print(z) Console.Write(z); 
 Console.ReadKey(); 
 } 
 Java 
 public static void main(String[]args) { 
 boolean z; 
 int x,x,x,y,y,y; 
 Scanner sc=new Scanner(System.in); 
 x=sc.nextInt(); 
 x=sc.nextInt(); 
 x=sc.nextInt(); 
 y=sc.nextInt(); 
 y=sc.nextInt(); 
 y=sc.nextInt(); 
 z=(x<x)&&(x<x)&&(y<y)&&(y<y); 
 System.out.println(z); 
 } 
 GO 
 package main 
 import "fmt" 
 func main() { 
 var x,x,y,y,x,y int 
 var z bool 
 fmt.Scanf("%d %d %d %d %d %d",&x,&x,&y,&y,&x,&y) 
 z=(x<x)&&(x<x)&&(y<y)&&(y<y); 
 fmt.Println(z) 
 } 
 ифода мекунанд. Дурустии мулоҳизаи “Секунҷаи додашуда, 
 секунҷаи баробарпаҳлӯ аст», муайян карда шавад. 
 PascalABC.NET C++ 
 Var #include <iostream> 
 a,b,c: Real; using namespace std; 
 z: Boolean; int main() 
 { 
 begin int a, b, c; 
 ReadLn(a,b,c); bool z; 
 z:=(a=b) or (b=c) or (c=a); cin >> a >> b >> c; 
 WriteLn(z); z=((a==b)||(b==c)||(c==a)); 
 end. cout << z; 
 system("pause"); 
 return; 
 } 
 Python C# 
 a=float(input( )) static void Main(string[] args) 
 b=float(input( )) { 
 c=float(input( )) bool z; 
 z=(a==b) or (b==c) int a, b, c; 
 or (c==a) a=Convert.ToInt(Console.ReadLine()); 
 print(z) b=Convert.ToInt(Console.ReadLine()); 
 c=Convert.ToInt(Console.ReadLine()); 
 y=((a==b)||(b==c)&&(c==a)); 
 Console.Write(y); 
 Console.ReadKey(); 
 } 
 Java Go 
 public static void main(String[] package main 
 args) { import ("fmt" 
 boolean z; ) 
 int a,b,c; func main() { 
 Scanner sc=new Scanner( var a,b,c int 
 System.in); var z bool 
 a=sc.nextInt(); fmt.Scanf("%d %d %d", 
 b=sc.nextInt(); &a,&b,&c) 
 c=sc.nextInt(); z=(a==b)||(b==c)||(c==a); 
 z=(a==b) ||(b==c) ||(c==a); fmt.Println(z) 
 System.out.println(z); } 
 } 
 (ададҳои бутуни аз то қимат қабул мекунад). Бо дар назардошти 
 он ки тарафи чапи поёнии майдон (.) сиёҳ мебошад, дурустии 
 мулоҳизаи “майдони додашуда сафед аст”, муайян кунед. 
 PascalABC.NET C++ 
 Var #include <iostream> 
 var using namespace std; 
 x, y: Integer; int main() 
 z:Boolean; { 
 int x, y; 
 begin bool z; 
 ReadLn(x, y); cin >> x >> y; 
 z:=not ((y+x) Mod =); z=!((x+y)%==); 
 WriteLn(z); cout <<z; 
 end. system("pause"); 
 return; 
 } 
 Python C# 
 x=int(input( )) static void Main(string[] args) 
 y=int(input( )) { 
 z=(x+y)%== bool z; 
 int x, y; 
 print(z) 
 x=Convert.ToInt(Console.ReadLine()); 
 y=Convert.ToInt(Console.ReadLine()); 
 z=(x+y)%==; 
 Console.Write(z); 
 Console.ReadKey() 
 } 
 Java Go 
 public static void main( package main 
 String[] args) { import "fmt" 
 boolean z; func main() 
 int x,y; { 
 Scanner sc=new Scanner( var x,y int 
 System.in); var z bool 
 x=sc.nextInt(); fmt.Scanf("%d %d",&x,&y) 
 y=sc.nextInt(); z=(x+y)%==; 
 z=(x+y)%==; fmt.Println(z) 
 System.out.println(z); } 
 } 
 (ададҳои бутуни дар фосилаи аз то ) дода шудааст. Дурустии 
 мулоҳизаи “Рух бо як амал (ход) метавонад аз як майдон ба майдони 
 дигар гузарад”, муайян карда шавад. 
 PascalABC.NET C++ 
 Var #include <iostream> 
 x, y, x, y: Integer; using namespace std; 
 z: Boolean; int main() 
 { 
 begin int x, x, y, y; 
 ReadLn(x, y); bool z; 
 ReadLn(x, y); cin>>x>>y>>x>>y; 
 z:=(x=x) Or (y=y); z=((x==x)||(y==y)); 
 WriteLn(z); cout<<z; 
 end. system("pause"); 
 return; 
 } 
 Python C# 
 x=int(input( )) static void Main(string[] args){ 
 y=int(input( )) int x, x, y, y; 
 bool z; 
 x=int(input( )) 
 x=Convert.ToInt(Console.ReadLine()); 
 y=int(input( )) 
 y=Convert.ToInt(Console.ReadLine()); 
 z=(x==x) or (y==y) x=Convert.ToInt(Console.ReadLine()); 
 print(z) y=Convert.ToInt(Console.ReadLine()); 
 z=(x==x) || (y==y); 
 Console.WriteLine(z); 
 Console.ReadKey(); 
 } 
 Java Go 
 public static void main(String[] package main 
 args) { import "fmt" 
 boolean z; func main() { 
 int x, x, y, y; var x,x,y,y int 
 Scanner sc=new Scanner( var z bool 
 System.in); fmt.Scanf("%d %d %d %d", 
 x=sc.nextInt(); &x,&x,&y,&y) 
 y=sc.nextInt(); z=(x==x) || (y==y); 
 x=sc.nextInt(); fmt.Println(z) 
 y=sc.nextInt(); } 
 z=(x==x) || (y==y); 
 System.out.println(z); 
 } 
 Масъалаҳо барои кори мустақилона 
 адади тоқ аст», муайян карда шавад. 
 адади ҷуфт аст», муайян карда шавад. 
 “Нобаробарии A > ё B≤ дуруст аст», муайян карда шавад. 
 “Нобаробарии дукаратаи A<B<C дуруст аст», муайян карда шавад. 
 “Адади B дар байни ададҳои A ва C воқеъ аст», муайян карда шавад. 
 “Аққалан яке аз ададҳои A ва B тоқ мебошад», муайян карда шавад. 
 “Ададҳои A ва B дар як вақт ё ҷуфт ё тоқ мебошанд», муайян карда 
 шавад. 
 “Аққалан яке аз ададҳои A, B ва C мусбат мебошад», муайян карда 
 шавад. 
 яке аз ададҳои A, B ва C мусбат мебошад», муайян карда шавад. 
 “Расо яке аз ададҳои A, B ва C мусбат мебошад», муайян карда шавад. 
 ду адад аз ададҳои A, B, C мусбат мебошад”, муайян намоед. 
 додашуда адади серақамаи тоқ аст», муайян карда шавад. 
 аққалан дутои онҳо байни ҳам муқобиланд», муайян карда шавад. 
 адади дода шуда пайдарпай афзуншавандаро ифода менамояд», 
 муайян карда шавад. 
 адади дода шуда пайдарпай афзуншаванда ё камшавандаро ташкил 
 менамояд», муайян карда шавад. 
 адади додашуда аз чап ба рост ва аз рост ба чап як хел хонда 
 мешавад», муайян карда шавад. 
 координатаҳояш (𝑥,𝑦) дар чоряки чоруми системаи координатӣ 
 мехобад”, муайян карда шавад. 
 координатаҳояш (𝑥,𝑦) дар чоряки дуюми ё сеюми системаи 
 координатӣ мехобад”, муайян карда шавад. 
 координатаҳояш (x,y) дар чоряки якум ё сеюми системаи координатӣ 
 мехобад”, муайян карда шавад. 
 ифода мекунанд. Дурустии мулоҳизаи “Секунҷаи додашуда 
 баробартараф аст», муайян карда шавад. 
 ифода мекунанд. Дурустии мулоҳизаи “Секунҷаи додашуда, 
 секунҷаи росткунҷа аст», муайян карда шавад. 
 тарафҳояш 𝑎,𝑏,𝑐 мавҷуд аст», муайян карда шавад. 
 (ададҳои бутуни дар фосилаи аз то ) дода шудааст. Дурустии 
 мулоҳизаи “Майдонҳои додашуда рангҳои якхела доранд”, муайян 
 карда шавад. 
 (ададҳои бутуни дар фосилаи аз то ) дода шудааст. Дурустии 
 мулоҳизаи “Шоҳ бо як ҳаракат (ход) аз як майдон ба майдони дигар 
 гузашта метавонад”, муайян карда шавад. 
 (ададҳои бутуни дар фосилаи аз то ) дода шудааст. Дурустии 
 мулоҳизаи “Фил бо як ҳаракат (ход) аз як майдон ба майдони дигар 
 гузашта метавонад”, муайян карда шавад. 
 (ададҳои бутуни дар фосилаи аз то ) дода шудааст. Дурустии 
 мулоҳизаи “Фарзин бо як ҳаракат (ход) аз як майдон ба майдони 
 дигар гузашта метавонад”, муайян карда шавад. 
 (ададҳои бутуни дар фосилаи аз то ) дода шудааст. Дурустии 
 мулоҳизаи “Асп бо як ҳаракат (ход) аз як майдон ба майдони дигар 
 гузашта метавонад”, муайян карда шавад. 
 Масъалаҳои гуруҳи if 
 PascalABC.Net, C++, C#, Python, Java ва GO-ро аз [-] азбар намоед. 
 Python, Java ва GO нависед. 
 Намунаи ҳалли масъалаҳо 
 ҳамроҳ карда шавад, дар акси ҳол бетағйир гузошта шавад. Адади 
 ҳосилшуда чоп карда шавад. 
 PascalABC.NET C++ 
 Var #include <iostream> 
 a: Integer; using namespace std; 
 int main() 
 begin { 
 ReadLn(a); int a; 
 if a > Then cin>>a; 
 a:=a+; if (a>) 
 WriteLn(a); a=a+; 
 end. cout<<a<<endl; 
 system("pause"); 
 return; 
 } 
 Python C# 
 a=int(input( )) static void Main(string[] args){ 
 if (a>): int a; 
 a=a+ a=Convert.ToInt(Console.ReadLine()); 
 if (a>) 
 print(a) 
 a=a+; 
 Console.WriteLine (a); 
 Console.ReadKey(); 
 } 
 Java Go 
 public static void main(String[] args) { package main 
 int a; import "fmt" 
 Scanner sc=new Scanner(System.in); func main() { 
 a=sc.nextInt(); var a int 
 if(a>) fmt.Scanf("%d",&a) 
 a=a+; if a>{ 
 System.out.println(a); a=a+ 
 } } 
 fmt.Println(a) 
 } 
 ҳамроҳ карда шавад, дар акси ҳол аз он тарҳ карда шавад. Адади 
 ҳосилшуда чоп карда шавад. 
 PascalABC.NET C++ 
 Var #include <iostream> 
 a: Integer; using namespace std; 
 int main() 
 begin { 
 ReadLn(a); int a; 
 if a > Then cin>>a; 
 a:=a+; if (a > ) 
 Else a=a+; 
 a:=a-; else 
 WriteLn(a); a=a-; 
 end. cout<<a<<endl; 
 system("pause"); 
 return; 
 } 
 Python C# 
 a=int(input( )) static void Main(string[] args){ 
 if (a>): int a; 
 a=a+ a=Convert.ToInt(Console.ReadLine()); 
 else: if (a > ) 
 a=a- a=a+; 
 print(a) else 
 a=a-; 
 Console.WriteLine (a); 
 Console.ReadKey(); 
 } 
 Java Go 
 public static void main(String[] args) package main 
 { import "fmt" 
 int a; func main() { 
 Scanner sc=new Scanner(System.in); var a int 
 a=sc.nextInt(); fmt.Scanf("%d", &a) 
 if(a>) if a>{ 
 a=a+; a+= 
 else }else{ 
 a=a-; a=a- 
 System.out.println(a); } 
 } fmt.Println(a) 
 } 
 карда шавад; агар адад манфӣ бошад, аз он кам карда шавад; агар 
 адад нол бошад он бо иваз карда шавад. Адади ҳосилшуда чоп 
 карда шавад. 
 PascalABC.NET C++ 
 Var #include <iostream> 
 a: Integer; using namespace std; 
 int main() 
 begin { 
 ReadLn(a); int a; 
 if a > Then cin>>a; 
 a:=a+; if (a>) 
 Else a=a+; 
 if a < Ten else if (a<) 
 a:=a –; a=a-; 
 Else else 
 a:= a=; 
 WriteLn(a); cout<<a<<endl; 
 end. system("pause"); 
 return; 
 } 
 Python C# 
 a=int(input( )) static void Main(string[] args) 
 if (a>): { 
 a=a+ int a; 
 elif (a<): a=Convert.ToInt(Console.ReadLine()); 
 a=a- if (a > ) 
 else: a=a+; 
 a= else if (a < ) 
 print(a) a=a-; 
 else 
 a=; 
 Console.WriteLine (a); 
 Console.ReadKey(); 
 } 
 Java Go 
 public static void main(String[] args) package main 
 { import "fmt" 
 int a; func main() 
 Scanner sc=new Scanner(System.in); { 
 a=sc.nextInt(); var a int 
 if(a>){ fmt.Scanf("%d", &a) 
 a=a+;} if a>{ 
 else if (a<) a+= 
 a=a-; }else if a<{ 
 else a=a- 
 a=; }else{ 
 System.out.println(a); a= 
 } } 
 fmt.Println(a) 
 } 
 кардашуда, муайян карда шавад. 
 PascalABC.NET C++ 
 Var #include <iostream> 
 a,b,c, k: Integer; using namespace std; 
 begin int main() 
 k:=; { 
 ReadLn(a, b, c); int a, b, c, k=; 
 if a > Then cin >> a >> b >> c; 
 k:=k+; if(a > ) k++; 
 if b > Then if(b > ) k++; 
 k:=k+; if(c > ) k++; 
 if c > Then cout << k << endl; 
 k:=k+; system("pause"); 
 WriteLn(k); return; 
 end. } 
 Python C# 
 a=int(input( )) static void Main(string[] args) 
 b=int(input( )) { 
 c=int(input( )) int a, b, c, k=; 
 a=Convert.ToInt(Console.ReadLine()); 
 k=; 
 b=Convert.ToInt(Console.ReadLine()); 
 if (a>): 
 c=Convert.ToInt(Console.ReadLine()); 
 k+= 
 if (a > ) 
 if (b>): 
 k++; 
 k+= 
 if (b > ) 
 if (c>): 
 k++; 
 k+= if (c>) 
 print(k) k++; 
 Console.WriteLine (k); 
 Console.ReadKey(); 
 } 
 Java Go 
 public static void main(String[]args) package main 
 { import "fmt" 
 int a,b,c,k=; func main() 
 Scanner sc=new Scanner (System.in); { 
 a=sc.nextInt(); var a,b,c int 
 b=sc.nextInt(); var k int 
 c=sc.nextInt(); fmt.Scanf("%d %d %d", 
 if(a>) &a,&b,&c) 
 k++; if(a>){ 
 if(b>) k+= 
 k++; } 
 if(c>) if(b>){ 
 k++; k+= 
 System.out.println(k); } 
 } if(c>){ 
 k+=} 
 fmt.Println(k) 
 } 
 PascalABC.NET C++ 
 Var Варианти. 
 a, b: Integer; #include <iostream> 
 using namespace std; 
 begin int main(){ 
 ReadLn(a, b); int a,b; 
 if a > b Then cin>>a>>b; 
 WriteLn(a) if(a > b) 
 Else cout<<a<<endl; 
 WriteLn(b); else 
 end. cout<<b<<endl; 
 system("pause"); 
 return; 
 } 
 Варианти. 
 #include <iostream> 
 using namespace std; 
 int main(){ 
 int a,b,mx; 
 cin>>a>>b; 
 mx=a>b?a:b; 
 cout<<mx<<endl; 
 system("pause"); 
 return; 
 } 
 Python C# 
 a=int(input( )) static void Main(string[] args){ 
 b=int(input( )) int a, b; 
 if (a>b): a=Convert.ToInt(Console.ReadLine()); 
 b=Convert.ToInt(Console.ReadLine()); 
 print(a) 
 if (a > b) 
 else: 
 Console.WriteLine (a); 
 print(b) 
 else 
 Console.WriteLine (b); 
 Console.ReadKey(); 
 } 
 Java Go 
 public static void main(String[] args) { package main 
 int a,b; import "fmt" 
 Scanner sc=new Scanner(System.in); func main(){ 
 a=sc.nextInt(); var a,b int 
 b=sc.nextInt(); fmt.Scanf("%d %d", 
 if(A>B) &a,&b) 
 System.out.println(a); if a > b { 
 else fmt.Println(a); 
 System.out.println(b); } 
 } if a<b { 
 fmt.Println(b) 
 } 
 } 
 тағйирёбандаҳоро чунон иваз кунед, ки дар А қиматҳи хурд ва дар B 
 қимати калон ҷойгир шавад. Қимати нави тағйирёбандаҳои A ва B 
 хориҷ карда шавад. 
 PascalABC.NET C++ 
 Var #include <iostream> 
 a, b: Real; using namespace std; 
 int main() 
 begin { 
 ReadLn(a, b); int a,b,с; 
 if a < b Then cin>>a>>b; 
 begin if (a<b){ 
 (a,b):=(b,a) с=a; 
 end; a=b; 
 WriteLn(a, ' ', b); b=с; 
 end. } 
 cout<<a<<" "<<b<<endl; 
 system("pause"); 
 return; 
 } 
 Python C# 
 a=int(input( )) static void Main(string[] args){ 
 b=int(input( )) int a, b, с; 
 if (a>b): a=Convert.ToInt(Console.ReadLine()); 
 b=Convert.ToInt(Console.ReadLine()); 
 (a,b)=(b,a) 
 if(a>b){ 
 print(a,' ',b) 
 c=b; 
 b=a; 
 a=c; 
 } 
 Console.WriteLine(a+" "+b); 
 } 
 Java Go 
 public static void main(String[] args) package main 
 { import "fmt" 
 int a,b,c; func main() 
 Scanner sc=new Scanner (System.in); { 
 a=sc.nextInt(); var a,b,c int 
 b=sc.nextInt(); fmt.Scanf("%d %d", 
 if(a>b){ &a,&b) 
 c=b; if(a>b){ 
 b=a; c=b; 
 a=c; b=a; 
 } a=c; 
 System.out.println(a+" "+b); } 
 } fmt.Println(a," ",b) 
 } 
 PascalABC.NET C++ 
 Var #include <iostream> 
 a, b, c, mn: Real; using namespace std; 
 int main() 
 begin { 
 ReadLn(a, b, c); int a,b,c,mn; 
 mn:=a; cin>>a>>b>>c; 
 if mn > b Then mn=a; 
 mn:=b; if (mn>b) 
 if mn > c then mn=b; 
 mn:=c; if (mn>c) 
 WriteLn(Mn) mn=c; 
 end. cout<<mn<<endl; 
 system("pause"); 
 return; 
 } 
 Python C# 
 a=int(input( )) static void Main(string[] args){ 
 b=int(input( )) int a, b, c, mn; 
 c=int(input( )) a=Convert.ToInt(Console.ReadLine()); 
 mn=a b=Convert.ToInt(Console.ReadLine()); 
 if (mn>b): c=Convert.ToInt(Console.ReadLine()); 
 mn=b mn=a; 
 if (mn>c): if (mn>b) 
 mn=c; mn=b; 
 print(mn) if (mn>c) 
 mn=c; 
 Console.WriteLine(mn); 
 Console.ReadKey(); 
 } 
 Java Go 
 public static void main(String[] args) package main 
 { import "fmt" 
 int a,b,c,mn; func main() { 
 var a,b,c,mn int 
 Scanner sc=new Scanner (System.in); 
 fmt.Scanf("%d %d %d", 
 a=sc.nextInt(); 
 &a,&b,&c) 
 b=sc.nextInt(); 
 mn=a; 
 c=sc.nextInt(); 
 if mn>b{ 
 mn=a; 
 mn=b; 
 if (mn>b) 
 } 
 mn=b; if mn>c { 
 if (mn>c) mn=c; 
 mn=c; } 
 System.out.println(mn); fmt.Println(mn) 
 } } 
 онҳо ба таври афзуншавӣ ҷойгир бошад, онгоҳ қимати онҳоро 
 дучанд намоед, дар акси ҳол ҳар як қимати тағйирёбандаҳоро ба 
 қимати баръакси он иваз намоед. Қимати нави тағйирёбандаҳои A, 
 B, C – ро хориҷ кунед. 
 PascalABC.NET C++ 
 Var #include <iostream> 
 a,b,c: Real; using namespace std; 
 int main() 
 begin { 
 ReadLn(a,b,c); int a,b,c; 
 if (a<b) And (b<c) Then cin>>a>>b>>c; 
 begin if ((a < b)&&(b < c)) { 
 a:=a*; a*=; 
 b:=b*; b*=; 
 c:=c*; c*=; } 
 end else { 
 Else a*=-; 
 begin b*=-; 
 a:=-a; c*=-; 
 b:=-b; } 
 c:=-c; cout<<a<<" "<<b<<" "<<c<<endl; 
 end; system("pause"); 
 WriteLn(a,' ',b,' ',c); return; 
 end. } 
 Python C# 
 a=int(input( )) static void Main(string[] args){ 
 b=int(input( )) int a, b, c; 
 c=int(input( )) a=Convert.ToInt(Console.ReadLine( )); 
 if (a<b<c): b=Convert.ToInt(Console.ReadLine( )); 
 a=a* c=Convert.ToInt(Console.ReadLine( )); 
 b=b* if ((a < b) && (b < c)){ 
 c=c* a=a*; 
 else: b=b*; 
 a=-a c=c*; 
 b=-b } 
 c=-c else{ 
 print(a,' ',b,' ',c) a=-a; 
 b=-b; 
 c=-c; 
 } 
 Console.WriteLine(a); 
 Console.ReadKey(); 
 } 
 Java Go 
 public static void main(String[] package main 
 args) { import "fmt" 
 int a,b,c; func main() { 
 Scanner sc=new Scanner var a,b,c int 
 (System.in); fmt.Scanf("%d %d %d", 
 a=sc.nextInt(); &a,&b,&c) 
 b=sc.nextInt(); if((a<b)&&(b<c)){ 
 c=sc.nextInt(); a=a*; 
 if((a<b)&&(b<c)){ b=b*; 
 a=a*; c=c*; 
 b=b*; }else{ 
 c=c*; a=-a; 
 } b=-b; 
 else{ c=-c; 
 a=-a; } 
 b=-b; fmt.Println(a," ",b,"",c) 
 c=-c; } 
 } 
 System.out.println(a+" "+b+" "+c); 
 якеашон фарқ мекунад. Рақами тартибии адади фарқкунандаро 
 хориҷ кунед. 
 PascalABC.NET C++ 
 Var #include <iostream> 
 a,b,c: Real; using namespace std; 
 int main() 
 begin { 
 Readln(a,b,c); SetConsoleCP(); 
 SetConsoleOutputCP(); 
 if b=c then int a, b, c, n; 
 Writeln(''); cin >> a>>b>>c; 
 if a=c then if (b==c) 
 Writeln(''); n=; 
 if a=b then else if (a==c ) 
 Writeln(''); n=; 
 end. else if (a==b ) 
 n=; 
 cout << n << endl; 
 system("pause"); 
 return; 
 } 
 Python C# 
 a=int(input( )) static void Main(string[] args){ 
 b=int(input( )) int a, b, c; 
 c=int(input( )) a=Convert.ToInt(Console.ReadLine( )); 
 b=Convert.ToInt(Console.ReadLine( )); 
 if (b==c): 
 c=Convert.ToInt(Console.ReadLine( )); 
 n=; 
 if ((a==b) && (b!=c)) 
 if (a==c): 
 Console.WriteLine(); 
 k=; 
 elseif ((a==c) && (c!=b)) 
 if (a==b): 
 Console.WriteLine(); 
 k=; 
 else if ((c==b) && (b!=a)) 
 print(k) Console.WriteLine(); 
 Console.ReadKey(); 
 } 
 Java Go 
 public static void main(String[] args) package main 
 { import "fmt" 
 int a,b,c,n=; func main() { 
 Scanner sc=new Scanner (System.in); var a,b,c int 
 a=sc.nextInt(); fmt.Scanf("%d %d %d", 
 b=sc.nextInt(); &a,&b,&c) 
 c=sc.nextInt(); if((a==b)&&(b!=c)){ 
 if((a==b)&&(b!=c)){ fmt.Println() 
 n=; } 
 } if((a==c)&&(c!=b)){ 
 if((a==c)&&(c!=b)){ fmt.Println() 
 n=; } 
 } if((b==c)&&(c!=a)){ 
 if((b==c)&&(c!=a)){ fmt.Println() 
 n=; } 
 } } 
 System.out.println(n); 
 кадоме аз ин ду нуқта (𝑏 ё 𝑐) ба нуқтаи а наздиктар ҷойгир шудааст. 
 Нуқтаи матлуб ва масофаи байни он то нуқтаи а чоп карда шавад. 
 PascalABC.NET C++ 
 Var #include <iostream> 
 a,b,c: Real; using namespace std; 
 int main() 
 begin { 
 ReadLn(a,b,c); int c,b,a; 
 if (b-a) < (c – a) Then cin >>a>>b>>c; 
 WriteLn((b-a)) if ( abs(b-a)>abs(c- 
 Else a)) 
 WriteLn((c-a)); cout<<abs(c-a); 
 end. else 
 cout<<abs(b-a); 
 system("pause"); 
 return; 
 } 
 Python C# 
 from math import sqrt static void Main(string[] args) 
 a=int(input( )) { 
 b=int(input( )) int a, b, c; 
 a=Convert.ToInt(Console.ReadLine()); 
 c=int(input( )) 
 b=Convert.ToInt(Console.ReadLine()); 
 if (abs(b-a)<abs(c-a)): 
 c=Convert.ToInt(Console.ReadLine()); 
 print(b-a) 
 if (Math.abs(b-a)< Math.abs(c-a)) 
 else: 
 Console.WriteLine(b-a); 
 print(c-a) 
 else 
 Console.WriteLine(c-a); 
 Console.ReadKey(); 
 } 
 Java Go 
 public static void main(String[] package main 
 args) { import ("fmt" 
 double a,b,c,s; "math" 
 Scanner sc=new Scanner (System.in); ) 
 a=sc.nextDouble(); func main() { 
 b=sc.nextDouble(); var a,b,c float 
 c=sc.nextDouble(); fmt.Scanf("%v %v %v", 
 if (Math.abs(b-a)< Math.abs(c-a)) &a, &b, 
 System.out.println(b-a); &c) 
 else if(b<c){ 
 System.out.println(c-a); s = m a t h. A b s ( a - b );
 } fmt.Println("B=",s) 
 } 
 if(c<b){ 
 s=math.Abs(a-c); 
 fmt.Println("C=",s) 
 } 
 } 
 Маълум аст, ки тарафҳои росткунҷа бо тирҳои координатӣ 
 параллел мебошанд. Координатаҳои қуллаи чоруми росткунҷа 
 ёфта шавад. 
 PascalABC.NET C++ 
 Var #include <iostream> 
 x,y,x,y,x,y,x,y: using namespace std; 
 integer; int main() 
 { 
 begin int x,y,x,y,x,y,x,y; 
 ReadLn(x,y,x,y,x,y); cin>> x>>y>>x>>y>>x>>y; 
 if x=x Then if (x==x) x=x; 
 x:=x; if (x==x) x=x; 
 if x=x Then if (x==x) x=x; 
 x:=x; if (y==y) y=y; 
 if x=x Then if (y==y) y=y; 
 x:=x; if (y==y) y=y; 
 if y=y Then cout<<x<<" "<<y<<endl; 
 y:=y; system("pause"); 
 if y=y Then return; 
 y:=y; } 
 if y=y Then 
 y:=y; 
 WriteLn(x, ' ', y); 
 end. 
 Python C# 
 x=int(input( )) static void Main(string[] args){ 
 y=int(input( )) int x,y,x,y,x,y,x,y; 
 x=Convert.ToInt(Console.ReadLine( )); 
 x=int(input( )) 
 y=int(input( )) y=Convert.ToInt(Console.ReadLine( )); 
 x=int(input( )) x=Convert.ToInt(Console.ReadLine( )); 
 y=Convert.ToInt(Console.ReadLine( )); 
 y=int(input( )) 
 x=Convert.ToInt(Console.ReadLine( )); 
 if (x==x): 
 y=Convert.ToInt(Console.ReadLine( )); 
 x=x; if (x==x) x=x; 
 if (x==x): if (x==x) x=x; 
 x=x if (x==x) x=x; 
 if (y==y) y=y; 
 if (x==x): 
 if (y==y) y=y; 
 x=x 
 if (y==y) y=y; 
 Console.WriteLine(x+” “+y); 
 if (y==y): } 
 y=y; 
 if (y==y): 
 y=y 
 if (y==y): 
 y=y 
 print(x,' ',y); 
 Java Go 
 public static void main( package main 
 String[] args) { import "fmt" 
 int x,y,x,y,x,y,x,y; func main() { 
 Scanner sc=new Scanner var x,y,x,y,x,y, 
 (System.in); x,y int 
 x=sc.nextInt(); fmt.Scanf("%d %d %d %d %d %d", 
 y=sc.nextInt(); &x,&y,&x,&y,&x,&y) 
 x=sc.nextInt(); if (x==x) {x=x}; 
 y=sc.nextInt(); if (x==x) {x=x;} 
 x=sc.nextInt(); if (x==x) {x=x;} 
 y=sc.nextInt(); if (y==y) {y=y;} 
 if (x==x) x=x; if (y==y) {y=y;} 
 if (x==x) x=x; if (y==y) {y=y;} 
 if (x==x) x=x; fmt.Println(x," ",y) 
 if (y==y) y=y; } 
 if (y==y) y=y; 
 if (y==y) y=y; 
 System.out.println(x+""+y); 
 } 
 −𝑥,агар 𝑥 ≤, 
 𝑓(𝑥) = {𝑥,агар < 𝑥 <,,агар 𝑥 ≥. 
 PascalABC.NET C++ 
 Var #include <cmath> 
 x, y: Real; #include <iostream> 
 using namespace std; 
 begin 
 int main() 
 ReadLn(x); 
 { 
 if x <= Then 
 y:=-x float x,y; 
 Else cin>> x; 
 if (x>) and (x<) if (x<=) 
 Then 
 y=-x; 
 y:=Sqr(x) 
 else if ((<x) && (x<=)) 
 Else 
 y=; 
 y:=; 
 else 
 WriteLn('f(x)=', y); 
 y=sqrt(x); 
 end. 
 cout<<y<<endl; 
 system("pause"); 
 return; 
 } 
 Python C# 
 x=float(input( )) static void Main(string[] args) 
 if (x<=): { 
 y=-x int y, x; 
 elif ((<x) and x=Convert.ToInt(Console.ReadLine()); 
 (x<)): if(x<=) 
 y=x** y=-x; 
 else: else if((<x) && (x<)) 
 y= y=x*x; 
 print(y); else 
 y=; 
 Console.WriteLine(y); 
 Console.ReadKey(); 
 } 
 Java Go 
 public static void main(String[] args) package main 
 { import "fmt" 
 Double x,y=null; func main() 
 Scanner sc=new Scanner(System.in); { 
 x=sc.nextDouble(); var x,y int 
 if(x<=) fmt.Scanf("%d",&x) 
 y=-x; if x<= { 
 else if((<x) && (x<)) y=-x 
 y=x*x; }else if x> && x< { 
 else y=x*x 
 y=; }else{ 
 System.out.println(f); y=} 
 } fmt.Println("F=",y) 
 } 
 дар ин сол бо назардошти, он ки соли одӣ – рӯз дошта, соли 
 қабиса – рӯз дорад, ёфта шавад. Сол қабиса номида мешавад, 
 агар он ба бебақия тақсим шавад, ба истиснои солҳое, ки ба 
 тақсим шуда, ба тақсим намешаванд. (мисол, солҳои, ва 
 солҳои қабиса нестанд ва солҳои ва қабисаанд). 
 PascalABC.NET C++ 
 Var #include <iostream> 
 y: Integer; using namespace std; 
 int main() 
 begin { 
 ReadLn(y); int y; 
 if y Mod = Then cin >>y; 
 begin if (y%==) 
 if (y Mod =) And { 
 (y Mod <> ) Then if ((y%==)&& (y%)!=)) 
 begin cout << ""<<<endl; 
 WriteLn('') else 
 end cout << ""<<endl; 
 Else } 
 WriteLn(''); else 
 end cout << ""<<endl; 
 Else system("pause"); 
 WriteLn(''); return; 
 end. } 
 Python C# 
 y=int(input( )) static void Main(string[] args){ 
 if (y%==): int y; 
 if((y%==) and y=Convert.ToInt(Console.ReadLine()); 
 (y%!=)): if (y%==) 
 print() if ((y%==) && (y%!=)) 
 else: Console.WriteLine(); 
 print() else 
 else: Console.WriteLine(); 
 print(); else 
 Console.WriteLine(); 
 Console.ReadKey(); 
 } 
 Java Go 
 public static void main( package main 
 String[] args) { import "fmt" 
 int y; func main() { 
 Scanner sc=new Scanner( var y int 
 System.in); fmt.Scanf("%d",&y) 
 y=sc.nextInt(); if (y%==){ 
 if (y%==){ if ((y%==)&& (y%)!=) { 
 if ((y%==)&& fmt.Println(""); 
 (y%)!=)) }else { 
 System.out.println(""); fmt.Println(""); 
 else }}else{ 
 System.out.println(""); fmt.Println("") 
 } } 
 else } 
 System.out.println(""); 
 } 
 Масъалаҳо барои кори мустақилона 
 дохил кардашуда, муайян карда шавад. 
 шавад. 
 хориҷ карда шавад. 
 онҳо нобаробар бошанд, он гоҳ ба ҳар яки ин тағйирёбандаҳо 
 суммаи ин бузургиҳо ва дар акси ҳол қимати нол бахшида шавад. 
 Қимати ба дастоварда ва тағйирёбандаҳои 𝑎 ва 𝑏-ро чоп кунед. 
 онҳо нобаробар бошанд, он гоҳ ба ҳар яки ин тағйирёбандаҳо 
 қимати калонтар аз онҳоро бахшед, агар баробар бошанд, он гоҳ ба 
 ин тағйирёбандаҳо қимати нол бахшед. Қиматҳои ба 
 дастовардашудаи тағйирёбандаҳои 𝑎 ва 𝑏 чоп карда шавад. 
 байни адади хурдтарин ва калонтарин ҷойгираст) ёфта шавад. 
 онҳо хориҷ карда шавад. 
 шавад. 
 онҳо бо тартиби афзуншавандагӣ ё камшавандагӣ ҷойгир шуда 
 бошанд, он гоҳ қимати онҳоро дучанд намоед, дар акси ҳол ҳар як 
 қимати тағйирёбандаҳоро ба қимати баръакси онҳо иваз намоед. 
 Қиматҳои нави тағйирёбандаҳои 𝑎,𝑏,𝑐 – ро хориҷ кунед. 
 якеаш аз онҳо фарқ мекунад. Рақами тартибии адади 
 фарқкунандаро хориҷ кунед. 
 нуқта бо ибтидои системаи координат мувофиқ ояд, қимати хориҷ 
 карда шавад. Агар нуқта ба тири O𝑥 ё O𝑦 хобаду аз ибтидои 
 системаи координат фарқ кунад, мувофиқан ё чоп карда шавад. 
 Агар нуқта дар тирҳои координата нахобад, он гоҳ чоп карда 
 шавад. 
 намехобанд, дода шудаанд. Рақами тартибии чоряки координатӣ 
 ёфта шавад, ки дар он ин нуқта мехобад. 
 шавад: 
 sin(𝑥),агар 𝑥 >, 
 𝑓(𝑥) = { 
 − 𝑥,агар 𝑥 ≤. 
 𝑥,агар 𝑥 < − ё 𝑥 >, 
 𝑓(𝑥) = { 
 −𝑥,дар акси ҳол. 
 шавад:,агар 𝑥 <, 
 𝑓(𝑥) = {,агар 𝑥 таълуқ дорад ба [,),[,),…, 
 −,агар 𝑥 таълуқ дорад ба [,),[,),…. 
 навиштаҷотҳои “адади манфии ҷуфт”, “сифр”, “адади мусбати тоқ” 
 ва ғайра, бароварда шавад. 
 “адади дурақамаи тоқ”, “адади серақамаи тоқ” ва ғайра хориҷ карда 
 шавад. 
 Масъалаҳои гуруҳи Case 
 C++, C#, Java ва GO аз [-] азбар намоед. 
 Java ва GO нависед. 
 Қайд. Дар забони Python оператори вариант мавҷуд намебошад. Баъзан 
 ба сифати он аз dictionarys (фарҳангоҳо) истифода мебаранд. 
 Намунаи ҳалли масъалаҳо 
 ҳафта хориҷ (чоп) карда шавад, ки ба адади додашуда мувофиқ аст 
 (-душанбе, – сешанбе, – чоршанбе, – панҷшанбе, – ҷумъа, – 
 шанбе, – якшанбе). 
 PascalABC.NET C++ 
 Var #include <iostream> 
 x: Integer; using namespace std; 
 int main() 
 begin { 
 ReadLn(x); int x; 
 case x Of cin >> x;: switch (x) 
 WriteLn('Dushanbe'); {: case:cout << "Dushanbe" << endl; 
 WriteLn('Seshanbe'); break;: case:cout << "Seshanbe" << endl; 
 WriteLn('Chorshanbe'); break;: case:cout<<"Chorshanbe"<< endl; 
 WriteLn('Panjshanbe'); break;: case:cout <<"Panjshanbe"<<endl; 
 WriteLn('Juma'); break;: case:cout << "Juma" << endl; 
 WriteLn('Shanbe'); break;: case:cout << "Shanbe" << endl; 
 WriteLn('Yakshanbe') break; 
 else case:cout <<"Yakshanbe"<<endl; 
 Writeln('Error'); break; 
 End; default:cout<<"Error"; 
 end. } 
 system("pause"); 
 return; 
 } 
 Python C# 
 def switch_case(case): static void Main(string[] args){ 
 return { int x;: "Душанбе", String S="";: "Сешанбе", x=Convert.ToInt(Console.ReadLine());: "Чоршанбе", switch (x){: "Панчшанбе", case: S="Dushanbe"; break;: "Чумъа", case: S="Seshanbe"; break;: "Шанбе", case: S="Chorshanbe";break;: "Якшанбе" case: S="Panjshanbe";break; 
 }.get(case, "Error") case: S="Juma"; break; 
 x=int(input( )) case: S="Shanbe"; break; 
 print(switch_case(x)) case: S="Yakshanbe";break; 
 default: S="Error");break; 
 } 
 Console.WriteLine(S); 
 } 
 Java 
 public static void main(String[] args) { 
 int x; 
 Scanner sc=new Scanner(System.in); 
 x=sc.nextInt(); 
 switch(x){ 
 case:System.out.println("Dushanbe");break; 
 case:System.out.println("Seshanbe");break; 
 case:System.out.println("Chorshanbe");break; 
 case:System.out.println("Panjshanbe");break; 
 case:System.out.println("Juma");break; 
 case:System.out.println("Shanbe");break; 
 case:System.out.println("Yakshanbe");break; 
 default:System.out.println("Error!");break; 
 } 
 Go 
 package main 
 import "fmt" 
 func main() { 
 var x int 
 fmt.Scanf("%d", &x) 
 switch x { 
 case: 
 fmt.Println("Dushanbe") 
 case: 
 fmt.Println("Seshanbe") 
 case: 
 fmt.Println("Chorshanbe") 
 case: 
 fmt.Println("Panjshanbe") 
 case: 
 fmt.Println("Juma") 
 case: 
 fmt.Println("Shanbe") 
 case: 
 fmt.Println("Yakshanbe") 
 default: 
 fmt.Println("Error") 
 } 
 } 
 шудааст ( – январ, – феврал, – март, – апрел, – май ва ғайра).
 Номи фасли мувофиқи сол чоп карда шавад (“зимистон”, “баҳор”, 
 “тобистон”,“тирамоҳ”). 
 PascalABC.NET C++ 
 Var #include <iostream> 
 m: Integer; using namespace std; 
 int main() 
 begin { 
 Readln(m); int m; 
 case m of cin>> m;,,: switch (m) { 
 Writeln('Zimiston'); case: 
 end; break; 
 end. case: 
 case: 
 case: 
 cout<<"Bahor\n"; 
 break; 
 case: 
 case: 
 case: 
 cout<<"Tobiston\n"; 
 break; 
 case: 
 case: 
 case: 
 cout<<"Tiramoh\n"; 
 break; 
 } 
 system("pause"); 
 return; 
 } 
 Python C# 
 def switch_case(case): static void Main(string[] args){ 
 return { int n; 
 n=Convert.ToInt(Console.ReadLine());:"Зимистон", 
 switch(n){:"Зимистон", 
 case::"Зимистон", case::"Бахор", case: 
 Console.WriteLine("Zimiston" );: "Бахор", 
 break;: "Бахор", 
 case::"Тобистон", case::"Тобистон", case:Console.WriteLine("Bahor");:"Тобистон", break; 
 case::"Тирамох", 
 case::"Тирамох", 
 case::"Тирамох", Console.WriteLine("Tobiston "); 
 }.get(case, "an break; 
 out of range number") case: 
 case: 
 m=int(input( )) 
 case: 
 print(switch_case(m)) 
 Console.WriteLine ("Tiramoh "); 
 break; 
 default:Console.WriteLine ("Error"); 
 break; 
 } 
 Console.ReadKey (); 
 } 
 Java 
 public static void main(String[] args) { 
 int m; 
 Scanner sc=new Scanner(System.in); 
 m=sc.nextInt(); 
 switch(m){ 
 case: 
 case: 
 case:System.out.println("Zimiston");break; 
 case:case: 
 case:System.out.println("Bahor");break; 
 case:case: 
 case:System.out.println("Tobiston");break; 
 case:case: 
 case:System.out.println("Tiramoh");break; 
 default:System.out.println("Error!");break; 
 } 
 шудааст: – ҷамъ, – тарҳ, – зарб, – тақсим). Рақами амал N (дар 
 фосилаи аз то ) ва ададҳои ҳақиқии A ва B (В нобаробари ) дода 
 шудааст. Вобаста ба қимати n амали лозимиро бо ададҳо иҷро 
 намуда, натиҷаро чоп кунед. 
 PascalABC.NET C++ 
 Var #include <iostream> 
 n, a, b: Integer; using namespace std; 
 int main() 
 begin { 
 Readln(n, a, b); int n; 
 float a,b; 
 case n of cin>>n>>a>>b;: Writeln(a+b); switch (n) {: Writeln(a-b); case:: Writeln(a*b); cout<<a+b<<endl;: Writeln(a/b); break; 
 end; case: 
 end. cout<<a-b<<endl; 
 break; 
 case: 
 cout<<a*b<<endl; 
 break; 
 case: 
 cout<<a/b<<endl; 
 break; 
 } 
 system("pause"); 
 return; 
 } 
 C# 
 static void Main(string[] args){ 
 int n; 
 double a, b; 
 n=Convert.ToInt(Console.ReadLine()); 
 a=Convert.ToInt(Console.ReadLine()); 
 b=Convert.ToInt(Console.ReadLine()); 
 switch(n){ 
 case:Console.WriteLine(a+b);break; 
 case: Console.WriteLine(a-b); break; 
 case: Console.WriteLine(a*b); break; 
 case: Console.WriteLine(a/b); break; 
 default: 
 Console.WriteLine ("Error"); break; 
 } 
 Console.ReadKey (); 
 } 
 Java 
 public static void main(String[] args) { 
 int n,a,b; 
 Scanner sc=new Scanner(System.in); 
 n=sc.nextInt(); 
 a=sc.nextInt(); 
 b=sc.nextInt(); 
 switch(n){ 
 case:System.out.println(a+b);break; 
 case:System.out.println(a-b);break; 
 case:System.out.println(a*b);break; 
 case:System.out.println(a/b);break; 
 default:System.out.println("Error");break; 
 } 
 моҳи ғайриқабисаро муайян мекунад. Таърихи рӯзӣ ба ин рӯз 
 пешинаро хориҷ кунед. Масалан, дохилкунӣ, хориҷкунӣ. 
 PascalABC.NET C++ 
 Var #include <iostream> 
 d, m: Integer; using namespace std; 
 int main() 
 begin { 
 Readln(d, m); int d, m; 
 d:=d-; cin >> d>>m; 
 if d= then if (d==) { 
 begin switch (m) 
 m:=m-; { 
 if m= then m:=; case: d=;break; 
 case m of case: d=;break;,,,,,,: case: d=;break; 
 d:=; case: d=;break;,,,: d:=; case: d=;break;: d:=; case: d=;break; 
 end; case: d=;break; 
 end; case: d=;break; 
 Writeln(d, ' ', m); case: d=;break; 
 end. case: d=;break; 
 case: d=;break; 
 case: d=;break; 
 } 
 } 
 else 
 d=d-; 
 cout<<d<<":"<<m<<endl; 
 system("pause"); 
 return; 
 } 
 C# 
 static void Main(string[] args){ 
 int d, m; 
 d=Convert.ToInt(Console.ReadLine()); 
 m=Convert.ToInt(Console.ReadLine()); 
 if (d==) 
 switch (m){ 
 case: Console.WriteLine(+" "+); break; 
 case: Console.WriteLine(+" "+); break; 
 case: Console.WriteLine(+" "+); break; 
 case: Console.WriteLine(+" "+); break; 
 case: Console.WriteLine(+" "+); break; 
 case: Console.WriteLine(+" "+); break; 
 case: Console.WriteLine(+" "+); break; 
 case: Console.WriteLine(+" "+); break; 
 case: Console.WriteLine(+" "+); break; 
 case: Console.WriteLine(+" "+); break; 
 case: Console.WriteLine(+" "+); break; 
 case: Console.WriteLine(+" "+); break; 
 } 
 else 
 Console.WriteLine(d-+ " "+m); 
 Console.ReadKey(); 
 } 
 Java 
 public static void main(String[] args) { 
 int d, m; 
 Scanner sc=new Scanner(System.in); 
 d=sc.nextInt(); 
 m=sc.nextInt(); 
 if(d==) 
 switch(m){ 
 case:System.out.println(+" "+);break; 
 case:System.out.println(+" "+);break; 
 case:System.out.println(+" "+);break; 
 case:System.out.println(+" "+);break; 
 case:System.out.println(+" "+);break; 
 case:System.out.println(+" "+);break; 
 case:System.out.println(+" "+);break; 
 case:System.out.println(+" "+);break; 
 case:System.out.println(+" "+);break; 
 case:System.out.println(+" "+);break; 
 case:System.out.println(+" "+);break; 
 case:System.out.println(+" "+);break;} 
 else{ 
 d=d-; 
 System.out.println(d+" "+m); 
 } 
 – шарқ, Ҷ – ҷануб), се фармони ададиро қабул кунад: – давом 
 додани ҳаракат, – гардиш ба тарафи чап, - – гардиш ба тарафи 
 рост. Рамзи С – мавқеи (самти) аввалаи робот ва адади бутуни N, ки 
 ягон фармонро ифода мекунад, дода шудааст. Самти ҳаракати робот 
 баъд аз иҷрои фармони ирсолшуда бароварда шавад. 
 PascalABC.NET C++ 
 Var #include <iostream> 
 s: Char; using namespace std; 
 n: Integer; int main() 
 { 
 begin int n; 
 Readln(s); char s; 
 Readln(n); cin>>s>>n; 
 if (s=='С') 
 case s of switch (n) { 
 'N': case: c='З'; break; 
 case n of case:c='С'; break;: c:='W'; case -: c='В'; break;: c:='N'; } 
 -: c:='E'; else if (s=='В') 
 end; switch (n) { 
 'E': case: c='С'; break; 
 case n of case:c='В';break;: c:='N'; case -:c='Ю';break;: c:='E'; } 
 -: c:='S'; else if (s=='Ю') 
 end; switch (n) { 
 'S': case:c='В'; break; 
 case n of case:c='Ю'; break;: c:='E'; case -: c='З';break;: c:='S'; } 
 -: c:='W'; else if (s=='З') 
 end; switch (n) { 
 'W': case: c='Ю';break; 
 case N of case:c='З'; break;: C:='S'; case -: c='С'; break;: C:='W'; } 
 -: C:='N'; cout<<s<<endl; 
 end; system("pause"); 
 end; return; 
 Writeln(C); } 
 end. 
 C# 
 static void Main(string[] args){ 
 int n; 
 char S; 
 S=Convert.ToChar(Console.ReadLine()); 
 n=Convert.ToInt(Console.ReadLine()); 
 if (S=='s') 
 { 
 switch (n) 
 { 
 case: Console.WriteLine("Zapad"); break; 
 case: Console.WriteLine("Sever"); break; 
 case -: Console.WriteLine("Vostok"); break; 
 } 
 } 
 else if (S=='z') 
 { 
 switch (n) 
 { 
 case: Console.WriteLine("Yug"); break; 
 case: Console.WriteLine("Zapad"); break; 
 case -: Console.WriteLine("Sever"); break; 
 } 
 } 
 else if (S=='v') 
 { 
 switch (n) 
 { 
 case: Console.WriteLine("Sever"); break; 
 case: Console.WriteLine("Vostok"); break; 
 case -: Console.WriteLine("Yug"); break; 
 } 
 } 
 else if (S=='y') 
 { 
 switch (n) 
 { 
 case: Console.WriteLine("Vostok"); break; 
 case: Console.WriteLine("Yug"); break; 
 case -: Console.WriteLine("Zapad"); break; 
 } 
 } 
 Console.ReadKey(); 
 } 
 Java 
 public static void main(String[] args) { 
 int n; 
 String s, c=null; 
 Scanner sc=new Scanner(System.in); 
 n=sc.nextInt(); 
 s=sc.next(); 
 if(s.equals("z")) 
 switch(n){ 
 case: c="z";break; 
 case: c="v";break; 
 case -: c="y";break; 
 } 
 else if(c.equals("s")) 
 switch(n){ 
 case: c="s";break; 
 case: c="z";break; 
 case -: c="y";break; 
 } 
 else if(c.equals("y")) 
 switch(n){ 
 case: c="y";break; 
 case: c="s";break; 
 case -: c="v";break; 
 } 
 else if(c.equals("v")) 
 switch(n){ 
 case: c="v";break; 
 case: c="y";break; 
 case -: c="z";break; 
 } 
 System.out.println(c); 
 } 
 радиус R, – диаметр D=R, – дарозӣ 𝐿 = 𝜋𝑅, – масоҳати доираи 
 бо ин давра маҳдуд 𝑆 = 𝜋𝑅. Рақами тартибии яке аз элементҳо ва 
 қимати он дода шудааст. Қимати элементҳои дигари давраро ҳисоб 
 карда хориҷ кунед (бо ҳамин тартиб). Ба сифати қимати 𝜋 бузургии 
 PascalABC.NET C++ 
 Var #include <iostream> 
 h, R, D, L, S: real; using namespace std; 
 n: integer; int main() 
 { 
 begin int n; 
 read(n); double h,R=,D,L,S; 
 read(h); cin>>n>>h; 
 case n of switch(n){: R:=h; case:R=h;break;: R:=h/; case:R=h/;break;: R:=h/(*.); case:R=h/*.;break;: R:=sqrt(h/.); case:R=sqrt(h/.);break; 
 end; } 
 D:=*R; D=*R; 
 L:=*.; L=*.; 
 S:=.*R*R; S=.*R*R; 
 Writeln(R, ' ', D, ' cout<<R<<" "<<D<<" "; 
 ', L, ' ', S); cout<<<<L<<" "<<S<<endl; 
 end. system("pause"); 
 return; 
 } 
 C# 
 static void Main(string[] args){ 
 Double h, D, R, L, S; 
 int n; 
 h=Convert.ToDouble(Console.ReadKey()); 
 n=Convert.ToInt(Console.ReadLine()); 
 switch (n) 
 { 
 case: R=h; break; 
 case: R=h/; break; 
 case: R=h/*.; break; 
 case: R=Math.Sqrt(h/.); break; 
 } 
 D=*R; 
 L=*.*R; 
 S=.*(R*R); 
 Console.WriteLine(R,D,L,S); 
 Console.ReadKey(); 
 } 
 Java 
 public static void main(String[] args) { 
 int n; 
 double h,R=,D,L,S; 
 Scanner sc=new Scanner(System.in); 
 n=sc.nextInt(); 
 h=sc.nextDouble(); 
 switch(n){ 
 case:R=h;break; 
 case:R=h/;break; 
 case:R=h/*Math.PI;break; 
 case:R=Math.sqrt(h/Math.PI);break; 
 } 
 D=*R; 
 L=*Math.PI*R; 
 S=Math.PI*R*R; 
 System.out.println(R+" "+" "+D+" "+L+" "+S+" "); 
 } 
 – паша, – ғишт, – дили сиёх, – дили сурх. Картаҳое, ки 
 рақамашон аз боло аст, чунин рақамгузорӣ шудаанд: – валет, 
 –дама, – карол, – туз. Ду адади бутун N ( ≤ 𝑁 ≤ )-рақами 
 карта ва M( ≤ 𝑀 ≤ ) −намуди карта дода шудааст. Номгӯи 
 картаҳои ба шакли “шаши дили сиёҳ”, “дамаи дили сурх”, “тузи 
 ғишт” ва ғайраро хориҷ кунед. 
 PascalABC.NET C++ 
 Var #include <iostream> 
 n, m: Integer; using namespace std; 
 int main() 
 begin { 
 Readln(n, m); int n,m; 
 case n of cin>>n>>m;: write('шаши '); switch (n) {: write('хафти '); case: cout<<"шаши ";break;: write('хаши '); case: cout<<"хафти "; break;: write('нухи '); case: cout<<"хаши "; break;: write('дахи'); case: cout<<"нухи ";break;: write('валет '); case:cout<<"дахи"; break;: write('дама '); case:cout<<"валет "; break;: write('корол '); case: cout<<"дама ";break;: write('туз '); case:cout<<"корол ";break; 
 end; case:cout<<"туз ";break; 
 } 
 case m of switch (m) {: write('пашша'); case:cout<<"пашша\n"; break;: write('гишт'); case:cout<<"гишт\n"; break;: write('дили сиёх'); case:cout<<"дили сиёх\n";: write('дили сурх'); break; 
 end; case:cout<<"дили сурх\n"; 
 end. break; 
 } 
 system("pause"); 
 return; 
 } 
 C# 
 static void Main(string[] args){ 
 int n, m; 
 n=Convert.ToInt(Console.ReadLine()); 
 m=Convert.ToInt(Console.ReadLine()); 
 switch (n){ 
 case: S="Дуӣ"; break; 
 case: S="Сеӣ"; break; 
 case: S="Чори"; break; 
 case: S="Панҷи"; break; 
 case: S="Шаши"; break; 
 case: S="Хафти"; break; 
 case: S="Хашти"; break; 
 case: S="Нухи"; break; 
 case: S="Дахи"; break; 
 case: S="Валет"; break; 
 case: S="Дама"; break; 
 case: S="Корол"; break; 
 case: S="Туз"; break; 
 } 
 switch (m) 
 { 
 case: S="Пашша"; break; 
 case: S="Гишт"; break; 
 case: S="Дили сиёх"; break; 
 case: S="Дили сурх"; break; 
 } 
 S=S+ " " +S; 
 Console.WriteLine(S); 
 Console.ReadKey(); 
 } 
 Java 
 public static void main(String[] args) { 
 int n, m; 
 Scanner sc=new Scanner(System.in); 
 n=sc.nextInt(); 
 m=sc.nextInt(); 
 switch (n) 
 { 
 case: S="Дӯӣ"; break; 
 case: S="Сеӣ"; break; 
 case: S="Чорӣ"; break; 
 case: S="Панҷи"; break; 
 case: S="Шаши"; break; 
 case: S="Хафти"; break; 
 case: S="Хашти"; break; 
 case: S="Нухи"; break; 
 case: S="Дахи"; break; 
 case: S="Валет"; break; 
 case: S="Дама"; break; 
 case: S="Корол"; break; 
 case: S="Туз"; break; 
 } 
 switch (m) 
 { 
 case: S="Пашша"; break; 
 case: S="Гишт"; break; 
 case: S="Дили сиёх"; break; 
 case: S="Дили сурх"; break; 
 } 
 S=S+ " " +S; 
 System.out.println(s); 
 } 
 мекунад, дода шудааст. Синни додашуда мувофиқи грамматика 
 ҳамчун сатр хориҷ карда шавад. Мисол, – бист сола, – чилу як 
 сола ва ғайра. 
 PascalABC.NET C++ 
 Var #include <windows.h> 
 n: Integer; #include <cstring> 
 #include <iostream> 
 begin using namespace std; 
 Readln(n); int main() 
 case n div of {:write('Бист '); SetConsoleCP();:write('Си '); SetConsoleOutputCP();:write('Чил '); string S, S=" ", S=" ";:write('Панҷоҳ'); int n, a, b;:write('Шаст'); cin>>n; 
 end; a=n/; 
 if n mod = then b=n%; 
 write(' сола') switch (a) 
 if n div > then { 
 if n div = then case: S="Бист"; break; 
 write('ю'); case: S="Си"; break; 
 else case: S="Чил"; break; 
 write('у'); case: S="Панҷоҳ"; break; 
 case n mod of case: S="Шаст"; break;: write('як '); }: write('ду'); switch (b): write('се'); {: write('чор'); case: S="як"; break;: write('панҷ'); case: S="ду"; break;: write('шаш'); case: S="се"; break;: write('ҳафт '); case: S="чор"; break;: write('ҳашт'); case: S="Панҷ"; break;: write('нуҳ'); case: S="Шаш"; break; 
 end; case: S="Ҳафт"; break; 
 if n mod > then case: S="Ҳашт"; break; 
 write(' сола'); case: S="Нуҳ"; break; 
 end; } 
 end. if (b=) 
 S=S+" сола "; 
 if (a=) 
 S=S+"ю "+S+" сола "; 
 else 
 S=S+"у "+S+" сола "; 
 cout<<S<<endl; 
 system("pause"); 
 return; 
 } 
 C# 
 static void Main(string[] args){ 
 String S, S=" ", S=" "; 
 int n, a, b; 
 n=Convert.ToInt(Console.ReadLine()); 
 a=n/; 
 b=n%; 
 switch (a) 
 { 
 case: S="Бист"; break; 
 case: S="Си"; break; 
 case: S="Чил"; break; 
 case: S="Панҷоҳ"; break; 
 case: S="Шаст"; break; 
 } 
 switch (b) 
 { 
 case: S="як"; break; 
 case: S="ду"; break; 
 case: S="се"; break; 
 case: S="чор"; break; 
 case: S="панҷ"; break; 
 case: S="шаш"; break; 
 case: S="ҳафт"; break; 
 case: S="ҳашт"; break; 
 case: S="нуҳ"; break; 
 } 
 if (b=) 
 S=S+" сола "; 
 if (a=) 
 S=S+"ю "+S+" сола "; 
 else 
 S=S+"у "+S+" сола "; 
 Console.WriteLine(S); 
 Console.ReadKey(); 
 } 
 Java 
 public static void main(String[] args) { 
 String S, S=" ", S=" "; 
 int n, a, b; 
 Scanner sc=new Scanner(System.in); 
 n=sc.nextInt(); 
 a=n/; 
 b=n%; 
 switch (a) 
 { 
 case: S="Бист"; break; 
 case: S="Си"; break; 
 case: S="Чил"; break; 
 case: S="Панҷоҳ"; break; 
 case: S="Шаст"; break; 
 } 
 switch (b) 
 { 
 case: S="як"; break; 
 case: S="ду"; break; 
 case: S="се"; break; 
 case: S="сор"; break; 
 case: S="панҷ"; break; 
 case: S="шаш"; break; 
 case: S="ҳафт"; break; 
 case: S="ҳашт"; break; 
 case: S="нуҳ"; break; 
 } 
 if (b=) 
 S=S+" сола "; 
 if (a=) 
 S=S+"ю "+S+" сола "; 
 else 
 S=S+"у "+S+" сола "; 
 System.out.println(S); 
 } 
 муайян мекунад. Бурҷи мувофиқи санаи дохилкардашуда хориҷ 
 карда шавад. 
 PascalABC.NET C++ 
 Var #include <windows.h> 
 s: string; #include <iostream> 
 d, m: byte; using namespace std; 
 int main() 
 begin { 
 readln(d, m); SetConsoleCP(); 
 case m of SetConsoleOutputCP();: int d,m; 
 if d < Then cin>>d>>m; 
 writeln('Ҷади') switch (m) { 
 Else case: 
 writeln('Далв'); if (d>): cout<<"Далв"<<endl; 
 if d < Then else 
 writeln('Далв') cout<<"Ҷади"<<endl; 
 Else break; 
 writeln('Наҳанг'); case:: if (d>) cout<<"Наҳанг"<<endl; 
 if d <= Then else cout<<"Далв"<<endl; 
 writeln('Наҳанг') break; 
 Else case: 
 writeln('Гусфанд'); if (d>): cout<<"Гусфанд"<<endl; 
 if d < Then else cout<<"Наҳанг"<<endl; 
 writeln('Гусфанд') break; 
 Else case: 
 writeln('Гусола'); if (d>): cout<<"Гусола"<<endl; 
 if d <= Then else cout<<"Гусфанд"<<endl; 
 writeln('Гусола') break; 
 Else case: 
 writeln('Ҷавзо'); if (d>): cout<<"Ҷавзо"<<endl; 
 if d <= Then else cout<<"Гусола"<<endl; 
 writeln('Ҷавзо') break; 
 Else case: 
 writeln('Саратон'); if (d>): cout<<"Саратон"<<endl; 
 if d <= Then else cout<<"Ҷавзо"<<endl; 
 writeln('Саратон') break; 
 Else case: 
 writeln('Асад'); if (d>): cout<<"Асад"<<endl; 
 else cout<<"Саратон"<<endl; 
 if d < Then break; 
 writeln('Асад') case: 
 Else if (d>) 
 writeln('Сунбула'); cout<<"Сунбула"<<endl;: else cout<<"Асад"<<endl; 
 if d < Then break; 
 writeln('Сунбула') case: 
 Else if (d>) 
 writeln('Мизон'); cout<<"Мизон"<<endl;: else cout<<"Сунбула"<<endl; 
 if d < Then break; 
 writeln('Мизон') case: 
 Else if (d>) 
 writeln('Ақраб'); cout<<"Ақраб"<<endl;: else cout<<"Мизон"<<endl; 
 if d <= Then break; 
 writeln('Ақраб') case: 
 Else if (d>) 
 writeln('Қавс'); cout<<"Қавс"<<endl;: else cout<<"Ақраб"<<endl; 
 if d <= Then break; 
 writeln('Қавс') case: 
 Else if (d>) 
 writeln('Ҷади'); cout<<"Ҷади"<<endl; 
 End; else cout<<"Қавс"<<endl; 
 end. break; 
 } 
 cout<<"\n"<<endl; 
 system("pause"); 
 return; 
 } 
 C# 
 static void Main(string[] args){ 
 int d,m; 
 String s=null; 
 m=Convert.ToInt(Console.ReadLine()); 
 d=Convert.ToInt(Console.ReadLine()); 
 switch(m){ 
 case:if(d<=) s="Ҷади"; 
 else 
 s="Далв";break; 
 case:if(d<=) s="Далв"; 
 else 
 s="Наҳанг";break; 
 case:if(d<=) s="Наҳанг"; 
 else 
 s="Гусфанд";break; 
 case:if(d<=) s="Гусфанд"; 
 else 
 s="Гусола";break; 
 case:if(d<=) s="Гусола"; 
 else 
 s="Ҷавзо";break; 
 case:if(d<=) s="Ҷавзо"; 
 else 
 s="Саратон";break; 
 case:if(d<=) s="Саратон"; 
 else 
 s="Асад";break; 
 case:if(d<=) s="Асад"; 
 else 
 s="Сунбула";break; 
 case:if(d<=) s="Сунбула"; 
 else 
 s="Мизон";break; 
 case:if(d<=) s="Мизон"; 
 else 
 s="Ақраб";break; 
 case:if(d<=) s="Ақраб"; 
 else 
 s="Қавс";break; 
 case:if(d<=) s="Қавс"; 
 else 
 s="Ҷади";break; 
 default:System.out.println("Error");break; 
 } 
 Console.WriteLine(s); 
 } 
 Java 
 public static void main(String[] args) 
 { 
 int d,m; 
 String s=null; 
 Scanner sc=new Scanner(System.in); 
 m=sc.nextInt(); 
 d=sc.nextInt(); 
 switch(m) 
 { 
 case:if(d<=) s="Ҷади"; 
 else 
 s="Далв";break; 
 case:if(d<=) s="Далв"; 
 else 
 s="Наҳанг";break; 
 case:if(d<=) s="Наҳанг"; 
 else 
 s="Гусфанд";break; 
 case:if(d<=) s="Гусфанд"; 
 else 
 s="Гусола";break; 
 case:if(d<=) s="Гусола"; 
 else 
 s="Ҷавзо";break; 
 case:if(d<=) s="Ҷавзо"; 
 else 
 s="Саратон";break; 
 case:if(d<=) s="Саратон"; 
 else 
 s="Асад";break; 
 case:if(d<=) s="Асад"; 
 else 
 s="Сунбула";break; 
 case:if(d<=) s="Сунбула"; 
 else 
 s="Мизон";break; 
 case:if(d<=) s="Мизон"; 
 else 
 s="Ақраб";break; 
 case:if(d<=) s="Ақраб"; 
 else 
 s="Қавс";break; 
 case:if(d<=) s="Қавс"; 
 else 
 s="Ҷади";break; 
 default:System.out.println("Error");break;} 
 System.out.println(s); 
 } 
 Масъалаҳо барои кори мустақилона 
 баҳои мувофиқро ифода мекунад ( – бад, – ғайриқаноатбахш, – 
 қаноатбахш, – хуб, – аъло). 
 шудааст ( – январ, – феврал, – март, – апрел, – май ва ғайра).
 Миқдори рӯзҳои моҳро бо назардошти соли одӣ хориҷ кунед. 
 детсиметр, – километр, – метр, – миллиметр, – сантиметр). 
 Рақами ченаки дарозӣ (адади бутун дар фосилаи аз то ) ва дарозии 
 порча бо ҳамин ченак (адади ҳақиқӣ) дода шудааст. Дарозии порча 
 бо метр гардонида шавад. 
 килограмм, – миллиграмм, – грамм, – тонна, – сентнер). 
 Рақами ченаки вазн (адади бутун дар фосилаи аз то ) ва массаи 
 ҷисм дар ин ченак (адади ҳақиқӣ) дода шудааст. Массаи ҷисмро ба кг 
 гардонида, натиҷаро хориҷ кунед. 
 моҳи ғайриқабисаро муайян мекунад. Таърихи рӯзӣ ба ин рӯз 
 баъдинаро хориҷ кунед. Масалан, дохилкунӣ, хориҷкунӣ. 
 Ҷ – ҷануб) ҳаракат карда, яке аз се фармони рақамиро қабул намояд: 
 – гардиш ба тарафи чап, - – гардиш ба тарафи рост, – гардиш ба 
 қафо о. Рамзи С – мавқеи аввалаи локатор ва ададҳои бутун 𝑁 ва 
 𝑁 ду фармон, дода шудааст. Самти локаторро пас аз иҷрои ин 
 фармонҳо муайян намоед. 
 рақамгузорӣ шудаанд: – катет а, – гипотенуза с = а√, – бандии 
 ба гипотенуза фаровардашуда ℎ = 𝑐/, – масоҳат 𝑠 = 𝑐 ∙ ℎ/. Рақами 
 тартибии яке аз элементҳо ва қимати он дода шудааст. Қимати 
 элементҳои дигари секунҷаи додашударо хориҷ кунед (бо ҳамин 
 тартиб). 
 шудаанд: – тараф а, – радиуси давраи дарункашида шуда 
 𝑅 = 𝑎√/, –радиуси давраи берункашда шуда 𝑅 = ∙ 𝑅, – 
 масоҳат 𝑠 = √/ ∙ 𝑎. Рақами тартибии яке аз элементҳо ва қимати он 
 дода шудааст. Қимати элементҳои дигари секунҷаи додашударо 
 ҳисоб намуда, хориҷ кунед. 
 масъалаҳоро дар мавзӯи муайян ифода мекунад. Сатри тафсири 
 миқдори масъалаҳоро хориҷ кунед (-ҳаждаҳ масъалаи дарсӣ, – 
 масъалаи дарсӣ ва ғайра). 
 намуди сатр бароварда шавад. 
 Мисол: – ду саду панҷою шаш, – ҳаштсаду чордаҳ ва ғайра. 
 навбати худ ба зердавр тақсим мешавад. Ҳар як зердавр солро 
 дарбар мегирад, ки бо номи ҳайвонот мувофиқ гузошта шудаанд. 
 Зердаврҳо бошанд, номи рангро ифода мекунанд: сабз, сурх, зард, 
 сафед ва сиёҳ. Бо дода шудани сол номи сол бароварда шавад. 
 Маълум аст, ки соли – оғози давр буда, ба соли соли муши сабз 
 мувофиқ меояд. 
 Масъалаҳои гуруҳи For 
 C++, C#, Python, Java ва GO-ро аз [-] азбар намоед. 
 Python, Java ва GO нависед. 
 Намунаи ҳалли масъалаҳо 
 ро хориҷ кунед. 
 PascalABC.NET C++ 
 Var #include <iostream> 
 k, n, i: Integer; using namespace std; 
 int main() 
 begin { 
 Readln(n, k); int k, n, i; 
 for i:= to n do cin>>k>>n; 
 Writeln(k); for (i=; i<n; ++i) 
 end. cout<<k; 
 system("pause"); 
 return; 
 } 
 Python C# 
 n=int(input( )) static void Main(string[] args){ 
 k=int(input( )) int n,k, i; 
 for i in range(,n): n=Convert.ToInt(Console.ReadLine()); 
 k=Convert.ToInt(Console.ReadLine()); 
 print(k) 
 for (i=; i <=n; i++) 
 Console.WriteLine(k); 
 Console.ReadKey(); 
 } 
 Java Go 
 public static void main(String[] args) package main 
 { import "fmt" 
 int i,n,k; func main() { 
 Scanner sc=new Scanner(System.in); var n,k,i int 
 n=sc.nextInt(); fmt.Scanf("%d %d", 
 k=sc.nextInt(); &n,&k) 
 for(i=; i<=n; i++) for i=;i<=n; i++{ 
 System.out.print(k); fmt.Print(k," ") 
 } } 
 } 
 ҳамаи ададҳои бутуни дар байни ададҳои A ва B ҷойгир буда (A ва B 
 низ), инчунин миқдори ин ададҳо чоп карда шавад. 
 PascalABC.NET C++ 
 Var #include <iostream> 
 a, b, i: Integer; using namespace std; 
 int main() 
 begin { 
 Readln(a, b); int a, b, i; 
 for i:= to b-a do cin>>a>>b; 
 Writeln(a+i); for (i=a; i<=b; ++i) 
 Writeln(b-a+); cout<<i<<" "; 
 end. cout<< b-a+; 
 system("pause"); 
 return; 
 } 
 Python C# 
 a=int(input( )) static void Main(string[] args){ 
 b=int(input( )) int a, b,i, k=; 
 a=Convert.ToInt(Console.ReadLine ()); 
 k=; 
 b=Convert.ToInt (Console.ReadLine ()); 
 for i in range(a,b): 
 for (i=a; i <=b; i++){ 
 print(i) k++; 
 k+=; Console.Write(i+" "); 
 print(k) } 
 Console.WriteLine("\n"+k); 
 Console.ReadKey(); 
 } 
 Java Go 
 public static void main(String[] args) package main 
 { import "fmt" 
 int i,a,b,k=; func main() { 
 Scanner sc=new Scanner(System.in); var a,b,i,k int 
 a=sc.nextInt(); fmt.Scanf("%d %d", 
 b=sc.nextInt(); &a,&b) 
 for(i=a; i<=b; i++){ k= 
 k++; for i=a; i<=b; i++{ 
 System.out.print(i+" "); k++; 
 } fmt.Println(i," ") 
 System.out.println(k); } 
 } fmt.Println("\n",k) 
 } 
 қанд чоп карда шавад. 
 PascalABC.NET C++ 
 Var #include <iostream> 
 c: Real; using namespace std; 
 i: Integer; int main() 
 { 
 begin float c; 
 Readln(c); int i; 
 for i:= to do cin>>c; 
 Writeln(i, ' ', i*c); for (i=; i<=; ++i) 
 end. cout<<c*i<<endl; 
 system("pause"); 
 return; 
 } 
 Python C# 
 a=int(input( )) static void Main(string[] args){ 
 for i in range(,): int i, c; 
 a=Convert.ToInt (Console.ReadLine ()); 
 print(i*a) 
 n=Convert.ToInt (Console.ReadLine ()); 
 for (i=; i <=; i++){ 
 Console.Write(i,i*a); 
 } 
 Console.WriteLine(); 
 Console.ReadKey(); 
 } 
 Java Go 
 public static void main(String[]args) package main 
 { import "fmt" 
 int i; func main() { 
 double c; var i int 
 Scanner sc=new Scanner(System.in); var s,t int 
 c=sc.nextDouble(); fmt.Scanf("%d",&t) 
 for(i=; i<=; i++){ for i=; i<=; i++{ 
 System.out.print(i*t+" "); s=i* t 
 } fmt.Println(s," ") 
 } 
 } 
 аз A то B ёфта шавад. 
 PascalABC.NET C++ 
 Var #include <iostream> 
 a,b, Sum, i: Integer; using namespace std; 
 int main() 
 begin { 
 Readln(a, b); int a,b, i, sum=; 
 sum:=; cin>>a>>b; 
 for i:=a to b do for (i=a; i<=b; ++i) 
 Sum:=Sum+i; sum +=i; 
 Writeln(Sum); cout<<sum<<endl; 
 end. system("pause"); 
 return; 
 } 
 Python C# 
 a=int(input( )) static void Main(string[] args){ 
 b=int(input( )) int a, b, i, Sum=; 
 a=Convert.ToInt(Console.ReadLine()); 
 Sum=; b=Convert.ToInt(Console.ReadLine()); 
 for i in range(a,b): for (i=a; i <=b; i++){ 
 if (i==a) 
 Sum +=i 
 Console.Write(a); 
 print(Sum) 
 else 
 Console.Write(i); 
 Sum=Sum+i; 
 } 
 Console.Write(Sum); 
 Console.ReadKey(); 
 } 
 Java Go 
 public static void main(String[]args) package main 
 { import "fmt" 
 int a,b,i, Sum=; func main(){ 
 Scanner sc=new Scanner(System.in); var i int 
 a=sc.nextInt(); var Sum=,a,b int 
 b=sc.nextInt(); fmt.Scanf("%d %d", 
 for(i=a; i<=b; i++) &a, &b) 
 Sum=Sum +i; for i=a; i<=b; i++ { 
 System.out.print(Sum +" "); Sum=Sum +i; 
 } fmt.Println(Sum," ") 
 } 
 } 
 PascalABC.NET C++ 
 Var #include <cmath> 
 n, i, k: Integer; #include <iostream> 
 S: Real; using namespace std; 
 int main(){ 
 begin int n, i, h=; 
 Readln(n); cin>>n; 
 S:=; float S=; 
 k:=; for (i=; i<=n; ++i) 
 for i:= to n do S +=i*h; 
 begin h=-h; 
 S:=S+i*k; } 
 k:=-k; cout<<S<<endl; 
 end; system("pause"); 
 Writeln(rez); return; 
 end. } 
 Python C# 
 n=int(input( )) static void Main(string[] args){ 
 h=; Double n, i, S=, h=; 
 S=; n=Convert.ToDouble(Console.ReadLine()); 
 for i in range(,n): for (i=.; i <=n; i+=.){ 
 S+=(+.*i)*h S=S+i*h; 
 h=-h h=-h; 
 print(S) } 
 Console.WriteLine("\n"+S); 
 Console.ReadKey(); 
 } 
 Java Go 
 public static void main(String[] package main 
 args) { import "fmt" 
 float S=,t=,i,n; func main() { 
 Scanner sc=new Scanner( var i, S,t,n float 
 System.in); fmt.Scanf("%v",&n) 
 n=sc.nextFloat(); S= 
 for(i=.; i<=n; i+=.){ t= 
 S=S +i*t; for i=.; i<=n; i+=.{ 
 t=-t; S=S +i*t; 
 } t=-t; 
 System.out.println(S); } 
 } fmt.Println(rez," ") 
 } 
 дар дараҷаи N бе истифодаи амали pow(a,n) ёфта шавад: 
 𝐴𝑁 = 𝐴 ∙ 𝐴 ∙ … ∙ 𝐴 
 (адади А, N маротиба зарб мешавад). 
 PascalABC.NET C++ 
 Var #include <iostream> 
 a, rez: Real; using namespace std; 
 n, i: Integer; int main(){ 
 float a, rez=; 
 begin int n,i; 
 Radln(a,n); cin>>n>>a; 
 rez:=; for (i=; i<=n; ++i) 
 for i:= to n do rez *=a; 
 rez:=rez*a; cout<<rez<<endl; 
 Writeln(rez); system("pause"); 
 end. return; 
 } 
 Python C# 
 a=float(input()) static void Main(string[] args){ 
 n=int(input()) Double a, n, i, rez=; 
 rez= a=Convert.ToDouble(Console.ReadLine()); 
 n=Convert.ToDouble(Console.ReadLine()); 
 for i in range(,n): 
 for (i=; i <=n; i++) 
 rez *=a 
 rez=rez*a; 
 print(rez) 
 Console.WriteLine(rez); 
 Console.ReadKey(); 
 } 
 Java Go 
 public static void main(String[] args) package main 
 { import "fmt" 
 int i,a,n,rez=; func main() { 
 Scanner sc=new Scanner(System.in); var rez, a float 
 a=sc.nextInt(); var n,i int 
 n=sc.nextInt(); fmt.Scanf("%v %d", 
 for(i=; i<=n; i++) &a,&n) 
 rez=rez*a; rez= 
 System.out.println(rez); for i=; i<=n; i++ { 
 } rez=rez *a; 
 fmt.Println(rez," ") 
 } 
 } 
 аз як давр, суммаи 
 + 𝐴 + 𝐴 + 𝐴 + ⋯+ 𝐴𝑁 
 ёфта шавад. Истифодаи функсияи pow мумкин нест. 
 PascalABC.NET C++ 
 Var #include <iostream> 
 a, Rez, Pow: Real; using namespace std; 
 n, i: Integer; int main() 
 { 
 begin float a, Pow=,Rez=; 
 Readln(a, n); int i,n; 
 Rez:=; cin>>a>>n; 
 Pow:=; for (i=; i<=n; ++i) 
 for i:= to n do { 
 begin Pow *=a; 
 Pow:=Pow*a; Rez +=Pow; 
 Rez:=Rez+Pow; } 
 end; cout<<Rez<<endl; 
 Writeln(Rez); system("pause"); 
 end. return; 
 } 
 Python C# 
 a=float(input( )) static void Main(string[] args){ 
 n=int(input( )) Double a, Pow=, Rez=; 
 Pow= int i, n; 
 a=Convert.ToDouble(Console.ReadLine()); 
 Rez=; 
 n=Convert.ToInt(Console.ReadLine()); 
 for i in range(,n): 
 for (i=; i <=n; i++){ 
 Pow=Pow *a Pow=Pow*a; 
 Rez=Rez+Pow Rez=Rez+Pow; 
 print(Rez) } 
 Console.WriteLine(Rez); 
 Console.ReadKey(); 
 } 
 Java Go 
 public static void package main 
 main(String[] args) { import "fmt" 
 int Pow=,n,i,a,Rez=; func main() { 
 Scanner sc=new var s,a,t float 
 Scanner(System.in); var n,i int 
 a=sc.nextInt(); fmt.Scanf("%v %d",&a,&n) 
 n=sc.nextInt(); Pow= 
 for(i=; i<=n; i++){ Rez= 
 Pow=Pow *a; for i=; i<=n; i++ { 
 Rez=Rez+Pow; Pow=Pow *a; 
 } Rez=Rez+Pow; 
 } 
 System.out.println(Rez); fmt.Println(Rez) 
 } } 
 зерин ёфта шавад:! +! +! + ⋯+ 𝑁! 
 (ифодаи N! –маънои зарби ҳамаи ададҳои аз то N –ро дорад: 𝑁! = 
 ∙ ∙ …∙ 𝑁). 
 PascalABC.NET C++ 
 Var #include <iostream> 
 Rez,p: Real; using namespace std; 
 n, i: Integer; int main() 
 { 
 begin int n, i; 
 Readln(n); float p=,Rez=; 
 Rez:=; cin>>n; 
 P:=; for (i=; i<=n; ++i){ 
 for i:= to n- do p *=(float)i; 
 begin Rez +=p; 
 p:=p*i; } 
 Rez:=Rez+p; cout<<Rez<<endl; 
 end; system("pause"); 
 Writeln(Rez); return; 
 end. } 
 Python C# 
 n=int(input( )) static void Main(string[] args){ 
 Rez=; Double Rez=, p=, n, i; 
 p=; n=Convert.ToDouble(Console.ReadLine()); 
 for (i=; i <=n; i++){ 
 for i in range(,n+): 
 P=P*i; 
 p=p*i 
 Rez=Rez+p; 
 Rez=Rez+p 
 } 
 print(Rez) Console.WriteLine(Rez); 
 Console.ReadKey(); 
 } 
 Java Go 
 public static void main(String[]args) package main 
 { import "fmt" 
 int Rez=,n,i,p=; func main() { 
 Scanner sc=new Scanner(System.in); var t,s,n,i int 
 n=sc.nextInt(); fmt.Scanf("%d",&n) 
 for(i=; i<=n; i++){ p= 
 p=p*i; Rez= 
 Rez=Rez +p; for i=; i<=n; i++ { 
 } p=p*i; 
 System.out.println(Rez); Rez=Rez +p; 
 } } 
 fmt.Println(Rez) 
 } 
 ифодаи зерин ёфта шавад: 
 + 𝑋 + 𝑋/(!) + ⋯+ 𝑋𝑁/(𝑁!) 
 𝑁! = ∙ ∙ …∙ 𝑁. Адади ёфташуда, қимати функсияи exp дар нуқтаи 
 X мебошад. 
 PascalABC.NET C++ 
 Var #include <iostream> 
 x, Rez, fact, p: Real; using namespace std; 
 n, i: Integer; int main() 
 { 
 begin float x, Rez, fact, p; 
 Readln(x, n); int n, i; 
 Rez:=; cin>>n>>x; 
 p:=; for (i=; i<=n; ++i){ 
 fact:=; fact *=(float)i; 
 for i:= to n do p *=x; 
 begin Rez +=p/fact; 
 fact:=fact*i; } 
 p:=pow*x; cout<<Rez<<endl; 
 Rez:=Rez+p/fact; system("pause"); 
 end; return; 
 Writeln(Rez); } 
 end. 
 Python C# 
 from math import pow static void Main(string[] args){ 
 x=float(input( )) Double x, Rez, fact, p; 
 n=int(input( )) int n, i; 
 x=Convert.ToDouble(Console.ReadLine()); 
 rez=;fact=; 
 n=Convert.ToInt(Console.ReadLine()); 
 for i in range(,n+): 
 for (i=; i <=n; i++){ 
 p=pow(x,i) p=Math.Pow(x, i); 
 fact=fact*i fact=fact*i; 
 rez=rez+p/fact Rez=Rez+p/fact; 
 } 
 print(rez) 
 Console.WriteLine(Rez); 
 Console.ReadKey(); 
 } 
 Java Go 
 public static void main(String[] package main 
 args) { import "fmt" 
 int n,i; func main() { 
 double x, Rez=, fact=, p; var x, Rez=, fact=, p, 
 Scanner sc=new Scanner( n,i float 
 System.in); fmt.Scanf("%v %v",&n,&x) 
 n=sc.nextInt(); Rez= 
 x=sc.nextInt(); fact= 
 for(i=; i<=n; i++){ p= 
 p=Math.pow(x,i); for i=; i<=n; i++ { 
 fact=fact*i; var p=p*x 
 rez=rez+p/fact; var fact=fact*i 
 } rez=rez+p/fact 
 System.out.println(t); } 
 } fmt.Println(t) 
 } 
 Қимати ифодаи зерин ёфта шавад: 
 𝑋 𝑋 
 𝑋 + ∙ + ∙ ∙ + ⋯+ ∙ ∙ …∙ ( ∙ 𝑁 − ) ∙ 𝑋𝑁+/( ∙ ∙
 ∙ ∙∙ 
 …∙ ( ∙ 𝑁) ∙ ( ∙ 𝑁 + )). 
 Натиҷаи ёфташуда, қимати функсияи 𝑎𝑟𝑐𝑠𝑖𝑛 − ро дар нуқтаи X 
 ифода мекунад. 
 PascalABC.NET C++ 
 Var #include <iostream> 
 x, p:=,s:=: Real; #include <math> 
 n, i: Integer; using namespace std; 
 int main() 
 begin { 
 Readln(x, n); double i, n, x, p=,s=; 
 for i:= to n- do cin>>n>>x; 
 begin for(int i=; i <=n;i++) { 
 p:=p**i+; p=p**i+; 
 s:=s+(*i-)*exp(ln(x)* s=s+(*i-)*Pow(x, (*i+))/ 
 (*i+))/(*i)*(*i+); (*i)*(*i+); 
 end; } 
 Writeln(s); cout <<s << endl; 
 end. system("pause"); 
 return; 
 } 
 Python C# 
 from math import pow static void Main(string[] args) 
 x=float(input( )) { 
 Double i, n, x, p=,s=; 
 n=int(input( )) 
 n=Convert.ToDouble(Console.ReadLine()); 
 S= 
 x=Convert.ToDouble(Console.ReadLine()); 
 p= for (i=; i <=n; i++){ 
 for i in range(,n+): p=p**i+; 
 p=p**i+; s=s+(*i-)*Math.Pow(x, *i+)/ 
 (*i)*(*i+); 
 S=S+(*i-)*pow(x, 
 } 
 *i+)/(*i)*(*i+) 
 Console.Write(s); 
 print(S) Console.ReadKey(); 
 } 
 Java Go 
 public static void main(String[] package main 
 args) { import ( 
 Double i, n, x, p=,s=; "fmt" 
 Scanner sc=new Scanner "math" 
 (System.in); ) 
 n=sc.nextDouble(); func main() 
 x=sc.nextDouble(); { 
 for (i=; i <=n; i++){ var n,s,p,x,i float 
 p=p**i+; fmt.Scanf("%v %v", 
 s=s+(*i-)*Math.Pow(x,*i+)/ &n,&x) 
 (*i)*(*i+); s= 
 } p= 
 System.out.println(s); for i=;i <=n; i++ { 
 } p=p**i+; 
 s=s+(*i-)*math.Pow 
 (x,*i+)/(*i)*(*i+); 
 } 
 fmt.Println(s) 
 } 
 дода шудааст. Порчаи A, B-ро ба N қисм тақсим карда, дарозии 
 |𝐵−𝐴| 
 порчаҳои A, A+H, A+H, …, B-ро хориҷ кунед. Дар ин ҷо 𝐻 = 
 𝑁 
 мебошад. 
 PascalABC.NET C++ 
 Var #include <iostream> 
 L,A, B, H: Real; using namespace std; 
 N, i: Integer; int main() 
 { 
 begin int n,i; 
 Readln(N, A, B); float a, b,h,L; 
 H:=(B-A)/N; cin>>a>>b; 
 Writeln(H); float h=(b-a)/n; 
 for i:= to N do cout<<h<<endl; 
 begin for (i=; i<=n; ++i){ 
 L=A+i*h; L=a+i*h; 
 Writeln(L); cout<<L; 
 end; } 
 end. system("pause"); 
 return; 
 } 
 Python C# 
 a=float(input( )) static void Main(string[] args){ 
 b=float(input( )) Double i, a, b, h, n,L; 
 n=int(input( )) a=Convert.ToDouble(Console.ReadLine()); 
 h=abs(b-a)/n b=Convert.ToDouble(Console.ReadLine()); 
 n=Convert.ToDouble(Console.ReadLine()); 
 for i in range h=Math.Abs(b-a)/n; 
 (,n+): for (i=; i <=n;i++ ){ 
 L=a+i*h L=a+i*h; 
 print(L) Console.WriteLine(L); 
 } 
 Console.ReadKey(); 
 } 
 Java Go 
 public static void main(String[] package main 
 args) { import ( 
 double a,h,i,n,L,b; "fmt" 
 Scanner sc=new Scanner( "math" 
 System.in); ) 
 a=sc.nextDouble(); func main() { 
 b=sc.nextDouble(); var a,h,i,n,L,b float 
 n=sc.nextDouble(); fmt.Scanf("%v %v %v", 
 h=Math.abs(a-b)/n; &a,&b,&n) 
 for(i=; i<=n; i++){ h=math.Abs(a-b)/n; 
 L=a+i*h; for i=; i<=n; i++ { 
 System.out.println(L); L=a+i*h; 
 } fmt.Println(L) 
 } } 
 } 
 𝐴 (𝑘 =,,..,𝑛) − ро бо тарзи зерин ҳисоб намуда хориҷ кунед: 
 𝑘 
 𝐴 =,𝐴 = + ⁄,𝑘 =,,… 
 𝑘 𝐴 
 𝑘− 
 PascalABC.NET C++ 
 Var #include <iostream> 
 A,b: Real; using namespace std; 
 N, i: Integer; int main() 
 { 
 begin int n,i; 
 Readln(N); double a, b; 
 A:=; cin >> n; 
 Write(a); a=; 
 for i:= to N do cout << a; 
 begin for (int i=; i <=n; ++i) { 
 b:=+/A; b=+/a; 
 A:=b; a=b; 
 Write(b); } 
 end; cout <<b<< endl; 
 end. system("pause"); 
 return; 
 } 
 Python C# 
 n=int(input( )) public static void Main(string[] args) 
 a= { 
 double a,b,n,i; 
 print(a) 
 for i in n=Convert.ToInt(Console.ReadLine()); 
 range(,n+): a=; 
 b=+./a Console.WriteLine(a); 
 print(b) for (int i=; i <=n; i++){ 
 a=b b=+./a; 
 a=b; 
 } 
 Console.WriteLine(b); 
 Console.ReadKey(); 
 } 
 Java Go 
 public static void package main 
 main(String[]args) { import "fmt" 
 Scanner pa=new func main() { 
 Scanner(System.in); var a,b,n,i float 
 double a,b,n,i; fmt.Scanf("%v",&n) 
 n=sc.nextDouble(); a= 
 a=; fmt.Println(a) 
 System.out.println(a); for i=; i<=n; i++ { 
 for(i=; i<=n; i++){ b=+/a; 
 b=+/a; a=b; 
 a=b; fmt.Println(b) 
 System.out.println(b); } 
 } } 
 истифода аз амали 𝑝𝑜𝑤(𝑁,𝑘) ҳисоб карда шавад. 
 PascalABC.NET C++ 
 Var #include <iostream> 
 N, K, i, j: Integer; using namespace std; 
 s, p: Real; int main() 
 { 
 begin int i,j; 
 Readln(N, K); float s=,p,n,k; 
 s:=; cin>>n>>k; 
 for i:= to N do for (i=; i<=n; ++i){ 
 begin p=; 
 p:=; for (j=; j<=k; ++j) 
 for j:= to K do p *=i; 
 p:=p*i; s +=p; 
 s:=s+p; } 
 end; cout <<s<<endl; 
 Writeln(s); system("pause"); 
 end. return; 
 } 
 Python C# 
 n=int(input( )) public static void Main(string[] args) 
 k=int(input( )) { 
 Double n, s=, k, p=; 
 S= 
 n=Convert.ToDouble(Console.ReadLine()); 
 for i in range(,n+): 
 p= k=Convert.ToDouble(Console.ReadLine()); 
 for j in for (int i=; i <=n; i++){ 
 p=; 
 range(,k+): 
 for (int j=; j <=k; j++){ 
 p=p*i 
 p=p*i; 
 S=S+p } 
 print(S) s=s+p; 
 } 
 Console.WriteLine(s); 
 Console.ReadKey(true); 
 } 
 Java GO 
 public static void main(String[] package main 
 args) { import "fmt" 
 double j,p,n,i,k,s=; func main() { 
 Scanner Sc=new Scanner( var j,n,i,k,s,p float 
 System.in); fmt.Scanf("%v %v",&n, &k) 
 n=Sc.nextDouble(); s= 
 k=Sc.nextDouble(); for i=; i<=n; i++ { 
 for(i=; i<=n; i++){ p= 
 p=; for j=; j<=k; j++ { 
 for(j=; j<=k; j++) p=p*j 
 p=p*j; s=s+p 
 s=s+p; } 
 } fmt.Println(s) 
 System.out.println(s); } 
 } } 
 ададҳои дар байни ададҳои A ва B буда, ба миқдори қиматашон 
 хориҷ карда шавад (мисол, адади, се маротиба, адади, чор 
 маротиба ва ғайра). 
 PascalABC.NET C++ 
 Var #include <iostream> 
 A, B, i, j: Integer; using namespace std; 
 int main() 
 begin { 
 Readln(A, B); int a,b; 
 for i:=A to B do cin>>a>>b; 
 for j:= to i do int i,j; 
 Writeln(i); for (i=a; i<=b; ++i){ 
 end. for (j=; j<=i; ++j) 
 cout<<i<<" "; 
 cout<<endl; 
 } 
 system("pause"); 
 return; 
 } 
 Python C# 
 a=int(input( )) public static void Main(string[] args) 
 b=int(input( )) { 
 int a,b, i,j; 
 for i in range(a,b): 
 a=Convert.ToInt(Console.ReadLine()); 
 for j in range(,i): 
 b=Convert.ToInt(Console.ReadLine()); 
 print(i) for (i=a; i<=b; ++i){ 
 for (j=; j<=i; ++j) 
 Console.WriteLine(i); 
 Console.WriteLine(); 
 } 
 Console.ReadKey(true); 
 } 
 Java GO 
 public static void main(String[] package main 
 args) { import "fmt" 
 int a,b,j,i; func main() { 
 Scanner Sc=new Scanner(System.in); var a,b,j,i float 
 a=Sc.nextInt(); fmt.Scanf("%v %v", 
 b=Sc.nextInt(); &a, &b) 
 for(i=a; i<=b; i++){ for i=a; i<=b; i++ { 
 for(j=; j<=i; j++) for j=;j<=i;j++ { 
 System.out.print(i); fmt.Println(i) 
 } } 
 } 
 } 
 Масъалаҳо барои кори мустақилона 
 ҳамаи ададҳои бутуни дар байни ададҳои A ва B мавҷуд буда (A ва B 
 низ), ва миқдлри онҳо чоп карда шавад. 
 кг қанд чоп карда шавад. 
 қанд чоп карда шавад. 
 A ва B ёфта шавад. 
 ҳамаи ададҳои аз A ва B ёфта шавад. 
 + ⁄ + ⁄ + ⋯+ ⁄ 
 𝑁 
 ёфта шавад. 
 𝑁 + (𝑁 + ) + (𝑁 + ) + ⋯+ ( ∙ 𝑁) ёфта шавад. 
 шавад, барои ҳисоб намудани он аз формулаи зерин истифода бурда 
 шавад: 
 𝑁 = + + + ⋯+ ( ∙ 𝑁 − ). 
 Баъд аз ҳамроҳкунии ҷамъшавандаҳо, ҳар як қимати сумма 
 бароварда шавад (дар натиҷа квадратҳои ҳамаи ададҳои бутун аз то N 
 бароварда шавад). 
 истифода аз як давр, қимати ифода зерин ёфта шавад: 
 − 𝐴 + 𝐴 − 𝐴 + ⋯+ (−)𝑁 ∙ 𝐴𝑁. 
 Оператори шартӣ истифода бурда нашавад. 
 𝑁! = ∙ ∙ …∙ 𝑁, 
 (N!-факториал) ёфта шавад. Барои замнашавии ададҳои бутун, 
 тағйирёбандаро ҳамчун адади ҳақиқӣ дохил ва хориҷ намоед. 
 зерин ёфта шавад: 
 + /(!)+ /(!) + /(!)+ ⋯+ /(𝑁!) 
 (ифодаи N! – N – зарби ҳамаи ададҳои аз то N – дорад: 𝑁! = ∙ ∙ 
 …∙ 𝑁). Адади ба дастовардашуда, қимати тақрибии доимии 𝑒 = 
 exp () мебошад. 
 ифодаи зерин ёфта шавад: 
 𝑋 𝑋 
 𝑋 − + − ⋯+ (−)𝑁 ∙ 𝑋𝑁+/((𝑁 + )!)!! 
 (𝑁! = ∙ ∙ …∙ 𝑁). Адади ёфташуда, қимати функсияи sin дар нуқтаи X 
 мебошад. 
 ифодаи зерин ёфта шавад: 
 𝑋 𝑋 𝑋𝑁 
 − + − ⋯+ (−)𝑁 ∙!! (𝑁)! 
 (𝑁! = ∙ ∙ …∙ 𝑁). Адади ёфташуда, қимати функсияи cos дар нуқтаи X 
 мебошад. 
 Қимати ифодаи зерин ёфта шавад: 
 𝑋 𝑋 𝑋𝑁 
 𝑋 − + − ⋯+ (−)𝑁− ∙. 
 𝑁 
 Адади ёфташуда, қимати функсияи ln дар нуқтаи X+ мебошад. 
 Қимати ифодаи зерин ёфта шавад: 
 𝑋 𝑋 𝑋𝑁+ 
 𝑋 − + − ⋯+ (−)𝑁 ∙. 
 (𝑁+) 
 Адади ёфташуда, қимати функсияи 𝑎𝑟𝑐𝑡𝑔 дар нуқтаи X мебошад. 
 Қимати ифодаи зерин ёфта шавад: 
 𝑋 𝑋 𝑋 ∙∙…∙(∙𝑁−)∙𝑋𝑁 
 + − ∙ + ∙ ∙ − ⋯+ (−)𝑁− ∙. 
 ∙ ∙∙ ∙∙…∙(∙𝑁) 
 Адади ёфташуда қимати функсияи √𝑥 + мебошад. 
 дода шудааст. Порчаи [A, B] ба N порчаи баробар тақсим карда 
 шавад, H – дарозии ҳар яки порча баоварда шавад, инчунин гуруҳи 
 нуқтаҳои 𝐴,𝐴 + 𝐻,𝐴 + 𝐻,𝐴 + 𝐻,…,𝐵, ки нуқтаи тақсимшавии 
 порчаро ташкил медиҳад, ёфта шавад. 
 𝑘 
 бо тарзи зерин муайян карда мешавад: 
 (𝐴 +) 
 𝐴 =,𝐴 = 𝑘−,𝑘 =,,…. 
 𝑘 
 𝑘 
 Элементҳои 𝐴,𝐴,…,𝐴 чоп карда шавад. 
 𝑁 
 (типи бутун) бо чунин тарз муайян карда мешавад: 
 𝐹 =, 𝐹 =,𝐹 = 𝐹 + 𝐹, 𝑘 =,,…. 
 𝑘 𝑘− 𝑘− 
 Элементҳои 𝐹,𝐹,…,𝐹 чоп карда шавад. 
 𝑁 
 𝑘 
 бо чунин тарз муайян карда мешавад: 
 𝐴 =,𝐴 =,𝐴 = (𝐴 + 𝐴 )/,𝑘 =,,… 
 𝑘 𝑘− 𝑘− 
 Элементҳои 𝐴,𝐴,…,𝐴 чоп карда шавад. 
 𝑁 
 𝑘 
 бо чунин тарз муайян карда мешавад: 
 𝐴 =,𝐴 =,𝐴 =,𝐴 = 𝐴 + 𝐴 − 𝐴,𝑘 =,,… 
 𝑘 𝑘− 𝑘− 𝑘− 
 Элементҳои 𝐴,𝐴,𝐴,…,𝐴 чоп карда шавад. 
 𝑁 
 + + ⋯+ 𝑁𝑘, ҳисоб карда шавад. Барои замнашудани ададҳои 
 бутун, ҷамъшавандагони ин суммаро бо ёрии тағйирёбандаҳои 
 ҳақиқӣ ҳисоб намуда, натиҷаро дар намуди адади ҳақиқӣ хориҷ 
 намоед. 
 𝑁 + 𝑁− + ⋯+ 𝑁, ҳисоб карда шавад. Барои замнашудани ададҳои 
 бутун, ҷамъшавандагони ин суммаро бо ёрии тағйирёбандаҳои 
 ҳақиқӣ ҳисоб намуда, натиҷаро дар намуди адади ҳақиқӣ хориҷ 
 намоед. 
 дар байни ададҳои A ва B буда, хориҷ карда шаванд, инчунин: адади 
 А бояд як маротиба, адади А+ ду маротиба ва ғайра, бароварда 
 шавад. 
 Масъалаҳои гуруҳи While 
 барномасозии PascalABC.NET, C++, C#, Python, Java ва GO-ро аз [-] 
 азбар намоед. 
 Python, Java ва GO нависед. 
 Намунаи ҳалли масъалаҳо 
 дарозиаш 𝑎, миқдори максималии порчаҳои имконпазири дарозии 𝑏 
 ҷойгир карда шудааст. Бе истифода аз амали зарб ва тақсим дарозии 
 қисми холигии порчаи 𝑎 ёфта шавад. 
 PascalABC.NET C++ 
 Var #include <iostream> 
 A, B, temp: Integer; using namespace std; 
 int main() 
 begin { 
 Readln(A, B); int a,b; 
 temp:=A; cin>>a>>b; 
 while temp >= do int temp=a; 
 temp:=temp-B; while (temp>=){ 
 Writeln(temp+B); temp -=b; 
 end. } 
 cout<<temp+b; 
 system("pause"); 
 return; 
 } 
 Python C# 
 a=int(input( )) public static void Main(string[] args) 
 b=int(input( )) { 
 while (a>=b): int a, b; 
 a=a-b a=Convert.ToInt(Console.ReadLine()); 
 print(a) b=Convert.ToInt(Console.ReadLine()); 
 while (a >=b){ 
 a=a-b; 
 Console.WriteLine(a+" "); 
 } 
 Console.WriteLine( a); 
 Console.ReadKey(true); 
 } 
 Java Go 
 public static void main(String[]args) package main 
 { import "fmt" 
 int a,b; func main() { 
 Scanner sc=new Scanner(System.in); var a,b int 
 a=sc.nextInt(); fmt.Scanf("%d %d", 
 b=sc.nextInt(); &a,&b) 
 while(a>=b){ for a>b{ 
 a=a-b; a=a-b 
 } } 
 System.out.println(a); fmt.Println(a) 
 } } 
 гоҳ true, агар не false хориҷ карда шавад. 
 PascalABC.NET C++ 
 Var #include <iostream> 
 A, temp: Integer; using namespace std; 
 int main() 
 begin { 
 Readln(A); int a; 
 temp:=A; cin>>a; 
 while temp < A do while (a%==) 
 temp:=temp*; a /=; 
 Write(temp=A); cout<<(a==); 
 end. system("pause"); 
 return; 
 } 
 Python C# 
 a=int(input( )) public static void Main(string[] args) 
 while (a%==): { 
 a/= int a; 
 print(a==) bool s; 
 a=Convert.ToInt(Console.ReadLine()); 
 while (a%==){ 
 a=a/; 
 } 
 Console.WriteLine(a==); 
 Console.ReadKey(true); 
 } 
 Java GO 
 public static void main(String[] args) package main 
 import "fmt" 
 { 
 func main() { 
 int a; 
 var a int 
 Scanner sc=new Scanner(System.in); 
 fmt.Scanf("%v",&a) 
 a=sc.nextInt(); for a%== { 
 while(a%==){ a=a/; 
 } 
 a=a/; 
 fmt.Println(a==) 
 } 
 } 
 System.out.println(a==); 
 } 
 𝑁 = 𝑘. Адади бутуни К – нишондиҳандаи ин дараҷа ёфта шавад. 
 PascalABC.NET C++ 
 Var #include <iostream> 
 N, K: Integer; using namespace std; 
 int main(){ 
 begin int n; 
 Readln(N); cin>>n; 
 K:=; int k=; 
 while n > do while (n>){ 
 begin ++k; 
 n:=n div; n/=; 
 inc(K); } 
 end; cout<<k<<endl; 
 Writeln(K); system("pause"); 
 end. return; 
 } 
 Python C# 
 n=int(input()) public static void Main(string[] args){ 
 k= int n, k=; 
 n=Convert.ToInt(Console.ReadLine()); 
 while (<n): 
 while (n > ){ 
 n=n/; 
 n=n/; 
 k+= 
 k++; 
 print(k) 
 } 
 Console.WriteLine(k); 
 Console.ReadKey(true); 
 } 
 Java GO 
 public static void main(String[]args) package main 
 { import "fmt" 
 int n,k=; func main() { 
 Scanner sc=new Scanner(System.in); var k,n int 
 n=sc.nextInt(); fmt.Scanf("%d",&n) 
 while(n>){ k= 
 k++; for n> { 
 n=n/; k++; 
 } n=n/; 
 System.out.println(k); } 
 } fmt.Println(k) 
 } 
 К ёфта шавад, ки квадрати он аз N калон намебошад: 𝐾 ≤ 𝑁. Функсияи 
 ҳисобкунии решаи квадратӣ истифода бурда нашавад. 
 PascalABC.NET C++ 
 Var #include <iostream> 
 N, k: Integer; using namespace std; 
 int main() 
 begin { 
 Readln(N); int n, k=; 
 K:=; cin>>n; 
 while Sqr(K) <=N do while (k*k<=n) 
 inc(K, ); ++k; 
 Writeln(K-); cout<<k-; 
 end. system("pause"); 
 return; 
 } 
 Python C# 
 n=int(input()) public static void Main(string[] args) 
 k= { 
 while (k*k<=n): Double n, k=, t; 
 k+= n=Convert.ToInt(Console.ReadLine()); 
 print(k-) while ((k*k)<=n){ 
 k++; 
 } 
 Console.WriteLine(k-); 
 Console.ReadKey(); 
 } 
 Java GO 
 public static void main(String[] package main 
 import "fmt" 
 args) { 
 func main() { 
 int n,k=; 
 var k,n int 
 Scanner sc=new 
 fmt.Scanf("%d",&n) 
 Scanner(System.in); k= 
 n=sc.nextInt(); for k*k<=n { 
 k++; 
 while(k*k<=n){ 
 } 
 k++; 
 fmt.Println(k-) 
 } 
 } 
 System.out.println(k-); 
 } 
 ададҳои бутуни К ёфта шавад, ки барои он суммаи + + ⋯+ 𝐾 хурд ё 
 баробари N бошад ва қимати худи суммаро хориҷ кунед. 
 PascalABC.NET C++ 
 Var #include <iostream> 
 N, K, S: Integer; using namespace std; 
 begin int main() 
 Readln(N); { 
 K:=; int N; 
 S:=; int K=; 
 while S < N do int S=; 
 begin cin >> N; 
 inc(K, ); while(S < N) 
 S:=S+K; { 
 end; K++; 
 Writeln(K, ' ', S); S +=K; 
 end. } 
 cout <<K<<" " << S << endl; 
 system("pause"); 
 return; 
 } 
 Python C# 
 n=int(input()) public static void Main(string[] args) 
 S= { 
 k= Double n, s=, k=; 
 while (S<n): n=Convert.ToInt(Console.ReadLine()); 
 k+= while (s < n){ 
 S+=k k++; 
 print(k) s=s+k; 
 print(s) } 
 Console.WriteLine(k+’ ‘+s); 
 Console.ReadKey(true); 
 } 
 Java GO 
 public static void main(String[] args) package main 
 { import "fmt" 
 int n,k=,s=; func main() { 
 Scanner sc=new Scanner(System.in); var k,n,s int 
 n=sc.nextInt(); fmt.Scanf("%d",&n) 
 while(s<n){ s= 
 k++; k= 
 s=s+k; for s<n { 
 } k++; 
 System.out.println(k+" "+s); s=s+k; 
 } } 
 fmt.Println(k," ",s) 
 } 
 пасандоз Р фоиз аз ҳаҷми пасандози мавҷуда зиёд мешавад (Р – адади 
 ҳақиқӣ <P<). Пас аз чанд моҳ бо дода шудани Р ҳаҷми пасандоз аз 
 сомонӣ зиёд мешавад? Адади К (адади бутун) миқдори моҳҳо ва натиҷаи 
 ниҳоии пасандози S (адади ҳақиқӣ) хориҷ карда шавад. 
 PascalABC.NET C++ 
 Var #include <iostream> 
 P, S: Real; using namespace std; 
 K: Integer; int main() 
 { 
 begin float p; 
 Readln(P); cin>>p; 
 K:=; int k=; 
 S:=; float s=; 
 while S <= do while (s<=) { 
 begin ++k; 
 inc(K, ); s+=s*p/; 
 S:=S+S*P/; } 
 end; cout<<k<<" "<<s; 
 Writeln(K, ' ', S); system("pause"); 
 end. return; 
 } 
 Python C# 
 p=float(input()) public static void Main(string[] args) 
 S=. { 
 k= float p; 
 while (S<): p=Convert.ToDouble(Console.ReadLine()); 
 k+= int k=; 
 S+=(S*p)/; float s=; 
 print(k) while (s<=) { 
 print(s) ++k; 
 s+=s*p/; 
 } 
 Console.WriteLine(k+" "+s); 
 Console.ReadKey(true); 
 } 
 Java GO 
 public static void main(String[]args) package main 
 import "fmt" 
 { 
 func main() { 
 double p,k=,s=; 
 var k,p,s float 
 Scanner sc=new Scanner(System.in); 
 fmt.Scanf("%v",&p) 
 p=sc.nextDouble(); s= 
 while(s<=){ k= 
 for s<= { 
 k++; 
 k++; 
 s=s+*p/; 
 s=s+*p/; 
 } 
 } 
 System.out.println(k+" "+s); fmt.Println(k," ",s) 
 } } 
 бутун ва бақия аз тақсими бутун, рақамҳои ин ададро сар карда аз 
 разряди ибтидоӣ (разряди воҳидӣ), чоп карда шавад. 
 PascalABC.NET C++ 
 Var #include <iostream> 
 N: Integer; using namespace std; 
 int main(){ 
 begin int n; 
 Readln(N); cin>>n; 
 while N > do while (n>) { 
 begin cout<<n%; 
 Writeln(N mod ); n /=; 
 N:=N div; } 
 end; system("pause"); 
 end. return; 
 } 
 Python C# 
 n=int(input()) public static void Main(string[] args){ 
 while (n>): int n; 
 print(n%) n=Convert.ToInt(Console.ReadLine()); 
 n//= while (n>) { 
 Console.WriteLine(n%); 
 n /=; 
 } 
 Console.ReadKey(); 
 } 
 Java GO 
 public static void main(String[] args) package main 
 { import "fmt" 
 int n; func main(){ 
 Scanner sc=new Scanner(System.in); var n int 
 n=sc.nextInt(); fmt.Scanf("%d",&n) 
 while(n>){ s= 
 System.out.print(n%); for n> { 
 n=n/; fmt.Println(n%) 
 } n=n/; 
 } } 
 } 
 бутун ва бақия аз тақсими бутун, муайян карда шавад, ки дар навишти 
 адади N, рақами мавҷуд аст ё не. Агар мавҷуд бошад, он гоҳ true, 
 вагарна не false чоп карда шавад. 
 PascalABC.NET C++ 
 Var #include <iostream> 
 N: Integer; using namespace std; 
 begin int main() 
 Readln(N); { 
 while (N > ) and ((N int n; 
 mod ) <> ) do cin>>n; 
 begin while((n>)&((n%)!=)) { 
 N:=N div; n /=; 
 end; } 
 Writeln((N mod )=); cout<<((n>)&((n%)==)); 
 end. system("pause"); 
 return; 
 } 
 Python C# 
 n=int(input( )) public static void Main(string[] args) 
 while ((n%)%==): { 
 n//= int n; 
 print((n%)%==) n=Convert.ToInt(Console.ReadLine()); 
 while((n>)&((n%)!=)) { 
 n /=; 
 } 
 Console.WriteLine( ((n>)&(n%)==)); 
 Console.ReadKey(); 
 } 
 Java GO 
 public static void main( package main 
 String[] args) import "fmt" 
 { func main() { 
 int n; var n int 
 Scanner sc=new Scanner( fmt.Scanf("%d",&n) 
 System.in); for ((n>)&((n%)!=)) 
 n=sc.nextInt(); { 
 while((n>)&((n%)!=)){ n=n/; 
 n=n/; } 
 } System.out.print((n>)& fmt.Println((n>)&((n%)==)) 
 ((n%)==)); } 
 } 
 Евклид: КТУ(𝐴,𝐵) = КТУ(𝐵,𝐴 𝑚𝑜𝑑 𝐵),агар 𝐵 ≠; КТУ(𝐴,) = 
 калонтарин тақсимкунандаи умумии онҳо ёфта шавад. 
 PascalABC.NET C++ 
 Var #include <iostream> 
 A, B: Integer; using namespace std; 
 begin int main(){ 
 Readln(A, B); int a,b; 
 while (A<>) and (B<>) do cin>>a>>b; 
 begin while ((a!=)&(b!=)){ 
 if a > b then if (a>b) a=a%b; 
 A:=(a mod b) else b=b%a; 
 else B:=(B mod A); } 
 end; cout<<a+b<<endl; 
 Writeln(A+B); system("pause"); 
 end. return; 
 } 
 Python C# 
 a=int(input()) public static void Main(string[] args){ 
 b=int(input()) int a,b; 
 while ((a!=) and a=Convert.ToInt(Console.ReadLine()); 
 (b!=)): b=Convert.ToInt(Console.ReadLine()); 
 if (a>b): while ((a!=)&(b!=)){ 
 a=a%b if (a>b) 
 else: a=a%b; 
 b=b%a else 
 print(a+b) b=b%a; 
 } 
 Console.WriteLine( a+b); 
 Console.ReadKey(); 
 } 
 Java GO 
 public static void main(String[] args){ package main 
 import "fmt" 
 int a,b; 
 func main() { 
 Scanner sc=new Scanner(System.in); 
 var a,b int 
 a=sc.nextInt(); 
 fmt.Scanf("%d %d", 
 b=sc.nextInt(); &a,&b) 
 while(a!=b){ for ((a!=)&(b!=)){ 
 if a>b { 
 if(a>b) 
 a=a%b; 
 a=a-b; 
 }else { 
 else 
 b=b%a; 
 b=b-a; } 
 } fmt.Println(a+b) 
 } 
 System.out.println(a); 
 } 
 } 
 чунин тарз муайян карда мешавад: 
 𝐹 =,𝐹 =,𝐹 = 𝐹 + 𝐹, 𝑘 =,,…. 
 𝑘 𝑘− 𝑘− 
 Санҷед, оё адади додашудаи N адади Фибоначӣ ҳаст ё не. Агар 
 бошад true, вагарна false бароварда шавад. 
 PascalABC.NET C++ 
 Var #include <iostream> 
 N,F,F, F: Integer; using namespace std; 
 begin int main(){ 
 Readln(N); int n; 
 F:=; int f=,f=,f=; 
 F:=; cin>>n; 
 F:=; while (f<n){ 
 while F < N do f=f+f; 
 begin f=f; 
 F:=F+F; f=f; 
 F:=F; } 
 F:=F; cout<<(f==n); 
 end; system("pause"); 
 Writeln(F=N); return; 
 end. } 
 Python C# 
 n=int(input( )) public static void Main(string[] args){ 
 f= int n, f=,f=,f=;; 
 f= n=Convert.ToInt(Console.ReadLine()); 
 f= while (f<n) { 
 while (f<n): f=f+f; 
 f=f+f; f=f; 
 f=f; f=f; 
 f=f } 
 print(f==n) Console.WriteLine(f==n); 
 Console.ReadKey(); 
 } 
 Java GO 
 public static void main(String[] package main 
 import "fmt" 
 args) { 
 func main() { 
 int f=,f=,f=,n; 
 var f=,f=,f=,n int 
 Scanner sc=new Scanner(System.in); 
 fmt.Scanf("%d",&n) 
 n=sc.nextInt(); for f<=n { 
 while (f<n){ f=f+f; 
 f=f; 
 f=f+f; 
 f=f; 
 f=f; 
 fmt.Println(f==n) 
 f=f; 
 } 
 } } 
 System.out.println(f==n); 
 } 
 𝑘 
 бо чунин тарз муайян карда мешавад: 
 𝐴 =,𝐴 = +, 𝑘 =,,…. 
 𝑘 
 𝐴 
 𝑘− 
 Рақами тартибии адади аввали K ёфта шавад, ки шарти зеринро 
 қаноат мекунад: |𝐴 − 𝐴 | < 𝜀, ин рақам ва ададҳои 𝐴, 𝐴 чоп карда 
 𝑘 𝑘− 𝑘 𝑘− 
 шавад. 
 PascalABC.NET C++ 
 Var #include <iostream> 
 k: Integer; using namespace std; 
 A, A, e: Real; int main(){ 
 float e; 
 begin cin>>e; 
 Readln(e); float ak=,ak=; 
 A:=; int k=; 
 A:=; while (fabs(ak-ak)>=e) { 
 K:=; ++k; 
 while Abs(Ak-Ak)>=e do a=a; 
 begin a=+/a; 
 Inc(k, ); } 
 A:=A; cout<<k<<a<<a<<endl; 
 A:=+/A; system("pause"); 
 end; return; 
 Writeln(k, '', A,'', A); } 
 end. 
 Python C# 
 e=float(input()) public static void Main(string[] args) 
 { 
 k= 
 double h,e,a,a; 
 a= 
 e=Convert.ToSingle(Console.ReadLine()); 
 a=+./a; 
 int k=; 
 h=abs(a-a); a=; 
 while (h>=e): a=+./a; 
 k+= h=Math.abs(a-a); 
 a=a; while (h>=e) { 
 a=+./a; ++k; 
 a=a; 
 h=abs(a-a); 
 a=+/a; 
 print(k,' ',a,' ',a) 
 h=math.Abs(a-a); 
 } 
 Console.WriteLine(k+” “+a+” “+a); 
 Console.ReadKey(); 
 } 
 Java GO 
 public static void main(String[] package main 
 import ( 
 args) { 
 "fmt" 
 double a,a, h,eps; 
 "math" 
 int k=; 
 ) 
 Scanner sc=new Scanner( func main() 
 System.in); { 
 var a,a, h,eps float 
 eps=sc.nextDouble(); 
 var k int 
 a=; 
 fmt.Scanf("%v",&eps) 
 a=+./a; 
 a=; 
 h=Math.abs(a-a); k=; 
 while (h>=eps){ a=+./a; 
 h=math.Abs(a-a); 
 k++; 
 for h>=eps { 
 a=a; 
 k++; 
 a=+./a; a=a; 
 h=Math.abs(a-a); a=+./a; 
 h=math.Abs(a-a); 
 } 
 } 
 System.out.println(k+" "+a+ 
 fmt.Println(k," ",a, 
 " "+a); 
 " ",a) 
 } } 
 дарозии тарафҳояш мувофиқан ба A ва B баробар миқдори максималии 
 квадратҳои дарозии тарафашон ба С баробар ҷойгир карда шудааст. 
 Миқдори квадратҳои дар росткунҷа ҷойгирбударо ёбед. Амали зарб ва 
 тақсим истифода бурда нашавад. 
 PascalABC.NET C++ 
 Var #include <iostream> 
 A, B, C,t: Real; using namespace std; 
 K: integer; int main() 
 { 
 begin float a,b,c; 
 Readln(A, B, C); cin>>a>>b>>c; 
 K:=; int k=; 
 while (A-C >=) do float t; 
 begin while ((a-c)>=) { 
 A:=A-C; a=a-c; 
 t:=B; t=b; 
 while (t-C >=) do while (t-c>=){ 
 begin t=t-c; 
 t:=t-C; ++k; 
 inc(K, ); } 
 end; } 
 end; cout<<k<<endl; 
 Writeln(k); system("pause"); 
 end. return; 
 } 
 Python C# 
 a=float(input()) public static void Main(string[] args) 
 b=float(input()) { 
 c=float(input()) float a,b,c; 
 a=Convert.ToSingle(Console.ReadLine()); 
 k= 
 b=Convert.ToSingle(Console.ReadLine()); 
 while ((a-c)>=): 
 c=Convert.ToSingle(Console.ReadLine()); 
 a-=c 
 int k=; 
 t=b float t; 
 while (t-c>=): while ((a-c)>=) { 
 a-=c; 
 t-=c 
 t=b; 
 k+= 
 while (t-c>=){ 
 print(k) 
 t-=c; 
 ++k; 
 } 
 } 
 Console.WriteLine(k); 
 Console.ReadKey(); 
 } 
 Java GO 
 public static void main(String[] package main 
 import "fmt" 
 args) { 
 func main() { 
 double a,b,c,t; 
 var a,b,c,t,k float 
 Scanner sc=new Scanner(System.in); 
 fmt.Scanf("%v %v %v", 
 a=sc.nextDouble(); &a,&b,&c) 
 b=sc.nextDouble(); k=; 
 for ((a-c)>=) { 
 c=sc.nextDouble(); 
 a=a-c; 
 int k=; 
 t=b; 
 while ((a-c)>=) { 
 } 
 a-=c; 
 for (t-c>=) { 
 t=b; t=t-c; 
 while (t-c>=){ ++k; 
 t-=c; } 
 ++k; fmt.Println(s," ") 
 } 
 System.out.println(k); 
 } 
 } 
 Масъалаҳо барои кори мустақилона 
 дарозиаш А, миқдори максималии порчаҳои имконпазири дарозии В 
 ҷойгир шудааст. Бе истифода аз амали зарб ва тақсим, миқдори 
 порчаҳои В – и дар порчаи А ҷойгир буда ёфта шавад. 
 ва тарҳ, қисми тақсими бутуни N ба K ва бақия аз тақсими он ёфта шавад. 
 𝑁‼ = 𝑁 ∙ (𝑁 − ) ∙ (𝑁 − ) ∙ … (ҷамъшавандаи охирон баробари аст, агар
 N – ҷуфт бошад, ва баробари аст, агар N тоқ бошад). 
 мусбати К ёфта шавад, ки квадрати он аз N калон аст: 𝐾 > 𝑁. Функсияи 
 ҳисобкунии решаи квадратии адад истифода бурда нашавад. 
 ададҳои бутуни К ёфта шавад, ки нобаробарии зеринро қаноат мекунад: 
 𝑘 > 𝑁. 
 ададҳои бутуни К ёфта шавад, ки нобаробарии зеринро қаноат мекунад: 
 𝑘 < 𝑁. 
 ададҳои бутуни К ёфта шавад, ки барои он суммаи + + 
 ⋯+ 𝐾 калон ё баробари N бошад ва қимати худи суммаро низ нависед. 
 ададҳои бутуни К ёфта шавад, ки барои он суммаи 
 + ⁄ + ⋯+ ⁄ калони А бошад, қимати худи сумма низ хориҷ 
 К 
 карда шавад. 
 ададҳои бутуни К ёфта шавад, ки ки барои он суммаи 
 + ⁄ + ⋯+ ⁄ хурди А бошад, қимати худи сумма низ хориҷ карда 
 К 
 шавад. 
 намуд. Ҳар рӯзи оянда ин масофаро ба андозаи Р ( < 𝑃 < ) – фоиз 
 зиёд кардан мегирад. Аз рӯи Р – и додашуда муайян кунед, ки пас аз чанд 
 рӯз масофаи умумии тайкардаи лижарон аз км зиёд мешавад. 
 Миқдори рӯзҳои тамрин K(адади бутун) ва суммаи масофаи умумии 
 тайкардашуда S (адади ҳақиқӣ) – ро бароред. 
 ва бақия аз тақсими бутун, миқдори рақамҳо ва суммаи рақамҳои ин 
 адад ёфта шавад. 
 ва бақия аз тақсими бутун, ададе ки ҳангоми аз рост ба чап хондани адади
 N пайдо мешавад, чоп карда шавад. 
 ва бақия аз тақсими бутун, муайян карда шавад, ки дар навишти адади 
 N, рақами тоқ мавҷуд аст. Агар мавҷуд бошад, он гоҳ true, агар не false 
 чоп карда шавад. 
 ҳол false чоп карда шавад. 
 калон аст, ёфта шавад. 
 𝐹 (муайянкунии адади Фибоначӣ дар масъалаи нишон дода шудааст). 
 𝑘 
 Ададҳои бутуни 𝐹 ва 𝐹, ки ададҳои пешоянд ва пасоянди Фибоначӣ 
 𝑘− 𝑘+ 
 мебошанд, ёфта шавад. 
 𝐹 (муайянкунии адади Фибоначӣ дар масъалаи нишон дода шудааст). 
 𝑘 
 Адади бутуни К, ки рақами тартибии Фибоначӣ N аст, ёфта шавад. 
 𝑘 
 бо чунин тарз муайян карда мешавад: 
 𝐴 =,𝐴 =,𝐴 = (𝐴 + ∙ 𝐴 )/, 𝑘 =,,…. 
 𝑘 𝑘− 𝑘− 
 Рақами тартибии адади аввали K ёфта шавад, ки шарти зеринро 
 қаноат мекунад: |𝐴 − 𝐴 | < 𝜀, ин рақам ва ададҳои 𝐴, 𝐴 чоп карда 
 𝑘 𝑘− 𝑘 𝑘− 
 шавад. 
 Масъалаҳои гуруҳи Series 
 Java, GO, Kotlin ва VB.NET-ро аз [-] азбар намоед. 
 PascalABC.Net, C++, C#, Python, Java, GO, Kotlin ва VB.NET нависед. 
 Намунаи ҳалли масъалаҳо 
 PascalABC.NET C++ 
 Var int main() 
 R, Rez: Real; { 
 i: Integer; float S =, r; 
 begin for (int i =; i <=; ++i) { 
 Rez:=; cin >> r; 
 for i:= to do S+= r; 
 begin } 
 Readln(R); cout << S; 
 Rez:= Rez + R; return; 
 end; } 
 Writeln(Rez); 
 end. 
 Python C# 
 S= static void Main(string[] args){ 
 for i in range(,): float a, S =; 
 a=float(input("->")) for (int i=; i<; i++){ 
 S=S+a a=Convert.ToSingle(Console.ReadLine()); 
 print(S) S = S + a; 
 } 
 Console.WriteLine(S); 
 Console.ReadKey(); 
 } 
 Java Go 
 public static void main(String[] package main 
 args){ import "fmt" 
 Scanner sc=new Scanner(System.in); func main() { 
 float a, S =; var S=. 
 for (int i=; i<; i++){ var a=. 
 a =sc.nextFloat(); for i:=; i<=; i++{ 
 S+=a; fmt.Scan(&a) 
 } S=S+a 
 System.out.println(S); } 
 } fmt.Println(S) 
 } 
 Kotlin 
 import java.util.Scanner 
 fun main(args: Array<String>){ 
 var S: Double =. 
 val reader = Scanner(System.`in`) 
 for(i in..){ 
 val x = reader.nextDouble() 
 S=S+x; 
 } 
 println(S) 
 } 
 VB.NET 
 Sub Main() 
 Dim a, S As Single 
 For i As Integer = To 
 a = Convert.ToSingle(Console.ReadLine()) 
 S += a 
 Next 
 Console.WriteLine(S) 
 Console.ReadKey() 
 End Sub 
 мусбат дода шудааст. Қисмҳои бутуни ҳамаи ададҳои маҷмӯи 
 батартибовардашудаи додашуда бо ҳамон тартиби аввала (чун ададҳои 
 ҳақиқӣ бо қисми касрии нулӣ), инчунин суммаи ҳамаи қисми бутуни 
 ададҳо хориҷ карда шаванд. 
 PascalABC.NET C++ 
 Begin int main() 
 write('N = '); { 
 var N:= readInteger; int S =, i; 
 var S: real:=; float r; 
 for var i:= to N do for (i =; i <=; ++i) { 
 begin cin >> r; 
 var a:= readReal; S+= (int)r; 
 S:= S + int(a); cout << (int)r << endl; 
 write(int(a), ' ') } 
 end; cout << S; 
 writeln; return; 
 writeln(S); } 
 end. 
 Python 
 S= 
 n=int(input("->")) 
 for i in range(,n): 
 a=float(input("->")) 
 S=S+int(a) 
 print(int(a)) 
 print(S) 
 анҷомёбии он адади аст, дода шудааст. Миқдори ададҳои аз К хурди 
 маҷмӯи додашуда, хориҷ карда шавад. 
 PascalABC.NET C++ 
 Var #include <iostream> 
 i, R, K: Longint; using namespace std; 
 int main(){ 
 begin int a, i = -, k; 
 readln(K); bool y =; 
 R:=; cin >> k; 
 i:=; do { 
 while(R <> ) do i++; 
 begin cin >> a; 
 Readln(R); if (a > k) 
 if R < K then y =; 
 i +=; } while (a!= ); 
 end; cout<<y<<" "<<i<<endl; 
 i -=; system("pause"); 
 Writeln(i); return; 
 end. } 
 ададҳои ҳақиқие, ки бо тартиби афзуншавӣ омадаанд, дода шудаанд. 
 Элементҳои маҷмӯро якҷоя бо адади B хориҷ карда, тартибро нигоҳ 
 доред. 
 PascalABC.NET C++ 
 var int main(){ 
 n, i, c: integer; int n; 
 b, num: real; float b,r=.; 
 begin cout<<"N, B"; 
 read(n); cin >> n >> b; 
 read(b); bool f=; 
 c:=; for (int i=; i<=n; i++){ 
 for i:= to n do cin>>r; 
 begin if ((b<=r)&&f){ 
 readln(num); cout<<b; 
 if (c=) and (b<num) then f=; 
 begin } 
 writeln(b); cout<< r; 
 c:=; system("pause"); 
 end; return; 
 writeln(num); } 
 end; 
 if c = then write(b); 
 end. 
 бутун дода шудааст. Чунин элементҳои маҷмӯе, ки хурди ҳамсояи чапи 
 худ мебошад ва К миқдори чунин элементҳо, хориҷ карда шавад. 
 PascalABC.NET C++ 
 Var int main(){ 
 i, K, N, Num, Num: Integer; int n, i, a,b, kol=; 
 cin>>n>>b; 
 begin for (i=; i<=n; i++){ 
 Readln(N); cin >> a; 
 K:=; if (a < b) { 
 for i:= to N do cout << a << "\n"; 
 begin kol++; 
 Readln(Num); } 
 if (Num>Num) and (i<>) then b = a; 
 begin } 
 writeln(Num); cout << kol << endl; 
 inc(K); system("pause"); 
 end; return; 
 Num:= Num; } 
 end; 
 Writeln(K); 
 end. 
 ҳақиқӣ дода шудааст. Санҷед, ки маҷмӯи додашуда пайдарпаии 
 афзуншавандаро ташкил мекунад ё не. Агар чунин бошад, он гоҳ true, 
 дар акси ҳол false хориҷ карда шавад. 
 PascalABC.NET C++ 
 Var #include <iostream> 
 a, Prev: real; using namespace std; 
 N, i: byte; int main(){ 
 IncSeq: boolean; int n, i, a,b; 
 begin bool y =; 
 write('N = '); cin>>n>>b; 
 readln(N); for (i=; i<=n; i++){ 
 IncSeq:= true; cin >> a; 
 for i:= to N do if (b>a) 
 begin y =; 
 read(a); b = a; 
 if i > then } 
 if IncSeq then cout << y << endl; 
 if not (a > Prev) then system("pause"); 
 IncSeq:= false; return; 
 Prev:= a } 
 end; 
 writeln; 
 writeln(IncSeq); 
 end. 
 ҳақиқӣ додашудааст. Маҷмӯъ аррамонанд номида мешавад, агар ҳар як 
 элементи дохилии он калон, ё ин ки хурди ҳарду ҳамсояи худ бошад 
 (яъне “дандона”). Агар маҷмӯи додашуда аррамонанд бошад, он гоҳ, 
 дар акси ҳол рақами якуми элемент, ки дандона намебошад чоп карда 
 шавад. 
 PascalABC.NET 
 Var 
 a, Left, Right: real; 
 N, i, Number: byte; 
 begin 
 write('N = '); 
 readln(N); 
 Number:=; 
 for i:= to N do 
 begin 
 read(Right); 
 if i = then 
 Left:= Right 
 else 
 if i = then 
 a:= Right 
 else begin 
 if Number = then 
 if not (((a < Right) and (a < Left)) or 
 ((a > Right) and (a > Left))) then 
 Number:= i; 
 Left:= a; 
 a:= Right 
 end 
 end; 
 writeln; 
 if Number = then 
 writeln('Пайдарпайи дандоншакл аст') 
 else 
 writeln('Раками элементи конуниятро вайронкарда:',Number) 
 end. 
 C++ 
 #include <iostream> 
 using namespace std; 
 bool pilob(int a, int b, int c) { 
 return ((a > b) && (b < c)) || ((a < b) && (b > c)); 
 } 
 int main(){ 
 int n, i, a, b, h; 
 bool y=; 
 cin>>n>>a>>h; 
 for (i=; i<=n; i++){ 
 cin >> b; 
 if (!pilob(a, h, b)) 
 y=; 
 cout << a << " " << h << " " << b << endl; 
 a = h; 
 h = b; 
 } 
 cout << y << endl; 
 system("pause"); 
 return; 
 } 
 Series. Даврҳои мураккаб 
 ҳақиқии 𝐴,𝐴,…,𝐴 дода шудааст. Дараҷаи К – юми ададҳои додашудаи 
 𝑁 
 маҷмӯъ хориҷ карда шавад: (𝐴 )𝐾,(𝐴 )𝐾,…,(𝐴 )𝐾. 
 𝑁 
 PascalABC.NET 
 Var 
 K, N, i, j: byte; 
 A, S: real; 
 begin 
 write('K = '); readln(K); 
 write('N = '); readln(N); 
 for i:= to N do 
 begin 
 writeln; 
 write('A', i, ' = '); 
 readln(A); 
 S:=; 
 for j:= to K do 
 S:= S * A; 
 writeln(' --> ', A, '^', K, ' = ', S) 
 end; 
 end. 
 C++ 
 int main(){ 
 int k, n; 
 cin >> n >> k; 
 int i, j; 
 float a, P; 
 for (i =; i <= n; ++i) { 
 cin >> a; 
 P =; 
 for (j =; j <= k; j++) 
 P *= a; 
 cout << P << endl; 
 } 
 system("pause"); 
 return; 
 } 
 батартибовардашудаи ададҳои бутун, ки ҳар яки он аз N элемент иборат 
 аст. Суммаи умумии ҳамаи элементҳои ҳар як маҷмӯҳои 
 батартибовардашударо хориҷ кунед. 
 PascalABC.NET C++ 
 Var #include <iostream> 
 a, Sum: integer; using namespace std; 
 K, N, i, j: byte; 
 int main(){ 
 begin int k, n, i, j,a, S=; 
 write('K = '); cin >> k >> n; 
 readln(K); for (i =; i <= k; ++i) { 
 write('N = '); S =; 
 readln(N); for (j =; j <= n; j++) { 
 for i:= to K do cin >> a; 
 begin S += a; 
 writeln; } 
 Sum:=; cout << "S="<<S << endl; 
 for j:= to N do } 
 begin system("pause"); 
 read(a); return; 
 Sum:= Sum + a } 
 end; 
 writeln(' S= ', Sum) 
 end; 
 end. 
 дода шудааст. Нишонаи анҷомёбии адади аст. Барои ҳар як маҷмӯи 
 батартибовардашуда, миқдори элементҳои он хориҷ карда шавад. 
 Ичунин, миқдори умумии элементҳои ҳар як маҷмӯи 
 батартибовардашуда чоп карда шавад. 
 PascalABC.NET C++ 
 Var #include <iostream> 
 a, Q, count: integer; using namespace std; 
 K, i: byte; int main(){ 
 begin int n, i, j,a, S=, kol; 
 write('K = '); cin >> n; 
 readln(K); for (i =; i <= n; ++i) { 
 Q:=; kol =; 
 for i:= to K do cin >> a; 
 begin while (a!=){ 
 count:=; kol++; 
 repeat cin >> a; 
 read(a); } 
 inc(count) cout << "kol=" << kol << endl; 
 until a =; S += kol; 
 writeln('--> ', count); } 
 Q:= Q + count cout << S << endl; 
 end; system("pause"); 
 writeln('Q= ', Q); return; 
 end. } 
 дода шудааст. Ҳар як маҷмӯи батартибовардашуда дорои на кам аз ду 
 элемент буда, нишонаи анҷомёбии он адади аст. Барои ҳар як маҷмӯи 
 батартибовардашуда амали зерин иҷро карда шавад: агар элементҳои 
 маҷмӯи батартибовардашуда афзуншаванда бошанд, адади бароварда 
 шуда, камшаванда бошанд, адади - ва агар на камшаванда ва на 
 афзуншаванда бошанд адади бароварда шавад. 
 PascalABC.NET C++ 
 Var #include <iostream> 
 a, b, K, i, p: integer; using namespace std; 
 begin int main(){ 
 readln(K); int k; 
 for i:= to K do cin >> k; 
 begin int count=,i,a=,b; 
 read(b); for (i=; i<=k; ++i){ 
 read(a); cout<<">"; 
 if a < b then p:= - cin>>a; 
 else int checkup=, 
 if a > b then p:= checkdown=; 
 else p:=; while(a!=){ 
 while a <> do b=a; 
 begin cout<<">"; 
 if p <> then cin>>a; 
 if (p = -) and (a < b) if ((b<=a)&&(a!=)) 
 or (p=) and (a>b) then checkup=; 
 b:= a if ((b>=a)&&(a!=)) 
 else p:=; checkdown=; 
 read(a) } 
 end; if (checkup&checkdown) 
 writeln(p) cout << "" << endl; 
 end; else if (checkup) 
 cout << "" << endl; 
 end. else if (checkdown) 
 cout << "-" << endl; 
 } 
 system("pause"); 
 return; 
 } 
 Масъалаҳо барои кори мустақилона 
 шавад. 
 шудааст. Сумма ва ҳосили зарби ададҳои аз маҷмӯи додашуда ёфта 
 шаванд. 
 мусбат дода шудааст. Қисмҳои қасрии ҳамаи ададҳои маҷмӯи 
 батартибовардашудаи додашуда бо ҳамон тартиби аввала (чун ададҳои 
 ҳақиқӣ бо қисми бутуни нулӣ), инчунин ҳосили зарби ҳамаи қисми 
 касрии ададҳо, хориҷ карда шаванд. 
 мусбат дода шудааст. Бо ҳамон тартиби аввала қимати 
 яклухткардашудаи ҳамаи ададҳои маҷмӯи батартибовардашуда (ҳамчун 
 ададҳои ҳақиқӣ бо қисми нулии қасрӣ), инчунин суммаи ҳамаи ададҳои 
 яклухткардашуда бароварда шаванд. 
 шудааст. Ҳамаи ададҳои ҷуфти аз маҷмӯи батартибовардашудаи 
 додашуда ба К миқдори чунин ададҳо бо тартиби аввалаашон, хориҷ 
 карда шаванд. 
 шудааст. Ҳамаи ададҳои тоқи маҷмӯи батартибовардашудаи 
 додашударо бо К миқдори чунин ададҳо бо ҳамон тартиби рақамҳои 
 аввала, хориҷ карда шаванд. 
 дода шудааст. Агар дар маҷмӯи батартибовардашудаи додашуда адади 
 мусбат иштирок кунад true, дар акси ҳол false, хориҷ карда шаванд. 
 шудааст. Агар дар маҷмӯи батартибовардашуда адади хурд аз К 
 иштирок кунад, он гоҳ true,дар аски ҳол false, хориҷ карда шавад. 
 он адади мебошад. Миқдори ададҳои маҷмӯъ, хориҷ карда шавад. 
 он адади мебошад. Суммаи ҳамаи ададҳои бутуни ҷуфти маҷмӯи 
 додашуда, хориҷ карда шавад. 
 анҷомёбии он адади аст, дода шудааст. Рақами адади охирони маҷмӯъ, 
 ки аз К хурд аст,хориҷ карда шавад. Агар чунин ададҳо иштирок 
 накунанд, хориҷ карда шавад. 
 анҷомёбии он адади аст, дода шудааст. Рақами адади якуми маҷмӯъ, 
 ки аз К калон аст, хориҷ карда шавад. Агар чунин ададҳо иштирок 
 накунанд, хориҷ карда шавад. 
 ки бо тартиби афзуншавӣ омадаанд, дода шудааст. Маҷмӯӣ додашуда 
 метавонад дорои элементҳои якхела бошад. Бо ҳамон тартиби аввала 
 ҳамаи элементҳои гуногуни маҷмӯъ, хориҷ карда шавад. 
 бутун дода шудааст. Чунин элементҳои маҷмӯе, ки хурди ҳамсояи рости 
 худ мебошад ва К миқдори чунин элементҳо, хориҷ карда шавад. 
 ҳақиқӣ дода шудааст. Агар маҷмӯи додашуда, пайдарпаии 
 камшавандаро ташкил кунад, он гоҳ ва дар акси ҳол рақами якуми 
 адади қонуниятро вайронкунанда, хориҷ карда шавад. 
 ки ҳаддиақал дорои ду нол мебошанд, дода шудааст. Суммаи ададҳои аз 
 маҷмӯи батартибовардашудаи додашуда ро, ки дар байни ду нол 
 мехобанд, хориҷ кунед (агар нолҳо пайдарҳам омада бошанд нол хориҷ 
 карда шаванд). 
 ҳаддиақал дорои ду нол мебошанд, дода шудааст. Суммаи ададҳои аз 
 маҷмӯи батартибовардашудаи додашуда, ки дар байни нолҳои аввалу 
 охир ҷойгиранд, хориҷ карда шавад (агар нолҳо аввалу охир пайи ҳам 
 омадаанд, он гоҳ нол хориҷ карда шавад). 
 Series. Даврҳои дохили ҳам 
 ҳақиқии 𝐴,𝐴,…,𝐴 дода шудааст. Ададҳои зерин хориҷ карда шаванд: 
 𝑁 
 𝐴,(𝐴 ),…,(𝐴 )𝑁−,(𝐴 )𝑁. 
 𝑁− 𝑁 
 ҳақиқии 𝐴,𝐴,…,𝐴 дода шудааст. Ададҳои зерин хориҷ карда шаванд: 
 𝑁 
 (𝐴 )𝑁,(𝐴 )𝑁−,…,(𝐴 ),𝐴. 
 𝑁− 𝑁 
 батартибовардашудаи ададҳои бутун, ки ҳар яки он аз N элемент иборат 
 аст. Барои ҳар як маҷмӯи батартибовардашуда, суммаи элементҳояш 
 ёфта шавад. 
 батартибовардашудаи ададҳои бутун, ки ҳар яки он аз N элемент иборат 
 аст. Шумораи маҷмӯҳои батартибовардашуда, ки дар он адади ду 
 иштирок мекунад, ёфта шавад. Агар чунин маҷмӯи батартибовардашуда 
 вуҷуд надошта бошад, адади чоп карда шавад. 
 батартибовардашудаи ададҳои бутун, ки ҳар яки он аз N элемент иборат 
 аст. Барои ҳар як маҷмӯъ рақами элементи якуми ба ду баробарбудаи он 
 муайян карда шавад, агар чунин элемент набошад, адади бароварда 
 шавад. 
 батартибовардашудаи ададҳои бутун, ки ҳар яки он аз N элемент иборат 
 аст. Барои ҳар як маҷмӯъ рақами тартибии элементи ба ду баробари 
 элементи он ёфта шавад, агар чунин элемент вуҷуд надошта бошад, 
 рақами бароварда шавад. 
 батартибовардашудаи ададҳои бутун, ки ҳар яки он аз N элемент иборат 
 аст. Барои ҳар як маҷмӯи батартибовардашуда амалҳои зерин иҷро 
 карда шаванд: агар дар маҷмӯи батартибовардашуда адади вуҷуд 
 дошта бошад, он гоҳ суммаи элементҳои маҷмӯи батартибовардашуда 
 хориҷ карда шавад, дар акси ҳол. Инчунин миқдори умумии элеметҳои 
 ҳар як маҷмӯи батартибовардашуда, чоп карда шавад. 
 дода шудааст. Ҳар як маҷмӯи батартибовардашуда дорои на кам аз ду 
 элемент буда, нишонаи анҷомёбии он адади аст. Шумораи он 
 маҷмӯъҳои батартибовардашудае, ки элементҳояш бо тартиби 
 афзуншавандагӣ ҷойгиранд, ёфта шавад. 
 дода шудааст. Ҳар як маҷмӯи батартибовардашуда дорои на кам аз ду 
 элемент буда, нишонаи анҷомёбии он адади аст. Шумораи он 
 маҷмӯъҳои батартибовардашудае, ки элементҳои он бо тартиби 
 афзуншавӣ ё камшавӣ ҷойгиранд, ёфта шавад. 
 ғайринулии бутун дода шудааст. Ҳар як маҷмӯи батартибовардашуда 
 дорои на кам аз се элемент мебошанд, ки нишонаи анҷомёбии он аст. 
 Миқдори маҷмӯҳои батартибовардашудаи аррашакл, хориҷ карда 
 шавад. 
 ғайринулии бутун дода шудааст. Ҳар як маҷмӯи батартибовардашуда 
 дорои на кам аз се элемент мебошанд, ки нишонаи анҷомёбии он аст. 
 Барои ҳар як маҷмӯи батартибовардашуда амали зерин иҷро карда 
 шавад: агар маҷмӯи батартибовардашуда аррашакл бошад, он гоҳ 
 шумораи элементҳои он чоп карда шавад, дар акси ҳол рақами тартибии 
 аввалин элементе, ки дандона нест бароварда шавад. 
 Масъалаҳои гурӯҳи Proc 
 Java, GO, Kotlin ва VB.NET-ро аз [-] азбар намоед. 
 PascalABC.Net, C++, C#, Python, Java, GO, Kotlin ва VB.NET нависед. 
 Намунаи ҳалли масъалаҳо 
 А – ро ҳисоб намуда, қимати онро ба B (A – параметри дохилшаванда, 
 B – параметри хориҷшаванда; ҳар ду параметрҳо ҳақиқӣ мебошанд) 
 бармегардонад. Бо ёрии ин протседура дараҷаи сеи панҷ адади 
 додашударо ёбед. 
 PascalABC.NET C++ 
 procedure PowerA(A: Real; void poweraA(float a, float &b){ 
 var B: Real); b=a*a*a; 
 begin } 
 B:= A * A * A; int main(){ 
 end; int i; 
 var for(i=;i<=;++i){ 
 i: Integer; float a,b; 
 A, B: Real; cin>>a>>b 
 begin poweraA(a, b); 
 for i:= to do cout<<b<<" "; 
 begin } 
 Write('A: '); return; 
 Readln(A); } 
 PowerA(A, B); 
 Writeln(B); 
 end; 
 end. 
 Python C# 
 def powerA(x): static void powerA(float a, out float b){ 
 return a*a*a b = a * a * a; 
 for i in range(,): } 
 a=float(input("a")) static void Main(string[] args){ 
 print(powerA(a)) float a, b; 
 for (int i=; i<; i++){ 
 a=Convert.ToSingle(Console.ReadLine()); 
 powerA(a, out b); 
 Console.WriteLine(b); 
 } 
 Console.ReadKey(); 
 } 
 Java Go 
 static void PowerA(double a){ package main 
 double b=a*a*a; import "fmt" 
 System.out.println(b); func PowerA(a float) { 
 } var b=a*a*a; 
 public static void main(String[] fmt.Println(b) 
 args){ } 
 Scanner sc=new Scanner(System.in); func main() { 
 double a, S =; var a float 
 for (int i=; i<; i++){ for i:=; i<; i++ { 
 a=sc.nextDouble(); fmt.Scan(&a) 
 PowerA(a); PowerA(a) 
 } } 
 } } 
 Kotlin 
 import java.util.Scanner 
 fun powerA(a: Double) { 
 var b=Math.pow(a,.) 
 println(b) 
 } 
 fun main(args: Array<String>){ 
 val reader = Scanner(System.`in`) 
 for(i in..){ 
 val x = reader.nextDouble() 
 powerA(x); 
 } 
 } 
 VB.NET 
 Sub PowerA(ByRef x As Integer, ByVal a As Integer) 
 x = a * a * a 
 End Sub 
 Sub Main() 
 Dim a, b As Integer 
 For i As Integer = To 
 a = Convert.ToInt(Console.ReadLine()) 
 PowerA(b, a) 
 Console.WriteLine(b) 
 Next 
 Console.ReadKey() 
 End Sub 
 миёнаи арифметикии AMean(X+Y)/ ва қимати миёнаи геометрии 
 𝐺𝑀𝑒𝑎𝑛 = √𝑋 ∙ 𝑌 ду адади мусбати X ва Y (X ва Y – параметрҳои 
 дохилшаванда, Amean ва GMean параметрҳои хориҷшандаи типашон 
 ҳақиқӣ). Бо ёрии ин протседура барои ҷуфтҳо (A,B), (A,C), (A,D) 
 қимати миёнаи арифметикӣ ва қимати миёнаи геометрӣ ёфта шавад, 
 агар A,B,C,D дода шуда бошад. 
 PascalABC.NET C++ 
 procedure Mean(X, Y: Real; var #include <iostream> 
 AMean, GMean: Real); #include <cmath> 
 begin using namespace std; 
 AMean:= (X + Y) /; void Mean(float x, float y, float 
 GMean:= sqrt(X * Y); &a, float &g) { 
 end; a = (x + y) /; 
 g = sqrt(x*y); 
 var } 
 i: Integer; int main(){ 
 A, B, C, D, AMean, GMean: float a, b, c, d, x, y; 
 Real; cin >> a >> b >> c >> d; 
 Mean(a, b, x, y); 
 begin cout << x << " " << y << endl; 
 Mean(a, c, x, y); 
 Write('A,B,C,D: '); cout << x << " " << y << endl; 
 Readln(A, B, C, D); Mean(a, d, x, y); 
 cout << x << " " << y << endl; 
 Mean(A, B, AMean, GMean); system("pause"); 
 Writeln(AMean, ' ', GMean); return; 
 } 
 Mean(A, C, AMean, GMean); 
 Writeln(AMean, ' ', GMean); 
 Mean(A, D, AMean, GMean); 
 Writeln(AMean, ' ', GMean); 
 end. 
 Python C# 
 import math static void Mean(double x, double y, out 
 def Mean(x,y): double a, out double g) 
 a=(x+y)/ { 
 g=math.sqrt(x*y) a=(x+y)/; 
 return(a,g) g=Math.Sqrt(x*y); 
 for i in range(,): } 
 a=float(input("a")) static void Main(string[] args){ 
 b=float(input("b")) double a,b,c,d,x,y; 
 print(Mean(a,b)) a=Convert.ToSingle(Console.ReadLine()); 
 b=Convert.ToSingle(Console.ReadLine()); 
 c=Convert.ToSingle(Console.ReadLine()); 
 d=Convert.ToSingle(Console.ReadLine()); 
 Mean(a,b, out x, out y); 
 Console.WriteLine("AMean={} 
 GMean={}", x,y); 
 Mean(a, c, out x, out y); 
 Console.WriteLine("AMean={} 
 GMean={}", x, y); 
 Mean(a, d, out x, out y); 
 Console.WriteLine("AMean={} 
 GMean={}", x, y); 
 Console.ReadKey(); 
 } 
 Go 
 package main 
 import ( 
 "fmt" 
 "math" 
 ) 
 func Mean(x,y float) (float,float) { 
 var a=(x+y)/; 
 var g=math.Sqrt(x*y) 
 return a,g 
 } 
 func main() { 
 var a,b float 
 for i:=; i<; i++ { 
 fmt.Print("a, b->") 
 fmt.Scan(&a,&b) 
 fmt.Println( 
 Mean(a,b)) 
 } 
 } 
 бутуни мусбати К, инчунин сумма онҳо S ( K – параметри 
 дохилшаванда, С ва S – параметрҳои хориҷшаванда) – ро дар бар 
 мегирад, тасвир кунед. Бо ёрии ин протседура миқдор ва суммаи 
 рақамҳоро аз панҷ адади додашуда ҳисоб кунед. 
 PascalABC.NET C++ 
 procedure DigitCountSum(K: #include <iostream> 
 Integer; var C, S: Integer); using namespace std; 
 var void DigitCountSum(int k, int &c, 
 TempI: Integer; int &S) { 
 begin c = S =; 
 C:=; while (k!= ) { 
 S:=; S = S + k /; 
 while (k <> ) do c++; 
 begin k = k /; 
 S:= S + (K mod ); } 
 C:= C +; } 
 K:= K div; int main(){ 
 end; int i,k, c, S; 
 end; for (i =; i <; i++) { 
 var cin >> k; 
 i, K, C, S: Integer; DigitCountSum(k, c, S); 
 begin cout << "c="<<c << " 
 for i:= to do S=" << S << endl; 
 begin } 
 Write('K: '); system("pause"); 
 Readln(K); return; 
 DigitCountSum(K, C, S); } 
 Writeln(C, ' ', S); 
 end; 
 end. 
 Go 
 package main 
 import "fmt" 
 func digitcountsum(x int) (int, int) { 
 var s= 
 var k= 
 for x!={ 
 s=s+x% 
 x=x/ 
 k++; 
 } 
 return k,s 
 } 
 func main() { 
 var a int 
 for i:=; i<; i++ { 
 fmt.Print("a->") 
 fmt.Scan(&a) 
 fmt.Println(digitcountsum(a)) 
 } 
 } 
 мекунад (X ва Y – параметрҳои ҳақиқие, ки дар як вақт ҳам параметри 
 дохилшаванда ва ҳам параметри хориҷшаванда мешавад), тасвир 
 кунед. Бо воситаи он, барои додашудаҳои A ва B, C ва D, B ва C иваз 
 карда шавад ва қиматҳои нави A,B,C,D чоп карда шавад. 
 PascalABC.NET C++ 
 procedure Swap(var X,Y: Real); #include <iostream> 
 begin using namespace std; 
 (X,Y):=(Y,X); void swap(int &a, int &b) { 
 end; int h = a; 
 a = b; 
 var b = h; 
 A,B,C,D:Real; } 
 int main(){ 
 begin int a, b, c, d; 
 Write('A,B,C,D:'); cin >> a >> b >> c >> d; 
 Readln(A,B,C,D); swap(a, b); 
 Swap(A,B); swap(c, d); 
 Swap(C,D); swap(b, c); 
 Swap(B,C); cout << a << " " << b << " " 
 Writeln(A,' ',B,' ',C,' ',D); << c << " " << d << endl; 
 end. system("pause"); 
 return; 
 } 
 Go 
 package main 
 import "fmt" 
 func swap(x,y int) (int, int) { 
 return y,x 
 } 
 func main() { 
 var a,b,c,d int 
 fmt.Print("a,b,c,d->") 
 fmt.Scan(&a,&b,&c,&d) 
 fmt.Println(swap(a,b)) 
 fmt.Println(swap(c,d)) 
 fmt.Println(swap(b,c)) 
 } 
 Kotlin 
 import java.util.Scanner 
 fun swap(a: Float, b:Float): Unit { 
 println("b=$a a=$b") 
 } 
 fun main(args: Array<String>){ 
 val reader = Scanner(System.`in`) 
 var a=reader.nextFloat() 
 var b=reader.nextFloat() 
 var c=reader.nextFloat() 
 var d=reader.nextFloat() 
 swap(a,b) 
 swap(c,d) 
 swap(b,c) 
 } 
 Функсияҳо бо параметрҳои ададӣ 
 қиматҳои зеринро бармегардонад: -, агар x< бошад,, агар x= 
 бошад,, агар x> бошад, тасвир намоед. Бо воситаи ин функсия 
 қимати ифодаи sign(A)+sign(B)-ро, барои додашудаҳои ададҳои A ва 
 B, ҳисоб кунед. 
 PascalABC.NET C++ 
 function Sign(X: Real): #include <iostream> 
 Integer; using namespace std; 
 begin int sign(float x) { 
 if X< then Sign:=-; if (x<) 
 if X= then Sign:=; return -; 
 if X> then Sign:=; if (x == ) 
 end; return; 
 if (x>) 
 var return; 
 A, B: Real; } 
 int main(){ 
 begin float a, b; 
 Write('A,B:'); cin >> a >> b; 
 Readln(A, B); int c = sign(a) + sign(b); 
 Writeln(Sign(A) + cout << c<<endl; 
 Sign(B)); system("pause"); 
 end. return; 
 } 
 Python C# 
 def sign(x): package main 
 if x<: import "fmt" 
 return - func sign(x float) (int) { 
 elif x>: if x<{ 
 return return - 
 else: } else if x>{ 
 return return 
 a=float(input("a")) } else{ 
 b=float(input("b")) return 
 S=sign(a)+sign(b) } 
 print(S) } 
 func main() { 
 var a, b float 
 fmt.Print("a,b->") 
 fmt.Scan(&a,&b) 
 var c=sign(a)+sign(b) 
 fmt.Println(c) 
 } 
 Kotlin 
 import java.util.Scanner 
 fun sign(a: Float):Int{ 
 if (a<) 
 return - 
 else if (a>) 
 return 
 else 
 return 
 } 
 fun main(args: Array<String>) { 
 val reader = Scanner(System.`in`) 
 var a = reader.nextFloat() 
 var b = reader.nextFloat() 
 var c = sign(a) + sign(b); 
 println(c) 
 } 
 VB.NET 
 Function Sign(x As Single) As Integer 
 If x > Then 
 Return 
 ElseIf x < Then 
 Return - 
 Else 
 Return 
 End If 
 End Function 
 Sub Main() 
 Dim a, b As Single 
 Dim m As Integer 
 a = Convert.ToSingle(Console.ReadLine()) 
 b = Convert.ToSingle(Console.ReadLine()) 
 m = Sign(a) + Sign(b) 
 Console.WriteLine(m) 
 Console.ReadKey() 
 End Sub 
 бутуни дар фосилаи аз А то В (А ва В, низ инчунин) бударо ҳисоб 
 мекунад, тасвир кунед. Агар A>B бошад, он гоҳ функсия нол бахшад. 
 Бо ёрии ин функсия суммаи ададҳои аз А то В ва аз В то С, агар 
 ададҳои А,В,С дода шуда бошанд, ёфта шавад. 
 PascalABC.NET C++ 
 function SumRange(A, B: #include <iostream> 
 Integer): Integer; using namespace std; 
 var int sumrange(int a, int b) { 
 i, S: Integer; int sum =; 
 begin for (; a <= b; ++a) 
 S:=; sum += a; 
 for i:= A to B do return sum; 
 begin } 
 S:= S + i; int main(){ 
 end; int a, b, c, S, S; 
 SumRange:= S; cin >> a >> b>>c; 
 end; S = sumrange(a, b); 
 S = sumrange(b, c); 
 var cout <<S<<" "<<S<<endl; 
 A, B, C: Integer; system("pause"); 
 return; 
 begin } 
 Write('A,B,C:'); 
 Readln(A, B, C); 
 Writeln(SumRange(A, B)); 
 Writeln(SumRange(B, C)); 
 end. 
 Go 
 package main 
 import "fmt" 
 func sum(a,b int) (int) { 
 var s= 
 for;a<=b; a++{ 
 s+=a 
 } 
 return s 
 } 
 func main() { 
 var a, b,c int 
 fmt.Print("a,b,c->") 
 fmt.Scan(&a,&b, &c) 
 fmt.Println(sum(a,b)) 
 fmt.Println(sum(b,c)) 
 } 
 N(>) адади сода бошад, қимати true мебахшад ва дар акси ҳол false 
 аст, тасвир кунед. Маҷмӯи аз адади бутун дода шуда, калони 
 мебошад. Бо воситаи функсияи IsPrime, миқдори ададҳои сода дар 
 маҷмӯи ададҳои сода ёфта шавад. 
 PascalABC.NET C++ 
 function IsPrime(N: Integer): #include <iostream> 
 Boolean; #include <cmath> 
 var using namespace std; 
 i: integer; int isprime(int n) { 
 begin int i, p =; 
 i:=; for (i=;i<=(int)sqrt(n);i++) 
 IsPrime:= True; if (n%i == ) { 
 while(i<=trunc(sqrt(N)))do p =; 
 begin break; 
 Inc(i); } 
 if N mod i = then return p; 
 begin } 
 I:= N; int main(){ 
 IsPrime:= False; int i, n, res =; 
 end; for (i =; i <=; ++i) { 
 end; cin >> n; 
 end; res += isprime(n); 
 } 
 var cout << res << endl; 
 i, N, Res: Integer; system("pause"); 
 return; 
 begin } 
 Res:=; 
 for i:= to do 
 begin 
 Write('N:'); 
 Readln(N); 
 if IsPrime(N) then 
 Inc(Res); 
 end; 
 Writeln(Res); 
 end. 
 Go 
 package main 
 import "fmt" 
 func isprime(a int) (bool) { 
 var y bool=true 
 for i:=; i< a/; i++{ 
 if (a%i==){ 
 y=false 
 break 
 } 
 } 
 return y 
 } 
 func main() { 
 var a,k int=, 
 fmt.Print("a->") 
 for i:=; i<=; i++{ 
 fmt.Scan(&a) 
 if (isprime(a)){ 
 k++ 
 } 
 } 
 fmt.Println(k) 
 } 
 Масъалаҳо барои кори мустақилона 
 тартиби дуюм, сеюм ва чоруми адади А – ро ҳисоб намуда, қимати 
 онро мувофиқан ба тағийрёбандаҳои B,C ва D (А – параметри 
 дохилшаванда, B,C,D – параметрҳои хориҷшаванда; ҳамаи 
 параметрҳо ҳақиқӣ мебошанд), мебахшад. Бо ёрии ин протседура 
 дараҷаи дуюм, сеюм ва чоруми панҷ адади додашударо ёбед. 
 додашудаи a – и секунҷаи баробартарафи периметраш 𝑃 = ∙ 𝑎 ва 
 масоҳат 𝑆 = 𝑎√/, (a – параметри дохилшаванда, P ва S – 
 параметрҳои хориҷшаванда; ҳамаи параметрҳо ҳақиқӣ мебошанд), 
 ёфта шаванд. Бо воситаи ин протседура периметр ва масоҳати се 
 секунҷаи баробартараф бо тарафҳои додашуда, ёфта шавад. 
 периметраш P ва масоҳаташ S буда тарафҳояш ба тирҳои координатӣ 
 параллел аз рӯи координатаҳои қуллаҳояш муқобил (𝑥,𝑦 ) ва (𝑥,𝑦 ) 
 ҳисоб кунад ( 𝑥,𝑦,𝑥,𝑦 – параметрҳои дохилшаванда ва P,S – 
 параметрҳои хориҷшаванда). Бо воситаи ин протседура масоҳат ва 
 периметри се росткунҷаи бо қуллаҳои муқобили додашударо ёбед. 
 бутуни мусбати К ба баръакси онро (К – параметри типаш бутун, ки 
 дар як вақт дохшаванда ва хориҷшаванда мебошад), иваз мекунад. Бо 
 воситаи ин протседура тартиби панҷ адади бутуни додашуда, иваз 
 карда шавад. 
 бутуни мусбати К, адади D – ро ҳамроҳ мекунад, (D – параметри 
 дохилшавандаи бутун, ки дар фосилаи аз то мехобад, К – дар як 
 вақт ҳам параметри дохилшаванда ва ҳам хориҷшаванда) тасвир 
 кунед. Бо воситаи ин протседура пайи ҳам аз тарафи рости адади К 
 додашудаҳои адади 𝐷 ва 𝐷 – ро ҳамроҳ кунед ва ҳар дохилшавӣ 
 хориҷ карда шавад. 
 мусбати К, адади D – ро ҳамроҳ мекунад, (D – параметри 
 дохилшавандаи бутун, ки дар фосилаи аз то мехобад, К – дар як 
 вақт ҳам параметри дохилшаванда ва ҳам хориҷшаванда) тасвир 
 кунед. Бо воситаи ин протседура пайи ҳам аз тарафи чапи адади К 
 додашудаҳои адади 𝐷 ва 𝐷 – ро ҳамроҳ кунед ва ҳар дохилшавӣ 
 хориҷ карда шавад. 
 минималии X ва Y, ва дар Y қимати максималии онҳоро сабт мекунад 
 (X ва Y – параметрҳои ҳақиқие, ки ҳамзамон параметрҳои 
 дохилшаванда ва хориҷшаванда мебошанд), тасвир кунед. Бо 
 истифода аз чор муроҷиат ба ин протседура аз ададҳои додашудаи 
 A,B,C,D минималӣ ва максималии онҳо ёфта шавад. 
 – ро чунин тарз иваз мекунад, ки қиматҳои онҳо ба таври 
 афзуншавандагӣ ба тартиб овардашудаанд (A,B,C - A,B,C – 
 параметрҳои ҳақиқие, ки дар як муддат ҳам дохилшаванда ва ҳам 
 хориҷшанда мебошанд), тасвир карда шавад. Бо воситаи ин 
 протседура маҷмӯи аз се адади додашуда иборатро ба таври 
 афзуншавӣ бо ду додашудаҳо тасвир кунед: (𝐴,𝐵,𝐶 ) ва (𝐴,𝐵,𝐶 ). 
 – ро бо чунин тарз иваз мекунад, ки қиматҳои онҳо ба таври 
 камшавандагӣ ба тартиб овардашудаанд (A,B,C – параметрҳои 
 ҳақиқие, ки дар як замон ҳам дохилшаванда ва ҳам хориҷшанда 
 мебошанд), тасвир карда шавад. Бо воситаи ин протседура маҷмӯи аз 
 се адади додашуда иборатро ба таври камшавӣ бо ду додашудаҳо 
 тасвир кунед: (𝐴,𝐵,𝐶 ) ва (𝐴,𝐵,𝐶 ). 
 ростро иҷро мекунад: қимати A ба B, қимати В ба C, қимати С ба А 
 мегузарад (A,B,C – параметрҳои ҳақиқие, ки дар як замон ҳам 
 дохилшаванда ва ҳам хориҷшанда мебошанд), тасвир кунед. Бо 
 воситаи ин протседура барои ду додашудаҳои маҷмӯи аз се адади 
 додашудаи (𝐴,𝐵,𝐶 ) ва (𝐴,𝐵,𝐶 ), лағжиши даврии тарафи рост, 
 амалӣ карда шавад. 
 иҷро мекунад: қимати A ба B, қимати В ба C, қимати С ба А мегузарад 
 (A,B,C – параметрҳои ҳақиқие, ки дар як замон ҳам дохилшаванда ва 
 ҳам хориҷшанда мебошанд), тасвир кунед. Бо воситаи ин протседура 
 барои ду додашудаҳои маҷмӯи аз се адади додашудаи (𝐴,𝐵,𝐶 ) ва 
 (𝐴,𝐵,𝐶 ), лағжиши даврии тарафи чап амалӣ карда шавад. 
 Функсияҳо бо параметрҳои ададӣ 
 муодилаи квадратиро 𝐴𝑥 + 𝐵𝑥 + 𝐶 = муайян мекунад (A,B,C 
 параметрҳои ҳақиқӣ, 𝐴 ≠ ), тасвир кунед. Бо воситаи он, миқдори 
 решаҳои барои се муодилаи квадратӣ бо коэффитсиентҳои додашуда, 
 ёфта шавад. Миқдори решаҳоро бо воситаи қимати дискриминант 
 𝐷 = 𝐵 − 𝐴𝐶, муайян карда шавад. 
 (R – ҳақиқӣ) – ро меёбад, тасвир карда шавад. Бо воситаи ин давра, 
 масоҳати се давра бо радиусҳои додашуда, ёфта шавад. Масоҳати 
 давраи радиусаш R бо формулаи 𝑆 = 𝜋 ∙ 𝑅 ҳисоб карда шуда, ба 
 сифати 𝜋 қимати. истифода бурда шавад. 
 ки дар байни давраҳои радиуси 𝑅 ва 𝑅 аст, инчунин маркази 
 умумидоштаро, тасвир кунед. Бо воситаи ин функсияи додашуда, 
 масоҳати се ҳалқаеро ҳисоб кунед, ки қиматҳои радиуси дохилӣ ва 
 берунаи онҳо дода шудаанд. Формулаи масоҳати давраи радиусаш R 
 бо формулаи 𝑆 = 𝜋 ∙ 𝑅 ҳисоб карда шуда, ба сифати 𝜋 қимати. 
 истифода бурда шавад. 
 асосаш a ва баландиаш h, ки бо асосаш бароварда шудааст (a ва h – 
 ҳақиқӣ) муайян мекунад, тасвир карда шавад. Бо воситаи ин функсия, 
 параметри се секунҷаи баробарпаҳлӯ, ки барои онҳо асос ва баландӣ 
 дода шудааст, ёфта шавад. Барои ёфтани тарафи паҳлӯӣ аз теоремаи 
 Пифагор истифода баред: 𝑏 = (𝑎/) + ℎ, 𝑝 = 𝑏 + 𝑎 = 𝑎 + 
 √ℎ + 𝑎. 
 ғайринулии А ва В яке аз амалҳои арифметикиро иҷро мекунад ва 
 қимати онро бармегардонад, тасвир кунед. Намуди амал бо 
 параметри бутуни Op муайян карда шавад: – тарҳ, – ҷамъ, – 
 тақсим ва – зарб. Бо воситаи ин функсия, барои додаҳои А ва В амали
 муайянеро барои додашудаҳои бутуни 𝑁,𝑁,𝑁 иҷро намоед. 
 тири координатие, ки дар он қиматҳои ғайринулии ҳақиқии 
 координатаҳои (x,y) ҷойгиранд муайян мекунад, тасвир кунед. Бо ёрии 
 ин функсия рақами чоряки координата барои се нуқтаи додашудаҳои 
 ғайринуллии координатиро муайян кунед. 
 параметри бутуни К ҷуфт бошад, дар акси ҳол false мебахшад, тасвир 
 кунед. Бо воситаи ин функсия, миқдори ададҳои ҷуфт дар маҷмӯи аз 
 адади бутун иборат буда, ёфта шавад. 
 параметри бутуни K(>) дараҷаи адади бошад, дар акси ҳол false, 
 тасвир кунед. Бо воситаи ин функсия, миқдори дараҷаи адади – ро 
 барои маҷмӯи аз адади бутуни мусбат иборат буда, ёбед. 
 параметри бутуни K(>) дараҷаи адади бошад, дар акси ҳол false 
 бахшида шавад, тасвир кунед. Бо воситаи ин функсия, миқдори 
 дараҷаҳои адади дар маҷмӯи аз адади мусбат иборат ёбед. 
 агар параметри бутуни K(>) дараҷаи адади N(>) бошад ва дар акси 
 ҳол қимати false мебахшад. Адади N(>) ва маҷмӯи аз адади бутуни 
 мусбат иборат буда, дода шудааст. бо воситаи функсияи IsPowerN 
 миқдори дараҷаҳои адади N аз маҷмӯи додашуда, ёфта шавад. 
 бутуни мусбати К – ро меёбад, тасвир кунед. Бо истифода аз ин, 
 функсия миқдори рақамҳои аз адади бутуни мусбати додашударо 
 ёбед. 
 мусбати К – ро бармегардонад, тасвир кунед. Агар миқдори рақамҳо 
 дар адади К хурди N бошад, он гоҳ функсия - – ро мебахшад. Барои 
 ҳар гуна аз адади бутуни мусбати додашудаи 𝐾,𝐾,…,𝐾 функсияи 
 DigitN бо параметри N, ки аз то тағйир меёбад, созед. 
 Масъалаҳои гурӯҳи Minmax 
 Python, Java, GO, Kotlin ва VB.NET-ро аз [-] азбар намоед. 
 PascalABC.Net, C++, C#, Python, Java, GO, Kotlin ва VB.NET нависед. 
 Намунаи ҳалли масъалаҳо 
 минималӣ ва максималӣ аз маҷмӯи додашуда ёфта шаванд, инчунин бо 
 тартиби додашуда хориҷ карда шаванд. 
 PascalABC.NET C++ 
 Var #include <iostream> 
 R, Min, Max: Real; using namespace std; 
 i, N: Integer; int main() { 
 int n, i; 
 begin float a, min, max; 
 Write('N:'); cin >> n >> a; 
 Readln(N); min = max = a; 
 for i:= to N do for (i =; i <= n; ++i) { 
 begin cin >> a; 
 Readln(R); if (i == ) { 
 if i = then min = a; 
 begin max = a; 
 Min:= R; } 
 Max:= R; if (a < min) min = a; 
 end; if (a > max) max = a; 
 if R<Min then Min:= R; } 
 cout<<"min="<<min<<" max="<<max 
 if R>Max then Max:= R; 
 <<endl; 
 end; 
 system("pause"); 
 Writeln(Min, ' ', Max); return; 
 } 
 End. 
 Python C# 
 n=int(input("->")) static void Main(string[] args) 
 a=float(input("->")) { 
 mx=a double a, mx, mn; 
 mn=a int n; 
 for i in range(,n): n=Convert.ToInt(Console.ReadLine()); 
 a=float(input("a")) a=Convert.ToDouble(Console.ReadLine()); 
 if a>mx: mx=mn=a; 
 mx=a for (int i=; i<=n; i++){ 
 if a<mn: a=Convert.ToDouble(Console.ReadLine()); 
 mn=a if (a>mx) 
 print(mx,mn) mx=a; 
 if (a<mn) 
 mn=a; 
 } 
 Console.WriteLine("max={} min={}", mx, 
 mn); 
 Console.ReadKey(); 
 } 
 Java Go 
 public static void main(String[] package main 
 args){ import "fmt" 
 Scanner sc=new Scanner(System.in); func main() { 
 double a, max, min; n:=; 
 a=sc.nextDouble(); fmt.Scan(&n) 
 int n=sc.nextInt(); var a=. 
 min = max = a; fmt.Scan(&a) 
 for (int i =; i <= n; ++i) { mx:=a 
 mn:=a 
 a=sc.nextDouble(); 
 for i:=; i<=n; i++{ 
 if (a < min) 
 fmt.Scan(&a) 
 min = a; if (a>mx){ 
 mx=a 
 if (a > max) 
 } 
 max = a; 
 if (a<mn){ 
 } mn=a 
 System.out.println("min="+min+" } 
 } 
 max="+max); 
 fmt.Println(mx, mn) 
 } 
 } 
 Kotlin 
 import java.util.Scanner 
 fun main(args: Array<String>) { 
 val reader = Scanner(System.`in`) 
 var n = reader.nextInt() 
 var a = reader.nextDouble() 
 var max = a 
 var min = a 
 for (i in..n) { 
 val a = reader.nextDouble() 
 if (a > max) 
 max = a; 
 if (a < min) 
 min = a; 
 } 
 println("min=$min max=$max") 
 } 
 VB.NET 
 Sub Main() 
 Dim i, n As Integer 
 Dim a, mn, mx As Single 
 n = Convert.ToInt(Console.ReadLine()) 
 a = Convert.ToSingle(Console.ReadLine()) 
 mx = a 
 mn = a 
 For i = To n 
 a = Convert.ToSingle(Console.ReadLine()) 
 If mx < a Then 
 mx = a 
 If mn > a Then 
 mn = a 
 End If 
 End If 
 Next 
 Console.WriteLine("min={} max={}", mn, mx) 
 Console.ReadKey() 
 End Sub 
 ададҳои (a,b) дода шудааст. Периметри максималии росткунҷаҳо аз 
 маҷмӯи додашуда, ёфта шавад. 
 PascalABC.NET C++ 
 Var #include <iostream> 
 P, a, b, Min: Real; using namespace std; 
 i, N: Integer; int main() { 
 int n, i; 
 begin float a, b, p, min, max; 
 Write('N:'); cin >> n; 
 Readln(N); for (i =; i <= n; ++i) { 
 for i:= to N do cin >> a >> b; 
 begin p = * (a + b); 
 Write('a b:'); if (i == ) { 
 Readln(a, b); min = p; 
 P:= * (a + b); max = p; 
 if i = then } 
 Min:= P; if (p<min) min = p; 
 if P < Min then if (p>max) max = p; 
 Min:= P; } 
 end; cout << "min=" << min << " 
 Writeln(Min); max=" << max << endl; 
 end. system("pause"); 
 return; 
 } 
 шудааст. Рақами тартибии элементи якуми минималӣ ва элементи 
 охирони максималӣ аз маҷмӯи батартибовардашудаи додашуда, бо 
 ҳамон тартиби додашуда бароварда шавад. 
 PascalABC.NET C++ 
 Var #include <iostream> 
 R, Min, Max: Real; using namespace std; 
 int main() { 
 i, N, MinNum, MaxNum: int i, n, minnum=, maxnum=, a, 
 Integer; min, max; 
 begin cin >> n; 
 Write('N:'); cin >> a; 
 Readln(N); max = min = a; 
 for i:= to N do for (i =; i <= n; ++i) { 
 begin cin >> a; 
 Write(i, ' число:'); if (a<min) { 
 Readln(R); min = a; 
 if i = then minnum = i; 
 begin } 
 Min:= R; if (a >= max) { 
 Max:= R; max = a; 
 MaxNum:= i; maxnum = i; 
 MinNum:= i; } 
 end; } 
 if R < Min then cout << "min=" << min << " 
 begin minnum=" << minnum << endl; 
 Min:= R; cout << "max=" << max << " 
 MinNum:= i; maxnum=" << maxnum << endl; 
 end; system("pause"); 
 if R >= Max then return; 
 begin } 
 Max:= R; 
 MaxNum:= i; 
 end; 
 end; 
 Write(MinNum, '',MaxNum); 
 end. 
 дода шудааст. Миқдори элементҳои маҷмӯи батартибовардашуда, ки 
 дар байни адади якум ва охирони максималӣ ҷойгиранд, хориҷ карда 
 шаванд. Агар дар маҷмӯи батартибовардашуда як элементи максималӣ 
 мавҷуд бошад, бароварда шавад. 
 PascalABC.NET C++ 
 Var #include <iostream> 
 N, Ni, Max, MaxNum, i, using namespace std; 
 RezNum: Integer; int main() 
 begin { 
 Write('N:'); int i, n, maxnum=, 
 Readln(N); maxnum=, a, max, max; 
 for i:= to N do cin >> n; 
 begin cin >> a; 
 Write(i, ': '); max = max = a; 
 Readln(Ni); for (i =; i <= n; ++i) { 
 if (Ni>Max) or (i=) then cin >> a; 
 begin if (a>max) { 
 Max:= Ni; max = a; 
 MaxNum:= i; maxnum = i; 
 RezNum:=; } 
 end if (a >= max) { 
 else max = a; 
 if Ni = Max then maxnum= i; 
 begin } 
 RezNum:=i--MaxNum; } 
 end; cout<<(maxnum-maxnum)-<<endl; 
 end; system("pause"); 
 Writeln(RezNum); return; 
 end. } 
 ки танҳо аз ва таркиб ёфтаанд, дода шудааст. Рақами тартибии 
 элементе ёфта шавад, ки дар он шумораи ададҳои якхела максималӣ аст 
 ва шумораи онҳо муайян карда шавад. Агар чунин пайдарпаиҳо якчанд 
 – то бошанд, рақами тартибии якуми онҳо, чоп карда шаванд. 
 PascalABC.NET 
 Var 
 N, i, Num, Numi, MaxNum, Maxi: Integer; 
 B, B: byte; 
 begin 
 B:=; 
 B:=; 
 Num:=; 
 Numi:=; 
 MaxNum:=; 
 Write('N:'); 
 Readln(N); 
 for i:= to N do 
 begin 
 B:= B; 
 Write(i, ' число:'); 
 Readln(B); 
 if B = B then inc(Num) 
 else 
 begin 
 if Num > MaxNum then 
 begin 
 MaxNum:= Num; 
 Maxi:= Numi; 
 end; 
 Numi:= i; 
 Num:=; 
 end; 
 end; 
 if Num > MaxNum then 
 begin 
 MaxNum:= Num; 
 Maxi:= Numi; 
 end; 
 Writeln(Maxi, ' ', MaxNum); 
 end. 
 C++ 
 #include <iostream> 
 using namespace std; 
 int main() 
 { 
 int b=,b=,num=,numi=, maxnum =, maxi, n, i; 
 cin >> n >> b; 
 for (i =; i <= n; ++i) { 
 b = b; 
 cin >> b; 
 if (b == b) ++num; 
 else 
 { 
 if (num > maxnum) { 
 maxnum = num; 
 maxi = numi; 
 } 
 numi = i; 
 num =; 
 } 
 } 
 if (num > maxnum) 
 { 
 maxnum = num; 
 maxi = numi; 
 } 
 cout << "maxi=" << maxi << " maxnum=" << maxnum << endl; 
 system("pause"); 
 return; 
 } 
 дода шудааст. Шумораи минималии элементҳои максималии 
 пайдарпайии оянда дар маҷмӯи батартибовардашудаи додашуда, ёфта 
 шавад. 
 PascalABC.NET C++ 
 Var #include <iostream> 
 N,i,Ni,Nmin,Num,MaxNum:Integer; using namespace std; 
 int main() { 
 begin int n,i,a,nmin,num,maxnum; 
 Num:=; cin >> n >> a; 
 MaxNum:=; nmin = a; 
 Write('N:'); num =; 
 Readln(N); maxnum =; 
 for i:= to N do for (i =; i <= n; ++i) { 
 begin cin >> a; 
 Write(i, ' число:'); if (a < nmin) { 
 Readln(Ni); nmin = a; 
 if (i=) or (Ni<Nmin) then num =; 
 begin maxnum =; 
 Nmin:= Ni; } 
 Num:=; if (a == nmin) 
 MaxNum:=; ++num; 
 end; else { 
 if Ni = Nmin then inc(Num) if (num > maxnum) 
 else maxnum = num; 
 begin num =; 
 if Num > MaxNum then } 
 MaxNum:= Num; } 
 Num:=; if ((num>maxnum) && 
 end; (a==nmin)) 
 end; maxnum = num; 
 if (Num>MaxNum) and (ni=Nmin) cout << maxnum << endl; 
 then system("pause"); 
 MaxNum:= Num; return; 
 Writeln(MaxNum); } 
 end. 
 Масъалаҳо барои кори мустақилона 
 ададҳо (a,b) дода шудааст. Масоҳати минималии росткунҷаҳо аз маҷмӯи 
 додашуда, ёфта шавад. 
 шудааст. Рақами минималии элементи маҷмӯи додашуда, ёфта шавад. 
 ҷуфти ададҳо (m,v), ки маълумот оид ба масса m ва ҳаҷми v деталҳоро 
 ифода мекунад. Рақами тартибии деталеро, ки зичии максималӣ дорад 
 ва қимати ададии ин зичиро бароред. Зичӣ P аз рӯи формулаи 𝑃 = 𝑚/𝑣 
 ҳисоб карда мешавад. 
 шудааст. Рақами тартибии элементи якуми минималӣ ва элементи 
 охирони максималӣ аз маҷмӯи батартибовардашудаи додашуда, бо 
 ҳамон тартиби додашуда бароварда шавад. 
 шуда аст. Рақами тартибии элементи якум ва охирони минималӣ аз 
 маҷмӯи батартибовардашудаи додашуда, бо ҳамон тартиби додашуда 
 бароварда шавад. 
 шуда аст. Рақами тартибии элементи якум ва охирони максималӣ аз 
 маҷмӯи батартибовардашудаи додашуда, бо ҳамон тартиби додашуда 
 бароварда шавад. 
 шудааст. Рақами тартибии элементи якуми экстремалӣ (яъне 
 максималӣ ё минималӣ) аз маҷмӯи батартибовардашудаи додашуда, 
 бароварда шавад. 
 шудааст. Рақами тартибии элементи охирони экстремалӣ (яъне 
 максималӣ ё минималӣ) аз маҷмӯи батартибовардашудаи додашуда, 
 бароварда шавад. 
 шуда аст. Дар маҷмӯи батартибовардашудаи додашуда, адади мусбати 
 минималӣ ёфта шавад. Агар дар он адади мусбат мавҷуд набошад, 
 бароварда шавад. 
 шудааст. Рақами тартибии элементи якуми максималии адади тоқ аз 
 маҷмӯи батартибовардашудаи додашуда, бароварда шавад. Агар дар он 
 адади мусбат мавҷуд набошад, бароварда шавад. 
 шудааст. Он элементҳои минималии маҷмӯи батартибовардашуда 
 бароварда шавад, ки рақами тартибиашон аз B калон аст. Агар адади аз 
 В калон мавҷуд набошад, ду маротиба адади бароварда шавад. 
 додашудааст. Рақами тартибӣ ва худи он элементи максималии дар 
 интервали (В,С) воқеъбудаи маҷмӯи батартибовардашуда, бароварда 
 шавад. 
 дода шудааст. Миқдори элементҳои пеш аз элементи якуми минималӣ 
 ҷойгир буда, ёфта шавад. 
 дода шуда аст.Миқдори элементҳои пас аз элементи охирони 
 максималӣ ҷойгир буда, ёфта шавад. 
 додашуда аст. Миқдори элементҳои минималӣ аз маҷмӯи 
 батартибовардашудаи додашуда, хориҷ карда шавад. 
 дода шудааст. Миқдори умумии элементҳои экстремалии маҷмӯи 
 батартибовардашудаи додашуда, хориҷ карда шавад. 
 қимати ягон бузургиро дар N санҷиш ифода мекунад, дода шудааст. 
 Ҳангоми муайян кардани қимати миёна, адади хурдтарин ва 
 калонтарин ба эътибор гирифта нашавад. 
 шудааст. Ду адади хурдтарин аз ин маҷмӯъ ёфта шавад ва батартиби 
 афзуншавӣ бароварда шавад. 
 додашудааст. Се элементи калонтарин аз маҷмӯи 
 батартибовардашудаи додашуда ёфта шавад ва ба тартиби камшавӣ 
 чоп карда шавад. 
 шудааст. Суммаи максималии ду адади ҳамсоя аз маҷмӯи 
 батартибовардашудаи додашуда, хориҷ карда шавад. 
 шудааст. Рақами тартибии ду адади ҳамсоя аз маҷмӯи 
 батартибовардашудаи дода шуда ёфта шавад, ки ҳосили зарби онҳо 
 камтарин аст. Рақами тартибии хурдтарини он дар аввал, сипас рақами 
 тартибии калонтаринаш чоп карда шавад. 
 дода шудааст. Миқдори максималии ададҳои ҷуфт дар маҷмӯи 
 батартиб овардашудае, ки пайдарҳам сохта шудааст, ёфта шавад. Агар 
 дар дар он адади ҷуфт мавҷуд наошад, чоп карда шавад. 
 ки танҳо аз ва таркиб ёфтаанд, дода шудааст. Рақами тартибии 
 элементе ёфта шавад, ки дар он шумораи максималии воҳидҳо мавҷуд 
 аст ва шумораи онҳо ҳисоб карда шавад. Агар чунин пайдарпаиҳо 
 якчанд-то бошанд, он гоҳ рақами тартибии охирони онҳо чоп карда 
 шаванд. Агар дар маҷмӯи батартиб овардашудаи додашуда воҳид 
 набошад, он гоҳ ду чоп карда шавад. 
 дода шудааст. Шумораи максималии элементҳои мининималии 
 пайдарпаии оянда дар маҷмӯи батартиб овардашудаи дода шуда, ёфта 
 шавад. 
 Масъалаҳои гурӯҳи Array 
 GO, Kotlin ва VB.NET-ро аз [-] азбар намоед. 
 PascalABC.Net, C++, C#, Python, Java, GO, Kotlin ва VB.NET нависед. 
 Намунаи ҳалли масъалаҳо 
 N, ки N адади аввали бутуни тоқро дарбар мегирад, тартиб дода чоп 
 карда шавад:,,,.... 
 PascalABC.NET C++ 
 Var #include <iostream> 
 a: array of integer; using namespace std; 
 N, i: Integer; int main(){ 
 int *a,i,n; 
 begin cin >> n; 
 Write('N:'); a = new int[n]; 
 Readln(N); for (i =; i<n; ++i) 
 a:=new integer[N+]; a[i] = *i+; 
 for i:= to N do for (i =; i<n; ++i) 
 a[i]:= i * -; cout<<a[i]<<" "; 
 print(a); system("pause"); 
 end. return; 
 } 
 Python C# 
 a=[] static void Main(string[] args){ 
 n=int(input("")) int n, I; 
 for i in range (,n): n=Convert.ToInt(Console.ReadLine()); 
 a.append(*i-) int []x=new Int[n]; 
 print(a) for (i=; i<n; i++){ 
 x[i]=*i+; 
 Console.Write(x[i]+" "); 
 } 
 Console.ReadKey(); 
 } 
 Java Go 
 public static void main(String[] package main 
 args){ import "fmt" 
 Scanner sc=new Scanner(System.in); func main() { 
 int n, i; var n int 
 n=sc.nextInt(); fmt.Print("n->") 
 int [] x=new int[n]; fmt.Scan(&n) 
 for (i=; i<n; i++){ var a [] int 
 x[i]=*i+; a=make([]int, n) 
 System.out.print(x[i]+" "); for i:=; i < n; i++{ 
 } a[i]=*i+ 
 } } 
 fmt.Println(a) 
 } 
 Kotlin 
 import java.util.Scanner import java.util.Scanner 
 fun main(args: Array<String>) fun main(args: Array<String>) { 
 { val reader=Scanner(System.`in`) 
 val reader=Scanner(System.`in`) var n=reader.nextInt() 
 var n=reader.nextInt() val x = Array(n,{i->*i+}) 
 var x = Array<Int>(n){} for(i in..n-) { 
 for (i in..n-){ println(x[i]) 
 x[i]=*i- } 
 } } 
 for(i in..n-) { 
 println(x[i]) 
 } 
 } 
 VB.NET 
 Sub Main() 
 Dim a() As Integer 
 Dim i, n As Integer 
 n = Convert.ToInt(Console.ReadLine()) 
 a = New Integer(n) {} 
 For i = To n - 
 a(i) = * i + 
 Console.Write("{} ", a(i)) 
 Next 
 Console.ReadKey() 
 End Sub 
 арифметикӣ дода шудаанд.Массиви андозааш N, ки аз N аъзои ин 
 прогрессия иборат аст, тартиб дода чоп карда шавад: 
 𝐴, 𝐴 + 𝐷, 𝐴 + ∙ 𝐷, 𝐴 + ∙ 𝐷,…. 
 PascalABC.NET C++ 
 Var #include <iostream> 
 a: array of integer; using namespace std; 
 D, N, i: Integer; int main(){ 
 begin int *x,i,n, a,d; 
 Write('N:'); cin >> n>>a>>d; 
 Read(N); x= new int[n]; 
 a:= new integer[N + ]; for (i =; i<n; ++i) 
 Write('A,D:'); x[i] = a+i*d; 
 Readln(a[], D); for (i =; i<n; ++i) 
 for i:= to N do cout<<x[i]<<" "; 
 a[i]:=a[]+(i-)*D; system("pause"); 
 for i:= to N do return; 
 writeln(i,':',a[i]); } 
 end. 
 Python Go 
 N = int(input("N:")) package main 
 a=[] import "fmt" 
 a.append(int(input("A:"))) func main() { 
 D = int(input("D:")) var n,a,d int 
 fmt.Print("n,a,d->") 
 for i in range(,N-): fmt.Scan(&n,&a,&d) 
 a.append(a[]+(i)*D) var x [] int 
 x=make([]int, n) 
 for i in range(N-): for i:=; i < n; i++{ 
 print(a[i], end=' ') x[i]=a+i*d 
 } 
 fmt.Println(x) 
 } 
 хориҷ карда шавад. 
 PascalABC.NET C++ 
 Var #include <iostream> 
 a: array of integer; using namespace std; 
 N, i: Integer; int main(){ 
 int *x,i,n; 
 begin cin >> n; 
 Write('N:'); x= new int[n]; 
 Readln(N); for (i =; i < n; ++i) { 
 a:= new integer[N + ]; x[i] = rand() %; 
 for i:= to N do cout << x[i] << " "; 
 begin } 
 write(i, ':'); cout << endl; 
 readln(a[i]); for (i = n-; i>=; i--) 
 end; cout<<x[i]<<" "; 
 for i:= N downto do system("pause"); 
 writeln(i, ': ', a[i]); return; 
 end. } 
 Python C# 
 n=int(input("n->")) Вариант. 
 x=[] static void Main(string[] args) 
 for i in range(,n): { 
 int 
 x.append(int(input("x"))); n=Convert.ToInt(Console.ReadLine()); 
 for i in range(n-,-,-): int []x=new Int[n]; 
 print(x[i]) Random rnd=new Random(); 
 for (int i=; i<n; i++){ 
 x[i] = rnd.Next(); 
 Console.Write(x[i]+" "); 
 } 
 Console.WriteLine(); 
 for (int i= n -; i>=; i--) 
 Console.Write(x[i]+" "); 
 Console.ReadKey(); 
 } 
 Вариант. 
 static void Main(string[] args) 
 { 
 int 
 n=Convert.ToInt(Console.ReadLine()); 
 int []x=new Int[n]; 
 for (int i=; i<n; i++) 
 x[i] = 
 Convert.ToInt(Console.ReadLine()); 
 Console.WriteLine(); 
 for (int i= n -; i>=; i--) 
 Console.Write(x[i]+" "); 
 Console.ReadKey(); 
 } 
 Java Go 
 Вариант. package main 
 public static void main(String[] args){ import "fmt" 
 Scanner sc=new Scanner(System.in); func main() { 
 int n, i; var n int 
 n=sc.nextInt(); fmt.Print("n->") 
 int [] x=new int[n]; fmt.Scan(&n) 
 for (i=; i<n; i++){ var x=make([]int, n) 
 x[i]=sc.nextInt(); for i:=; i < n; i++ { 
 } fmt.Scan(&x[i]) 
 for (i=; i<n; i++) } 
 System.out.print(x[i]+" "); fmt.Print("PrintArray \n") 
 System.out.println(); for i:= n-; i >=; i--{ 
 for (i=n-; i>=; i--) fmt.Println(x[i]) 
 System.out.print(x[i]+" "); } 
 } } 
 Вариант. 
 public static void main(String[] args){ 
 Scanner sc=new Scanner(System.in); 
 int n, i; 
 n=sc.nextInt(); 
 int [] x=new int[n]; 
 Random rnd=new Random(); 
 for (i=; i<n; i++){ 
 x[i]=rnd.nextInt(); 
 System.out.print(x[i]+" "); 
 } 
 System.out.println(); 
 for (i=n-; i>=; i--) 
 System.out.print(x[i]+" "); 
 } 
 шудааст. Он элементҳои массив, ки рақами тартибиашон ба К каратӣ 
 аст, чоп карда шавад: 𝐴,𝐴,𝐴,…. Аз операторҳои шартӣ истифода 
 𝐾 ∙𝐾 ∙𝐾 
 бурда нашавад. 
 PascalABC.NET C++ 
 Var #include <iostream> 
 a: array of integer; using namespace std; 
 N, i, K: Integer; int main(){ 
 int *x,i,n,k; 
 begin cin >> n>>k; 
 (N, K):= readInteger; x= new int[n]; 
 a:= new integer[N + ]; for (i =; i < n; ++i) { 
 for i:= to N do x[i] = rand() %; 
 begin cout << x[i] << " "; 
 write(i, ':'); } 
 readln(a[i]); cout << endl; 
 end; for (i = k -; i<n; i += k) 
 i:= K; cout<<x[i]<<" "; 
 while (i <= N) do system("pause"); 
 begin return; 
 writeln(i,':',a[i]); } 
 i:= i + K; 
 end; 
 end. 
 Go 
 package main 
 import ( 
 "fmt" 
 "math/rand" 
 ) 
 func main() { 
 var n,k int 
 fmt.Print("n,k->") 
 fmt.Scan(&n,&k) 
 var x=make([]int, n) 
 for i:=; i < n; i++ { 
 x[i]=rand.Intn(); 
 } 
 fmt.Println(x) 
 for i:=k-; i<n; i+=k{ 
 fmt.Println(x[i]) 
 } 
 } 
 зерин чоп карда шаванд: 𝐴,𝐴,𝐴,𝐴,𝐴,𝐴,𝐴,𝐴, …. 
 𝑁 𝑁− 𝑁− 𝑁− 
 PascalABC.NET 
 Var 
 a: array of integer; 
 N, i, P: word; 
 begin 
 readln(N); 
 a:= new integer[N + ]; 
 for i:= to N do 
 read(a[i]); 
 writeln(' Результат: '); 
 P:= N div; 
 for i:= to P do 
 write(a[*i-],'',a[*i],'',a[N+-*i],' ',a[N+-*i],' '); 
 if N mod > then 
 write(a[ * P + ], ' '); 
 if N mod > then 
 write(a[ * P + ], ' '); 
 if N mod > then 
 write(a[N - * P]) 
 end. 
 C++ 
 #include <iostream> 
 using namespace std; 
 int main(){ 
 int *x,i,j,n,p; 
 cin >> n; 
 x= new int[n]; 
 for (i =; i < n; ++i) { 
 x[i] = rand() %; 
 cout << x[i] << " "; 
 } 
 cout << endl; 
 p = n /; 
 for (i =; i<p; i++) 
 cout<<x[*i]<<" "<<x[*i+]<<" "<<x[n--*i]<<" "<<x[n--*i]<<" "; 
 if (n % == ) 
 cout << x[(n / )] << " "; 
 else 
 for (j =; j < (n % ); j++) 
 cout << x[(n / ) - + j] << " "; 
 system("pause"); 
 return; 
 } 
 Go 
 package main 
 import ( 
 "fmt" 
 "math/rand" 
 ) 
 func main() { 
 var n,p int 
 fmt.Print("n->") 
 fmt.Scan(&n) 
 p=n / 
 var x=make([]int, n) 
 for i:=; i < n; i++ { 
 x[i]=rand.Intn(); 
 } 
 fmt.Println(x) 
 for i:=; i<p; i++{ 
 fmt.Printf("%v %v %v %v",x[*i],x[*i+],x[n--*i], 
 x[n--*i]) 
 } 
 if (n%==){ 
 fmt.Printf("%+v ", x[(n/)]) 
 }else{ 
 for j:=; j<(n%); j++{ 
 fmt.Printf("%+v ", x[(n/)-+j]) 
 } 
 } 
 } 
 Таҳлили элементҳои массив 
 Қимати аввалини элементҳои 𝐴, ки нобаробарии 𝐴 < 𝐴 – ро қаноат 
 𝐾 𝐾 
 мекунонанд, чоп карда шавад. Агар чунин элементҳо вуҷуд надошта 
 бошанд, чоп карда шавад. 
 PascalABC.NET C++ 
 Var #include <iostream> 
 a: array[..] of integer; using namespace std; 
 k: Integer; int main(){ 
 begin int x[],i; 
 for k:= to do for (i =; i <=; ++i) { 
 begin x[i] = rand() %; 
 write(k, ':'); cout << x[i] << " "; 
 readln(a[k]); } 
 end; cout << endl; 
 k:=; i =; 
 while(A[k]>=A[])and(k<)do while ((x[i]>=x[])&&(i<)) 
 inc(k); i++; 
 if k = then if(i == ) cout << ""; 
 writeln('') else cout << x[i] << endl; 
 else system("pause"); 
 Writeln(a[k]); return; 
 end. } 
 локалии (минимуми локалӣ гуфта, он элементеро меноманд, ки аз 
 элементҳои дилхоҳ ҳамсояаш хурд мебошад ) он ёфта шавад. 
 PascalABC.NET C++ 
 Var #include <iostream> 
 a:array of integer; using namespace std; 
 N,i:Integer; int main(){ 
 begin int *x,i, n; 
 Write('N: '); cin >> n; 
 Readln(N); x = new int[n]; 
 a:=new integer[N+]; for (i =; i <n; ++i) 
 for i:= to N do { 
 begin x[i] = rand() %; 
 write(i,':'); cout << x[i] << " "; 
 readln(a[i]); } 
 end; cout << endl; 
 i:=; if (x[] < x[]) 
 if a[]<a[] then cout << "" << endl; 
 writeln('') else { 
 else begin i =; 
 while (i<=N-) and while ((i<n-) &&!((x[i-]> x[i]) 
 (not((a[i-]>a[i]) and && (x[i] < x[i + ]))) 
 (a[i]<a[i+]))) do ++i; 
 inc(i); cout << i + << endl; 
 Writeln(i); } 
 end; system("pause"); 
 end. return; 
 } 
 массив монотоннӣ афзуншаванда мебошанд, чоп карда шаванд. 
 PascalABC.NET 
 Var 
 a: array of integer; 
 N, i, Num: Integer; 
 begin 
 a[]:=; 
 Write('N: '); 
 Readln(N); 
 a:=new integer[N + ]; 
 for i:= to N do 
 begin 
 readln(a[i]); 
 end; 
 Num:=; 
 for i:= to N do 
 if (a[i - ] < a[i - ]) and not (a[i - ] < a[i]) then 
 inc(Num); 
 if a[N - ] < a[N] then 
 inc(Num); 
 Writeln(Num); 
 End. 
 C++ 
 #include <iostream> 
 using namespace std; 
 int main(){ 
 int *x,i, n, num=; 
 cin >> n; 
 x = new int[n]; 
 for (i =; i <n; ++i) 
 { 
 x[i] = rand() %; 
 cout << x[i] << " "; 
 } 
 cout << endl; 
 for (i =; i<n; ++i) 
 if ((x[i - ]<x[i - ]) &&!(x[i - ]<x[i])) 
 ++num; 
 if (x[n - ]<x[n - ]) 
 ++num; 
 cout << num << endl; 
 system("pause"); 
 return; 
 } 
 тартиб оварда шудааст, (бо тартиби афзуншавӣ ё камшавӣ) дода 
 шудааст. Миқдори элементҳои гуногуни ин массив ёфта шавад. 
 PascalABC.NET 
 Var 
 i, N, Q: integer; 
 A: array of integer; 
 begin 
 write('N= '); 
 readln(N); 
 a:=new integer[N + ]; 
 Q:=; 
 for i:= to N do 
 begin 
 read(a[i]); 
 if (i > ) and (a[i] <> a[i - ]) then inc(Q) 
 end; 
 writeln; 
 writeln('Различных чисел: ', Q) 
 end. 
 C++ 
 #include <iostream> 
 using namespace std; 
 int main(){ 
 int *x, i, n, k =; 
 bool f; 
 cin >> n; 
 x = new int[n]; 
 for (i =; i <n; ++i) { 
 x[i] = rand() %; 
 cout << x[i] << " "; 
 } 
 cout << endl; 
 for ( i =; i < n; i++){ 
 int j =; 
 while (j < i && x[j]!= x[i]) 
 ++j; 
 k += j == i; 
 } 
 cout << k << endl; 
 delete x; 
 system("pause"); 
 return; 
 } 
 массив ёфта шавад, ки суммаи онҳо ба адади додашудаи R қифоя наздик 
 бошад ва онҳоро бо тартиби афзуншавии индексҳои онҳо, чоп кунед. 
 PascalABC.NET 
 Var 
 A: array of real; 
 R, MinDiffSum, c: real; 
 i, j, N, i, i: byte; 
 begin 
 write('N = '); 
 readln(N); 
 a:= new real[N + ]; 
 write('R = '); 
 readln(R); 
 for i:= to N do 
 begin 
 a[i]:= random()+; 
 write(' ', a[i]::); 
 if i = then 
 begin 
 MinDiffSum:= abs(a[] + a[] - R); 
 i:=; 
 i:=; 
 end 
 else 
 for j:= to i- do 
 begin 
 c:= abs(a[j] + a[i] - R); 
 if c < MinDiffSum then 
 begin 
 MinDiffSum:= c; 
 i:= j; 
 i:= I; 
 end 
 end 
 end; 
 Writeln; 
 writeln('a[]:=',a[i]::, ' ', 'a[]:=',a[i]::); 
 end. 
 C++ 
 #include <iostream> 
 using namespace std; 
 int main(){ 
 int *x, i,j, r,n, k =, k=; 
 bool f; 
 cin >> n>>r; 
 x = new int[n]; 
 for (i =; i <n; ++i) { 
 x[i] = rand() %; 
 cout << x[i] << " "; 
 } 
 cout << endl; 
 for (i =; i<n -; ++i) { 
 for (j= i +; j<n; ++j) { 
 if (abs(x[i] + x[j] - r)<abs(x[k] + x[k] - r)) { 
 k = i; 
 k = j; 
 } 
 } 
 } 
 cout<<k + <<" "<<k +; 
 delete x; 
 system("pause"); 
 return; 
 } 
 ҷойивазкунӣ бошад, яъне ҳамаи ададҳои аз то N – ро дарбар гирад, 
 чоп карда шавад, дар акси ҳол рақами тартибии элементи 
 имконнопазир чоп карда шавад. 
 PascalABC.NET 
 Var 
 a: array of integer; 
 N, i, i: Integer; 
 check: Boolean; 
 begin 
 Write('N: '); 
 Readln(N); 
 a:= new integer[N + ]; 
 for i:= to N do 
 begin 
 write(i, ':'); 
 readln(a[i]); 
 end; 
 for i:= to N do 
 begin 
 check:= False; 
 for i:= to N do 
 if i = a[i] then 
 check:= True; 
 if not (check) then 
 begin 
 Writeln(i); 
 break; 
 end; 
 end; 
 if check then 
 Writeln(); 
 end. 
 C++ 
 #include <iostream> 
 using namespace std; 
 int main() { 
 int *x, i, j, n; 
 cin >> n; 
 x = new int[n]; 
 for (i =; i < n; ++i) { 
 x[i] = rand() %; 
 cout << x[i] << " "; 
 } 
 cout << endl; 
 for (i =; i <= n; ++i) { 
 for (j =; j < n; ++j) { 
 if (x[j] == i) { 
 j = n +; 
 break; 
 } 
 } 
 if (j!= n + ) { 
 cout << i << endl; 
 break; 
 } 
 } 
 if (i == n + ) 
 cout << << endl; 
 system("pause"); 
 return; 
 } 
 Кор бо якчанд массивҳо 
 массиви С тартиб дода шавад, ки ҳар як элементаш аз элементи 
 максималии ҳамон як рақами тартибии ин массивҳо таркиб ёфтааст. 
 PascalABC.NET C++ 
 Var #include <iostream> 
 a, b, c: array of real; using namespace std; 
 N, k: Integer; int main() { 
 begin int *x, *y, *z, i, j, n; 
 Write('N: '); cin >> n; 
 Readln(N); x = new int[n]; 
 a:=new integer[N+]; y = new int[n]; 
 b:=new integer[N+]; z = new int[n]; 
 c:=new integer[N+]; for (i =; i < n; ++i) { 
 Writeln('A: '); x[i] = rand() %; 
 for k:= to N do y[i] = rand() %; 
 begin cout << x[i] << " "; 
 write(k, ':'); } 
 readln(a[k]); cout << endl; 
 end; for (i =; i < n; ++i) 
 Writeln('B: '); cout << y[i] << " "; 
 for k:= to N do for (int k =; k<n; ++k){ 
 begin if (x[k]>y[k]) 
 write(k, ':'); z[k] = x[k]; 
 readln(b[k]); else z[k] = y[k]; 
 end; } 
 for k:= to N do cout << endl; 
 c[k]:= max(a[k], b[k]); for (i =; i < n; ++i) 
 Writeln('C: '); cout << z[i] << " "; 
 for k:= to N do system("pause"); 
 writeln(k, ':', c[k]); return; 
 end. } 
 Go 
 package main 
 import ( 
 "fmt" 
 "math/rand" 
 ) 
 func MaxInt(a,b int) int{ 
 if a>b{ 
 return a 
 }else{ 
 return b 
 } 
 } 
 func main() { 
 var n int 
 fmt.Print("n->") 
 fmt.Scan(&n) 
 var x=make([]int, n) 
 var y=make([]int, n) 
 var z=make([]int, n) 
 for i:=; i < n; i++ { 
 x[i]=rand.Intn(); 
 y[i]=rand.Intn(); 
 z[i]=MaxInt(x[i],y[i]); 
 } 
 fmt.Println(x) 
 fmt.Println(y) 
 fmt.Println(z) 
 } 
 Табдилдиҳии массив 
 Массиви додашударо бо роҳи зиёд кардани ҳар як элементаш бо андозаи 
 қимати аввалаи элементи 𝐴 тартиб диҳед. 
 𝐾 
 PascalABC.NET C++ 
 Var #include <iostream> 
 a: array of integer; using namespace std; 
 N, K, i, Ak: Integer; int main() { 
 int *x, i, k, n; 
 begin cin >> n >> k; 
 Write('N: '); x = new int[n]; 
 Readln(N); for (i =; i < n; ++i) { 
 a:= new integer[N + ]; x[i] = rand() %; 
 Write('K: '); cout << x[i] << " "; 
 Readln(K); } 
 Writeln('A: '); cout << endl; 
 for i:= to N do for (i =; i < n; ++i) { 
 begin x[i] += x[k - ];; 
 write(i, ':'); } 
 readln(a[i]); for (i =; i < n; ++i) 
 end; cout << x[i] << " "; 
 Ak:= a[k]; system("pause"); 
 for i:= to N do return; 
 a[i]:= a[i] + Ak; } 
 for i:= to N do 
 writeln(i, ':', a[i]); 
 end. 
 мавқеъ ба тарафи рост амалӣ созед (дар ин маврид 𝐴, ба А, А, ба А,..., 𝐴 ба 𝐴 табдил меёбад ва элементи охирони массив аз байн меравад). 
 𝑁− 𝑁 
 Элементи аввали массивро ба табдил диҳед. 
 PascalABC.NET C++ 
 var #include <iostream> 
 a: array of Integer; using namespace std; 
 N, i: Integer; int main() { 
 begin int *a, i, n; 
 Write('N: '); cin >> n; 
 Readln(N); a = new int[n]; 
 a:= new integer[N + ]; for (i =; i < n; ++i) { 
 Writeln('A: '); a[i] = rand() %; 
 for i:= to N do cout << a[i] << " "; 
 begin } 
 write(i, ':'); cout << endl; 
 readln(a[i]); for (i = n -; i >=; --i) 
 end; a[i] = a[i - ]; 
 for i:= N downto do a[] =; 
 a[i]:= a[i - ]; for (i =; i < n; ++i) 
 A[]:=; cout << a[i] << " "; 
 for i:= to N do system("pause"); 
 writeln(i, ':', a[i]); return; 
 end. } 
 Несткунӣ ва гузориши элементҳо 
 массиви додашуда элементе, ки рақами тартибиаш К аст, хориҷ кунед. 
 PascalABC.NET C++ 
 Var #include <iostream> 
 a: array of Integer; using namespace std; 
 N, K, i: Integer; int main() { 
 begin int *a, i, n, k; 
 Write('N: '); cin >> n>>k; 
 Readln(N); a = new int[n]; 
 a:=new integer[N + ]; for (i =; i < n; ++i) { 
 Write('K: '); a[i] = rand() %; 
 Readln(K); cout << a[i] << " "; 
 Writeln('A: '); } 
 for i:= to N do cout << endl; 
 begin --n; 
 write(i, ':'); for (i = k -; i<n; ++i) { 
 readln(a[i]); a[i] = a[i + ]; 
 end; } 
 N:= N -; for (i =; i < n; ++i) 
 for i:= K to N do cout << a[i] << " "; 
 a[i]:= a[i + ]; system("pause"); 
 for i:= to N do return; 
 writeln(i,':',a[i]); } 
 end. 
 додашуда ҳамаи ададҳои тоқ нест карда шуда, андозаи массиви нави 
 ҳосилшуда ва таркиби он чоп карда шавад. 
 PascalABC.NET C++ 
 Var #include <iostream> 
 a: array of Integer; using namespace std; 
 N, i, k: Integer; int main() { 
 begin int *a, i, n, k=; 
 Readln(N); cin >> n; 
 a:= new integer[N + ]; a = new int[n]; 
 Writeln('A: '); for (i =; i < n; ++i) { 
 for i:= to N do a[i] = rand() %; 
 begin cout << a[i] << " "; 
 write(i, ':'); } 
 readln(a[i]); cout << endl; 
 end; for (i =; i<n; ++i) { 
 k:=; if (a[i] % == ) { 
 for i:= to n do a[k] = a[i]; 
 if not odd(a[i]) then ++k; 
 begin } 
 inc(k); } 
 a[k]:= a[i]; for (i =; i < k; ++i) 
 end; cout << a[i] << " "; 
 Writeln(N); system("pause"); 
 for i:= to k do return; 
 writeln(i, ':', a[i]); } 
 end. 
 додашуда ҳамаи элементҳои камтар аз се маротиба такрор мешаванд 
 нест карда шаванд. Андоза ва таркиби массиви нави ҳосилшуда чоп 
 карда шавад. 
 PascalABC.NET C++ 
 Var #include <iostream> 
 a: array of Integer; using namespace std; 
 N, i, i, k, num: int main() { 
 Integer; int *a, i, n, k = -, num, j; 
 cin >> n; 
 begin a = new int[n]; 
 Write('N: '); for (i =; i < n; ++i) { 
 Readln(N); a[i] = rand() %; 
 a:= new integer[N + ]; cout << a[i] << " "; 
 Writeln('A: '); } 
 for i:= to N do cout << endl; 
 begin for (i =; i < n; ++i) { 
 write(i, ':'); for (j =; j <= k; ++j) { 
 readln(a[i]); if (a[i] == a[j]) 
 end; break; 
 repeat } 
 k:=; if (j!= k + ) { 
 for i:= to N do ++k; 
 begin a[k] = a[i]; 
 Num:=; } 
 for i:= to N do else { 
 if a[i]=a[i] then num =; 
 inc(num); for (j = i; j < n; ++j) { 
 if num< then k:= i; if (a[j] == a[i]) 
 end; ++num; 
 if k <> then } 
 begin if (num >= ) { 
 N:= N -; ++k; 
 for i:= K to N do a[k] = a[i]; 
 a[i]:= a[i + ]; } 
 end; } 
 until (k = ); } 
 Writeln(N); ++k; 
 for i:= to N do for (i =; i < k; ++i) 
 writeln(i, ':', cout << a[i] << " "; 
 a[i]); system("pause"); 
 end. return; 
 } 
 аз элементи рақами тартибиаш К – и массив ба элементи нулӣ гузоред. 
 PascalABC.NET C++ 
 Var #include <iostream> 
 a: array of Integer; using namespace std; 
 N, i, K: Integer; int main() { 
 int *a, i, n, k; 
 begin cin >> n >> k; 
 Write('N: '); a = new int[n]; 
 Readln(N); for (i =; i < n; ++i) { 
 a:= new integer[N + ]; a[i] = rand() %; 
 Write('K: '); cout << a[i] << " "; 
 Readln(K); } 
 Writeln('A: '); cout << endl; 
 for i:= to N do n++; 
 begin for (i = n -; i >= k; --i) 
 write(i, ':'); a[i] = a[i - ]; 
 readln(a[i]); a[k - ] =; 
 end; for (i =; i <n; ++i) 
 N:= N +; cout << a[i] << " "; 
 for i:= N downto K + do system("pause"); 
 a[i]:= a[i - ]; return; 
 a[k]:=; } 
 Writeln(N); 
 for i:= to N do 
 writeln(i, ':', a[i]); 
 end. 
 массиви додашуда ба элементи қиматаш нулӣ гузошта шаванд. 
 PascalABC.NET C++ 
 var #include <iostream> 
 a, b: array of Integer; using namespace std; 
 N, Nk, i, k: Integer; int main() { 
 begin int *a, i, n, j; 
 Write('N: '); cin >> n; 
 Readln(N); a = new int[n]; 
 a:= new integer[N + ]; for (i =; i < n; ++i) { 
 b:= new integer[*N + ]; a[i] = rand() % -; 
 Writeln('A: '); cout << a[i] << " "; 
 for i:= to N do } 
 begin cout << endl; 
 write(i, ':'); for (i = n -; i >=; --i) { 
 readln(a[i]); if (a[i] > ) { 
 end; ++n; 
 Nk:= N; for (j = n -; j > i; --j) 
 k:=; a[j] = a[j - ]; 
 for i:= to N do a[i] =; 
 begin } 
 if a[i] > then } 
 begin for (i =; i <n; ++i) 
 Nk:= Nk +; cout << a[i] << " "; 
 b[k + ]:= a[i]; system("pause"); 
 b[k]:=; return; 
 K:= k +; } 
 end 
 else 
 b[k]:= a[i]; 
 K:= k +; 
 end; 
 N:= Nk; 
 a:= b; 
 Writeln(N); 
 for i:= to N do 
 writeln(i, ':', a[i]); 
 end. 
 Мураттабсозии массивҳо 
 бо усули ҳубобӣ мураттаб созед: массивро аз назар гузаронида, ҳамаи 
 элементҳои ҳамсояи онро муқоиса кунед (𝐴 ва А, А ва А ва ғайраҳо), 
 агар элементи чапи ҷуфт калони росташ бошад; тавсири ин амалро N- 
 маротиба такрор кунед. Барои санҷиш пас аз ҳар як ин гуна амал 
 массиви ҳосилшударо чоп кунед. Ба эътибор гиред, ки ҳар дафъа 
 шумораи ҷуфтҳои таҳқиқшаванда ба як адад кам мешавад. 
 PascalABC.NET C++ 
 Var #include <iostream> 
 a: array of real; using namespace std; 
 N, N, i, i, i: integer; int main() { 
 int *a, i, n, j; 
 begin cin >> n; 
 Write('N: '); a = new int[n]; 
 Readln(N); for (i =; i < n; ++i) { 
 a:= new real[N + ]; a[i] = rand() % -; 
 Writeln('A: '); cout << a[i] << " "; 
 for i:= to N do } 
 begin cout << endl; 
 write(i, ':'); for (int i =; i < n; ++i) 
 readln(a[i]); { 
 end; for (int j =; j < n - i; j++) 
 N:= N; { 
 for i:= to N - do if (a[j] < a[j + ]) 
 begin { 
 i:=; int temp = a[j]; 
 N:= N -; a[j] = a[j + ]; 
 while (i <= N) do a[j + ] = temp; 
 begin } 
 if a[i]>a[i+] then } 
 swap(a[i],a[i+]); } 
 inc(i); for (i =; i < n; ++i) 
 end; cout << a[i] << " "; 
 for i:= to N do system("pause"); 
 writeln(a[i]::); return; 
 end; } 
 end. 
 бо усули гузориши сода ба тартиби авзуншавӣ мураттаб кунед: 
 элементҳои А ва А – ро муқоиса намуда, дар мавриди зарурӣ мавқеи 
 онҳоро чунон иваз намоед, ки бо тартиби афзуншавӣ ҷойгир шаванд; пас 
 аз он ба элементи А эътибор дода, онро ҳамин тавр ҷойгир намудан 
 лозим аст, ки тартиби афзуншавӣ вайрон нашавад; ин амалро барои 
 ҳамаи элементҳои массив такрор намуда, пас аз коркарди ҳар як 
 элементи массив, таркиби массивро чоп кунед (аз – юм то N - ум). 
 Ҳангоми иҷроиши амалҳои овардашуда усули “монеъа”, яъне пеш аз 
 коркарди элементи навбатии массив ҳамроҳ намудани элементи 
 иловагӣ А, истифода бурдан нисбатан қулай аст. 
 PascalABC.NET C++ 
 Var #include <iostream> 
 a: array of real; using namespace std; 
 N, i, i, i: integer; int main() { 
 begin int *a, i, n, j, temp; 
 Write('N: '); cin >> n; 
 Readln(N); a = new int[n]; 
 a:= new real[N + ]; for (i =; i < n; ++i) { 
 Writeln('A: '); a[i] = rand() % -; 
 for i:= to N do cout << a[i] << " "; 
 begin } 
 write(i, ':'); cout << endl; 
 readln(a[i]); if (a[] > a[]) { 
 end; temp = a[]; 
 if a[] > a[] then a[] = a[]; 
 swap(a[], a[]); a[] = temp; 
 for i:= to N do } 
 begin for (i =; i <= n -; ++i) { 
 a[]:= a[i]; temp = a[i]; 
 for i:=i- downto do for (j = i -; j >=; --j) 
 if a[] < a[i] then if (temp<a[j]) a[j+]=a[j]; 
 a[i + ]:= a[i] else 
 else break; 
 begin a[j + ] = temp; 
 a[i + ]:= a[]; } 
 break; for (i =; i < n; ++i) 
 end; cout << a[i] << " "; 
 for i:= to N do system("pause"); 
 writeln(i,':',a[i]); return; 
 writeln; } 
 end; 
 end. 
 Қатори адаҳои бутун 
 ададҳо гуфта, гуруҳи ададҳоеро меноманд, ки паиҳам ҷойгир шудаанд, 
 дарозии қатор гуфта, миқдори элементҳои (дарозии қатор метаванад ба 
 баробар шавад) онро меноманд. Ду массив нави ададҳои бутун B ва C – 
 и андозаашон якхела сохта шавад, ки дарозии ҳамаи қаторҳои массиви 
 дода шударо дар В ҷойгир карда, дар массиви С бошад қимати 
 элементҳои қаторҳои онро ҷойгир кунад. 
 PascalABC.NET C++ 
 Var #include <iostream> 
 a, b, c: array of real; using namespace std; 
 N, i, k: integer; int main() { 
 begin int *a,*b,*c, i, n, j, k=; 
 Write('N: '); cin >> n; 
 Readln(N); a = new int[n]; 
 a:=new real[N + ]; b = new int[n]; 
 Writeln('A: '); c = new int[n]; 
 for i:= to N do for (i =; i < n; ++i) { 
 begin a[i] = rand() %; 
 write(i, ':'); cout << a[i] << " "; 
 readln(a[i]); } 
 end; cout << endl; 
 k:=; b[k] =; 
 b[k]:=; c[k] = a[k]; 
 c[k]:= a[k]; for (i =; i < n; ++i) { 
 for i:= to N do if (a[i - ] == a[i]) ++b[k]; 
 begin else { 
 if a[i-]=a[i] then ++k; 
 b[k]:= b[k] + b[k] =; 
 else c[k] = a[i]; 
 begin } 
 inc(k); } 
 b[k]:=; for (i =; i < k; ++i) 
 c[k]:= a[i]; cout <<b[i] << " "; 
 end; cout << endl; 
 end; for (i =; i < k; ++i) 
 for i:= to k do cout << c[i] << " "; 
 writeln(c[i],' - ',b[i] ); system("pause"); 
 end. return; 
 } 
 қатори массиви додашуда, элементи қиматаш нулӣ гузошта шавад. 
 PascalABC.NET C++ 
 Var #include <iostream> 
 a, b: array of real; using namespace std; 
 N, i, k: integer; int main() { 
 begin int *a,*b, i, n, k=; 
 Write('N: '); cin >> n; 
 Readln(N); a = new int[n]; 
 a:=new real[N + ]; b = new int[n*]; 
 b:=new real[N + ]; for (i =; i < n; ++i) { 
 Writeln('A: '); a[i] = rand() %; 
 for i:= to N do cout << a[i] << " "; 
 begin } 
 write(i, ':'); cout << endl; 
 readln(a[i]); b[] =; 
 end; b[k] = a[]; 
 b[]:=; for (i =; i<n; ++i) { 
 k:=; ++k; 
 b[k]:= a[]; if (a[i - ]!= a[i]) { 
 for i:= to N do b[k] =; 
 begin ++k; 
 inc(k); } 
 if a[i-] <> a[i] then b[k] = a[i]; 
 begin } 
 b[k]:=; for (i =; i < k; ++i) 
 inc(k); cout <<b[i] << " "; 
 end; system("pause"); 
 b[k]:= a[i]; return; 
 end; } 
 a:= b; 
 for i:= to k do 
 writeln(a[i]); 
 end. 
 шудааст. Массиви додашударо ба воситаи ду маротиба зиёд намудани 
 дарозии қатори рақами тартибиаш К табдил диҳед. 
 PascalABC.NET C++ 
 Var #include <iostream> 
 a, b: array of real; using namespace std; 
 N, K, i, i, ki: integer; int main() { 
 begin int *a, i, n, k =; 
 Write('N: '); cin >> n; 
 Readln(N); a = new int[ * n]; 
 a:= new real[N + ]; for (i =; i < n; ++i) { 
 b:= new real[N + ]; a[i] = rand() %; 
 Write('K: '); cout << a[i] << " "; 
 Readln(K); } 
 Writeln('A: '); cout << endl; 
 for i:= to N do int num =; 
 begin for (i=;(i<n-)&&(num<k);++i) { 
 write(i, ':'); if (a[i]!= a[i + ]) 
 readln(a[i]); ++num; 
 end; } 
 i:=; int begine = i; 
 ki:=; 
 for i:= to N - do for (i=begine; (i<n-); ++i) { 
 begin if (a[i]!= a[i + ]) break; 
 if ki = K then } 
 begin int ende = i; 
 inc(i); int i; 
 b[i]:= a[i]; for (i=;i<=ende-begine+; ++i) { 
 n++; 
 end; 
 for (i = n -; i > ende; i--) { 
 inc(i); 
 a[i] = a[i - ]; 
 b[i]:= a[i]; } 
 } 
 if a[i] <> a[i + ] then 
 for (i =; i < n; ++i) 
 inc(ki); 
 cout << a[i] << " "; 
 end; system("pause"); 
 if ki = K then return; 
 } 
 begin 
 inc(i); 
 b[i]:= a[i]; 
 end; 
 inc(i); 
 b[i]:= a[i]; 
 a:= b; 
 for i:= to i do 
 writeln(a[i]); 
 end. 
 қатори охирони массиви додашударо ба як элемент зиёд намуда, 
 массивро табдил диҳед. 
 PascalABC.NET C++ 
 Const #include <iostream> 
 col =; using namespace std; 
 int main() { 
 var int *a, i, n, k =; 
 a, c, temp: array [..col] of cin >> n; 
 real; a = new int[ * n]; 
 x, y: array [..col] of for (i =; i < n; ++i) { 
 integer; a[i] = rand() %; 
 N, i, i, i, ns, ms: cout << a[i] << " "; 
 integer; } 
 begin cout << endl; 
 Write('N: '); int len =, maxlen =, 
 Readln(N); endmaxseries =; 
 Writeln('A: '); for (i =; i < n; ++i) { 
 for i:= to N do if (a[i - ]!= a[i]) { 
 begin if (len >= maxlen) { 
 write(i, ':'); maxlen = len; 
 readln(a[i]); endmaxseries=i-; 
 end; } 
 ns:=; len =; 
 x[ns]:=; } 
 y[ns]:= ns; ++len; 
 ms:= ns; } 
 c[ns]:= a[]; if (len > maxlen) { 
 for i:= to N do maxlen = len; 
 begin endmaxseries = i -; 
 if a[i - ] = a[i] then 
 } 
 begin 
 for (i=++n-;i>endmaxseries;--i) 
 x[ns]:= x[ns] + 
 end a[i] = a[i - ]; 
 else begin 
 for (i =; i < n; ++i) 
 if x[ns]>=x[ms] then 
 cout << a[i] << " "; 
 ms:=ns; 
 inc(ns); system("pause"); 
 x[ns]:=; return; 
 y[ns]:= i; 
 } 
 c[ns]:= a[i]; 
 end; 
 end; 
 if x[ns] >= x[ms] then 
 ms:= ns; 
 y[ns + ]:= N +; 
 x[ms]:= x[ms] +; 
 i:=; 
 for i:= to ns do 
 for i:= to x[i] do 
 begin 
 inc(i); 
 temp[i]:= c[i]; 
 end; 
 a:= temp; 
 for i:= to i do 
 writeln(a[i] ); 
 end. 
 Маҷмӯи нуқтаҳо дар ҳамворӣ 
 координатаҳояш x,y) дода шудааст. Он нуқтаи маҷмӯи А – ро ёбед, ки ба 
 нуқтаи В наздиктарин аст. Масофаи R байни ду нуқтаи ҳамворӣ (𝑥,𝑦 ) 
 ва (𝑥,𝑦 ) бо формулаи зерин ёфта мешавад: 
 𝑅 = √(𝑥 − 𝑥 ) + (𝑦 − 𝑦 ). 
 PascalABC.NET 
 Var 
 Ax, Ay: array of real; 
 Bx, By, R, Rmin: real; 
 N, i, Amin: integer; 
 begin 
 Write('N: '); 
 Readln(N); 
 Ax:=new real[N + ]; 
 Ay:=new real[N + ]; 
 Writeln('A: '); 
 for i:= to N do 
 begin 
 write(i, '.x:'); 
 readln(Ax[i]); 
 write(i, '.y:'); 
 readln(Ay[i]); 
 end; 
 Writeln('B'); 
 Write('x: '); 
 Readln(Bx); 
 Write('y: '); 
 Readln(By); 
 Rmin:= sqrt(sqr(AX[] - Bx) + sqr(Ay[] - By)); 
 Amin:=; 
 for i:= to N do 
 begin 
 R:= sqrt(sqr(Ax[i] - Bx) + sqr(Ay[i] - By)); 
 if R < Rmin then 
 begin 
 Rmin:= R; 
 Amin:= i; 
 end; 
 end; 
 Writeln(Amin); 
 end. 
 C++ 
 #include <iostream> 
 using namespace std; 
 int main() { 
 float a[][]; 
 int n, amin = INT_MAX; 
 float bx, by; 
 cin >> n >> bx >> by; 
 int i; 
 for (i =; i < n; ++i) { 
 cout << (i + ) << endl; 
 cout << "x="; 
 cin >> a[i][]; 
 cout << "y="; 
 cin >> a[i][]; 
 } 
 float r, rmin=; 
 for (i =; i < n; ++i) { 
 r=sqrt(pow(bx-a[i][],)+pow(by- a[i][], )); 
 if (r < rmin || i == ) { 
 rmin = r; 
 amin = i; 
 } 
 } 
 cout<<amin+<<" "<< a[amin][] 
 << " " << a[amin][]; 
 system("pause"); 
 return; 
 } 
 иборатанд (нуқтаҳо бо координатаҳояш x,y дода шудаанд). Масофаи 
 кӯтоҳтарини байни нуқтаҳои ин маҷмӯҳо ва ин нуқтаҳоро ёбед (дар аввал 
 нуқта аз маҷмӯи А ва пас аз он нуқта аз маҷмӯи В бароварда мешаванд). 
 PascalABC.NET 
 Var 
 Ax,Ay: array of real; 
 R,Rmax:real; 
 N,i,i,Point,Point: integer; 
 begin 
 Write('N: '); 
 Readln(N); 
 Ax:=new real[N+]; 
 Ay:=new real[N+]; 
 Writeln('A: '); 
 for i:= to N do 
 begin 
 write(i,'.x:'); 
 readln(ax[i]); 
 write(i,'.y:'); 
 readln(Ay[i]); 
 end; 
 Rmax:=; 
 Point:=; 
 Point:=; 
 for i:= to N- do 
 for i:=i+ to N do 
 begin 
 R:=sqrt(sqr(Ax[i]-Ay[i])+sqr(Ax[i]-Ay[i])); 
 writeln(R); 
 if (R > Rmax) then 
 begin 
 Rmax:=R; 
 Point:=i; 
 Point:=i; 
 end; 
 end; 
 Writeln ('(',Ax[Point],':',Ay[Point],')(',Ax[Point],':', 
 Ay[Point],')'); 
 end. 
 C++ 
 #include <iostream> 
 using namespace std; 
 int main() { 
 float a[][]; 
 int i, n; 
 cin >> n; 
 for (i =; i < n; ++i) 
 cin >> a[i][] >> a[i][]; 
 int a =, a =, i; 
 float r, rmax =; 
 for (i =; i < n; ++i) { 
 for (i = i +; i < n; ++i) { 
 r=sqrt(pow(a[i][]-a[i][],)+pow(a[i][]-a[i][],)); 
 if (r > rmax) { 
 rmax = r; 
 a = i; 
 a = i; 
 } 
 } 
 } 
 cout << a + << " " << a[a][] << " " << a[a][]; 
 cout << a + << " " << a[a][] << " " << a[a][]; 
 system("pause"); 
 return; 
 } 
 Масъалаҳо барои кори мустақилона 
 N, ки дараҷаҳои ду то N – ро дарбар мегирад, тартиб дода, чоп карда 
 шавад:,,,,.... 
 геометрӣ Q дода шудааст. Массиви андозааш N, ки аз N аъзои аввали 
 прогрессияи додашударо дар бар мегирад. Тартиб дода, чоп карда 
 шавад: 𝐴,𝐴 ∙ 𝐷,𝐴 ∙ 𝐷,𝐴 ∙ 𝐷,…. 
 N, ки N элементҳои якуми пайдарпаиҳои ададҳои Фибоначиро 
 𝐹 дарбар мегирад, тартиб дода хориҷ карда шавад: 
 𝑘 
 𝐹 =, 𝐹 =, 𝐹 = 𝐹 + 𝐹, 𝐾 =,,…. 
 𝑘 𝐾− 𝐾− 
 андозааш N, ки элементи якуми он баробари A, дуюмаш баробари B ва 
 ҳар элементи ояндаи он ба суммаи элементҳои пештарааш баробар аст, 
 тартиб дода, чоп карда шавад. 
 афзуншаванда ҳамаи ададҳои тоқи массиви додашуда, инчунин К 
 миқдори онҳо баровада ва чоп карда шавад. 
 камшаванда ҳамаи ададҳои ҷуфти массиви додашуда, инчунин К 
 миқдори онҳо баровада, чоп карда шавад. 
 тартиби афзуншавандагӣ ҳамаи ададҳои тоқи массиви додашуда, сипас 
 бо тартиби камшавандагӣ ҳамаи ададҳои ҷуфти массиви додашуда, чоп 
 карда шавад. 
 элементҳои рақами тартибаашон ҷуфти массив бо тартиби афзуншавӣ 
 чоп карда шавад: 𝐴,𝐴,𝐴,…,𝐴. Оператори шартӣ истифода бурда 
 𝑁 
 шавад. 
 элементҳои рақами тартибаашон тоқи массив бо тартиби камшавӣ чоп 
 карда шавад: 𝐴,𝐴,𝐴,…,𝐴. Оператори шартӣ истифода бурда 
 𝑁 𝑁− 𝑁− 
 шавад. 
 рақами ҷуфти массив (бо тартиби афзуншавии рақамҳои он), сипас 
 ҳамаи элементҳои рақами тоқи массив (бо тартиби афзуншавӣ 
 рақамҳои он), чоп карда шавад: 𝐴,𝐴,𝐴,…,𝐴,𝐴,𝐴,…. Оператори 
 шартӣ истифода бурда шавад. 
 рақами тоқи массив (бо тартиби афзуншавии рақамҳои он), сипас ҳамаи 
 элементҳои рақами ҷуфти массив (бо тартиби камшавии рақамҳои он), 
 чоп карда шавад: 𝐴,𝐴,𝐴,…,𝐴,𝐴,𝐴,…. Оператори шартӣ истифода 
 бурда шавад. 
 тартиби зерин чоп карда шаванд: 𝐴,𝐴,𝐴,𝐴,𝐴,𝐴,…. 
 𝑁 𝑁− 𝑁− 
 Таҳлили элементҳои массив 
 охирони элементҳои 𝐴, ки нобаробарии дукаратаи 𝐴 < 𝐴 < 𝐴 – ро 
 𝐾 𝐾 
 қаноат мекунонанд, чоп карда шавад. Агар чунин элементҳо вуҷуд 
 надошта бошанд, чоп карда шавад. 
 шудааст. Суммаи элеменҳои массив бо рақамҳои аз K то L, ёфта шавад. 
 шудааст. Қимати миёнаи арифметикии элеменҳои массив бо рақамҳои 
 аз K то L, ёфта шавад. 
 шудааст. Суммаи ҳамаи элеменҳои массив, ғайр аз рақамҳои аз K то L, 
 ёфта шавад. 
 шудааст. Қимати миёнаи арифметикии ҳамаи элеменҳои массив, ғайр 
 аз рақамҳои аз K то L, ёфта шавад. 
 шудааст. Санҷед, ки оё элементҳои ин массив прогрессияи 
 арифметикиро ташкил медиҳанд, ё не. Агар ташкил диҳанд, прогрессия 
 чоп карда шавад, дар акси ҳол чоп карда шавад. 
 Санҷед, ки оё элементҳои ин массив прогрессияи геометриро ташкил 
 медиҳанд, ё не. Агар ташкил диҳанд, махраҷи прогрессия чоп карда 
 шавад, дар акси ҳол чоп карда шавад. 
 ҷуфт ва тоқ дар он пайдарпай ҳамдигарро иваз мекунанд. Агар чунин 
 бошад, чоп карда шавад, агар не рақами тартибии элементи якумеро 
 чоп кунед, ки ин қонуниятро вайрон мекунад. 
 Санҷед, ки ададҳои мусбат ва манфӣ дар он пайдарпай ҳамдигарро иваз 
 мекунанд. Агар чунин бошад, чоп карда шавад, агар не рақами 
 тартибии элементи якумеро чоп кунед, ки ин қонуниятро вайрон 
 мекунад. 
 массиви додашуда, ёфта шавад, ки рақами тартибиашон ҷуфт аст: 
 𝐴,𝐴,𝐴,…. 
 массиви додашуда, ёфта шавад, ки рақами тартибиашон тоқ аст: 
 𝐴,𝐴,𝐴,…. 
 массив ёфта шавад, ки аз ҳамсояи тарафи росташон калон бошанд ва 
 миқдори чунин элементҳо ҳисоб карда шавад. Рақамҳои ёфташуда бо 
 тартиби афзуншавӣ хориҷ карда шаванд. 
 массив ёфта шавад, ки аз ҳамсояи тарафи чапашон калон бошанд ва 
 миқдори чунин элементҳо ҳисоб карда шавад. Рақамҳои ёфташуда бо 
 тартиби камшавӣ хориҷ карда шаванд. 
 локалии (максимуми локалӣ гуфта, он элементеро меноманд, ки аз 
 элементҳои дилхоҳ ҳамсояаш калон мебошад ) он ёфта шавад. 
 он ёфта шавад. 
 он ёфта шавад. 
 шавад, ки на максимуми локалӣ ва на минимуми локалӣ аст. Агар чунин 
 элементҳо дар массив набошанд, чоп карда шавад. 
 массив монотоннӣ камшаванда мебошанд, чоп карда шаванд. 
 фосилаҳое, ки дар онҳо элементҳо ё афзун мешаванд ё кам мешаванд) он 
 ёфта шаванд. 
 массив ёфта шавад, ки ба адади R (яъне он элементе 𝐴, ки фарқи он бо 
 𝐾 
 R минималӣ аст: |𝐴 − 𝑅| ) наздиктар аст. 
 𝐾 
 суммаи онҳо максималианд ва онҳоро бо тартиби афзуншавии 
 индексҳои онҳо чоп кунед. 
 массив ёфта шавад, ки суммаи онҳо ба адади додашудаи R қифоя наздик 
 бошад ва онҳоро бо тартиби афзуншавии индексҳои онҳо чоп кунед. 
 элементи якхела дорад. Рақамҳои тартибии элементҳои якхеларо ёбед 
 ва ба тартиби афзуншавӣ чоп кунед. 
 массив (яъне элементҳо бо фарқи модулҳои хурдтарин) ёфта шавад ва бо 
 тартиби афзуншавӣ чоп карда шавад. 
 элементҳои гуногуни массиви додашуда, ёфта шавад. 
 максималии элементҳои якхелаи массиви додашуда, ёфта шавад. 
 ҷойивазкунӣ мебошад. Миқдори бетартибиҳо (инверсия) дар ин 
 ҷойивазкуниҳо ёфта шавад, яъне чунин ҷуфти элементҳои 𝐴 ва 𝐴, ки дар 
 𝑖 𝑗 
 он адади калон аз адади хурд чаптар воқеъ аст: 𝐴 > 𝐴 ҳангоми 𝑖 < 𝑗 
 𝑖 𝑗 
 будан. 
 Кор бо якчанд массивҳо 
 таркиби онҳоро иваз намуда, дар аввал элементҳои массиви 
 табдилдодашудаи А, сипас элементҳои массиви табдилдодашудаи В 
 чоп карда шавад. 
 андозаро ташкил диҳед, ки элементҳояш чунин муайян карда шавад: 
 ∙ 𝐴, агар 𝐴 <, 
 𝐾 𝐾 
 𝐵 
 𝐾 
 = 
 𝐴 𝐾,дар акси ҳол. 
 нави ададҳои бутуни В – ро аз элементҳои ҷуфти массиви А ташкил 
 намоед, андоза ва таркиби онро чоп кунед. 
 Массиви нави ададҳои бутуни В – ро аз элементҳои тоқи (,,...) массиви
 А ташкил намоед, андоза ва таркиби онро чоп кунед. Оператори шартӣ 
 истифода бурда нашавад. 
 Массиви нави ададҳои бутуни В – ро аз элементҳои массиви додашуда, 
 ки рақами тартибиашон ба се каратиианд (,,...) нависед, андоза ва 
 таркиби онро чоп кунед. Оператори шартӣ истифода бурда нашавад. 
 ададҳои бутуни В – и ҳамон андозаро созед, ки дар аввал аз элементҳои 
 рақами тартибиашон ҷуфт ва сипас аз элементҳои рақами тартибиашон 
 тоқи массиви аввала таркиб ёфта бошанд. 
 нави В – и ҳамон андоза аз рӯи қоидаи зерин тартиб диҳед: элементи 
 В баробар аст ба суммаи элементҳои массиви А бо рақамҳои аз то К. 
 К 
 нави В – и ҳамон андозаро аз рӯи қоидаи зерин тартиб диҳед: элементи 
 В баробар аст ба қимати миёнаи арифметикии элементҳои массиви А 
 К 
 бо рақамҳои аз то К. 
 В – и ҳамон андозаро аз рӯи қоидаи зерин тартиб диҳед: элементи В 
 К 
 баробар аст ба суммаи элементҳои массиви А бо рақамҳои аз К то N. 
 В – и ҳамон андозаро аз рӯи қоидаи зерин тартиб диҳед: элементи В ба 
 К 
 қимати миёна арифметикии элементҳои массиви А бо рақамҳои аз К то 
 N баробар аст. 
 нави В ва С, чунин сохта шавад: дар массиви В ҳамаи элементҳои мусбати 
 массиви А ва дар массиви С ҳамаи элементҳо манфии массиви А 
 (тартиби аввалаи ҷойгиршавии элементҳоро вайрон накарда) навишта 
 шавад. Аввал андоза ва таркиби массиви В, сипас андоза ва таркиби 
 массиви С чоп карда шавад. 
 ба таври афзуншавӣ тартиб ёфтаанд. Ин массивҳоро чунин ҳамҷоя 
 кунед, ки тартиби афзуншавии массиви С (андозааш ) вайрон нашавад. 
 𝑁,𝑁,𝑁 аст, ки элементҳояшон бо тартиби камшавӣ ҷойгир шудаанд, 
 𝐴 𝐵 𝐶 
 дода шудааст. Ин массивҳоро чунин ҳамҷоя кунед, ки элементҳо массиви 
 нави D – и (андозааш 𝑁 + 𝑁 + 𝑁 ) ҳосилшуда, низ бо ҳамон тартиби 
 𝐴 𝐵 𝐶 
 камшавӣ ҷойгир шуда бошанд. 
 Табдилдиҳии массив 
 ҷуфти дар массив бударо ба қиммати адади ҷуфти якум зиёд намоед. 
 Агар дар массив адади ҷуфт набошад онро бетағийр гузоред. 
 тоқи дар массив бударо ба қиммати адади тоқи охирон зиёд намоед. 
 Агар дар массив адади тоқ набошад, онро бетағийр гузоред. 
 максималии массивро иваз намоед. 
 якум ба дуюм, сеюм ба чорум ва ғайраи массивро иваз намоед. 
 якум ва дуюми элементҳои массивро иваз намоед. 
 баръаксаш иваз намоед. 
 дода шудааст. Элементҳои массив, ки дар байни элементҳои 𝐴 ва 𝐴 
 𝐾 𝐿 
 ҷойгиранд бо шумули худи ин элемент бо тартиби баръакс нависед. 
 дода шудааст. Элементҳои массив, ки дар байни элементҳои 𝐴 ва 𝐴 
 𝐾 𝐿 
 ҷойгиранд бе шумули худи ин элемент бо тартиби баръакс нависед. 
 элементҳои хурдтарин ва калонтарини он ҷойгир бударо ба истиснои 
 худи элементҳо ба нол, тартиб диҳед. 
 хурдтарин ва калонтарини массиви додашуда воқеъ бударо бо шумули 
 худи ин элементҳо бо тартиби баръакс нависед. 
 ба тартиб диҳед (яъне ададҳое, ки калон аз ҳамсояашон мебошанд). 
 ба квадрат бардоред (яъне ададҳое, ки хурд аз ҳамсояашон мебошанд). 
 миёнаи арифметикии он бо ҳамсояҳояш иваз намоед. 
 як мавқеъ ба тарафи чап амалӣ созед (дар ин маврид 𝐴, ба 𝐴, 𝐴, 
 𝑁 𝑁− 𝑁− 
 ба 𝐴,..., 𝐴 ба 𝐴 табдил меёбад ва элементи аввали массив аз байн 
 𝑁− 
 меравад). Элементи охирони массивро ба табдил диҳед. 
 Лағжиши элементҳои массивро K мавқеъ ба тарафи рост амалӣ созед 
 (дар ин маврид 𝐴, ба 𝐴, 𝐴, ба 𝐴,..., 𝐴 ба 𝐴 табдил меёбад ва 
 𝐾+ 𝐾+ 𝑁−𝐾 𝑁 
 мавқеи ибтидоии K элементи охирони массив аз байн меравад). К 
 элементи аввали массив ҳосилшударо ба табдил диҳед. 
 Лағжиши элементҳои массивро K мавқеъ ба тарафи чап амалӣ созед 
 (дар ин маврид 𝐴, ба 𝐴, 𝐴, ба 𝐴,..., 𝐴 ба 𝐴 табдил меёбад 
 𝑁 𝑁−𝐾 𝑁− 𝑁−𝐾− 𝐾+ 
 ва мавқеи ибтидоии K элементи аввали массив аз байн меравад). К 
 элементи аввали массив ҳосилшударо ба табдил диҳед. 
 массивро як мавқеъ ба тарафи рост амалӣ созед (дар ин маврид 𝐴, ба 
 А, А, ба А,..., 𝐴 ба 𝐴 табдил меёбад ). 
 𝑁 
 массивро як мавқеъ ба тарафи чап амалӣ созед (дар ин маврид 𝐴, ба 
 𝑁 
 𝐴, 𝐴, ба 𝐴,..., 𝐴 ба 𝐴 табдил меёбад). 
 𝑁− 𝑁− 𝑁− 𝑁 
 шудааст. Лағжиши даврии элементҳои массивро K мавқеъ ба тарафи 
 рост амалӣ созед (дар ин маврид 𝐴, ба 𝐴, 𝐴, ба 𝐴,..., 𝐴 ба 𝐴 
 𝐾+ 𝐾+ 𝑁 
 табдил меёбад). Истифодаи массив иборат аз чор элемент иҷозат дода 
 мешавад. 
 шудааст. Лағжиши даврии элементҳои массивро K мавқеъ ба тарафи 
 чап амалӣ созед (дар ин маврид 𝐴, ба 𝐴, 𝐴, ба 𝐴,..., 𝐴 ба 
 𝑁 𝑁−𝐾 𝑁− 𝑁−𝐾− 
 𝐴 табдил меёбад). Истифодаи массив иборат аз чор элемент иҷозат 
 𝑁−𝐾+ 
 дода мешавад. 
 элементҳояш бо тартиби афзуншавӣ ҷойгир шудаанд. Массиви дода 
 шударо бо ҷойиваз намудани элементи якум ба мавқеи нав ба тартиб 
 оред. 
 боқи элементҳояш бо тартиби афзуншавӣ ҷойгир шудаанд. Массиви 
 дода шударо бо ҷойиваз намудани элементи охиронаш ба мавқеи нав ба 
 тартиб оред. 
 элементҳояш бо тартиби афзуншавӣ ҷойгир шудаанд. Массив бо иваз 
 намудани мавқеи элементе, ки тартибро вайрон мекунад, ба тартиб 
 оред. 
 Хориҷкунӣ ва гузориши элементҳо 
 шудааст. Аз массиви додашуда элементҳое, ки рақами тартибиашон аз 
 K то L мебошанд, инчунин K ва L, низ нест карда шуда, андозаи массиви 
 нави ҳосилшуда ва таркиби он чоп карда шавад. 
 додашуда ҳамаи элементҳои рақами тартибиашон ҷуфт (,,...) буда, 
 нест карда шавад. Оператори шартӣ истифода бурда нашавад. 
 додашуда ҳамаи элементҳои рақами тартибиашон тоқ (,,...) буда, нест
 карда шавад. Оператори шартӣ истифода бурда нашавад. 
 додашуда ҳамаи элементҳои якхелаи ҳамсояро ғайр аз якумаш нест 
 кунед. 
 додашуда ҳамаи элементҳои якхеларо ғайр аз якумаш нест кунед. 
 додашуда, ҳамаи элементҳои якхеларо ғайр аз охиронаш нест кунед. 
 додашуда, ҳамаи элементҳои зиёда аз ду маротиба такрор мешаванд, 
 нест карда шаванд. Андоза ва таркиби массиви нави ҳосилшуда чоп 
 карда шавад. 
 додашуда ҳамаи элементҳои рассо ду маротиба такрор мешаванд нест 
 карда шаванд. Андоза ва таркиби массиви нави ҳосилшуда чоп карда 
 шавад. 
 аз элементи рақами тартибиаш К – и массив, ба элементи нулӣ гузоред. 
 аз элементи максималии додашуда, элементи нулӣ гузоред. 
 дода шудааст. Пеш аз элементи рақами тартибиаш К, ба М элементҳои 
 қиматашон нулӣ гузоред. 
 дода шудааст. Пас аз элементи рақами тартибиаш К, ба М элементҳои 
 қиматашон нулӣ гузоред. 
 элементҳои рақами тартибиашон ҷуфт (,,...) такрор карда шаванд. 
 Оператори шартӣ истифода бурда нашавад. 
 элементҳои рақами тартибиашон тоқ (,,...) се маротиба зиёд карда 
 шаванд. Оператори шартӣ истифода бурда нашавад. 
 массиви додашуда, элементи қиматаш нулӣ гузошта шаванд. 
 ҷуфт дар массиви додашуда такрор карда шаванд. 
 дар массиви додашуда се маротиба зиёд карда шаванд. 
 Мураттабсозии массивҳо 
 бо усули интихоби оддӣ ба навъҳо ҷудо (мураттабсозӣ) карда, ба тартиб 
 дароред: элементи максималии массиви додашударо ёфта онро бо 
 элементи (N- ум) охирони массив иваз намоед; тавсири ин амалро N- 
 маротиба такрор кунед, ки ҳар дафъа шумораи элементҳои 
 таҳқиқшаванда ба як адад кам шуда, таркиби массиви ҳосилшуда чоп 
 карда шавад. 
 надода, рақами тартибии элементҳои онро чунон ҷо ба ҷо гузоред, ки 
 тартиби ҷойгиршавии элементҳои он афзуншаванда бошад. Усули 
 батартибдарории ҳубобчаҳоро (ниг. ба масъалаи ) чунин такил дода 
 истифода баред: аз рақамҳои тартибии элементҳои массиви додашуда I, 
 массиви ёридиҳандаро, ки аз ададҳои бутуни аз то N тартиб ёфтааст, 
 тартиб диҳед. Массиви А – ро аз назар гузаронида, ҷуфти элементҳои 
 массиви А бо рақамҳои тартибии 𝐼 ва 𝐼,𝐼 ва 𝐼,… - ро, агар элементи 
 чапи ҷуфт калони росташ бошад, рақамҳои тартибии массив I – ро 
 мувофиқашон иваз намоед. Тартиби муоинаи овардашударо N- 
 маротиба иакрор намуда, массивиро ҳосил мекунем, ки элементҳояш ба 
 тартиби талабкардаи мо мувофиқ меояд. 
 Қатори адаҳои бутун 
 қатори массиви додашуда, элементи қиматаш нулӣ гузошта шавад. 
 ба воситаи зиёд намудани ҳар як қатори он ба як элемент табдил дода 
 шавад. 
 дорозиаш аз як калон аст, дода шудааст. Массиви додашуда ба воситаи 
 кам намудани ҳар як қатори он ба як элемент табдил дода шавад. 
 шудааст. Аз массиви додашуда, қатори рақами тартибиаш К нест карда 
 шавад. Агар қаторҳои массиви додашуда аз К хурд бошанд, массив бе 
 тағийр чоп карда шавад. 
 шудааст. Ҷои қатори якуми массиви додашударо бо қатори К – юми 
 массиви додашуда иваз намоед. Агар қаторҳои массиви додашуда аз К 
 хурд бошанд, массив бе тағийр чоп карда шавад. 
 шудааст. Ҷои қатори охирони массиви додашударо бо қатори К – юми 
 массиви додашуда иваз намоед. Агар қаторҳои массиви додашуда аз К 
 хурд бошанд, массив бе тағийр чоп карда шавад. 
 шудааст. Ҳар як қатори массиви додашударо, ки дарозиаш аз L хурд аст, 
 ба як элементи қиматаш нулӣ иваз намоед. 
 аст. Ҳар як қатори массиви додашударо, ки дарозиаш ба L баробар аст, 
 ба як элементи қиматаш нулӣ иваз намоед. 
 шудааст. Ҳар як қатори массиви додашударо, ки дарозиаш аз L калон 
 аст, ба як элементи қиматаш нулӣ иваз намоед. 
 қатори якуми массиви додашударо ба як элемент зиёд намуда, массивро 
 табдил диҳед. 
 калонтарин қаторҳои массиви додашударо ба як элемент зиёд намуда, 
 массивро табдил диҳед. 
 Маҷмӯи нуқтаҳо дар ҳамворӣ 
 координатаҳояш x,y), дода шудааст. Аз байни нуқтаҳои ин маҷмӯъ, ки 
 дар чоряки дуюм воқеъ аст, нуқтаеро ёбед, ки аз нуқтаи додашуда дар 
 масофаи дуртарин воқеъ бошад. Агар чунин нуқта набошад, он гоҳ 
 нуқтаеро чоп кунед, ки координатаҳои нулӣ дорад. 
 координатаҳояш x,y), дода шудааст. Аз байни нуқтаҳои ин маҷмӯъ, ки 
 дар чоряки якум ё сеюм воқеъ аст, нуқтаеро ёбед, ки ба нуқтаи додашуда 
 дар масофаи нисбатан ҷойгир аст, воқеъ бошад. Агар чунин нуқта 
 набошад, он гоҳ нуқтаеро чоп кунед, ки координатаҳои нулӣ дорад. 
 координатаҳояш x,y дода шудаанд), дода шудааст. Ҷуфти нуқтаҳои ин 
 маҷмӯъро ёбед, ки масофаи байни онҳо максималӣ бошад ва ин 
 масофаро ёбед (нуқтаҳо бо ҳамон тартибе чоп карда мешаванд, ки дар 
 маҷмӯи А омадаанд). 
 нуқтаҳо дода шудааст. Чунин нуқтаеро аз ҳамин маҷмӯъ ёбед, ки суммаи 
 масофаҳо аз он то дигар нуқтаҳои ин маҷмӯъ минималӣ аст ва худи он 
 нуқтаро ёбед (нуқтаҳо бо ҳамон тартибе чоп карда мешаванд, ки дар 
 маҷмӯи А ҷойгиранд). 
 нуқтаҳо дода шудааст. Секунҷаеро ёбед, ки қуллаҳояш дар нуқтаҳои 
 гуногуни маҷмӯи А ҷойгир буда, периметри калонтарин дорад (нуқтаҳо 
 бо ҳамон тартибе чоп карда мешаванд, ки дар маҷмӯи А ҷойгиранд). 
 нуқтаҳо дода шудааст. Секунҷаеро ёбед, ки қуллаҳояш дар нуқтаҳои 
 гуногуни маҷмӯи А ҷойгир буда, периметри хурдтарин дорад (нуқтаҳо 
 бо ҳамон тартибе чоп карда мешаванд, ки дар маҷмӯи А ҷойгиранд). 
 Тартибро дар координатаҳои додашуда бо усули зерин муайян мекунем: 
 (𝑥,𝑦 ) < (𝑥,𝑦 ), агар 𝑥 < 𝑥, ё 𝑥 = 𝑥 ва 𝑦 < 𝑦 бошад. Нуқтаҳои 
 маҷмӯи додашударо бо тартиби афзуншавӣ тибқи қоидаи зикршуда 
 нависед. 
 Тартибро дар координатаҳои додашуда бо усули зерин муайян мекунем: 
 (𝑥,𝑦 ) < (𝑥,𝑦 ), агар 𝑥 + 𝑦 < 𝑥 + 𝑦, ё 𝑥 + 𝑦 = 𝑥 + 𝑦 ва 𝑥 < 𝑥 
 бошад. Нуқтаҳои маҷмӯи додашударо бо тартиби камшавӣ тибқи 
 қоидаи зикршуда нависед. 
 Масъалаҳои гуруҳи Matrix 
 Java, GO, Kotlin ва VB.NET-ро аз [-] азбар намоед. 
 PascalABC.Net, C++, C#, Python, Java, GO, Kotlin ва VB.NET нависед. 
 Намунаи ҳалли масъалаҳо 
 ададҳои бутуни андозааш 𝑀 × 𝑁 созед, ки ҳамаи элементҳои I – юми 
 сатри он ба ∙ 𝐼(I=, …,M) баробар бошад. 
 PascalABC.NET C++ 
 Var #include <iostream> 
 i, j: Integer; using namespace std; 
 int main() { 
 begin int **x, n, m, i, j; 
 var m:= ReadInteger('m'); cin >> m >> n; 
 var n:= ReadInteger('n: '); x = new int*[m]; 
 var a: array [,] of integer for (i =; i < m; i++):=new integer[m +, n + ]; x[i] = new int[n]; 
 for i:= to M do for (i =; i < m; i++) 
 for j:= to N do for (j =; j < n; j++) 
 a[i, j]:= i *; x[i][j] = * (i+); 
 for i:= to M do for (i =; i < m; i++) { 
 begin for (j =; j < n; j++) 
 for j:= to N do cout<<x[i][j] << " "; 
 Write(a[i, j], ''); cout << endl; 
 writeln(); } 
 end; system("pause"); 
 end. return; 
 } 
 Python C# 
 from random import static void Main(string[] args) 
 random { 
 a=[] int m, n, i, j; 
 n=int(input("")) m=Convert.ToInt(Console.ReadLine()); 
 for i in range(,n+): n = Convert.ToInt(Console.ReadLine()); 
 x=[] int [,]x=new Int[m,n]; 
 for j in range (,n+): for (i=; i<m; i++) 
 x.append(i*)) for (j=; j<n; j++) 
 a.append(x); x[i, j]=(i+)*; 
 for row in a: for (i=; i<m; i++) { 
 print(row) for (j=; j<n; j++) 
 Console.Write(x[i, j]+" "); 
 Console.WriteLine(); 
 } 
 Console.ReadKey(); 
 } 
 Java Go 
 public static void main(String[] package main 
 args){ import "fmt" 
 Scanner sc=new Scanner(System.in); func main() { 
 int m, n, i, j; var n,m int 
 m=sc.nextInt(); x:= [][]int{} 
 n=sc.nextInt(); fmt.Print("n, m(<)") 
 int [][] x=new int[m][n]; fmt.Scan(&n, &m) 
 Random rnd=new Random(); for i:=; i<n; i++ { 
 for (i=; i<m; i++) for j:=; j<m; j++ { 
 for (j=; j<n; j++) x[i][j] = *(i+) 
 x[i][j]=rnd.nextInt(); } 
 for (i=; i<m; i++){ } 
 for (j=; j<n; j++) for i:=; i<n; i++ { 
 System.out.print(x[i][j]+" "); for j:=; j<m; j++ { 
 System.out.println(); fmt.Printf("%v ",x[i][j]) 
 } } 
 } fmt.Println() 
 } 
 } 
 Kotlin 
 import java.util.Scanner 
 fun main(args: Array<String>) { 
 val reader = Scanner(System.`in`) 
 var m = reader.nextInt() 
 var n = reader.nextInt() 
 val a = Array(m) { arrayOfNulls<Int>(n) } 
 for (i in (..m - )) { 
 for (j in (..n - )) 
 a[i][j] = * (i + ) 
 } 
 for (i in (..m - )) { 
 for (j in (..n - )) 
 print(a[i][j].toString() + " ") 
 println() 
 } 
 } 
 VB.NET 
 Sub Main() 
 Dim a(,) As Integer 
 Dim i, j, m, n As Integer 
 m = Convert.ToInt(Console.ReadLine()) 
 n = Convert.ToInt(Console.ReadLine()) 
 a = New Integer(m, n) {} 
 For i = To m - 
 For j = To n - 
 a(i, j) = * (i + ) 
 Next 
 Next 
 For i = To m - 
 For j = To n - 
 Console.Write("{} ", a(i, j)) 
 Next 
 Console.WriteLine() 
 Next 
 Console.ReadKey() 
 End Sub 
 шудааст. Чунин, матритсаи ададҳои бутуни андозааш 𝑀 × 𝑁 – ро 
 созед, ки дар ҳар як сутуни он ҳамаи ададҳои маҷмӯи дода шуда, 
 иштирок кунанд (бо ҳам тартиби додашуда). 
 PascalABC.NET C++ 
 Var #include <iostream> 
 a: array [..,..] of using namespace std; 
 integer; int main() { 
 M, N, i, j: Integer; int **x, n, m, i, j; 
 cin >> m >> n; 
 begin x = new int*[m]; 
 Write('N,M: '); for (i =; i < m; i++) 
 Readln(N, M); x[i] = new int[n]; 
 for (i =; i < m; i++) 
 Writeln('Nabor:'); cin >> x[i][]; 
 for i:= to M do for (i =; i < m; i++) 
 begin for (j =; j < n; j++) 
 Write(i, ': '); x[i][j] = x[i][j - ]; 
 readln(a[i, ]); for (i =; i < m; i++) { 
 end; for (j =; j < n; j++) 
 cout << x[i][j] << " "; 
 for i:= to M do cout << endl; 
 for j:= to N do } 
 a[i, j]:= a[i, j - ]; system("pause"); 
 return; 
 for i:= to M do } 
 begin 
 for j:= to N do 
 Write(a[i, j], ' '); 
 writeln; 
 end; 
 end. 
 Go 
 package main 
 import "fmt" 
 func main() { 
 var n,m int 
 x:= [][]int{} 
 fmt.Print("m, n(<)") 
 fmt.Scan(&m, &n) 
 for j:=; j<n; j++ { 
 fmt.Scan(&x[][j]) 
 } 
 for i:=; i<m; i++ { 
 for j:=; j<n; j++ { 
 x[i][j] = x[i-][j] 
 } 
 } 
 for i:=; i<m; i++ { 
 for j:=; j<n; j++ { 
 fmt.Printf("%+v ", x[i][j]) 
 } 
 fmt.Println() 
 } 
 } 
 А оғоз намуда, ҳамаи элементҳои онро бо усули кунҷӣ хориҷ, 
 кунед: ҳамаи элементҳои сатри якум; элементҳои сутуни охирон ба 
 ғайр аз элементи якумаш; элементҳои боқимондаи сатри дуюм; 
 элементҳои боқимондаи сутуни охирон ва ғайра; дар охир элементи 
 А хориҷ карда мешавад. 
 М, 
 PascalABC.NET C++ 
 Var #include <iostream> 
 a: array [..,..] of using namespace std; 
 integer; int main() { 
 M, i, j, i: Integer; int **x, m, i, j; 
 cin >> m; 
 begin m = m -; 
 x = new int*[m+]; 
 Write('M: '); for (i =; i <=m; i++) 
 Readln(M); x[i] = new int[m+]; 
 M:= M -; for (i =; i <=m; i++) 
 for i:= to M do for (j =; j <= m; j++) 
 begin cin>>x[i][j]; 
 for j:= to M do for (i =; i <= m; i++) { 
 begin for (j =; j <=m; j++) 
 a[i, j]:= Random(); cout << x[i][j] << " "; 
 write(a[i, j], ' '); cout << endl; 
 end; } 
 writeln; cout << endl; 
 end; for (i =; i <= m; i++) { 
 writeln; for (j =; j <=m-i; j++) 
 for i:= to M do cout << " "<<x[i][j]; 
 begin for (int k=i+; k<=m; k++) 
 for j:= to M - i do cout << " " << x[k][m-i]; 
 write(' ', a[i, j]); cout << endl; 
 for var k:= i + to M do } 
 write(' ', a[k, M - i]); system("pause"); 
 writeln(''); return; 
 end; } 
 end. 
 Go 
 package main 
 import ( 
 "fmt" 
 "math/rand" 
 ) 
 func main() { 
 var m,i,j,k int 
 x:= [][]int{} 
 fmt.Print("m(<)") 
 fmt.Scan(&m) 
 for i=; i<m; i++ { 
 for j=; j<m; j++ { 
 x[i][j] = rand.Intn() 
 fmt.Printf("%+v ", x[i][j]) 
 } 
 fmt.Println() 
 } 
 fmt.Println() 
 for i=; i<m; i++ { 
 for j=; j<m-i; j++ { 
 fmt.Printf("%v ", x[i][j]) 
 } 
 for k=i+; k<m; k++ { 
 fmt.Printf("%v ", x[k][m--i]) 
 } 
 fmt.Println() 
 } 
 } 
 шудааст. Аз элементи А оғоз намуда, бо самти ҳаракати ақрабаки, 
 соат чун симпеч ҳаракат намуда, ҳамаи элементҳои матритсаи 
 додашударо чоп намоед: сатри якум, сутуни охирон, сатри охирон 
 бо тартиби баръакс, сутуни якум бо тартиби баръакс, элементҳои 
 боқимондаи сатри дуюм ва ғайра; дар охир элементи марказии 
 матритса хориҷ карда мешавад. 
 PascalABC.NET C++ 
 Var #include <iostream> 
 a: array [..,..] using namespace std; 
 of integer; int main() { 
 M, i, j, k: Integer; int **x, m, i, j, k; 
 begin cin >> m; 
 Write('M: '); m = m -; 
 Readln(M); x = new int*[m+]; 
 M:= M -; for (i =; i <=m; i++) 
 for i:= to M do x[i] = new int[m+]; 
 begin for (i =; i <=m; i++) 
 for j:= to M do for (j =; j <= m; j++) 
 begin x[i][j]=rand()%; 
 a[i,j]:=Random(); for (i =; i <= m; i++) { 
 write(a[i, j], ' '); for (j =; j <=m; j++) 
 end; cout << x[i][j] << " "; 
 writeln; cout << endl; 
 end; } 
 writeln; cout << endl; 
 for i:= to M div do for (i =; i <= m/; i++) { 
 begin for (j = i; j <= m-i; j++) 
 for j:=i to M-i do cout <<x[i][j]<<" "; 
 Write(a[i, j], ' '); for (k=i+; k<=m-i; k++) 
 for k:=i+ to M-i do cout << x[k][m-i]<<" "; 
 Write(a[k,M-i],' '); for (j=m--i; j>=i; j--) 
 for j:=M--i downto i do cout << x[m-i][j] << " "; 
 Write(a[M-i,j], ' '); for (k=m--i; k>=i+; k--) 
 for k:=M--i downto i+ do cout << x[k][i] << " "; 
 Write(a[k, i], ' '); cout << endl; 
 writeln(''); } 
 end; system("pause"); 
 end. return; 
 } 
 Go 
 package main 
 import ( 
 "fmt" 
 "math/rand" 
 ) 
 func main() { 
 var m,i,j,k int 
 x:= [][]int{} 
 fmt.Scan(&m) 
 for i=; i<m; i++ { 
 for j=; j<m; j++ { 
 x[i][j] = rand.Intn() 
 fmt.Printf("%+v ", x[i][j]) 
 } 
 fmt.Println() 
 } 
 fmt.Println() 
 for i=; i<m/; i++ { 
 for j=; j<m-i; j++ { 
 fmt.Printf("%v ", x[i][j]) 
 } 
 for k=i+; k<m-i; k++ { 
 fmt.Printf("%v ", x[k][m--i]) 
 } 
 for j=m--i;j >=i; j--{ 
 fmt.Printf("%v ", x[m--i][j]) 
 } 
 for k=m--i; k>=i+; k-- { 
 fmt.Printf("%v ", x[k][i]) 
 } 
 fmt.Println() 
 } 
 } 
 Таҳлили элементҳои матритса 
 шудааст. Сумма ва ҳосили зарби элементҳои сатри К – юми 
 матритсаи дода шударо ёбед. 
 PascalABC.NET C++ 
 Var #include <iostream> 
 a: array [..,..] using namespace std; 
 of integer; int main() { 
 M, N, K, i, j, i: int **x, m, n,k, i, j, S=, P=; 
 Integer; cin >> m>>n>>k; 
 x = new int*[m]; 
 begin for (i =; i <m; i++) 
 Write('M,N,K: '); x[i] = new int[n]; 
 Readln(M, N, K); for (i =; i <m; i++) 
 for i:= to M do for (j =; j <n; j++) 
 begin x[i][j]=rand()%; 
 for j:= to N do for (i =; i <m; i++) { 
 begin for (j =; j <n; j++) 
 a[i,j]:=Random(); cout << x[i][j] << " "; 
 write(a[i, j], ' '); cout << endl; 
 end; } 
 writeln; cout << endl; 
 end; for (j =; j < n; j++) { 
 writeln; S = S + x[k-][j]; 
 P = P*x[k-][j]; 
 var S:=; } 
 var P:=; cout << S << " " << P << endl; 
 for j:= to N do system("pause"); 
 begin return; 
 S:= S + a[K, j]; } 
 P:= P * a[K, j]; 
 end; 
 Write('S=', S, 'P=', P); 
 end. 
 C# 
 static void Main(){ 
 int m, n, k, i, j, sum =, mult =; 
 Console.Write("M="); 
 m = Convert.ToInt(Console.ReadLine()); 
 Console.Write("N="); 
 n = Convert.ToInt(Console.ReadLine()); 
 Console.Write("K="); 
 k = Convert.ToInt(Console.ReadLine()); 
 int[, ] A = new int[m, n]; 
 for (i =; i < m; i++) 
 { 
 for (j =; j < n; j++) 
 { 
 Console.Write("A[" + (i + ) + "," + (j + ) + "]="); 
 A[i, j] = Convert.ToInt(Console.ReadLine()); 
 } 
 } 
 for (j =; j < n; j++) 
 { 
 sum += A[k -, j]; 
 mult *= A[k -, j]; 
 } 
 Console.WriteLine("Сумма " + sum); 
 Console.WriteLine("Хосили закрб " + mult); 
 } 
 } 
 } 
 Go 
 package main 
 import ( 
 "fmt" 
 "math/rand" 
 ) 
 func main() { 
 var m,i,j,k int 
 x:= [][]int{} 
 fmt.Print("m(<)") 
 fmt.Scan(&m) 
 for i=; i<m; i++ { 
 for j=; j<m; j++ { 
 x[i][j] = rand.Intn() 
 fmt.Printf("%+v ", x[i][j]) 
 } 
 fmt.Println() 
 } 
 fmt.Println() 
 fmt.Print("k(<)") 
 fmt.Scan(&k) 
 var S,P int=, 
 for j=;j<m; j++{ 
 S+=x[k-][j]; 
 P*=x[k-][j]; 
 } 
 fmt.Printf("%d %d", S,P) 
 } 
 элементҳои он қиматҳои аз то – ро қабул мекунад. Сатрҳои 
 гуногуни матрисаро монанд меномем, агар ададҳои дар ин сатрҳо 
 вохӯранда ба ҳам мувофиқат кунанд. Миқдори сатрҳое, ки ба сатри 
 якуми матритса монанданд, ёфта шавад. 
 PascalABC.NET 
 Var 
 a: array [..,..] of integer; 
 Num, M, N, i, j: Integer; 
 L, LM: set of byte; 
 begin 
 Write('N,M: '); 
 Readln(N, M); 
 for i:= to M do 
 for j:= to N do 
 Read(a[i, j]); 
 writeln; 
 for i:= to M do 
 begin 
 for j:= to N do 
 begin 
 write(a[i, j], ' '); 
 end; 
 writeln; 
 end; 
 writeln; 
 L:= []; 
 for j:= to N do 
 L:= L + [a[, j]]; 
 Num:=; 
 for i:= to M do 
 begin 
 LM:= []; 
 for j:= to N do 
 LM:= LM + [a[i, j]]; 
 if L = LM then 
 inc(Num); 
 end; 
 Writeln(Num); 
 end. 
 С++ 
 #include <iostream> 
 using namespace std; 
 void sort(int a[], int n) { 
 for (int i =; i < n; ++i) 
 for (int j =; j < n - i; j++) 
 if (a[j] > a[j + ]){ 
 int temp = a[j]; 
 a[j] = a[j + ]; 
 a[j + ] = temp; 
 } 
 } 
 bool isLike(int a[], int b[], int n) { 
 sort(a, n); 
 sort(b, n); 
 int i =; 
 while ((a[i] == b[i]) && (i<n)) 
 i++; 
 return i == n; 
 } 
 int main() { 
 int **a, m,n, i,j, k=; 
 cin >> m>>n; 
 a = new int*[m]; 
 for (i =; i < m; i++) 
 a[i] = new int[n]; 
 for (i =; i < m; ++i) 
 for (j=; j<n; j++) 
 cin>>a[i][j]; 
 cout << endl; 
 for (i =; i < m; ++i) { 
 for (j =; j < n; j++) 
 cout << a[i][j] << " "; 
 cout << endl; 
 } 
 for (i =; i < m; i++) 
 if (isLike(a[], a[i], n)) 
 k++; 
 cout <<"k="<<k<<endl; 
 for (i =; i < m; i++) 
 delete a[i]; 
 delete a; 
 system("pause"); 
 return; 
 } 
 Миқдори сатрҳои он, ки ҳамаи элементҳояш гуногун аст, ёфта 
 шавад. 
 PascalABC.NET 
 Var 
 a: array [..,..] of integer; 
 Rez, M, N, i, j: Integer; 
 Row: set of byte; 
 begin 
 Write('N,M: '); 
 Readln(N, M); 
 for i:= to M do 
 begin 
 for j:= to N do 
 begin 
 a[i, j]:= Random(); 
 write(a[i, j], ' '); 
 end; 
 writeln; 
 end; 
 writeln; 
 Rez:=; 
 for i:= to M do 
 begin 
 j:=; 
 Row:= []; 
 while (not (a[i, j] in Row)) and (j <= N) do 
 begin 
 Row:= Row + [a[i, j]]; 
 inc(j); 
 end; 
 if J = N + then 
 inc(Rez); 
 end; 
 Writeln(Rez); 
 end. 
 С++ 
 #include <iostream> 
 using namespace std; 
 void sort(int a[], int n) { 
 for (int i =; i < n; ++i) 
 for (int j =; j < n - i; j++) 
 if (a[j] > a[j + ]){ 
 int temp = a[j]; 
 a[j] = a[j + ]; 
 a[j + ] = temp; 
 } 
 } 
 bool isUnique(int a[], int n) { 
 sort(a, n); 
 int i =; 
 while ((a[i-]<a[i]) && (i<n)) 
 i++; 
 return i == n; 
 } 
 int main() { 
 int **a, m,n, i,j, k=; 
 cin >> m>>n; 
 a = new int*[m]; 
 for (i =; i < m; i++) 
 a[i] = new int[n]; 
 for (i =; i < m; ++i) 
 for (j=; j<n; j++) 
 cin>>a[i][j]; 
 cout << endl; 
 for (i =; i < m; ++i) { 
 for (j =; j < n; j++) 
 cout << a[i][j] << " "; 
 cout << endl; 
 } 
 for (i =; i < m; i++) 
 if (isUnique(a[i], n)) 
 k++; 
 cout <<"k="<<k<<endl; 
 for (i =; i < m; i++) 
 delete a[i]; 
 delete a; 
 system("pause"); 
 return; 
 } 
 Табдилдиҳии матритсаҳо 
 𝐾 ≤ ≤ 𝑀) дода шуда аст. Мавқеи сатрҳои рақами тартибиашон 
 𝐾 ва 𝐾 - и матритса ёфта шавад. 
 PascalABC.NET C++ 
 Type #include <iostream> 
 matrix = array [.., using namespace std; 
 var int h = a; 
 a: matrix; a = b; 
 M,N,i,j,K,K: Integer; b = h; 
 begin } 
 Write('N,M: '); int main() { 
 Readln(N, M); int **x, m, n, i, j,k, k; 
 for i:= to M do cin >> m >> n; 
 begin x = new int*[m]; 
 for j:= to N do for (i =; i < m; i++) 
 begin x[i] = new int[n]; 
 a[i,j]:=Random(); for (i =; i < m; i++) 
 write(a[i, j], ' '); for (j =; j < n; j++) 
 end; x[i][j]=rand() %; 
 writeln; for (i =; i < m; i++) { 
 end; for (j =; j < n; j++) 
 writeln; cout << x[i][j] << " "; 
 writeln('K,K'); cout << endl; 
 Read(K, K); } 
 for j:= to N do cout << "k,k: \n"; cin >> k >> k; 
 swap(a[K,j], a[K,j]); for (j =; j<n; j++) 
 for i:= to M do swap(x[k][j], x[k][j]); 
 begin cout << endl; 
 for j:= to N do for (i =; i < m; i++) { 
 begin for (j =; j < n; j++) 
 Write(a[i, j],' '); cout << x[i][j] << " "; 
 end; cout << endl; 
 writeln(); } 
 end; system("pause"); 
 end. return; 
 } 
 Go 
 package main 
 import ( 
 "fmt" 
 "math/rand" 
 ) 
 func main() { 
 var m,i,j, k, k int 
 x:= [][]int{} 
 fmt.Print("m(<)") 
 fmt.Scan(&m) 
 for i=; i<m; i++ { 
 for j=; j<m; j++ { 
 x[i][j] = rand.Intn() 
 fmt.Printf("%+v ", x[i][j]) 
 } 
 fmt.Println() 
 } 
 fmt.Println() 
 fmt.Print("k, k(<)") 
 fmt.Scan(&k, &k) 
 for j:=; j<m; j++{ 
 x[k][j], x[k][j]=x[k][j], x[k][j] 
 } 
 for i=; i<m; i++ { 
 for j=; j<m; j++ { 
 fmt.Printf("%+v ", x[i][j]) 
 } 
 fmt.Println() 
 } 
 } 
 шудааст. Сатри рақами К – юми матритса нест карда шавад. 
 PascalABC.NET C++ 
 Var #include <iostream> 
 a: array [..,..] of using namespace std; 
 integer; int main() { 
 K, M, N, i, j: Integer; int **x, m, n, i, j, k; 
 cin >> m >> n; 
 begin x = new int*[m]; 
 Write('N,M,K: '); for (i =; i < m; i++) 
 Readln(N, M, K); x[i] = new int[n]; 
 for i:= to M do for (i =; i < m; i++) 
 begin for (j =; j < n; j++) 
 for j:= to N do x[i][j] = rand() %; 
 begin for (i =; i < m; i++) { 
 a[i,j]:=Random(); for (j =; j < n; j++) 
 write(a[i,j],''); cout << x[i][j] << " "; 
 end; cout << endl; 
 writeln; } 
 end; cout << "k="; cin >> k; 
 writeln; m = m -; 
 M:= M -; for (i = k -; i < m; i++) 
 for (j =; j < n; j++) 
 for i:= K to M do 
 x[i][j] = x[i + ][j]; 
 for j:= to N do 
 cout << endl; 
 a[i,j]:=a[i+,j]; for (i =; i < m; i++) { 
 for (j =; j < n; j++) 
 for i:= to M do 
 cout << x[i][j] << " "; 
 begin 
 cout << endl; 
 for j:= to N do } 
 begin system("pause"); 
 return; 
 Write(a[i,j],''); 
 } 
 end; 
 writeln(); 
 end; 
 end. 
 Go 
 package main 
 import ( 
 "fmt" 
 "math/rand" 
 ) 
 func main() { 
 var m,n,i,j, k int 
 x:= [][]int{} 
 fmt.Print("m, n(<)") 
 fmt.Scan(&m, &n) 
 for i=; i<m; i++ { 
 for j=; j<n; j++ { 
 x[i][j] = rand.Intn() 
 fmt.Printf("%+v ", x[i][j]) 
 } 
 fmt.Println() 
 } 
 fmt.Println() 
 fmt.Print("k(<)") 
 fmt.Scan(&k) 
 m=m- 
 for i=k; i<m; i++ { 
 for j:=; j<n; j++{ 
 x[i][j]=x[i+][j] 
 } 
 } 
 for i=; i<m; i++ { 
 for j=; j<n; j++ { 
 fmt.Printf("%+v ", x[i][j]) 
 } 
 fmt.Println() 
 } 
 } 
 шудааст. Пеш аз сатри рақами К – юми матритса, сатри нулӣ 
 гузоред. 
 PascalABC.NET 
 Var 
 a: array [..,..] of integer; 
 K, M, N, i, j: Integer; 
 begin 
 Write('N,M,K: '); 
 Readln(N, M, K); 
 for i:= to M do 
 begin 
 for j:= to N do 
 begin 
 a[i, j]:= Random(); 
 write(a[i, j], ' '); 
 end; 
 writeln; 
 end; 
 writeln; 
 if k > then 
 begin 
 M:= M +; 
 for i:= M downto k + do 
 for j:= to N do 
 a[i, j]:= a[i -, j]; 
 end; 
 for j:= to N do 
 a[k, j]:=; 
 for i:= to M do 
 begin 
 for j:= to N do 
 begin 
 Write(a[i, j], ' '); 
 end; 
 writeln(); 
 end; 
 end. 
 C++ 
 #include <iostream> 
 using namespace std; 
 int main() { 
 int **x, m, n, i, j, k; 
 cin >> m >> n; 
 x = new int*[m+]; 
 for (i =; i < m+; i++) 
 x[i] = new int[n]; 
 for (i =; i < m; i++) 
 for (j =; j < n; j++) 
 x[i][j] = rand() %; 
 for (i =; i < m; i++) { 
 for (j =; j < n; j++) 
 cout << x[i][j] << " "; 
 cout << endl; 
 } 
 cout << "k="; cin >> k; 
 k = k -; 
 m = m +; 
 for (i = m -; i > k; i--) 
 for (j =; j < n; j++) 
 x[i][j] = x[i - ][j]; 
 for (j =; j < n; j++) 
 x[k][j] =; 
 cout << endl; 
 for (i =; i < m; i++) { 
 for (j =; j < n; j++) 
 cout << x[i][j] << " "; 
 cout << endl; 
 } 
 system("pause"); 
 return; 
 } 
 Go 
 package main 
 import ( 
 "fmt" 
 "math/rand" 
 ) 
 func main() { 
 var m,n,i,j, k int 
 x:= [][]int{} 
 fmt.Print("m, n(<)") 
 fmt.Scan(&m, &n) 
 for i=; i<m; i++ { 
 for j=; j<n; j++ { 
 x[i][j] = rand.Intn() 
 fmt.Printf("%+v ", x[i][j]) 
 } 
 fmt.Println() 
 } 
 fmt.Println() 
 fmt.Print("k(<)") 
 fmt.Scan(&k) 
 m=m+ 
 for i=m-; i>k; i--{ 
 for j:=; j<n; j++{ 
 x[i][j]=x[i-][j] 
 } 
 } 
 for j=; j<n; j++{ 
 x[k][j]= 
 } 
 for i=; i<m; i++ { 
 for j=; j<n; j++ { 
 fmt.Printf("%+v ", x[i][j]) 
 } 
 fmt.Println() 
 } 
 } 
 минимуми локалӣ номида мешавад, агар он аз ҳамаи элементҳои 
 онро иҳотакунанда хурд бошад. Ҳамаи минимумҳои локалии 
 матритсаро ба нулҳо иваз намоед. Ҳангоми ҳал истифодаи 
 матритсаи ёридиҳанда иҷозат дода мешавад. 
 PascalABC.NET 
 Type 
 matrix = array [..,..] of integer; 
 var 
 a: matrix; 
 K, M, N, i, j: Integer; 
 function LocMinMatr(var mat: matrix; X, Y: Integer): Boolean; 
 begin 
 LocMinMatr:= true; 
 if x > then 
 if mat[x, y] >= mat[x -, y] then 
 LocMinMatr:= False; 
 if x = mat[x +, y] then 
 LocMinMatr:= False; 
 if y > then 
 if mat[x, y] >= mat[x, y - ] then 
 LocMinMatr:= False; 
 if y = mat[x, y + ] then 
 LocMinMatr:= False; 
 if (y > ) and (x > ) then 
 if mat[x, y] >= mat[x -, y - ] then 
 LocMinMatr:= False; 
 if (y < N) and (x < M) then 
 if mat[x, y] >= mat[x +, y + ] then 
 LocMinMatr:= False; 
 if (y > ) and (x < M) then 
 if mat[x, y] >= mat[x +, y - ] then 
 LocMinMatr:= False; 
 if (y < N) and (x > ) then 
 if mat[x, y] >= mat[x -, y + ] then 
 LocMinMatr:= False; 
 end; 
 begin 
 Write('N,M: '); 
 Readln(N, M); 
 for i:= to M do 
 begin 
 for j:= to N do 
 begin 
 a[i, j]:= Random(); 
 write(a[i, j], ' '); 
 end; 
 writeln; 
 end; 
 writeln; 
 for i:= to M do 
 for j:= to N do 
 if LocMinMatr(a, i, j) then 
 a[i, j]:=; 
 for i:= to M do 
 begin 
 for j:= to N do 
 begin 
 Write(a[i, j], ' '); 
 end; 
 writeln; 
 end; 
 end. 
 C++ 
 #include <iostream> 
 using namespace std; 
 int main() { 
 int **x, m, n, i, j, k; 
 cin >> m >> n; 
 x = new int*[m+]; 
 for (i =; i < m+; i++) 
 x[i] = new int[n]; 
 for (i =; i < m; i++) 
 for (j =; j < n; j++) 
 x[i][j] = rand() %; 
 for (i =; i < m; i++) { 
 for (j =; j < n; j++) 
 cout << x[i][j] << " "; 
 cout << endl; 
 } 
 int num; 
 for (i =; i < m; ++i) { 
 for (j =; j < n; ++j) { 
 num =; 
 if (i - >= ) { 
 if (x[i][j] < x[i - ][j]) num++; 
 } 
 else ++num; 
 if ((i + ) < m) { 
 if (x[i][j] < x[i + ][j]) num++; 
 } 
 else ++num; 
 if (j - >= ) { 
 if (x[i][j] < x[i][j - ]) num++; 
 } 
 else ++num; 
 if ((j + ) < n) { 
 if (x[i][j] < x[i][j + ]) num++; 
 } 
 else 
 ++num; 
 if (num == ) x[i][j] =; 
 } 
 } 
 cout << endl; 
 for (i =; i < m; i++) { 
 for (j =; j < n; j++) 
 cout << x[i][j] << " "; 
 cout << endl; 
 } 
 for (i =; i < m +; i++) 
 delete x[i]; 
 delete x; 
 system("pause"); 
 return; 
 } 
 Диагонали матритсаҳои квадратӣ 
 диагонали асосии он ёфта шавад, яъне диагонале, ки элементҳои 
 зеринро дар бар мегирад: А,А,А,…,А.,,, М,М 
 PascalABC.NET C++ 
 Var #include <iostream> 
 a: array [..,..] of using namespace std; 
 integer; int main() { 
 N,i,j: Integer; int **x, m, i, j, S =; 
 cin >> m; 
 begin x = new int*[m]; 
 Write('N '); for (i =; i < m; i++) 
 Readln(N); x[i] = new int[m]; 
 for i:= to N do for (i =; i < m; i++) 
 begin for (j =; j < m; j++) 
 for j:= to N do x[i][j] = rand() %; 
 begin for (i =; i < m; i++) { 
 a[i, j]:= Random(); for (j =; j < m; j++) 
 write(a[i, j], ' '); cout << x[i][j] << " "; 
 end; cout << endl; 
 writeln; } 
 end; for (i =; i < m; i++) 
 writeln; S += x[i][i]; 
 cout << S << endl; 
 var S:=; for (i =; i < m; i++) 
 for i:= to N do delete x[i]; 
 S+=a[i,i]; delete x; 
 WriteFormat('Sum={}',S); system("pause"); 
 end. return; 
 } 
 Go 
 package main 
 import ( 
 "fmt" 
 "math/rand" 
 ) 
 func main() { 
 var m,i,j int 
 x:= [][]int{} 
 fmt.Print("m, n(<)") 
 fmt.Scan(&m) 
 for i=; i<m; i++ { 
 for j=; j<m; j++ { 
 x[i][j] = rand.Intn() 
 fmt.Printf("%+v ", x[i][j]) 
 } 
 fmt.Println() 
 } 
 fmt.Println() 
 S:= 
 for j=; j<m; j++{ 
 S+=x[j][j] 
 } 
 fmt.Println(S) 
 } 
 ҳар як элементи диагонали параллели асосии он ёфта шавад, (аз 
 диагонали якэлементаи А оғоз намуда).,М 
 PascalABC.NET C++ 
 Var #include <iostream> 
 a:array [..,..] of using namespace std; 
 integer; int main() { 
 S,N, i, j:Integer; int **x, m, i, j, S =; 
 cin >> m; 
 Begin x = new int*[m]; 
 Write('N '); for (i =; i < m; i++) 
 Readln(N); x[i] = new int[m]; 
 for i:= to N do for (i =; i < m; i++) 
 begin for (j =; j < m; j++) 
 for j:= to N do x[i][j] = rand() %; 
 begin for (i =; i < m; i++) { 
 a[i,j]:=Random(); for (j =; j < m; j++) 
 write(a[i, j], ' '); cout << x[i][j] << " "; 
 end; cout << endl; 
 writeln; } 
 end; m--; 
 writeln; for (j =; j <= m; j++) { 
 S =; 
 for j:= to N- do for (i =; i <= j; i++) 
 begin S += x[i][m - (j - i)]; 
 S:=; cout << "S=" << S << endl; 
 for i:= to j do } 
 begin for (j = m -; j >=; j--) { 
 S:=S+a[i,N-(j-i)]; S =; 
 end; for (i =; i <= j; i++) 
 Writeln(S); S += x[m - (j - i)][i]; 
 end; cout << "S=" << S << endl; 
 } 
 for j:=N- downto do for (i =; i < m; i++) 
 begin delete x[i]; 
 S:=; delete x; 
 for i:= to j do system("pause"); 
 begin return; 
 S:=S+a[N-(j-i),i]; } 
 end; 
 Writeln(S); 
 end; 
 end. 
 Go 
 package main 
 import ( 
 "fmt" 
 "math/rand" 
 ) 
 func main() { 
 var m,i,j int 
 x:= [][]int{} 
 fmt.Print("m(<)") 
 fmt.Scan(&m) 
 for i=; i<m; i++ { 
 for j=; j<m; j++ { 
 x[i][j] = rand.Intn() 
 fmt.Printf("%+v ", x[i][j]) 
 } 
 fmt.Println() 
 } 
 fmt.Println() 
 m-- 
 for j=; j<=m; j++{ 
 S:= 
 for i=; i<=j; i++{ 
 S+=x[i][m-(j-i)] 
 } 
 fmt.Println(S) 
 } 
 for j=m-; j>=; j--{ 
 S:= 
 for i=; i<=j; i++{ 
 S+=x[m-(j-i)][i] 
 } 
 fmt.Println(S) 
 } 
 } 
 диагонали асосӣ элементҳои онро ба таври оинавӣ инъикос намоед 
 (дар ин маврид мавқеи диагонали асосӣ тағийр намеёбад, элементи 
 А ҷои худро бо элементи А ва элементи А бо А ва ғайра иваз,,,, 
 мекунанд). Матритсаи ёридиҳанда истифода бурда нашавад. 
 PascalABC.NET 
 Type 
 matrix = array [..,..] of integer; 
 var 
 a: matrix; 
 M, i, j: Integer; 
 begin 
 Write('M: '); 
 Readln(M); 
 for i:= to M do 
 begin 
 for j:= to M do 
 begin 
 a[i, j]:= Random(); 
 write(a[i, j], ' '); 
 end; 
 writeln; 
 end; 
 writeln; 
 for j:= to M do 
 for i:= to M - j do 
 Swap(a[i, j], a[M - j +, M - i + ]); 
 for i:= to M do 
 begin 
 for j:= to M do 
 begin 
 Write(a[i,j],' '); 
 end; 
 writeln(); 
 end; 
 end. 
 C++ 
 #include <iostream> 
 using namespace std; 
 void swap(int &a, int &b) { 
 int h = a; 
 a = b; 
 b = h; 
 } 
 int main() { 
 int **x, m, i, j, S =; 
 cin >> m; 
 x = new int*[m]; 
 for (i =; i < m; i++) 
 x[i] = new int[m]; 
 for (i =; i < m; i++) 
 for (j =; j < m; j++) 
 x[i][j] = rand() %; 
 for (i =; i < m; i++) { 
 for (j =; j < m; j++) 
 cout << x[i][j] << " "; 
 cout << endl; 
 } 
 m--; 
 for (j =; j <= m; j++) 
 for (i =; i <= m - j; i++) 
 swap(x[i][j], x[m - j][m - i]); 
 cout << endl; 
 m++; 
 for (i =; i < m; i++) { 
 for (j =; j < m; j++) 
 cout << x[i][j] << " "; 
 cout << endl; 
 } 
 for (i =; i < m; i++) 
 delete x[i]; 
 delete x; 
 system("pause"); 
 return; 
 } 
 Go 
 package main 
 import ( 
 "fmt" 
 "math/rand" 
 ) 
 func main() { 
 var m,i,j int 
 x:= [][]int{} 
 fmt.Print("m(<)") 
 fmt.Scan(&m) 
 for i=; i<m; i++ { 
 for j=; j<m; j++ { 
 x[i][j] = rand.Intn() 
 fmt.Printf("%+v ", x[i][j]) 
 } 
 fmt.Println() 
 } 
 fmt.Println() 
 m-- 
 for j=; j<=m; j++{ 
 for i=; i<=m-j; i++{ 
 x[i][j],x[m-j][m-i]=x[m-j][m-i],x[i][j] 
 } 
 } 
 for i=; i<=m; i++ { 
 for j=; j<=m; j++ { 
 fmt.Printf("%+v ", x[i][j]) 
 } 
 fmt.Println() 
 } 
 } 
 Масъалаҳо барои кори мустақилона 
 ададҳои бутуни андозааш 𝑀 × 𝑁 – ро созед, ки ҳамаи элементҳои J– 
 юми сутуни он ба ∙ 𝐽(J=, …,N) баробар бошад. 
 шудааст. Чунин матритсаи ададҳои бутуни андозааш 𝑀 × 𝑁 – ро 
 созед, ки дар ҳар як сатри он ҳамаи ададҳои маҷмӯи дода шуда, 
 иштирок кунанд (бо ҳам тартиби додашуда). 
 ададҳо дода шудааст. Чунин матритсаи ададҳои бутуни андозааш 
 𝑀 × 𝑁 – ро созед, ки сутуни якуми он ба ададҳои маҷмӯи додашуда 
 мувофиқ омада, ҳамаи сутунҳои ояндаи он бошад, ба суммаи 
 элементи пешинааш бо адади D баробар бошад (дар натиҷа ҳар як 
 сатри матритса аз элементҳои прогрессияи арифметикӣ иборат 
 мешавад). 
 ададҳо дода шудааст. Чунин, матритсаи ададҳои бутуни андозааш 
 𝑀 × 𝑁 – ро созед, ки сатри якуми он ба ададҳои маҷмӯи додашуда 
 мувофиқ омада, ҳамаи сатрҳои ояндаи он бошад, ба ҳосили зарби 
 элементи пешинааш бо адади D баробар бошад (дар натиҷа ҳар як 
 сутуни матритса аз элементҳои прогрессияи геометрӣ иборат 
 мешавад). 
 шудааст. Элементҳои сатри К – юми матритсаи дода шударо, хориҷ 
 кунед. 
 шудааст. Элементҳои сутуни К – юми матритсаи дода шударо хориҷ 
 кунед. 
 рақамҳои ҷуфти (,,...) сатри матритсаи дода шударо, хориҷ кунед. 
 Элементҳоро бо намуди сатри чоп кунед, оператори шартӣ 
 истифода бурда нашавад. 
 рақамҳои тоқи (,,...) сутуни матритсаи дода шударо, хориҷ кунед. 
 додашударо бо тартиби зерин хориҷ кунед: сатри якум аз чап ба 
 рост, сатри дуюм аз рост ба чап, сатри сеюм аз чап ба рост, сатри 
 чорум аз рост ба чап ва ғайра. 
 додашударо бо тартиби зерин хориҷ кунед: сутуни якум аз боло ба 
 поён, сутуни дуюм аз поён ба боло, сутуни сеюм аз боло ба поён, 
 сутуни чорум аз поён ба боло ва ғайра. 
 А оғоз намуда, ҳамаи элементҳои онро бо чунин усул хориҷ кунед:, 
 ҳамаи элементҳои сутуни якум; элементҳои сатри охирон ба ғайр аз 
 элементи якумаш; элементҳои боқимондаи сутуни дуюм; 
 элементҳои боқимондаи сатри охирон ва ғайра; дар охир элементи 
 А хориҷ карда мешавад. 
 М, 
 шудааст. Аз элементи А оғоз намуда, бо муқобили самти ҳаракати, 
 ақрабаки соат чун симпеч ҳаракат намуда, ҳамаи элементҳои 
 матритсаи додашударо чоп намоед: сутуни якум, сатри охирон, 
 сутуни охирон бо тартиби баръакс, сатри якум бо тартиби баръакс, 
 элементҳои боқимондаи сутуни дуюм ва ғайра; дар охир элементи 
 марказии матритса хориҷ карда мешавад. 
 Таҳлили элементҳои матритса 
 шудааст. Сумма ва ҳосили зарби элементҳои сутуни К – юми 
 матритсаи дода шударо ёбед. 
 матритса, суммаи элементҳои он ёфта шавад. 
 матритса ҳосили зарби элементҳои он ёфта шавад. 
 рақами тартибиаш тоқи (,,...) матритса, қимати миёнаи 
 арифметикии элементҳои онро ёбед. Оператори шартӣ истифода 
 бурда нашавад. 
 рақами тартибиаш ҷуфти (,,...) матритса, суммаи элементҳои онро 
 ёбед. Оператори шартӣ истифода бурда нашавад. 
 матритса, элементи хурдтарин ёфта шавад. 
 матритса, элементи калонтарин ёфта шавад. 
 сатри матритсаро ёбед, ки суммаи элементҳояш калонтарин аст. 
 Рақами тартибии ин сатр ва қимати суммаи калонтаринро чоп 
 кунед. 
 сутуни матритсаро ёбед, ки ҳосили зарби элементҳояш хурдтарин 
 аст. Рақами тартибии ин сутун ва қимати ҳосили зарби хурдтаринро 
 чоп кунед. 
 дар байни калонтарин элементи сатрҳои матритса ёфта шавад. 
 дар байни хурдтарин элементи сутунҳои матритса ёфта шавад. 
 миқдори элементҳоеро ёбед, ки хурд аз қимати миёнаи 
 арифметикии ҳамаи элементҳои ин сатр бошад. 
 миқдори элементҳоеро ёбед, ки калон аз қимати миёнаи 
 арифметикии ҳамаи элементҳои ин сутун бошад. 
 ва сутуни матритсаро, ки дар буриши онҳо элементе ҷойгир бошад, 
 ки ба миёнаи арифметикии ҳамаи элементҳои матритса 
 наздиктарин аст. 
 сатри аввалини матритсаро ёбед, ки шумораи элементҳои мусбат ва 
 манфиаш баробаранд (элементҳои нулии матритса ба ҳисоб 
 гирифта намешавад). Агар чунин сатр мавҷуд набошад, чоп карда 
 шавад. 
 Рақами сутуни охирони онро ёбед, ки миқдори якхелаи мусбат ва 
 манфиро дорад (элементҳои нулии матритса дар назар гирифта 
 нашавад). Агар чунин сутунҳо набошанд, чоп карда шавад. 
 сатри охирони онро ёбед, ки танҳо ададҳои ҷуфт дошта бошад. Агар 
 чунин сатрҳо набошанд, чоп карда шавад. 
 сутуни якуми онро ёбед, ки танҳо ададҳои тоқ дошта бошад. Агар 
 чунин сатрҳо набошанд, чоп карда шавад. 
 элементҳои он қиматҳои аз то – ро қабул мекунад. Сутунҳои 
 гуногуни матрисаро монанд меномем, агар ададҳои дар ин сутунҳо 
 вохӯранда ба ҳам мувофиқат кунанд. Миқдори сутунҳое, ки ба 
 сутуни охирони матритса монанданд, ёфта шавад. 
 Миқдори сутунҳои он ёфта шавад, ки ҳамаи элементҳояш гуногун 
 аст. 
 тартибии сатри охирони он ёфта шавад, ки миқдори максималии 
 элементҳои якхеларо дорад. 
 тартибии сутуни якуми он ёфта шавад, ки миқдори максималии 
 элементҳои якхеларо дорад. 
 ёфта шавад, ки элементҳои он ба таври афзуншавӣ тартиб ёфтаанд. 
 ёфта шавад, ки элементҳои он ба таври камшавӣ тартиб ёфтаанд. 
 сатрҳое, ки бо тартиби афзуншавӣ ё камшавӣ ҷойгиранд, элементи 
 хурдтарини он ёфта шавад. Агар сатрҳои батартибовардашудаи 
 матритса мавҷуд набошад, он гоҳ чоп карда шавад. 
 сутунҳое, ки бо тартиби афзуншавӣ ё камшавӣ ҷойгиранд, элементи 
 калонтарини он ёфта шавад. Агар сутунҳои батартибовардашудаи 
 матритса мавҷуд набошад, он гоҳ чоп карда шавад. 
 Элементе, ки дар сатри худ калонтарин ва дар сутуни худ хурдтарин 
 аст, ёфта шавад. Агар чунин элемент мавҷуд набошад, он гоҳ чоп 
 карда шавад. 
 Табдилдиҳии матритса 
 𝐾 ≤≤ 𝑁) дода шуда аст. Мавқеи cутунҳои рақами тартибиашон 
 𝐾 ва 𝐾 - и матритса ёфта шавад. 
 элементҳои хурдтарин ва калонтарини сатрҳои матритса, онро 
 табдил диҳед. 
 элементҳои хурдтарин ва калонтарини сутунҳои матритса онро 
 табдил диҳед. 
 матритса, ки дар онҳо элементҳои калонтарин ва хурдтарини 
 матритса ҷойгиранд, иваз намоед. 
 матритса, ки дар онҳо элементҳои калонтарин ва хурдтарини 
 матритса ҷойгиранд, иваз намоед. 
 сутуни охироне, ки танҳо аз ададҳои мусбат иборат аст, иваз карда 
 шавад. Агар сутунҳои матлуб мавҷуд набошанд, матритса батағийр 
 гузошта шавад. 
 сутуни якуме, ки танҳо аз ададҳои манфӣ иборат аст, иваз карда 
 шавад. Агар сутунҳои матлуб мавҷуд набошанд, матритса батағийр 
 гузошта шавад. 
 Мавқеи нимаи поёнӣ ва болоии матритсаро иваз намоед. 
 Мавқеи нимаи тарафи чап ва тарафи рости матритсаро иваз намоед. 
 Мавқеи чоряки чапи болоӣ ва чоряки рости поёнии матритсаро 
 иваз намоед. 
 Мавқеи чоряки чапи поёнӣ ва чоряки рости болоии матритсаро 
 иваз намоед. 
 горизонталии симметрияи матритса онро ба тарзи оинавӣ инъикос 
 кунед (дар ин маврид мавқеи сатрҳои -ум бо М-ум, -юм ва М--ум 
 ва ғайра иваз карда мешавад ). 
 вертикалии симметрияи матритса онро ба тарзи оинавӣ инъикос 
 кунед (дар ин маврид мавқеи сатрҳои -ум боN -ум, -юм ва N--ум 
 ва ғайра иваз карда мешавад ). 
 шудааст. Сутуни рақами К – юми матритса нест карда шавад. 
 элементи хурдтарини матритса мавҷуд аст, нест карда шавад. 
 элементи калонтарини матритса мавҷуд аст, нест карда шавад. 
 ки танҳо элементҳои мусбат дорад, нест карда шавад. Агар чунин 
 сутун набошад, матритса бе тағйир чоп карда шавад. 
 матритса, ки танҳо элементҳои манфӣ дорад, нест карда шавад. Агар 
 чунин сутун набошад, матритса бе тағйир чоп карда шавад. 
 мусбат дорад ва ҳам манфӣ. Ҳамаи сутунҳоии матритса, ки танҳо 
 элементҳои мусбат дорад, нест карда шаванд. Агар чунин сутунҳо 
 набошанд, матритса бе тағйир чоп карда шавад. 
 шудааст. Пас аз сутуни рақами К – юми матритса, сутуни иборат - 
 ҳо гузоред. 
 элементи калонтарини матритсаро дар бар мегирад, такрор карда 
 шавад. 
 элементи хурдтарини матритсаро дар бар мегирад, такрор карда 
 шавад. 
 матритса, ки танҳо элементҳои мусбат дорад, сутуни иборат аз – 
 ҳоро гузоред. Агар чунин сутун набошад, матритса бе тағйир чоп 
 карда шавад. 
 матритса, ки танҳо элементҳои манфӣ дорад, сутуни иборат аз – 
 ҳоро гузоред. Агар чунин сутун набошад, матритса бе тағйир чоп 
 карда шавад. 
 максимуми локалӣ номида мешавад, агар он аз ҳамаи элементҳои 
 онро иҳотакунанда калон бошад. Аломати ҳамаи максимумҳои 
 локалии матритсаро бо баръаксаш иваз намоед. Ҳангоми ҳал, 
 истифодаи матритсаи ёридиҳанда иҷозат дода мешавад. 
 тартиб дароред, ки элементҳои якуми онҳо пайдарпаии 
 афзуншавандаро тартиб диҳанд. 
 ба тартиб дароред, ки элементҳои якуми онҳо пайдарпаии 
 камшавандаро тартиб диҳанд. 
 тартиб дароред, ки элементҳои хурдтарини онҳо пайдарпаии 
 камшавандаро тартиб диҳанд. 
 ба тартиб дароред, ки элементҳои калонтарини онҳо пайдарпаии 
 афзуншавандаро тартиб диҳанд. 
 Матритсаҳои диагоналӣ ва квадратӣ 
 миёнаи арифметикии диагонали иловагии он ёфта шавад, яъне 
 диагонале, ки элементҳои зеринро дар бар мегирад: 
 А,А,А,…,А.,М,М−,М− М, 
 ҳар як элементи диагонали параллели иловагии он ёфта шавад, (аз 
 диагонали як элементаи А оғоз намуда)., 
 миёнаи арифметикии ҳар як элементи диагонали параллели асосии 
 он ёфта шавад (аз диагонали якэлементаи А оғоз намуда).,М 
 миёнаи арифметикии ҳар як элементи диагонали параллели 
 иловагии он ёфта шавад (аз диагонали якэлементаи А оғоз, 
 намуда). 
 хурдтарин барои ҳар як элементи диагонали параллели асосии он 
 ёфта шавад, (аз диогонали якэлементаи А оғоз намуда).,М 
 калонтарин барои ҳар як элементи диагонали параллели иловагии 
 он, ёфта шавад, (аз диогонали якэлементаи А оғоз намуда)., 
 матритса, ки поён аз диагонали асосии он хобидаанд, ба нол табдил 
 диҳед. Оператори шарти истифода бурда нашавад. 
 матритса, ки боло аз диагонали иловагии он хобидаанд, ба нол 
 табдил дода шаванд. Оператори шарти истифода бурда нашавад. 
 матритса, ки дар диагонали иловагӣ ва поён аз он хобидаанд ба нол 
 табдил дода шаванд. Оператори шарти истифода бурда нашавад. 
 матритса, ки дар диагонали асосӣ ва боло аз он хобидаанд ба нол 
 табдил дода шаванд. Оператори шартӣ истифода бурда нашавад. 
 матритса, ки дар як вақт боло аз диагонали асосӣ ва поён аз 
 диагонали иловагии он хобидаанд, ба нол табдил дода шаванд. 
 Оператори шартӣ истифода бурда нашавад. 
 матритса, ки дар як вақт поён аз диагонали асосӣ ва боло аз 
 диагонали иловагии он хобидаанд, ба нол табдил дода шаванд. 
 Оператори шартӣ истифода бурда нашавад. 
 матритса, ки дар як вақт поён аз диагонали асосӣ (ҳамин диагонал 
 ҳам) ва боло аз диагонали иловагии (инчунин ҳамин диагонал ҳам) 
 он хобидаанд ба нол табдил дода шаванд. Оператори шарти 
 истифода бурда нашавад. 
 матритса, ки дар як вақт боло аз диагонали асосӣ (ҳамин диагонал 
 ҳам) ва поён аз диагонали иловагии (инчунин ҳамин диагонал ҳам) 
 он хобидаанд, ба нол табдил дода шаванд. Оператори шартӣ 
 истифода бурда нашавад. 
 диагонали иловагӣ элементҳои онро ба таври оинавӣ инъикос 
 намоед (дар ин маврид мавқеи диагонали иловагӣ тағийр намеёбад, 
 элементи А ҷои худро бо элементи А ва элементи А бо А, М,М, М−,М 
 ва ғайра иваз мекунанд). Матритсаи ёридиҳанда истифода бурда 
 нашавад. 
 кунҷи о тоб диҳед (дар ин маврид элементи А ҷои худро бо, 
 элементи А ва элементи А бо А ва ғайра иваз мекунанд). 
 М,М, М,М− 
 Матритсаи ёридиҳанда истифода бурда нашавад. 
 кунҷи о ба самти мусбат, яъне муқобили гардиши ақрабаки соат 
 тоб диҳед (дар ин маврид элементи А ҷои худро бо элементи А, М, 
 ва элементи А бо А ва ғайра иваз мекунанд). Матритсаи 
 М, М,М 
 ёридиҳанда истифода бурда нашавад. 
 кунҷи о ба самти манфӣ, яъне самти гардиши ақрабаки соат тоб 
 диҳед (дар ин маврид элементи А ҷои худро бо элементи А ва,,М 
 элементи А бо А ва ғайра иваз мекунанд). Матритсаи,М М,М 
 ёридиҳанда истифода бурда нашавад. 
 Маълумотҳои ёрирасон 
 Аз баски бисёр хонандагон бо забонҳои Python ва GO он қадар 
 шинос нестанд, бинобар ин, баъзе хусусиятҳои асосӣ ва насбу ҷурсозии 
 забонҳои мазкурро мухтасар дида мебароем. 
 Маълумоти умуми оиди забони барномасозии Python 
 Python-забони маъмули сатҳи олӣ буда, барои сохтани лоиҳаҳои 
 типи гуногун, ба монанди: веб-лоиҳаҳо, бозиҳо, барномаҳо барои мизи 
 корӣ, барномаҳои кор бо пойгоҳи додаҳо ва ғайра истифода бурда 
 мешавад. Яке аз сабабҳои маъмул гардидани Питон-ин истифодабарии 
 он дар соҳаи омӯзиши машинӣ ва тадқиқоти зеҳни сунъӣ мебошад. 
 Забони мазкур дар рейтинги tiobe (https://www.tiobe.com/tiobe- 
 index) мавқеи чорумро ишғол мекунад. 
 Апрели Апрели Тағйиёбӣ Номи забон Рейтинг Тағйирёбӣ 
 Java.% +.% 
 C.% +.% 
 C++.% +.% 
 Python.% +.% 
 C#.% +.% 
 Visual Basic.% +.%.NET 
 PHP.% +.% 
 JavaScript.% +.% 
 - SQL.% +.% 
 Ruby.% -.% 
 Delphi/Object.% -.% 
 Pascal 
 R.% -.% 
 Visual Basic.% -.% 
 Assembly.% -.% 
 language 
 Swift.% -.% 
 Perl.% -.% 
 MATLAB.% -.% 
 Objective-C.% -.% 
 Go.% -.% 
 PL/SQL.% -.% 
 Нахустин маротиба забони Python соли аз ҷониби 
 барномасозӣ голландӣ Гвидо Ван Россум сохта шуда, то айни ҳол роҳи 
 дарози инкишофро аз сар гузаронидааст. Дар соли версияи. ва 
 соли версияи.-и забони Python пайдо шуд. Новобаста аз ин, ҳар 
 сол пайдарпай версияҳои нав ба нави забони мазкур пайдо мешаванд. 
 Масалан, айни ҳол версияи навтарини забони Python-.. мебошад. 
 Барои ба даст овардани маълумоти бештар оиди версияҳо, 
 имкониятҳо, версияи нав, утилитаҳои лозими ва ғайра метавон аз 
 сомонаи расмии Python, яъне https://www.python.org/ истифода кард. 
 Хусусиятҳои асосии забони Python 
 Забони барноманависии Python дорои хусусиятҳои зиёде 
 мебошад, ки ҳоло якчандтои онҳоро меорем: 
 ) Забони скриптӣ. Коди барнома ҳамчун скрипт муайян карда 
 мешавад. 
 ) Пуштибонии прадигмаҳои (Парадигма калимаи юнонии 
 παράδειγμα, «мисол, модел, намуна») гуногуни барноманависии 
 муосир, аз ҷумлаи барномнависси ба объектҳо нигаронидашуда 
 ва функсионалӣ. 
 ) Интерпретатсияи программа. Барои кор бо скриптҳо 
 инерпретатор лозим меояд, ки скриптро фаъол гардонида иҷро 
 кунад. 
 Қайд. Иҷроиши барнома дар Python шакли зеринро дорад: Ибтидо дар 
 файли матнӣ барномаи (скрипти) лозимӣ таввасути забони мазкур 
 навишта мешавад. Сипас скрипт барои иҷроиш ба интерпритатор равон 
 карда мешавад. Интерпретатор коди скриптро ба байткодҳои навбатӣ 
 табдил дода, баъд аз ин машинаи виртуалӣ байткодҳои ба дастомадаро ба 
 маҷмӯи дастурҳое, ки системаи омилӣ (СО) онҳоро иҷро мекунад табдил 
 медиҳад. 
 Қайд кардан ба маврид аст, ки ба таври формалӣ тавассути 
 интерпритатор тарҷумакунии коди скрипт ба байткод ва тарҷумакунии 
 байткод ба машинаи виртуалӣ дар маҷмӯӣ фармонҳои машинӣ ду ҷараёнро 
 ифода мекунад, аммо дар ҳақиқат онҳо дар худи интерпритатор якҷоя 
 мешаванд. Ба намуди схематики ин амал шакли зеринро дорад: 
 ) Портативӣ ва аз платформа вобаста набудан. Барои Python муҳим 
 нест, ки СО-и мо кадом аст, танҳо навиштани скрипт кифоя асту 
 халос. Скрипти навишташуда дар дилхоҳ СО ба монанди 
 Windows, Mac OS, Linux ва ғайра ҳангоми мавҷуд будани 
 интерпритатор бе душворӣ кор мекунад 
 ) Ба таври автомати идоракунии ҳофиза. 
 Қайд. Скрипт –ин барномаи на онқадар калон буда, барои интернет- 
 сомонаҳо ё лоиҳаҳо истифода бурда мешавад. Мафҳуми скрипт аз калимаи 
 англисии «Script», ки дар навбати худ аз калимаи лотинии «Scriptum» 
 гирифта шуда, маънояш навиштани матн мебошад. 
 Бо тораққиёти интернет забонҳои зиёди скрипти пайдо шудаанд, ба 
 монанди JavaScript, Python, VBScript ва ғайра. 
 Мафҳуми компилятор ва интерпритатор 
 Барномасоз бояд донад, ки забони барноманависӣ дар компютер 
 хислати барномаро муайян мекунад, на роҳҳои иҷроиши онро. Барои 
 иҷроиши барнома аз транслятор истифода бурда мешавад. 
 Транслятор (англ. translator), ин барномаи тарҷумон буда, 
 барномаи дар ягон забони барноманависӣ навишташударо ба 
 варианти охирон, яъне фармонҳои мошинӣ ва ё коди мошинӣ табдил 
 медиҳад. 
 Транслятор ба сурати компилятор ё интерпритатор истифода 
 бурда мешавад. 
 Компилятор (англ. compiler) барнома ё маҷмӯае аз барномаҳои 
 компютерӣ аст, ки матни дар забонҳои барноманависии сатҳи боло 
 навишташударо хонда, онро ба забони сатҳи поён (Target Language), 
 монанди Ассамблер ё забони сатҳи мошинӣ табдил медиҳад. (Дар 
 компилятор амали тарҷумаи барнома якбора иҷро карда мешавад). 
 Интерпретатор (англ. interpreter — мутарҷим, мутарҷими 
 шифоҳӣ) ба монанди компилятор кор карда, барномаро сатр ба сатр 
 тарҷума ва иҷро мекунад. 
 Дилхоҳ забони барноманавӣ, вобаста аз мақсади сохтанаш дорои 
 компилятор ё интерпретатор мебошад. Масалан, забони Паскал, ки 
 асосан барои ҳалли масъалаҳо пешбинӣ шудааст. Барои он суръати 
 иҷроиш муҳим мебошад, аз ин рӯ, он аз компилятор истифода 
 мекунад, яъне дар он компилятор муайян шудааст. 
 Забони Python аз интерпритатор истифода мекунад, яъне дар он 
 барнома сатр ба сатр хонда ва иҷро карда мешавад. 
 Насб ва ҷурсозии Python 
 Барои сохтани лоиҳа дар забони Python интерпритатор лозим 
 мешавад. Барои ба даст овардани интерпритатор аз сомонаи 
 https://www.python.org/ версияи охирони онро (дар айни ҳол..) 
 боргузорӣ мекунем. 
 Аз менюи Download фармони Windows-ро пахш мекунем, дар 
 натиҷа руйхати версияҳои он ба сурати зерин пайдо мешаванд. 
 Аз ин руйхат версияи лозимӣ дар айни ҳол банди 
 Download Windows x executable installer-ро интихоб мекунем, ки дар 
 натиҷа ба таври автоматӣ боргузории он оғоз мегардад. 
 Баъдан дар муҳити системаи омилии Windows файли ба 
 дастовардаамонро мекушоем, ки шакли зеринро мегирад: 
 Дар ин ҷо метавон мавқеи насби барномаро муайян кард. Барои 
 ин банди Customize installation-ро пахш карда, пас аз пахши тугмачаи 
 Next-бо истифода аз тугмачаи Browse мавқеи лозимӣ, масалан суроғаи 
 C:\Python-ро интихоб мекунем. 
 Қайд кардан ба маврид аст, ки дар ин расм фармони "Add Python 
 to environment variables" мавҷуд аст, ки ҳангоми интихоб кардани он 
 роҳи интерпретаторро ба муҳити тағйирёбандаҳо (переменные среды) 
 илова карда мешавад. 
 Дар сурати ба муҳити тағйирёбандаҳо илова накардани мавқи 
 ҷойгиршавии барномаи насбшуда, барои истифодабарӣ ибтидо 
 фармонҳои зеринро иҷро мекунем. 
 муш->”Свойство”->”Дополнительные параметры системы”- 
 >варақаи ”Дополнительно”->”Переменные среды” 
 Ва аз “Системные переменные” банди Path–ро интихоб 
 карда тугмачаи Изменитро пахш мекунем. 
 Дар охири сатри “Значение переменной” нуқта вергул гузошта, 
 сатрҳои C:\Python; C:\Python\Scripts-ро менависем. 
 Пас аз ин, аз менюи пуск (дар СО Windows) метавон нишонаи 
 дастраси ба утилитаҳои гуногуни Python-ро пайдо кард: 
 Барои сохтани барнома аз менюи Пуск-и СО Windows утилитаи 
 Python. (-bit)-ро кушода, фармони зеринро менависем: 
 print(“Hello Dushanbe”); 
 Қайд. Ҳангоми дар муҳити тағйирёбанда илова намудани роҳи Python 
 метавон барномаҳои (фармонҳои) питонро дар хати фармони Windows 
 навишт. 
 Барои иҷрои ин амал хати фармонро кушода калимаи python-ро 
 нависем, ки дар натиҷа python ба кор медарояд. Пас аз ин метавон 
 дилхоҳ фармонҳои python-ро дар хати фармон навишт. Масалан, 
 барномаи суммаи ду адад: 
 Сохтани файлҳои барнома 
 Дар амалия ибтидо скрипт файл омода гардида, сипас барои 
 иҷроиш ба интерпритатор равон карда мешавад. Аз ин рӯ, зарурати 
 истифодабарии файли барнома пеш меояд. Барои иҷрои ин амал дар 
 ягон диски компютер папкае барои нигоҳдории файлҳои Python 
 месозем, масалан D:\\Python. Дар ин папка бо номи hello.py файл 
 месозем. Файлҳои Python дорои пасванди py мебошанд. 
 Файли сохтаамонро кушода, дар фармонҳои зеринро илова 
 мекунем: 
 Дар ин ҷо скрипт аз ду сатр иборат мебошад. Дар сатри якум 
 тавассути метои input() аз истифодабаранда дохилкунии номашро 
 талаб мекунад. Пас аз дохилкунӣ номи истифодабаранда дар 
 тағйирёбандаи name қарор мегирад. 
 Сатри дуюм бошад, тавассути методи print() пеш аз номи 
 дохилкардашуда, Салому алейкум-ро менависад. 
 Акнун хати фармонро фаъол карда, тавассути фармони cd ба 
 папкае, ки дар онҷо файламон (hello.py) ҷойгир аст, яъне D:\Python 
 меравем. Пас аз ин, фармони hello.py-ро навишта тугмачаи Enter-ро 
 пахш мекунем, ки дар натиҷа дохилкунии номро талаб мекунад. Пас аз 
 дохилкунии ном, масалан Алӣ пайғоми “Салому алейкум, Алӣ” пайдо 
 мешавад. 
 Python дар Visual Studio 
 Яке аз муҳитҳои интегронидашудаи корбар (МИК)-е ки 
 имконияти кор бо Python-ро фароҳам меорад Visual Studio мебошад. 
 Бартарияти МИК -и мазкур дар он мебошад, ки дар Visual Studio 
 таҳриргари ройгони VS Community ва маҷмӯӣ функсия ва 
 имкониятҳои зиёде мавҷуд аст. Ин имкониятҳо танҳо дар версияи 
 тиҷоратии PyCharm, яъне Professional Edition мавҷуд мебошанд. Яке аз 
 ин бартариҳо таҳияи веб-саҳифаҳо бо истифода аз фреймворкҳои 
 гуногун ба ҳисобб меравад. Норасоии истифодаи Python дар Visual 
 Studo дар он аст, ки Visual Studo танҳо дар муҳити Windows кор 
 мекунад. 
 Файли Visual Studio Community-ро метавон аз 
 суроғаи https://visualstudio.microsoft.com/ru/vs/ ба таври ройгон ба даст
 овард. Пас аз кушодани файли насбгар Python-ро интихоб мекунем. 
 Пас аз насб Visual Studio-ро мекушоем. Пас аз кушодани барнома 
 аз менюи File (Файл) -> New (Создать) фармони Project (Проект)-ро 
 интихоб мекунем, ки равзанаи муколамавӣ пайдо мешавад. Дар қисми 
 рости ин равзанаи дарахтшакл забони Python-ро интихоб мекунем: 
 Пас аз оне ки аз ин равзана Python интихоб карда шуд, аз қисми 
 рост Python Application-ро интихоб карда, номи лоиҳаро HelloApp 
 мегузорем. Бо пахш кардани тугмачаи OK Visual Studio лоиҳаи нав 
 месозад: 
 Файли сохтаамонро кушода дар он фармонҳои озимиро 
 менависем. 
 Барои иҷрои барнома тугмачаи сабзи секунҷашаклро аз қисми 
 болоии барнома пахш мекунем: 
 Дар натиҷа равзанаи зерин пайдо мешавад, ки натиҷаи кори 
 барнома мебошад: 
 Насб ва ҷурсозии забони GO 
 Go (баъзан Golang) — забони бисёрҷараёнаи барномасозӣ 
 (многопоточный язык программирования) мебошад, ки аз тарафи 
 ширкати Google сохта шудааст. Моҳи сентябри соли 
 барноманависон Роберт Гризмер, Роб Пайк ва Кен Томпсон ба 
 навиштани ин забон шурӯъ карда буданд. Аммо забон ба таври расми 
 танҳо соли ба истифода дода шуд. Забони мазкур метавонад дар 
 муҳити системаҳои омилии FreeBSD, OpenBSD, Linux, Mac OS X, 
 Windows ва ғайра кор кунад. Сар карда аз версияи. — платформаи 
 Android-ро низ пуштибонӣ мекунад. 
 Барои истифодабарӣ ибтидо аз сайти https://golang.org версияи 
 охирони компилятори забони GO-ро боргузорӣ мекунем. Дар айни ҳол 
 версияи охирони забони мазкур go.. мебошад 
 Барои навиштани барнома, ибтидо дар ягон диск папкаи 
 лоиҳаҳои GO-ро месозем, масалан дар диски D папкаи GO сохта, дар 
 дохили он бо номи Projects папкаи дигар месозем. Сипас ягон 
 таҳриргари матнӣ, масалан Блокнотро кушода, дар дохили он 
 фармонҳои зеринро менависем ва симас файламонро бо номи hello ва 
 пасванди.go, яъне бо номи hello.go дар папкаи сохтаамон сабт мекунем. 
 package main 
 import ( 
 "fmt" 
 ) 
 func main() { 
 fmt.Println("Hello Dushanbe!") 
 } 
 Барои иҷро намудани барнома хати фармони Windows-ро 
 кушода, тавассути фармони cd ба суроғаи D:\GO\Projects меравем. Пас 
 аз ин, барои иҷро намудани файл фармони go run hello.go-ро дар хати 
 фамон менависем. Дар натиҷа барнома иҷро карда мешавад: