API tools faq
paste
Advertisement
Margoshinka

array

Margoshinka
Oct 18th, 2021
133
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 19.69 KB | None | 0 0
raw download clone embed print report
  1. using System;
  2.  
  3.  
  4.  
  5. namespace lab3
  6. {
  7. class Program
  8. {
  9. static int n=0, m=0;
  10. static int i, j, res = 0;
  11. static private Random rnd = new Random();
  12. static int[,] arr = new int[40, 40];
  13. static int[,] arr_ = new int[40, 40];
  14. static char[,] arr_ch = new char[40, 40];
  15. static Array inp1()
  16. {
  17.  
  18. string buf;
  19. bool ok;
  20. do
  21. {
  22. try
  23. {
  24. Console.WriteLine("Введите количесвто строк");
  25. buf = Console.ReadLine();
  26. n = int.Parse(buf);
  27. ok = true;
  28. }
  29. catch (FormatException)
  30. {
  31. Console.WriteLine("Error");
  32. ok = false;
  33. }
  34. } while (!ok);
  35.  
  36. do
  37. {
  38. try
  39. {
  40. Console.WriteLine("Введите количество столбцов");
  41. buf = Console.ReadLine();
  42. m = int.Parse(buf);
  43. ok = true;
  44. }
  45. catch (FormatException)
  46. {
  47. Console.WriteLine("Error");
  48. ok = false;
  49. }
  50. } while (!ok);
  51. int[,] arrq = new int[n, m];
  52. int count = 1;
  53. //заполнение массива
  54. for (i = 0; i < n; i++)
  55. {
  56. for (j = 0; j < m; j++)
  57. {
  58. do
  59. {
  60. try
  61. {
  62. Console.WriteLine($"Введите {count++}-й элемент");
  63. buf = Console.ReadLine();
  64. res = int.Parse(buf);
  65. ok = true;
  66. }
  67. catch (FormatException)
  68. {
  69. Console.WriteLine("Error");
  70. ok = false;
  71. }
  72. } while (!ok);
  73. arrq[i, j] = res;
  74.  
  75. }
  76. }
  77.  
  78. return arrq;
  79. }
  80. static Array inp2()
  81. {
  82. string buf;
  83. bool ok;
  84. do
  85. {
  86. try
  87. {
  88. Console.WriteLine("Введите n");
  89. buf = Console.ReadLine();
  90. n = int.Parse(buf);
  91. ok = true;
  92. }
  93. catch (FormatException)
  94. {
  95. Console.WriteLine("Error");
  96. ok = false;
  97. }
  98. } while (!ok);
  99. int[,] arrq = new int[n, n];
  100.  
  101. //заполнение массива
  102. for (i = 0; i < n; i++) //ниже главной диагонали
  103. {
  104. for (j = 0; j < i; j++)
  105. {
  106.  
  107. arrq[i, j] = rnd.Next(-70,151);
  108.  
  109. }
  110. }
  111. for(i = 0; i < n; i++) // на главной диагонали и выше
  112. {
  113. for (j = i; j < n; j++)
  114. {
  115.  
  116. arrq[i, j] = rnd.Next(17, 171);
  117.  
  118. }
  119. }
  120.  
  121. return arrq;
  122. }
  123. static Array inp3()
  124. {
  125. string buf;
  126. bool ok;
  127. do
  128. {
  129. try
  130. {
  131. Console.WriteLine("Введите n");
  132. buf = Console.ReadLine();
  133. n = int.Parse(buf);
  134. ok = true;
  135. }
  136. catch (FormatException)
  137. {
  138. Console.WriteLine("Error");
  139. ok = false;
  140. }
  141. } while (!ok);
  142. int[,] arrq = new int[n, n];
  143.  
  144. //заполнение массива
  145.  
  146.  
  147. if (n % 2 == 1)
  148. {
  149. int left_border = 0;
  150. int right_border = n;
  151. for (i = (n - 1) / 2; i < n; i++)
  152. {
  153. for (j = left_border; j < right_border; j++)
  154. {
  155. arrq[i, j] = rnd.Next(1, 100);
  156. }
  157. if (left_border != right_border)
  158. {
  159. left_border++;
  160. right_border--;
  161. }
  162. }
  163. left_border = 1;
  164. right_border = n-1;
  165. for (i = (n - 1) / 2-1; i >= 0; i--)
  166. {
  167. for (j = left_border; j < right_border; j++)
  168. {
  169. arrq[i, j] = rnd.Next(1, 100);
  170. }
  171. if (left_border != right_border)
  172. {
  173. left_border++;
  174. right_border--;
  175. }
  176. }
  177. }
  178. if (n % 2 != 1)
  179. {
  180. int left_border = 1;
  181. int right_border = n-1;
  182. for (i = n / 2; i < n-1; i++)
  183. {
  184. for (j = left_border; j < right_border; j++)
  185. {
  186. arrq[i, j] = rnd.Next(1, 100);
  187. }
  188. if (left_border != right_border)
  189. {
  190. left_border++;
  191. right_border--;
  192. }
  193. }
  194. left_border = 1;
  195. right_border = n-1;
  196. for (i = n / 2 - 1; i > 0; i--)
  197. {
  198. for (j = left_border; j < right_border; j++)
  199. {
  200. arrq[i, j] = rnd.Next(1, 100);
  201. }
  202. if (left_border != right_border)
  203. {
  204. left_border++;
  205. right_border--;
  206. }
  207. }
  208. }
  209.  
  210. return arrq;
  211. }
  212. static void inp1_(int j) // рекурсивный метод - собственно заполнение массива
  213. {
  214.  
  215.  
  216.  
  217. if (j < n)
  218. {
  219. for (i = 0; i <m; i++)
  220. {
  221. Console.Write("a[{0}, {1}]=? ", j, i);
  222. arr[j, i] = Convert.ToInt32(Console.ReadLine());
  223. }
  224. inp1_(j + 1);
  225. }
  226. }
  227. static void inp1_rec()
  228. {
  229. j = 0;
  230. string buf;
  231. bool ok;
  232. do
  233. {
  234. try
  235. {
  236. Console.WriteLine("Введите количесвто строк");
  237. buf = Console.ReadLine();
  238. n = int.Parse(buf);
  239. ok = true;
  240. }
  241. catch (FormatException)
  242. {
  243. Console.WriteLine("Error");
  244. ok = false;
  245. }
  246. } while (!ok);
  247.  
  248. do
  249. {
  250. try
  251. {
  252. Console.WriteLine("Введите количество столбцов");
  253. buf = Console.ReadLine();
  254. m = int.Parse(buf);
  255. ok = true;
  256. }
  257. catch (FormatException)
  258. {
  259. Console.WriteLine("Error");
  260. ok = false;
  261. }
  262. } while (!ok);
  263.  
  264. inp1_(j); // вызов рекурсивного метода заполнения
  265. }
  266. static void inp2_(int j) // рекурсивный метод - под главной диагональю
  267. {
  268.  
  269.  
  270.  
  271. if (j < n)
  272. {
  273. for (i = 0; i < j; i++)
  274. {
  275. arr[j, i] = rnd.Next(-70, 151);
  276. }
  277. inp2_(j + 1);
  278. }
  279.  
  280. }
  281. static void inp2_2(int j) // рекурсивный метод - главная диагональ и выше
  282. {
  283.  
  284.  
  285.  
  286. if (j < n)
  287. {
  288. for (i = j; i < n; i++)
  289. {
  290. arr[j, i] = rnd.Next(17, 171);
  291. }
  292. inp2_2(j + 1);
  293. }
  294. }
  295. static void inp2_rec()
  296. {
  297. j = 0;
  298. string buf;
  299. bool ok;
  300. do
  301. {
  302. try
  303. {
  304. Console.WriteLine("Введите n");
  305. buf = Console.ReadLine();
  306. n = int.Parse(buf);
  307. ok = true;
  308. }
  309. catch (FormatException)
  310. {
  311. Console.WriteLine("Error");
  312. ok = false;
  313. }
  314. } while (!ok);
  315.  
  316.  
  317.  
  318. inp2_(j); // вызов рекурсивного метода заполнения
  319. j = 0;
  320. inp2_2(j); // вызов рекурсивного метода заполнения
  321. }
  322. static void inp3_1nch(int j, int left_border, int right_border) // рекурсивный метод для нечетных n
  323. {
  324.  
  325.  
  326. if (j < n)
  327. {
  328. for (i = left_border; i < right_border; i++)
  329. {
  330. arr_[j, i] = rnd.Next(1, 100);
  331. }
  332. if (left_border != right_border)
  333. inp3_1nch(j + 1, left_border+1, right_border-1);
  334. else inp3_1nch(j + 1, left_border, right_border);
  335. }
  336.  
  337. }
  338. static void inp3_2nch(int j, int left_border, int right_border) // рекурсивный метод для нечетных n
  339. {
  340.  
  341.  
  342. if (j >= 0)
  343. {
  344. for (i = left_border; i < right_border; i++)
  345. {
  346. arr_[j, i] = rnd.Next(1, 100);
  347. }
  348. if (left_border != right_border)
  349. inp3_2nch(j -1, left_border+1, right_border-1);
  350. else inp3_2nch(j -1, left_border, right_border);
  351. }
  352.  
  353. }
  354. static void inp3_1ch(int j, int left_border, int right_border) // рекурсивный метод для чётных n
  355. {
  356.  
  357.  
  358. if (j <n-1)
  359. {
  360. for (i = left_border; i < right_border; i++)
  361. {
  362. arr_[j, i] = rnd.Next(1, 100);
  363. }
  364. if (left_border != right_border)
  365. inp3_1ch(j + 1, left_border + 1, right_border - 1);
  366. else inp3_1ch(j + 1, left_border, right_border);
  367. }
  368.  
  369. }
  370. static void inp3_2ch(int j, int left_border, int right_border) // рекурсивный метод для четных n;
  371. {
  372.  
  373.  
  374. if (j > 0)
  375. {
  376. for (i = left_border; i < right_border; i++)
  377. {
  378. arr_[j, i] = rnd.Next(1, 100);
  379. }
  380. if (left_border != right_border)
  381. inp3_2ch(j - 1, left_border + 1, right_border - 1);
  382. else inp3_2ch(j - 1, left_border, right_border);
  383. }
  384.  
  385. }
  386. static void inp3_rec()
  387. {
  388.  
  389. string buf;
  390. bool ok;
  391. do
  392. {
  393. try
  394. {
  395. Console.WriteLine("Введите n");
  396. buf = Console.ReadLine();
  397. n = int.Parse(buf);
  398. ok = true;
  399. }
  400. catch (FormatException)
  401. {
  402. Console.WriteLine("Error");
  403. ok = false;
  404. }
  405. } while (!ok);
  406.  
  407. if (n % 2 != 0)
  408. {
  409. j = (n - 1) / 2;
  410. int left_border = 0;
  411. int right_border = n;
  412. inp3_1nch(j, left_border, right_border); // вызов рекурсивного метода заполнения
  413. j = (n - 1) / 2 - 1;
  414. left_border = 1;
  415. right_border = n - 1;
  416. inp3_2nch(j, left_border, right_border);// вызов рекурсивного метода заполнения
  417. }
  418. if (n % 2 == 0)
  419. {
  420. j = n / 2;
  421. int left_border = 1;
  422. int right_border = n - 1;
  423. inp3_1ch(j, left_border, right_border); // вызов рекурсивного метода заполнения
  424. j = n / 2 - 1;
  425. left_border = 1;
  426. right_border = n - 1;
  427. inp3_2ch(j, left_border, right_border);// вызов рекурсивного метода заполнения
  428. }
  429.  
  430. }
  431.  
  432. static void out1(int[,] arr) //вывод массива
  433. {
  434. for (int i = 0; i < n; i++)
  435. {
  436. for (int j = 0; j < m; j++)
  437. {
  438. Console.Write("{0}\t", arr[i, j]);
  439. }
  440. Console.WriteLine();
  441. }
  442. }
  443. static void out_ch(char[,] arr) //вывод массива символов
  444. {
  445. for (int i = 0; i < n; i++)
  446. {
  447. for (int j = 0; j < m; j++)
  448. {
  449. Console.Write("{0}\t", arr[i, j]);
  450. }
  451. Console.WriteLine();
  452. }
  453. }
  454. static void sort_(string[] str) //сортируем подстроки
  455. {
  456. for (i = 1; i < n; i++)
  457. for (j = n - 1; j >= i; j--)
  458. if (str[j][0] < str[j - 1][0])
  459. {
  460. string temp = str[j];
  461. str[j] = str[j - 1];
  462. str[j - 1] = temp;
  463. }
  464. }
  465. static void sort_rec(int i,string[] str) //сортируем подстроки ркурсивно
  466. {
  467. if (i < n)
  468. {
  469. for (j = n - 1; j >= i; j--)
  470. if (str[j][0] < str[j - 1][0])
  471. {
  472. string temp = str[j];
  473. str[j] = str[j - 1];
  474. str[j - 1] = temp;
  475. }
  476. sort_rec(i + 1, str);
  477. }
  478. }
  479. static void rasp_(string[] str) //заполняем массив подстроками
  480. {
  481. for (i = 0; i < n; i++)
  482. for (j = 0; j < n; j++)
  483. arr_ch[i, j] = str[i][j];
  484. }
  485. static void rasp_rec(int i, string[] str) //заполняем массив подстроками рекурсивно
  486. {
  487. if (i < n)
  488. {
  489. for (j = 0; j < n; j++)
  490. arr_ch[i, j] = str[i][j];
  491. rasp_rec(i + 1, str);
  492. }
  493. }
  494. static void inp(int n, int[,] a)
  495. {
  496.  
  497. for (i = 0; i < n; i++)
  498. for (j = 0; j < n; j++)
  499. a[i, j] = -10 + rnd.Next(21);
  500. }
  501.  
  502. static void multiplication(int n, int[,] a, int[,] b, int[,] c)
  503. {
  504. int i, j, k;
  505. for (i = 0; i < n; i++)
  506. for (j = 0; j < n; j++)
  507. {
  508. c[i, j] = 0;
  509. for (k = 0; k < n; k++)
  510. c[i, j] += a[i, k] * b[k, j];
  511. }
  512. }
  513. static void multiplication_rec(int i, int n, int[,] a, int[,] b, int[,] c) // рекурсивный метод перемножения матриц
  514. {
  515. int j, k;
  516. if (i < n)
  517. {
  518. for (j = 0; j < n; j++)
  519. {
  520. c[i, j] = 0;
  521. for (k = 0; k < n; k++)
  522. c[i, j] += a[i, k] * b[k, j];
  523. }
  524. multiplication_rec(i + 1, n, a, b, c);
  525. }
  526. }
  527.  
  528.  
  529. static void Main(string[] args)
  530. {
  531. /* int[,] arr1 = new int[n,m];
  532.  
  533. arr1 = inp1() as int[,];
  534.  
  535. out1(arr1);
  536. int[,] arr2 = new int[n, n];
  537. arr2 = inp2() as int[,];
  538. m = n;
  539. out1(arr2);
  540. int[,] arr3 = new int[n, n];
  541. arr3 = inp3() as int[,];
  542. m = n;
  543.  
  544.  
  545. out1(arr3);*/
  546. /* inp1_rec();
  547. Console.WriteLine("Рекурсивный метод для первого массива:");
  548. out1(arr);*/
  549. /* inp2_rec();
  550. Console.WriteLine("Рекурсивный метод для второго массива:");
  551. m = n;
  552. out1(arr);
  553. inp3_rec();
  554. Console.WriteLine("Рекурсивный метод для третьего массива:");
  555. m = n;
  556. out1(arr_);
  557. string s = "";
  558.  
  559. Console.WriteLine("Введите строку");
  560. s = Console.ReadLine();
  561. double n1 = Math.Sqrt((double)s.Length);
  562. n = (int)n1;
  563. string[] str = new string[n];
  564. for (i = 0; i < n; i++)
  565. for (j = i * n; j < (i + 1) * n; j++)
  566. str[i] += s[j];
  567.  
  568. sort_(str);
  569.  
  570.  
  571.  
  572. rasp_(str);
  573.  
  574. m = n;
  575. out_ch(arr_ch);
  576.  
  577. Console.WriteLine("Введите строку");
  578. s = Console.ReadLine();
  579. n1 = Math.Sqrt((double)s.Length);
  580. n = (int)n1;
  581. string[] str1 = new string[n];
  582. for (i = 0; i < n; i++)
  583. for (j = i * n; j < (i + 1) * n; j++)
  584. str1[i] += s[j];
  585. i = 1;
  586. sort_rec(i, str1);
  587.  
  588. i = 0;
  589. rasp_rec(i, str1);
  590. m = n;
  591. out_ch(arr_ch);*/
  592. int[,] a = new int[40, 40];
  593. int[,] b = new int[40, 40];
  594. int[,] c = new int[40, 40];
  595. int[,] temp = new int[40, 40];
  596. int[,] mult = new int[40, 40];
  597. Console.WriteLine("n?");
  598. n = Convert.ToInt32(Console.ReadLine());
  599. m = n;
  600. Console.WriteLine("Массив A:");
  601. inp(n, a);
  602. out1( a);
  603. Console.WriteLine("Массив B:");
  604. inp(n, b);
  605. out1( b);
  606. Console.WriteLine("Массив C:");
  607. inp(n, c);
  608. out1( c);
  609. // multiplication(n, b, c, temp);
  610. // multiplication(n, a, temp, mult);
  611. i = 0;
  612. multiplication_rec(i,n, b, c, temp);
  613. multiplication_rec(i,n, a, temp, mult);
  614. Console.WriteLine("Массив A*(B*C):");
  615. out1(mult);
  616.  
  617.  
  618.  
  619.  
  620. }
  621. }
  622. }
  623.  
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!