Advertisement
Thewest123

171215 ČernýDC Komplet

Dec 22nd, 2017
151
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C# 32.10 KB | None | 0 0
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. using System.Threading.Tasks;
  6. using static System.Threading.Thread;
  7.  
  8. namespace _171215_ČernýDC
  9. {
  10.     class Program
  11.     {
  12.         static void Main(string[] args)
  13.         {
  14.             Console.ForegroundColor = ConsoleColor.White;
  15.             Console.Title = "Menu";
  16.  
  17.             while (true)
  18.             {
  19.                 Console.Clear();
  20.                 Console.WriteLine($"┌───────────────────────────────────────────┐");
  21.                 Console.WriteLine($"│{"Menu:",-42} │");
  22.                 Console.WriteLine($"├───────────┬───────────────────────────────┤");
  23.                 Console.WriteLine($"│{"k nebo K",10} │ {"Konec",-30}│");
  24.                 Console.WriteLine($"│{"prázdný",10} │ {"Začátek",-30}│");
  25.  
  26.                 Console.WriteLine($"│{"malé p",10} │ {"Přičítání po jedné",-30}│");
  27.                 Console.WriteLine($"│{"velké P",10} │ {"Příčítání po zadaném č.",-30}│");
  28.  
  29.                 Console.WriteLine($"│{"malé o",10} │ {"Odečítání po jedné",-30}│");
  30.                 Console.WriteLine($"│{"velké O",10} │ {"Odečítání po zadaném č.",-30}│");
  31.  
  32.                 Console.WriteLine($"│{"malé n",10} │ {"Násobení po jedné",-30}│");
  33.                 Console.WriteLine($"│{"velké N",10} │ {"Násobení po zadaném č.",-30}│");
  34.                
  35.                 Console.WriteLine($"│{"malé d",10} │ {"Dělení po jedné",-30}│");
  36.                 Console.WriteLine($"│{"velké D",10} │ {"Dělení po zadaném č.",-30}│");
  37.  
  38.                 Console.WriteLine($"└───────────┴───────────────────────────────┘");
  39.  
  40.                 Console.Write($"\nCo si přeješ: ");
  41.                 string vstup = Console.ReadLine();
  42.  
  43.                 if (vstup.ToLower() == "k") break;
  44.                 if (vstup == "") continue;
  45.  
  46.                 if (vstup == "p") PricitejPoJedne();
  47.                 else if (vstup == "P") PricitejPoZadanem();
  48.                 else if (vstup == "o") OdecitejPoJedne();
  49.                 else if (vstup == "O") OdecitejPoZadanem();
  50.                 else if (vstup == "n") NasobPoJedne();
  51.                 else if (vstup == "N") NasobPoZadanem();
  52.                 else if (vstup == "d") DelPoJedne();
  53.                 else if (vstup == "D") DelPoZadanem();
  54.                 else
  55.                 {
  56.                     Console.BackgroundColor = ConsoleColor.Red;
  57.                     Console.Write($"{vstup} neumím!");
  58.                     Console.BackgroundColor = ConsoleColor.Black;
  59.                     Sleep(2000);
  60.                 }
  61.  
  62.             }
  63.             Console.WriteLine("\nAhoj!");
  64.             Sleep(1000);
  65.         }
  66.  
  67.         #region Pricitani
  68.         static void PricitejPoJedne()
  69.         {
  70.             //Celý loop, kvůli podmínce pocatecni<konecna
  71.             while (true)
  72.             {
  73.                 Console.Clear();
  74.                 Console.WriteLine($"┌────────────────────────────────────────┐");
  75.                 Console.WriteLine($"│{"Přičítání po jedné",-40}│");
  76.                 Console.WriteLine($"└────────────────────────────────────────┘");
  77.  
  78.                 int pocatecni;
  79.                 int konecna;
  80.  
  81.                 //Loop pro počáteční hodnotu
  82.                 while (true)
  83.                 {
  84.                     Console.Write("Zadej číslo pro počáteční hodnotu <-100;100>: ");
  85.                     try
  86.                     {
  87.                         pocatecni = Convert.ToInt32(Console.ReadLine());
  88.  
  89.                         if (pocatecni <= 100 && pocatecni >= -100)
  90.                         {
  91.                             break;
  92.                         }
  93.  
  94.                         Console.Write("Počáteční hodnota musí být v z intervalu <-100;100>");
  95.                         Console.ReadLine();
  96.                     }
  97.                     catch (Exception e)
  98.                     {
  99.                         Console.WriteLine(e.Message);
  100.                         Console.ReadLine();
  101.                     }
  102.                 }
  103.                 //Loop pro konečnou hodnotu
  104.                 while (true)
  105.                 {
  106.                     Console.Write("Zadej číslo pro konečnou hodnotu <-100;100>: ");
  107.  
  108.                     try
  109.                     {
  110.                         konecna = Convert.ToInt32(Console.ReadLine());
  111.  
  112.                         if (konecna <= 100 && konecna >= -100)
  113.                         {
  114.                             break;
  115.                         }
  116.  
  117.                         Console.Write("Konečná hodnota musí být v z intervalu <-100;100>");
  118.                         Console.ReadLine();
  119.                     }
  120.                     catch (Exception e)
  121.                     {
  122.                         Console.WriteLine(e.Message);
  123.                         Console.ReadLine();
  124.                     }
  125.                 }
  126.  
  127.                 //Kontrola hodnot
  128.                 if (pocatecni < konecna)
  129.                 {
  130.                     Console.WriteLine();
  131.  
  132.                     for (int i = pocatecni+1; i <= konecna; i++)
  133.                         //(pocatecni+1 pro vynechani prvniho nuloveho pricitani)
  134.                     {
  135.                         Console.WriteLine($" >> {pocatecni} + {i-pocatecni} = {i}");
  136.                     }
  137.  
  138.                     Console.WriteLine();
  139.                     Console.Write("Odenteruj!");
  140.                     Console.ReadLine();
  141.                     break;
  142.                 }
  143.  
  144.                 Console.Write("Počáteční hodnota je větší než konečná!");
  145.                 Console.ReadLine();
  146.  
  147.             }
  148.         }
  149.  
  150.         static void PricitejPoZadanem()
  151.         {
  152.             //Celý loop, kvůli podmínce pocatecni<konecna
  153.             while (true)
  154.             {
  155.                 Console.Clear();
  156.                 Console.WriteLine($"┌────────────────────────────────────────┐");
  157.                 Console.WriteLine($"│{"Přičítání po zadané hodnotě",-40}│");
  158.                 Console.WriteLine($"└────────────────────────────────────────┘");
  159.  
  160.                 int pocatecni;
  161.                 int konecna;
  162.                 int pricitani;
  163.  
  164.                 //Loop pro počáteční hodnotu
  165.                 while (true)
  166.                 {
  167.                     Console.Write("Zadej číslo pro počáteční hodnotu <-100;100>: ");
  168.                     try
  169.                     {
  170.                         pocatecni = Convert.ToInt32(Console.ReadLine());
  171.  
  172.                         if (pocatecni <= 100 && pocatecni >= -100)
  173.                         {
  174.                             break;
  175.                         }
  176.                         Console.Write("Počáteční hodnota musí být v z intervalu <-100;100>");
  177.                         Console.ReadLine();
  178.                     }
  179.                     catch (Exception e)
  180.                     {
  181.                         Console.WriteLine(e.Message);
  182.                         Console.ReadLine();
  183.                     }
  184.                 }
  185.                
  186.                 //Loop pro konečnou hodnotu
  187.                 while (true)
  188.                 {
  189.                     Console.Write("Zadej číslo pro konečnou hodnotu <-100;100>: ");
  190.  
  191.                     try
  192.                     {
  193.                         konecna = Convert.ToInt32(Console.ReadLine());
  194.  
  195.                         if (konecna <= 100 && konecna >= -100)
  196.                         {
  197.                             break;
  198.                         }
  199.                         Console.Write("Konečná hodnota musí být v z intervalu <-100;100>");
  200.                         Console.ReadLine();
  201.                     }
  202.                     catch (Exception e)
  203.                     {
  204.                         Console.WriteLine(e.Message);
  205.                         Console.ReadLine();
  206.                     }
  207.                 }
  208.  
  209.                 //Loop pro honotu přičítání
  210.                 while (true)
  211.                 {
  212.                     Console.Write("Zadej číslo pro hodnotu příčítání <2;50>: ");
  213.                     try
  214.                     {
  215.                         pricitani = Convert.ToInt32(Console.ReadLine());
  216.  
  217.                         if (pricitani <= 50 && pricitani >= 2)
  218.                         {
  219.                             break;
  220.                         }
  221.                         Console.Write("Přičítací hodnota musí být v z intervalu <2;50>");
  222.                         Console.ReadLine();
  223.                     }
  224.                     catch (Exception e)
  225.                     {
  226.                         Console.WriteLine(e.Message);
  227.                         Console.ReadLine();
  228.                     }
  229.                 }
  230.  
  231.                 //Kontrola hodnot
  232.                 if (pocatecni < konecna)
  233.                 {
  234.                     //Kontrola, jestli jde přičítat zadané číslo
  235.                     if (pricitani <= (konecna - pocatecni))
  236.                     {
  237.                         Console.WriteLine($"\nVýpis od {pocatecni} do {konecna} po {pricitani}:");
  238.  
  239.                         int vysledna = pocatecni;
  240.                         for (int i = pocatecni+1; i <= konecna; i += pricitani)
  241.                         {
  242.                             Console.WriteLine($" >> {pocatecni} + {i-pocatecni} = {vysledna+1}");
  243.                             vysledna += pricitani;
  244.                         }
  245.  
  246.                         Console.WriteLine();
  247.                         Console.Write("Odenteruj!");
  248.                         Console.ReadLine();
  249.                         break;
  250.                     }
  251.                     Console.Write("Přičítací hodnota je moc velká pro zadaná čísla!");
  252.                     Console.ReadLine();
  253.                 }
  254.                 else
  255.                 {
  256.                     Console.Write("Počáteční hodnota je větší než konečná!");
  257.                     Console.ReadLine();
  258.                 }
  259.             }
  260.         }
  261.         #endregion
  262.  
  263.         #region Odecitani
  264.         static void OdecitejPoJedne()
  265.         {
  266.             //Celý loop, kvůli podmínce pocatecni<konecna
  267.             while (true)
  268.             {
  269.                 Console.Clear();
  270.                 Console.WriteLine($"┌────────────────────────────────────────┐");
  271.                 Console.WriteLine($"│{"Odečítání po jedné",-40}│");
  272.                 Console.WriteLine($"└────────────────────────────────────────┘");
  273.  
  274.                 int pocatecni;
  275.                 int konecna;
  276.  
  277.                 //Loop pro počáteční hodnotu
  278.                 while (true)
  279.                 {
  280.                     Console.Write("Zadej číslo pro počáteční hodnotu <-100;100>: ");
  281.                     try
  282.                     {
  283.                         pocatecni = Convert.ToInt32(Console.ReadLine());
  284.  
  285.                         if (pocatecni <= 100 && pocatecni >= -100)
  286.                         {
  287.                             break;
  288.                         }
  289.  
  290.                         Console.Write("Počáteční hodnota musí být v z intervalu <-100;100>");
  291.                         Console.ReadLine();
  292.                     }
  293.                     catch (Exception e)
  294.                     {
  295.                         Console.WriteLine(e.Message);
  296.                         Console.ReadLine();
  297.                     }
  298.                 }
  299.                 //Loop pro konečnou hodnotu
  300.                 while (true)
  301.                 {
  302.                     Console.Write("Zadej číslo pro konečnou hodnotu <-100;100>: ");
  303.  
  304.                     try
  305.                     {
  306.                         konecna = Convert.ToInt32(Console.ReadLine());
  307.  
  308.                         if (konecna <= 100 && konecna >= -100)
  309.                         {
  310.                             break;
  311.                         }
  312.  
  313.                         Console.Write("Konečná hodnota musí být v z intervalu <-100;100>");
  314.                         Console.ReadLine();
  315.                     }
  316.                     catch (Exception e)
  317.                     {
  318.                         Console.WriteLine(e.Message);
  319.                         Console.ReadLine();
  320.                     }
  321.                 }
  322.  
  323.                 //Kontrola hodnot
  324.                 if (pocatecni > konecna)
  325.                 {
  326.                     Console.WriteLine();
  327.  
  328.                     for (int i = pocatecni - 1; i >= konecna; i--)
  329.                     //(pocatecni+1 pro vynechani prvniho nuloveho odecitani)
  330.                     {
  331.                         Console.WriteLine($" >> {pocatecni} - {pocatecni-i} = {i}");
  332.                     }
  333.  
  334.                     Console.WriteLine();
  335.                     Console.Write("Odenteruj!");
  336.                     Console.ReadLine();
  337.                     break;
  338.                 }
  339.  
  340.                 Console.Write("Počáteční hodnota je menší než konečná!");
  341.                 Console.ReadLine();
  342.  
  343.             }
  344.         }
  345.  
  346.         static void OdecitejPoZadanem()
  347.         {
  348.             //Celý loop, kvůli podmínce pocatecni<konecna
  349.             while (true)
  350.             {
  351.                 Console.Clear();
  352.                 Console.WriteLine($"┌────────────────────────────────────────┐");
  353.                 Console.WriteLine($"│{"Odečítání po zadané hodnotě",-40}│");
  354.                 Console.WriteLine($"└────────────────────────────────────────┘");
  355.  
  356.                 int pocatecni;
  357.                 int konecna;
  358.                 int pricitani;
  359.  
  360.                 //Loop pro počáteční hodnotu
  361.                 while (true)
  362.                 {
  363.                     Console.Write("Zadej číslo pro počáteční hodnotu <-100;100>: ");
  364.                     try
  365.                     {
  366.                         pocatecni = Convert.ToInt32(Console.ReadLine());
  367.  
  368.                         if (pocatecni <= 100 && pocatecni >= -100)
  369.                         {
  370.                             break;
  371.                         }
  372.                         Console.Write("Počáteční hodnota musí být v z intervalu <-100;100>");
  373.                         Console.ReadLine();
  374.                     }
  375.                     catch (Exception e)
  376.                     {
  377.                         Console.WriteLine(e.Message);
  378.                         Console.ReadLine();
  379.                     }
  380.                 }
  381.  
  382.                 //Loop pro konečnou hodnotu
  383.                 while (true)
  384.                 {
  385.                     Console.Write("Zadej číslo pro konečnou hodnotu <-100;100>: ");
  386.  
  387.                     try
  388.                     {
  389.                         konecna = Convert.ToInt32(Console.ReadLine());
  390.  
  391.                         if (konecna <= 100 && konecna >= -100)
  392.                         {
  393.                             break;
  394.                         }
  395.                         Console.Write("Konečná hodnota musí být v z intervalu <-100;100>");
  396.                         Console.ReadLine();
  397.                     }
  398.                     catch (Exception e)
  399.                     {
  400.                         Console.WriteLine(e.Message);
  401.                         Console.ReadLine();
  402.                     }
  403.                 }
  404.  
  405.                 //Loop pro honotu odečítání
  406.                 while (true)
  407.                 {
  408.                     Console.Write("Zadej číslo pro hodnotu odečítání <2;50>: ");
  409.                     try
  410.                     {
  411.                         pricitani = Convert.ToInt32(Console.ReadLine());
  412.  
  413.                         if (pricitani <= 50 && pricitani >= 2)
  414.                         {
  415.                             break;
  416.                         }
  417.                         Console.Write("Odečítací hodnota musí být v z intervalu <2;50>");
  418.                         Console.ReadLine();
  419.                     }
  420.                     catch (Exception e)
  421.                     {
  422.                         Console.WriteLine(e.Message);
  423.                         Console.ReadLine();
  424.                     }
  425.                 }
  426.  
  427.                 //Kontrola hodnot
  428.                 if (pocatecni > konecna)
  429.                 {
  430.                     //Kontrola, jestli jde odečítat zadané číslo
  431.                     if (pricitani <= (pocatecni - konecna))
  432.                     {
  433.                         Console.WriteLine($"\nVýpis od {pocatecni} do {konecna} po {pricitani}:");
  434.  
  435.                         int vysledna = pocatecni;
  436.                         for (int i = pocatecni - 1; i >= konecna; i -= pricitani)
  437.                         {
  438.                             Console.WriteLine($" >> {pocatecni} - {pocatecni-i} = {vysledna - 1}");
  439.                             vysledna -= pricitani;
  440.                         }
  441.  
  442.                         Console.WriteLine();
  443.                         Console.Write("Odenteruj!");
  444.                         Console.ReadLine();
  445.                         break;
  446.                     }
  447.                     Console.Write("Odečítací hodnota je moc velká pro zadaná čísla!");
  448.                     Console.ReadLine();
  449.                 }
  450.                 else
  451.                 {
  452.                     Console.Write("Počáteční hodnota je menší než konečná!");
  453.                     Console.ReadLine();
  454.                 }
  455.             }
  456.         }
  457.         #endregion
  458.  
  459.         #region Nasobeni
  460.         static void NasobPoJedne()
  461.         {
  462.             //Celý loop, kvůli podmínce pocatecni<konecna
  463.             while (true)
  464.             {
  465.                 Console.Clear();
  466.                 Console.WriteLine($"┌────────────────────────────────────────┐");
  467.                 Console.WriteLine($"│{"Násobení po jedné",-40}│");
  468.                 Console.WriteLine($"└────────────────────────────────────────┘");
  469.  
  470.                 int pocatecni;
  471.                 int konecna;
  472.  
  473.                 //Loop pro počáteční hodnotu
  474.                 while (true)
  475.                 {
  476.                     Console.Write("Zadej číslo pro počáteční hodnotu <2;50>: ");
  477.                     try
  478.                     {
  479.                         pocatecni = Convert.ToInt32(Console.ReadLine());
  480.  
  481.                         if (pocatecni <= 50 && pocatecni >= 2)
  482.                         {
  483.                             break;
  484.                         }
  485.  
  486.                         Console.Write("Počáteční hodnota musí být v z intervalu <2;50>");
  487.                         Console.ReadLine();
  488.                     }
  489.                     catch (Exception e)
  490.                     {
  491.                         Console.WriteLine(e.Message);
  492.                         Console.ReadLine();
  493.                     }
  494.                 }
  495.                 //Loop pro konečnou hodnotu
  496.                 while (true)
  497.                 {
  498.                     Console.Write("Zadej číslo pro konečnou hodnotu <4;1000>: ");
  499.  
  500.                     try
  501.                     {
  502.                         konecna = Convert.ToInt32(Console.ReadLine());
  503.  
  504.                         if (konecna <= 1000 && konecna >= 4)
  505.                         {
  506.                             break;
  507.                         }
  508.  
  509.                         Console.Write("Konečná hodnota musí být v z intervalu <4;1000>");
  510.                         Console.ReadLine();
  511.                     }
  512.                     catch (Exception e)
  513.                     {
  514.                         Console.WriteLine(e.Message);
  515.                         Console.ReadLine();
  516.                     }
  517.                 }
  518.  
  519.                 //Kontrola hodnot
  520.                 if (pocatecni < konecna)
  521.                 {
  522.                     Console.WriteLine($"\nVýpis od {pocatecni} do {konecna} po jedné:\n");
  523.  
  524.                     int vysledek=0;
  525.                     for (int i = pocatecni; vysledek < konecna; i++)
  526.                     //(pocatecni+1 pro vynechani prvniho nuloveho pricitani)
  527.                     {
  528.                         vysledek = pocatecni * i;
  529.                         Console.WriteLine($" >> {pocatecni} * {i} = {vysledek}");
  530.                     }
  531.  
  532.                     Console.WriteLine();
  533.                     Console.Write("Odenteruj!");
  534.                     Console.ReadLine();
  535.                     break;
  536.                 }
  537.  
  538.                 Console.Write("Počáteční hodnota je větší než konečná!");
  539.                 Console.ReadLine();
  540.  
  541.             }
  542.         }
  543.  
  544.         static void NasobPoZadanem()
  545.         {
  546.             //Celý loop, kvůli podmínce pocatecni<konecna
  547.             while (true)
  548.             {
  549.                 Console.Clear();
  550.                 Console.WriteLine($"┌────────────────────────────────────────┐");
  551.                 Console.WriteLine($"│{"Přičítání po zadané hodnotě",-40}│");
  552.                 Console.WriteLine($"└────────────────────────────────────────┘");
  553.  
  554.                 int pocatecni;
  555.                 int konecna;
  556.                 int krokovani;
  557.  
  558.                 //Loop pro počáteční hodnotu
  559.                 while (true)
  560.                 {
  561.                     Console.Write("Zadej číslo pro počáteční hodnotu <2;50>: ");
  562.                     try
  563.                     {
  564.                         pocatecni = Convert.ToInt32(Console.ReadLine());
  565.  
  566.                         if (pocatecni <= 50 && pocatecni >= 2)
  567.                         {
  568.                             break;
  569.                         }
  570.                         Console.Write("Počáteční hodnota musí být v z intervalu <2;50>");
  571.                         Console.ReadLine();
  572.                     }
  573.                     catch (Exception e)
  574.                     {
  575.                         Console.WriteLine(e.Message);
  576.                         Console.ReadLine();
  577.                     }
  578.                 }
  579.  
  580.                 //Loop pro konečnou hodnotu
  581.                 while (true)
  582.                 {
  583.                     Console.Write("Zadej číslo pro konečnou hodnotu <4;1000>: ");
  584.  
  585.                     try
  586.                     {
  587.                         konecna = Convert.ToInt32(Console.ReadLine());
  588.  
  589.                         if (konecna <= 1000 && konecna >= 4)
  590.                         {
  591.                             break;
  592.                         }
  593.                         Console.Write("Konečná hodnota musí být v z intervalu <4;1000>");
  594.                         Console.ReadLine();
  595.                     }
  596.                     catch (Exception e)
  597.                     {
  598.                         Console.WriteLine(e.Message);
  599.                         Console.ReadLine();
  600.                     }
  601.                 }
  602.  
  603.                 //Loop pro honotu přičítání
  604.                 while (true)
  605.                 {
  606.                     Console.Write("Zadej číslo pro hodnotu kroku <2;50>: ");
  607.                     try
  608.                     {
  609.                         krokovani = Convert.ToInt32(Console.ReadLine());
  610.  
  611.                         if (krokovani <= 50 && krokovani >= 2)
  612.                         {
  613.                             break;
  614.                         }
  615.                         Console.Write("Hodnota kroku musí být v z intervalu <2;50>");
  616.                         Console.ReadLine();
  617.                     }
  618.                     catch (Exception e)
  619.                     {
  620.                         Console.WriteLine(e.Message);
  621.                         Console.ReadLine();
  622.                     }
  623.                 }
  624.  
  625.                 //Kontrola hodnot
  626.                 if (pocatecni < konecna)
  627.                 {
  628.                     Console.WriteLine($"\nVýpis od {pocatecni} do {konecna} po {krokovani}:\n");
  629.  
  630.                     for (int i = 2; i * pocatecni < konecna; i+=krokovani)
  631.                     {
  632.                         Console.WriteLine($" >> {pocatecni} * {i} = {i * pocatecni}");
  633.                     }
  634.  
  635.                     Console.WriteLine();
  636.                     Console.Write("Odenteruj!");
  637.                     Console.ReadLine();
  638.                     break;
  639.                 }
  640.                 else
  641.                 {
  642.                     Console.Write("Počáteční hodnota je větší než konečná!");
  643.                     Console.ReadLine();
  644.                 }
  645.             }
  646.         }
  647.         #endregion
  648.  
  649.         #region Deleni
  650.         static void DelPoJedne()
  651.         {
  652.             //Celý loop, kvůli podmínce pocatecni<konecna
  653.             while (true)
  654.             {
  655.                 Console.Clear();
  656.                 Console.WriteLine($"┌────────────────────────────────────────┐");
  657.                 Console.WriteLine($"│{"Dělení po jedné",-40}│");
  658.                 Console.WriteLine($"└────────────────────────────────────────┘");
  659.  
  660.                 double pocatecni;
  661.                 double konecna;
  662.  
  663.                 //Loop pro počáteční hodnotu
  664.                 while (true)
  665.                 {
  666.                     Console.Write("Zadej číslo pro počáteční hodnotu <1;10>: ");
  667.                     try
  668.                     {
  669.                         pocatecni = Convert.ToDouble(Console.ReadLine());
  670.  
  671.                         if (pocatecni <= 10 && pocatecni >= 1)
  672.                         {
  673.                             break;
  674.                         }
  675.  
  676.                         Console.Write("Počáteční hodnota musí být v z intervalu <1;10>");
  677.                         Console.ReadLine();
  678.                     }
  679.                     catch (Exception e)
  680.                     {
  681.                         Console.WriteLine(e.Message);
  682.                         Console.ReadLine();
  683.                     }
  684.                 }
  685.                 //Loop pro konečnou hodnotu
  686.                 while (true)
  687.                 {
  688.                     Console.Write("Zadej desetinné číslo pro konečnou hodnotu <0,1;0,01>: ");
  689.  
  690.                     try
  691.                     {
  692.                         konecna = Convert.ToDouble(Console.ReadLine());
  693.  
  694.                         if (konecna.CompareTo(0.1) <= 0 && konecna.CompareTo(0.01) >= 0)
  695.                         {
  696.                             break;
  697.                         }
  698.  
  699.                         Console.Write("Konečná hodnota musí být v z intervalu <0,1;0,01>");
  700.                         Console.ReadLine();
  701.                     }
  702.                     catch (Exception e)
  703.                     {
  704.                         Console.WriteLine(e.Message);
  705.                         Console.ReadLine();
  706.                     }
  707.                 }
  708.  
  709.                 //Kontrola hodnot
  710.                 if (pocatecni > konecna)
  711.                 {
  712.                     Console.WriteLine($"\nVýpis od {pocatecni} do {konecna} po jedné:\n");
  713.  
  714.                     for (double i = 2; pocatecni / i >= konecna; i++)
  715.                     {
  716.                         Console.WriteLine($" >> {pocatecni} / {i} = {pocatecni / i:0.#######}");
  717.                     }
  718.  
  719.                     Console.WriteLine();
  720.                     Console.Write("Odenteruj!");
  721.                     Console.ReadLine();
  722.                     break;
  723.                 }
  724.  
  725.                 Console.Write("Počáteční hodnota je menší než konečná!");
  726.                 Console.ReadLine();
  727.  
  728.             }
  729.         }
  730.  
  731.         static void DelPoZadanem()
  732.         {
  733.             //Celý loop, kvůli podmínce pocatecni<konecna
  734.             while (true)
  735.             {
  736.                 Console.Clear();
  737.                 Console.WriteLine($"┌────────────────────────────────────────┐");
  738.                 Console.WriteLine($"│{"Dělení po zadané hodnotě",-40}│");
  739.                 Console.WriteLine($"└────────────────────────────────────────┘");
  740.  
  741.                 double pocatecni;
  742.                 double konecna;
  743.                 double krokovani;
  744.  
  745.                 //Loop pro počáteční hodnotu
  746.                 while (true)
  747.                 {
  748.                     Console.Write("Zadej číslo pro počáteční hodnotu <1;10>: ");
  749.                     try
  750.                     {
  751.                         pocatecni = Convert.ToDouble(Console.ReadLine());
  752.  
  753.                         if (pocatecni <= 10 && pocatecni >= 1)
  754.                         {
  755.                             break;
  756.                         }
  757.                         Console.Write("Počáteční hodnota musí být v z intervalu <1;10>");
  758.                         Console.ReadLine();
  759.                     }
  760.                     catch (Exception e)
  761.                     {
  762.                         Console.WriteLine(e.Message);
  763.                         Console.ReadLine();
  764.                     }
  765.                 }
  766.  
  767.                 //Loop pro konečnou hodnotu
  768.                 while (true)
  769.                 {
  770.                     Console.Write("Zadej číslo pro konečnou hodnotu <0,1;0,01>: ");
  771.  
  772.                     try
  773.                     {
  774.                         konecna = Convert.ToDouble(Console.ReadLine());
  775.  
  776.                         if (konecna.CompareTo(0.1) <= 0 && konecna.CompareTo(0.01) >= 0)
  777.                         {
  778.                             break;
  779.                         }
  780.                         Console.Write("Konečná hodnota musí být v z intervalu <0,1;0,01>");
  781.                         Console.ReadLine();
  782.                     }
  783.                     catch (Exception e)
  784.                     {
  785.                         Console.WriteLine(e.Message);
  786.                         Console.ReadLine();
  787.                     }
  788.                 }
  789.  
  790.                 //Loop pro honotu přičítání
  791.                 while (true)
  792.                 {
  793.                     Console.Write("Zadej číslo pro hodnotu kroku <2;5>: ");
  794.                     try
  795.                     {
  796.                         krokovani = Convert.ToDouble(Console.ReadLine());
  797.  
  798.                         if (krokovani <= 5 && krokovani >= 2)
  799.                         {
  800.                             break;
  801.                         }
  802.                         Console.Write("Hodnota kroku musí být v z intervalu <2;5>");
  803.                         Console.ReadLine();
  804.                     }
  805.                     catch (Exception e)
  806.                     {
  807.                         Console.WriteLine(e.Message);
  808.                         Console.ReadLine();
  809.                     }
  810.                 }
  811.  
  812.                 //Kontrola hodnot
  813.                 if (pocatecni > konecna)
  814.                 {
  815.                     Console.WriteLine($"\nVýpis od {pocatecni} do {konecna} po {krokovani}:\n");
  816.  
  817.                     for (double i = 2; pocatecni / i >= konecna; i+=krokovani)
  818.                     {
  819.                         Console.WriteLine($" >> {pocatecni} / {i} = {pocatecni / i:0.#######}");
  820.                     }
  821.  
  822.                     Console.WriteLine();
  823.                     Console.Write("Odenteruj!");
  824.                     Console.ReadLine();
  825.                     break;
  826.                 }
  827.                 else
  828.                 {
  829.                     Console.Write("Počáteční hodnota je menší než konečná!");
  830.                     Console.ReadLine();
  831.                 }
  832.             }
  833.         }
  834.         #endregion
  835.     }
  836. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement