SHARE
TWEET

Untitled

a guest Mar 25th, 2019 85 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Drawing;
  4. using System.IO;
  5. using System.Linq;
  6. using System.Text;
  7. using System.Threading.Tasks;
  8.  
  9. namespace Sandbox
  10. {
  11.     class Program
  12.     {
  13.         const char separator = ' ';
  14.  
  15.         const string pathSeparator = ", ";
  16.  
  17.         static void Main(string[] args)
  18.         {
  19.             //Init();
  20.             InitRead();
  21.         }
  22.  
  23.         private static void InitRead()
  24.         {
  25.             //string[] lines = new string[]
  26.             //{
  27.                
  28.             //    "218 836 347 235",
  29.             //    "320 805 522 417 345",
  30.             //    "229 601 728 835 133 124",
  31.             //    "248 202 277 433 207 263 257",
  32.             //    "359 464 504 528 516 716 871 182",
  33.             //    "461 441 426 656 863 560 380 171 923",
  34.             //    "381 348 573 533 448 632 387 176 975 449",
  35.             //    "223 711 445 645 245 543 931 532 937 541 444",
  36.             //    "330 131 333 928 376 733 017 778 839 168 197 197",
  37.             //    "131 171 522 137 217 224 291 413 528 520 227 229 928",
  38.             //    "223 626 034 683 839 052 627 310 713 999 629 817 410 121",
  39.             //    "924 622 911 233 325 139 721 218 253 223 107 233 230 124 233"
  40.             //};
  41.  
  42.             //InitTreeReadFromList(lines, separator);
  43.  
  44.             //string[] lines2 = new string[]
  45.             //{
  46.             //    "1",
  47.             //    "8 9",
  48.             //    "1 5 9",
  49.             //    "4 5 2 3"
  50.             //};
  51.  
  52.             //string[] lines2 = new string[]
  53.             //  {
  54.             //        "1",
  55.             //        "8 9",
  56.             //        "11 5 9",
  57.             //        "4 5 2 3"
  58.             //  };
  59.  
  60.             string[] l1 = new string[]
  61.             {
  62.                    "1",
  63.                   "4 2",
  64.                  "1 5 3",
  65.                 "4 6 2 20"
  66.             };
  67.            
  68.             InitTreeReadFromList(l1, separator);
  69.  
  70.             //string[] l2 = new string[]
  71.             //{
  72.             //    "1",
  73.             //    "8 10",
  74.             //    "9 5 11",
  75.             //    "14 5 2 12"
  76.             //};
  77.  
  78.             //InitTreeReadFromList(l2, separator);
  79.  
  80.             //string[] l3 = new string[]
  81.             //{
  82.             //    "1",
  83.             //    "8 9",
  84.             //    "5 9 9",
  85.             //    "1 5 2 3"
  86.             //};
  87.  
  88.             //InitTreeReadFromList(l3, separator);
  89.  
  90.             //string[] l4 = new string[]
  91.             //{
  92.             //    "1",
  93.             //    "8 9",
  94.             //    "5 9 9",
  95.             //    "1 10 12 3"
  96.             //};
  97.  
  98.             //InitTreeReadFromList(l4, separator);
  99.  
  100.             //string[] l5 = new string[]
  101.             // {
  102.             //    "1",
  103.             //    "8 9",
  104.             //    "5 9 9",
  105.             //    "1 10 11 3",
  106.             //    "1 21 19 3 5"
  107.             // };
  108.  
  109.             //InitTreeReadFromList(l5, separator);
  110.  
  111.             //string[] l6 = new string[]
  112.             // {
  113.             //    "3"
  114.             // };
  115.  
  116.             //InitTreeReadFromList(l6, separator);
  117.  
  118.             //string[] l7 = new string[]
  119.             // {
  120.             //    "5 9 9",
  121.             //    "1 10 11 3",
  122.             //    "1 21 19 3 5"
  123.             // };
  124.  
  125.             //InitTreeReadFromList(l7, separator);
  126.  
  127.             //string[] l8 = new string[]
  128.             // {
  129.             //    "-1",
  130.             //    "-8 9",
  131.             //    "5 9 9",
  132.             //    "1 10 11 3",
  133.             //    "1 21 19 3 5"
  134.             // };
  135.  
  136.             //InitTreeReadFromList(l8, separator);
  137.  
  138.             //string[] l9 = new string[]
  139.             // {
  140.             //                "-1",
  141.             //        "-8 9",
  142.             //       "5 -9 9",
  143.             //     "1 -10 11 3",
  144.             //    "1 21 19,1 3 5"
  145.             // };
  146.  
  147.             //InitTreeReadFromList(l9, separator);
  148.         }
  149.  
  150.         private static void InitTreeReadFromList(string[] list, char separator)
  151.         {
  152.             try
  153.             {
  154.                 Tree tree = new Tree();
  155.                 tree.ReadFromList(separator, list);
  156.  
  157.                 var t = tree.ValidPaths;
  158.  
  159.                 int i = 0;
  160.                 foreach (var l in t)
  161.                 {
  162.                     i++;
  163.                     Console.WriteLine($"Path: {i}");
  164.                     foreach (var g in l)
  165.                     {
  166.                         Console.WriteLine($"{g.Value}");
  167.                         //Console.WriteLine($"[{g.Index}], [{g.Value}]");
  168.                     }
  169.                 }
  170.  
  171.                 //Console.WriteLine(tree.ToString(pathSeparator));
  172.             }
  173.             catch (Exception ex)
  174.             {
  175.                 Console.WriteLine(ex.Message);
  176.             }
  177.         }
  178.  
  179.         #region text
  180.         public class Text
  181.         {
  182.             public string text { get; set; }
  183.             public int width { get; set; }
  184.  
  185.         }
  186.  
  187.         private static void Init()
  188.         {
  189.             //var t1 = "Brandos atestatas Lietuvos Respublikoje atitinka Lietuvos kvalifikacijų sandaros ketvirtąjį lygį pagal Lietuvos kvalifikacijų sandaros aprašą ir suteikia teisę pretenduoti į pirmos pakopos (profesinio bakalauro ar bakalauro programas) ir vientisųjų studijų programas.";
  190.             //////var w1 = 415;
  191.             //var w1 = 650;
  192.  
  193.             //var t2 = "Baigta vidurinio ugdymo (Leaving Certificate) 2 metų trukmės programa, skirta parengti studijoms aukštosiose mokyklose, į kurią priimami įgijusieji pagrindinį išsilavinimą. Kvalifikacija suteikta sėkmingai baigus programą ir išlaikius valstybinius baigiamuosius egzaminus (Leaving Certificate Examination). Airijoje naudojama baigiamųjų egzaminų (Leaving Certificate Examinations) pasiekimų vertinimo sistema A1-A2, B1-B3, C1-C3, D1-D3, E, F, kur aukščiausias patenkinamas įvertinimas yra A1. Žemesni nei D3 įvertinimai nerekomenduojami priimant į aukštojo mokslo studijas ir/ar formuojant konkursinį balą. ";
  194.             //var w2 = 650;
  195.  
  196.             //var t3 = "Siekiant studijuoti, kvalifikacija pripažįstama tik kartu su papildomais reikalavimais, nes vertinimo metu nustatytas esminis skirtumas dėl individualios kvalifikacijos kokybės: pasiekti egzaminų rezultatai be papildomų reikalavimų įvykdymo neteikia teisės stoti į aukštąsias mokyklas Airijoje (gauti nepakankami įvertinimai). Vadovaujantis turima informacija, teisė stoti į aukštąsias mokyklas Airijoje įgyjama tik tais atvejais, kai kalba (anglų arba airių) ir matematika bei dar bent 3 pasirenkami baigiamieji egzaminai (Leaving Certificate Examinations) įvertinami ne žemiau, nei D3. Pareiškėjas pakankamu įvertinimu išlaikė 4 baigiamuosius egzaminus (iš 7 laikytų)." +
  197.             //        "Kadangi aukščiau nurodytos aplinkybės susijusios tik su tolesnėmis teisėmis studijų prasme, kvalifikacija siekiant dirbti ar kitų tikslų pripažįstama be jokių papildomų reikalavimų." +
  198.             //        "Sprendimas priimtas vadovaujantis Išsilavinimo ir kvalifikacijų, susijusių su aukštuoju mokslu ir įgytų pagal užsienio valstybių ir tarptautinių organizacijų švietimo programas, pripažinimo tvarkos aprašo 30.3 ir 12 punktais bei Išsilavinimo ir kvalifikacijų, susijusių su aukštuoju mokslu ir įgytų pagal užsienio valstybių ir tarptautinių organizacijų švietimo programas, vertinimo metodikos 52 ir 48 punktais.";
  199.             //var w3 = 650;
  200.  
  201.             //var t4 = "Dėl reikalavimo, susijusio su brandos egzaminų laikymu Lietuvoje, įvykdymo asmuo gali kreiptis į vieną iš bazinių mokyklų Lietuvoje. Bazinių mokyklų sąrašas teikiamas. Mokykla galės suteikti detalesnę informaciją apie egzaminų laikymą eksternu. Išlaikius egzaminus, kurie tenkintų stojimo reikalavimus Lietuvoje, asmuo galėtų stoti į aukštąsias mokyklas Lietuvoje. Pakartotinas kreipimasis į Studijų kokybės vertinimo centrą nereikalingas." +
  202.             //        "Siekiant įgyti Lietuvoje teikiamą brandos atestatą, dėl vidurinio ugdymo programos baigimo rekomenduojame kreiptis į pasirinktą mokyklą Lietuvoje. Vadovaujantis Nuosekliojo mokymosi pagal bendrojo ugdymo programas tvarkos aprašo, patvirtinto Švietimo ir mokslo ministro 2005 m.balandžio 5 d.įsakymu Nr. ISAK - 556, 4.1.1.punktu, pasirinkta mokykla priims sprendimą dėl reikalingos baigti vidurinio ugdymo programos dalies.";
  203.             //var w4 = 650;
  204.  
  205.             //var t1 = "Brandos atestatas Lietuvos Respublikoje atitinka Lietuvos kvalifikacijų sandaros ketvirtąjį lygį pagal Lietuvos kvalifikacijų sandaros aprašą ir suteikia teisę pretenduoti į pirmos pakopos (profesinio bakalauro ar bakalauro programas) ir vientisųjų studijų programas.";
  206.             //var w1 = 650;
  207.  
  208.             //var t2 = "Baigta vidurinio ugdymo (Leaving Certificate) 2 metų trukmės programa, skirta parengti studijoms aukštosiose mokyklose, į kurią priimami įgijusieji pagrindinį išsilavinimą. \nKvalifikacija suteikta sėkmingai baigus programą ir išlaikius valstybinius baigiamuosius egzaminus (Leaving Certificate Examination). \nAirijoje naudojama baigiamųjų egzaminų (Leaving Certificate Examinations) pasiekimų vertinimo sistema A1-A2, B1-B3, C1-C3, D1-D3, E, F, kur aukščiausias patenkinamas įvertinimas yra A1. Žemesni nei D3 įvertinimai nerekomenduojami priimant į aukštojo mokslo studijas ir/ar formuojant konkursinį balą. \n";
  209.             //var w2 = 650;
  210.  
  211.             //var t3 = "Baigta vidurinio ugdymo(Leaving Certificate) 2 metų trukmės programa, skirta parengti studijoms aukštosiose mokyklose, į kurią priimami įgijusieji pagrindinį išsilavinimą. \nKvalifikacija suteikta sėkmingai baigus programą ir išlaikius valstybinius baigiamuosius egzaminus (Leaving Certificate Examination). \nAirijoje naudojama baigiamųjų egzaminų (Leaving Certificate Examinations) pasiekimų vertinimo sistema A1-A2, B1 - B3, C1 - C3, D1 - D3, E, F, kur aukščiausias patenkinamas įvertinimas yra A1. Žemesni nei D3 įvertinimai nerekomenduojami priimant į aukštojo mokslo studijas ir / ar formuojant konkursinį balą.A\n";
  212.             //var w3 = 650;
  213.  
  214.             //var t4 = "Dėl reikalavimo, susijusio su brandos egzaminų laikymu Lietuvoje, įvykdymo asmuo gali kreiptis į vieną iš bazinių mokyklų Lietuvoje. Bazinių mokyklų sąrašas teikiamas. Mokykla galės suteikti detalesnę informaciją apie egzaminų laikymą eksternu. Išlaikius egzaminus, kurie tenkintų stojimo reikalavimus Lietuvoje, asmuo galėtų stoti į aukštąsias mokyklas Lietuvoje. Pakartotinas kreipimasis į Studijų kokybės vertinimo centrą nereikalingas.\nSiekiant įgyti Lietuvoje teikiamą brandos atestatą, dėl vidurinio ugdymo programos baigimo rekomenduojame kreiptis į pasirinktą mokyklą Lietuvoje. Vadovaujantis Nuosekliojo mokymosi pagal bendrojo ugdymo programas tvarkos aprašo, patvirtinto Švietimo ir mokslo ministro 2005 m. balandžio 5 d. įsakymu Nr. ISAK-556, 4.1.1. punktu, pasirinkta mokykla priims sprendimą dėl reikalingos baigti vidurinio ugdymo programos dalies.\n";
  215.             //var w4 = 650;
  216.  
  217.             //var t5 = "Eilute 1\nEilute 2\nEilute 3\nEilute4\nEilute5Eilute5Eilute5Eilute5Eilute5Eilute5Eilute5Eilute5Eilute5 Eilute5Eilute5Eilute5 Eilute5Eilute5Eilute5 Eilute5Eilute5Eilute5 Eilute5Eilute5 Eilute5 Eilute5 Eilute5 Eilute5Eilute5Eilute5 Eilute5  Eilute5 Eilute5 Eilute5 Eilute5 Eilute5Eilute5 Eilute5 Eilute5 Eilute5 Eilute5\n6";
  218.             //var w5 = 650;
  219.  
  220.             //var t6 = "Eilute 1\nEilute 2\nEilute 3\nEilute4\nEilute5Eilute5Eilute5Eilute5Eilute5Eilute5Eilute5Eilute5Eilute5 Eilute5Eilute5Eilute5 Eilute5Eilute5Eilute5 Eilute5Eilute5Eilute5 Eilute5Eilute5 Eilute5 Eilute5 Eilute5 Eilute5Eilute5Eilute5 Eilute5  Eilute5 Eilute5 Eilute5 Eilute5 Eilute5Eilute5 Eilute5 Eilute5 Eilute5 Eilute5\n6";
  221.             //var w6 = 650;
  222.  
  223.             var t1 = "Kvalifikaciją pripažinti lygiaverte brandos atestatu liudijamam Lietuvos Respublikoje teikiamam viduriniam išsilavinimui. Siekiant dirbti ar kitu tikslu (išskyrus studijas0). Siekiant studijuoti - tik kartu su šiais papildomais reikalavimais. Aukštosios mokyklos atliktu žinių ir gebėjimų patikrinimu, arba išlaikytais privalomais brandos egzaminais\n Lietuvos Respublikoje , arba baigtomis studijomis ar kitu formaliu poviduriniu mokymusi ar jo dalimi, ne trumpesne, kaip vieneri metai. Brandos atestatas Lietuvos Respublikoje atitinka Lietuvos kvalifikacijų sandaros ketvirtąjį lygį pagal Lietuvos kvalifikacijų sandaros aprašą ir suteikia teisę pretenduoti į pirmos pakopos (profesinio bakalauro ar bakalauro programas) ir vientisųjų studijų programas.";
  224.             var w1 = 434;
  225.  
  226.             var t2 = "Baigta vidurinio ugdymo (Leaving Certificate) 2 metų trukmės programa, skirta parengti studijoms aukštosiose mokyklose, į kurią priimami įgijusieji pagrindinį išsilavinimą. Kvalifikacija suteikta sėkmingai baigus programą ir išlaikius valstybinius baigiamuosius egzaminus (Leaving Certificate Examination). \nAirijoje naudojama baigiamųjų egzaminų (Leaving Certificate Examinations) pasiekimų vertinimo sistema A1-A2, B1-B3, C1-C3, D1-D3, E, F, kur aukščiausias patenkinamas įvertinimas yra A1. \nŽemesni nei D3 įvertinimai nerekomenduojami priimant į aukštojo mokslo studijas ir/ar formuojant konkursinį balą. ";
  227.             var w2 = 658;
  228.  
  229.  
  230.             var t3 = "Siekiant studijuoti, kvalifikacija pripažįstama tik kartu su papildomais reikalavimais, nes vertinimo metu nustatytas esminis skirtumas dėl individualios kvalifikacijos kokybės: pasiekti egzaminų rezultatai be papildomų reikalavimų įvykdymo neteikia teisės stoti į aukštąsias mokyklas Airijoje (gauti nepakankami įvertinimai). Vadovaujantis turima informacija, teisė stoti į aukštąsias mokyklas Airijoje įgyjama tik tais atvejais, kai kalba (anglų arba airių) ir matematika bei dar bent 3 pasirenkami baigiamieji egzaminai (Leaving Certificate Examinations) įvertinami ne žemiau, nei D3. Pareiškėjas pakankamu įvertinimu išlaikė 4 baigiamuosius egzaminus (iš 7 laikytų). Kadangi aukščiau nurodytos aplinkybės susijusios tik su tolesnėmis teisėmis studijų prasme, kvalifikacija siekiant dirbti ar kitų tikslų pripažįstama be jokių papildomų reikalavimų. \nSprendimas priimtas vadovaujantis Išsilavinimo ir kvalifikacijų, susijusių su aukštuoju mokslu ir įgytų pagal užsienio valstybių ir tarptautinių organizacijų švietimo programas, pripažinimo tvarkos aprašo 30.3 ir 12 punktais bei Išsilavinimo ir kvalifikacijų, susijusių su aukštuoju mokslu ir įgytų pagal užsienio valstybių ir tarptautinių organizacijų švietimo programas, vertinimo metodikos 52 ir 48 punktais.";
  231.             var w3 = 658;
  232.  
  233.  
  234.             var t4 = "Dėl reikalavimo, susijusio su brandos egzaminų laikymu Lietuvoje, įvykdymo asmuo gali kreiptis į vieną iš bazinių mokyklų Lietuvoje. Mokykla galės suteikti detalesnę informaciją apie egzaminų laikymą eksternu. Išlaikius egzaminus, kurie tenkintų stojimo reikalavimus Lietuvoje, asmuo galėtų stoti į aukštąsias mokyklas Lietuvoje. Siekiant įgyti Lietuvoje teikiamą brandos atestatą, dėl vidurinio ugdymo programos baigimo rekomenduojame kreiptis į pasirinktą mokyklą Lietuvoje. \nVadovaujantis Nuosekliojo mokymosi pagal bendrojo ugdymo programas tvarkos aprašo, patvirtinto Švietimo ir mokslo ministro 2005 m. balandžio 5 d. įsakymu Nr. ISAK-556, 4.1.1. punktu, pasirinkta mokykla priims sprendimą dėl reikalingos baigti vidurinio ugdymo programos dalies.\na\nb\nc";
  235.             var w4 = 658;
  236.  
  237.  
  238.             //var t5 =
  239.             //var w5 = 658;
  240.  
  241.  
  242.             List <Text> t = new List<Text>()
  243.             {
  244.                 new Text(){ text = t1, width = w1 },
  245.                 new Text(){ text = t2, width = w2 },
  246.                 new Text(){ text = t3, width = w3 },
  247.                 new Text(){ text = t4, width = w4 },
  248.                 //new Text(){ text = t5, width = w5 }
  249.             };
  250.             Console.WindowWidth = Console.LargestWindowWidth - 50;
  251.             Console.WindowHeight = Console.LargestWindowHeight - 20;
  252.  
  253.  
  254.             /*
  255.             string path = @"c:\Temp\RESULTOFREPORT.txt";
  256.             // This text is added only once to the file.
  257.             if (!File.Exists(path))
  258.             {
  259.                 // Create a file to write to.
  260.                 using (StreamWriter sw = File.CreateText(path))
  261.                 {
  262.                     foreach (Text p in t)
  263.                     {
  264.                         var text = GetParagraphs(p.text, p.width);
  265.                         sw.WriteLine(text);
  266.                     }
  267.                 }
  268.             }
  269.             */
  270.             Console.OutputEncoding = Encoding.UTF8;
  271.  
  272.             foreach (Text p in t)
  273.             {
  274.                 var text = GetParagraphs(p.text, p.width);
  275.                 Console.WriteLine(text);
  276.             }
  277.  
  278.             Console.ReadLine();
  279.         }
  280.  
  281.         //private static void PrintResult(List<string> text, bool printRes = false)
  282.         //{
  283.         //    Console.OutputEncoding = Encoding.UTF8;
  284.         //    for (int i = 0; i < text.Count; i++)
  285.         //    {
  286.         //        //Console.WriteLine($"lenght:{text[i].Length.ToString("000")}; line {i.ToString("00")}: {text[i]}");
  287.         //        Console.WriteLine($"{text[i]}");
  288.         //    }
  289.  
  290.         //    if (printRes)
  291.         //    {
  292.         //        Console.WriteLine("---------------------");
  293.         //        Console.Write(string.Join("\n", text));
  294.         //    }
  295.         //}
  296.  
  297.         public static string GetParagraphs(string text, int width)
  298.         {
  299.             string[] paragraphs = text.Split(
  300.                 new[] { "\r\n", "\r", "\n" },
  301.                 StringSplitOptions.None
  302.             );
  303.  
  304.             List<string> res = new List<string>();
  305.  
  306.             foreach (string a in paragraphs)
  307.             {
  308.                 List<string> aa = GetText2(a.TrimStart(), width);
  309.                 foreach (string b in aa)
  310.                 {
  311.                     res.Add(b);
  312.                 }
  313.             }
  314.  
  315.             return string.Join("\n", res);
  316.         }
  317.  
  318.         public static List<string> GetText2(string text, int width)
  319.         {
  320.             var words = text.Split(' ');
  321.             var sb1 = new StringBuilder();
  322.             var sb2 = new StringBuilder();
  323.             var length = words.Length;
  324.             var result = new List<string>();
  325.  
  326.             var graphics = Graphics.FromImage(new Bitmap(1, 1));
  327.             var font = new Font("Times New Roman", 11);
  328.  
  329.             char newLine = '\n';
  330.             int indentSpaces = 10;
  331.             string newLineReplace = $"{newLine}{string.Empty.PadLeft(indentSpaces)}";
  332.  
  333.             bool indentFirstLine = true;
  334.  
  335.             if (indentFirstLine)
  336.             {
  337.                 for (int i = 0; i < words.Length; i++)
  338.                 {
  339.                     if (i == 0)
  340.                     {
  341.                         words[i] = $"{string.Empty.PadLeft(indentSpaces)}{words[i].Trim()}";
  342.                     }
  343.                 }
  344.             }
  345.  
  346.             for (var i = 0; i < length; i++)
  347.             {
  348.                 sb1.AppendFormat("{0} ", words[i]);
  349.                 if (graphics.MeasureString(sb1.ToString(), font).Width > width)
  350.                 {
  351.                     result.Add(sb2.ToString());
  352.                     sb1 = new StringBuilder();
  353.                     sb2 = new StringBuilder();
  354.                     i--;
  355.                 }
  356.                 else
  357.                 {
  358.                     sb2.AppendFormat("{0} ", words[i]);
  359.                 }
  360.             }
  361.  
  362.             result.Add(sb2.ToString());
  363.  
  364.             var result2 = new List<string>();
  365.             string temp;
  366.  
  367.             int index1, index2, jump;
  368.             string target;
  369.             var limit = result.Count;
  370.             for (int q = 0; q < result.Count; q++)
  371.             {
  372.                 var item = result[q];
  373.                
  374.                 target = " ";
  375.                 bool indent = (q == 0) && indentFirstLine;
  376.  
  377.                 temp = indent ? item : item.Trim();
  378.  
  379.                 index1 = 0;
  380.                 index2 = 0;
  381.  
  382.                 jump = 2;
  383.  
  384.                 if (limit <= 1)
  385.                 {
  386.                     result2.Add(temp);
  387.                     break;
  388.                 }
  389.  
  390.  
  391.                 bool shiftSpace = true;
  392.                 while (graphics.MeasureString(temp, font).Width <= width)
  393.                 {
  394.                     if (indent && shiftSpace)
  395.                     {
  396.                         index1 = temp.IndexOf(target, temp.IndexOf(target) + indentSpaces);
  397.                         index2 = indentSpaces;
  398.                         shiftSpace = false;
  399.                     }
  400.                     else
  401.                     {
  402.                         index1 = temp.IndexOf(target, index2);
  403.                     }
  404.  
  405.                     if (temp.IndexOf(target, index2) < 0)
  406.                     {
  407.                         if (indent)
  408.                         {
  409.                             index1 = temp.IndexOf(target, temp.IndexOf(target) + indentSpaces);
  410.                             index2 = indentSpaces;
  411.                         }
  412.                         else
  413.                         {
  414.                             index1 = 0;
  415.                             index2 = 0;
  416.                         }
  417.                        
  418.                         target = target + " ";
  419.                         jump++;
  420.                     }
  421.  
  422.                     temp = temp.Insert(temp.IndexOf(target, index2), " ");
  423.                     index2 = index1 + jump;
  424.                 }
  425.  
  426.                 limit--;
  427.                 result2.Add(temp);
  428.             }
  429.  
  430.             return result2;
  431.         }
  432.  
  433.  
  434.         /*
  435.         private static List<string> DoStuff(string text, int width)
  436.         {
  437.             //var paragraphs = text.Split(System.Environment.NewLine);
  438.  
  439.             string[] paragraphs = text.Split(
  440.                 new[] { "\r\n", "\r", "\n" },
  441.                 StringSplitOptions.None
  442.             );
  443.  
  444.             List<string> res = new List<string>();
  445.  
  446.             foreach (string a in paragraphs)
  447.             {
  448.                 List<string> aa = GetText2(a, width);
  449.                 foreach (string b in aa)
  450.                 {
  451.                     //string s = b.PadLeft(10);
  452.                     res.Add(b);
  453.                 }
  454.             }
  455.  
  456.             return res;
  457.         }
  458.  
  459.         private static List<string> GetText2(string text, int width)
  460.         {
  461.             var words = text.Split(' ');
  462.             var sb1 = new StringBuilder();
  463.             var sb2 = new StringBuilder();
  464.             var length = words.Length;
  465.             var result = new List<string>();
  466.  
  467.             var graphics = Graphics.FromImage(new Bitmap(1, 1));
  468.             var font = new Font("Times New Roman", 11);
  469.  
  470.             char newLine = '\n';
  471.             int indentSpaces = 10;
  472.             string newLineReplace = $"{newLine}{string.Empty.PadLeft(indentSpaces)}";
  473.  
  474.             bool indentFirstLine = true;
  475.  
  476.             if (indentFirstLine)
  477.             {
  478.                 for (int i = 0; i < words.Length; i++)
  479.                 {
  480.                     if (i == 0)
  481.                     {
  482.                         words[i] = $"{string.Empty.PadLeft(indentSpaces)}{words[i].Trim()}";
  483.                     }
  484.                 }
  485.             }
  486.  
  487.             for (var i = 0; i < length; i++)
  488.             {
  489.                 sb1.AppendFormat("{0} ", words[i]);
  490.                 if (graphics.MeasureString(sb1.ToString(), font).Width > width)
  491.                 {
  492.                     result.Add(sb2.ToString());
  493.                     sb1 = new StringBuilder();
  494.                     sb2 = new StringBuilder();
  495.                     i--;
  496.                 }
  497.                 else
  498.                 {
  499.                     sb2.AppendFormat("{0} ", words[i]);
  500.                 }
  501.             }
  502.  
  503.             result.Add(sb2.ToString());
  504.  
  505.             var result2 = new List<string>();
  506.             string temp;
  507.  
  508.             int index1, index2, jump;
  509.             string target;
  510.             var limit = result.Count;
  511.             for (int q = 0; q < result.Count; q++)
  512.             {
  513.                 var item = result[q];
  514.  
  515.                 target = " ";
  516.                 bool indent = (q == 0) && indentFirstLine;
  517.  
  518.                 temp = indent ? item : item.Trim();
  519.  
  520.                 index1 = 0;
  521.                 index2 = 0;
  522.  
  523.                 jump = 2;
  524.  
  525.                 if (limit <= 1)
  526.                 {
  527.                     result2.Add(temp);
  528.                     break;
  529.                 }
  530.  
  531.                 bool shiftSpace = true;
  532.                 while (graphics.MeasureString(temp, font).Width <= width)
  533.                 {
  534.                     if (indent && shiftSpace)
  535.                     {
  536.                         index1 = temp.IndexOf(target, temp.IndexOf(target) + indentSpaces);
  537.                         index2 = indentSpaces;
  538.                         shiftSpace = false;
  539.                     }
  540.                     else
  541.                     {
  542.                         index1 = temp.IndexOf(target, index2);
  543.                     }
  544.  
  545.                     if (temp.IndexOf(target, index2) < 0)
  546.                     {
  547.                         index1 = 0;
  548.                         index2 = 0;
  549.                         target = target + " ";
  550.                         jump++;
  551.                     }
  552.  
  553.                     //index1 = temp.IndexOf(target, index2);
  554.                     temp = temp.Insert(temp.IndexOf(target, index2), " ");
  555.                     index2 = index1 + jump;
  556.                 }
  557.  
  558.                 limit--;
  559.                 result2.Add(temp);
  560.             }
  561.  
  562.  
  563.             return result2;
  564.         }
  565.  
  566.         private static List<string> GetText(string text, int width)
  567.         {
  568.             var words = text.Split(' ');
  569.             var sb1 = new StringBuilder();
  570.             var sb2 = new StringBuilder();
  571.             var length = words.Length;
  572.             var result = new List<string>();
  573.  
  574.             var graphics = Graphics.FromImage(new Bitmap(1, 1));
  575.             var font = new Font("Times New Roman", 11);
  576.  
  577.             char newLine = '\n';
  578.             int indentSpaces = 10;
  579.             string newLineReplace = $"{newLine}{string.Empty.PadLeft(indentSpaces)}";
  580.  
  581.             bool indentFirstLine = true;
  582.  
  583.             if (indentFirstLine)
  584.             {
  585.                 for (int i = 0; i < words.Length; i++)
  586.                 {
  587.                     if (words[i].Contains(newLine.ToString()))
  588.                     {
  589.                         words[i] = words[i].Replace(newLine.ToString(), newLineReplace);
  590.                     }
  591.  
  592.                     if (i == 0)
  593.                     {
  594.                         words[i] = $"{string.Empty.PadLeft(indentSpaces)}{words[i].Trim()}";
  595.                     }
  596.                 }
  597.             }
  598.  
  599.             //List<string> w = words.ToList();
  600.             //foreach (string aa in w.ToList())
  601.             //{
  602.             //    if (aa.Equals(newLineReplace))
  603.             //    {
  604.             //        w.Remove(aa);
  605.             //    }
  606.             //}
  607.  
  608.             //words = w.ToArray();
  609.  
  610.             for (var i = 0; i < words.Length; i++)
  611.             {
  612.                 sb1.AppendFormat("{0} ", words[i]);
  613.                 if (graphics.MeasureString(sb1.ToString(), font).Width > width)
  614.                 {
  615.                     if (!string.IsNullOrEmpty(sb2.ToString()))
  616.                     {
  617.                         result.Add(sb2.ToString());
  618.                     }
  619.  
  620.                     sb1 = new StringBuilder();
  621.                     sb2 = new StringBuilder();
  622.                     i--;
  623.                 }
  624.                 else
  625.                 {
  626.                     if (words[i].Contains(newLineReplace))
  627.                     {
  628.                         if (!string.IsNullOrEmpty(sb2.ToString()))
  629.                         {
  630.                             result.Add(sb2.ToString());
  631.                         }
  632.  
  633.                         if (!string.IsNullOrEmpty(sb2.ToString()))
  634.                         {
  635.                             sb1 = sb1.Replace(sb2.ToString(), "");
  636.                             if (sb1.Length > 0)
  637.                             {
  638.                                 sb2 = sb1.Replace(sb2.ToString(), "");
  639.                             }
  640.                         }
  641.                     }
  642.                     else
  643.                     {
  644.                         sb2.AppendFormat("{0} ", words[i]);
  645.                     }
  646.                 }
  647.             }
  648.  
  649.             if (!string.IsNullOrEmpty(sb2.ToString()))
  650.             {
  651.                 result.Add(sb2.ToString());
  652.             }
  653.  
  654.             //foreach (string a in result)
  655.             //{
  656.             //    Console.WriteLine(a);
  657.             //}
  658.  
  659.             var result2 = new List<string>();
  660.             string temp;
  661.  
  662.             int index1, index2, jump;
  663.             string target;
  664.             var limit = result.Count;
  665.             for (int q = 0; q < result.Count; q++)
  666.             {
  667.                 var item = result[q];
  668.  
  669.                 target = " ";
  670.                 bool indent = (q == 0 || item.Contains(newLineReplace)) && indentFirstLine;
  671.  
  672.                 temp = indent ? item : item.Trim();
  673.  
  674.                 index1 = 0;
  675.                 index2 = 0;
  676.  
  677.                 jump = 2;
  678.  
  679.                 if (result.Count > q + 1)
  680.                 {
  681.                     if (result[q + 1].Contains(newLine.ToString()))
  682.                     {
  683.                         result2.Add(temp);
  684.                         continue;
  685.                     }
  686.                 }
  687.  
  688.                 if (limit <= 1)
  689.                 {
  690.                     result2.Add(temp);
  691.                     break;
  692.                 }
  693.  
  694.                 bool shiftSpace = true;
  695.                 string t = temp.TrimEnd();
  696.                 if (!temp.EndsWith(newLineReplace) && t.Contains(" "))
  697.                 {
  698.                     while (graphics.MeasureString(temp, font).Width <= width)
  699.                     {
  700.                         if (temp.IndexOf(target, index2) < 0)
  701.                         {
  702.                             index1 = 0;
  703.                             index2 = 0;
  704.                             target = target + " ";
  705.                             jump++;
  706.                         }
  707.  
  708.                         if (indent && shiftSpace)
  709.                         {
  710.                             index1 = temp.IndexOf(target, temp.IndexOf(target) + indentSpaces);
  711.                             index2 = indentSpaces;
  712.                             shiftSpace = false;
  713.                         }
  714.                         else
  715.                         {
  716.                             index1 = temp.IndexOf(target, index2);
  717.                         }
  718.  
  719.                         temp = temp.Insert(temp.IndexOf(target, index2), " ");
  720.                         index2 = index1 + jump;
  721.                     }
  722.                 }
  723.  
  724.                 limit--;
  725.                 result2.Add(temp);
  726.             }
  727.  
  728.  
  729.             return result2;
  730.         }
  731.  
  732.         private static List<string> GetTextOld(string text, int width)
  733.         {
  734.             var palabras = text.Split(' ');
  735.             var sb1 = new StringBuilder();
  736.             var sb2 = new StringBuilder();
  737.             var length = palabras.Length;
  738.             var resultado = new List<string>();
  739.  
  740.             var graphics = Graphics.FromImage(new Bitmap(1, 1));
  741.             var font = new Font("Times New Roman", 11);
  742.  
  743.             for (var i = 0; i < length; i++)
  744.             {
  745.                 sb1.AppendFormat("{0} ", palabras[i]);
  746.                 if (graphics.MeasureString(sb1.ToString(), font).Width > width)
  747.                 {
  748.                     resultado.Add(sb2.ToString());
  749.                     sb1 = new StringBuilder();
  750.                     sb2 = new StringBuilder();
  751.                     i--;
  752.                 }
  753.                 else
  754.                 {
  755.                     sb2.AppendFormat("{0} ", palabras[i]);
  756.                 }
  757.             }
  758.             resultado.Add(sb2.ToString());
  759.  
  760.             var resultado2 = new List<string>();
  761.             string temp;
  762.  
  763.             int index1, index2, salto;
  764.             string target;
  765.             var limit = resultado.Count;
  766.             foreach (var item in resultado)
  767.             {
  768.                 target = " ";
  769.                 temp = item.Trim();
  770.                 index1 = 0; index2 = 0; salto = 2;
  771.  
  772.                 if (limit <= 1)
  773.                 {
  774.                     resultado2.Add(temp);
  775.                     break;
  776.                 }
  777.                 while (graphics.MeasureString(temp, font).Width <= width)
  778.                 {
  779.                     if (temp.IndexOf(target, index2) < 0)
  780.                     {
  781.                         index1 = 0; index2 = 0;
  782.                         target = target + " ";
  783.                         salto++;
  784.                     }
  785.                     index1 = temp.IndexOf(target, index2);
  786.                     temp = temp.Insert(temp.IndexOf(target, index2), " ");
  787.                     index2 = index1 + salto;
  788.  
  789.                 }
  790.                 limit--;
  791.                 resultado2.Add(temp);
  792.             }
  793.  
  794.             return resultado2;
  795.             ////return string.Join("\n", resultado2);
  796.         }
  797.    
  798.  
  799.  
  800.     */
  801.  
  802.         #endregion
  803.     }
  804. }
  805.  
  806.  
  807. using System;
  808. using System.Collections.Generic;
  809. using System.IO;
  810. using System.Linq;
  811. using System.Text;
  812.  
  813. namespace Sandbox
  814. {
  815.     public class Tree
  816.     {
  817.         private List<int> Path { get; set; }
  818.  
  819.         private delegate bool IsNumberEvenOrOdd(int value);
  820.  
  821.         private char Separator { get; set; }
  822.  
  823.         private int Index { get; set; }
  824.  
  825.         private int Level { get; set; }
  826.  
  827.         public List<List<Node>> ValidPaths { get; set; }
  828.  
  829.         #region Public
  830.  
  831.         public Tree()
  832.         {
  833.             Index = 0;
  834.             Level = 0;
  835.             Path = new List<int>();
  836.             ValidPaths = new List<List<Node>>();
  837.         }
  838.  
  839.         public void ReadFromFile(char numberSeparator, string filePath)
  840.         {
  841.             Separator = numberSeparator;
  842.             if (File.Exists(filePath))
  843.             {
  844.                 using (System.IO.StreamReader reader = new System.IO.StreamReader(filePath, Encoding.Default))
  845.                 {
  846.                     string line;
  847.                     while ((line = reader.ReadLine()) != null)
  848.                     {                        
  849.                         AddNodeValueToPath(line);
  850.                     }
  851.                 }
  852.             }
  853.         }
  854.  
  855.         public void ReadFromList(char numberSeparator, string[] lines)
  856.         {
  857.             Separator = numberSeparator;
  858.             for (int i = 0; i < lines.Length; i++)
  859.             {
  860.                 ReadValidPaths(lines[i]);
  861.                 AddNodeValueToPath(lines[i]);
  862.                
  863.             }
  864.         }
  865.  
  866.         public int GetMaxSum() => Path.Sum();
  867.  
  868.         public string GetPath(string separator) => string.Join(separator, Path);
  869.  
  870.         public string ToString(string separator)
  871.         {
  872.             return $"Max sum: {GetMaxSum()}{System.Environment.NewLine}Path: {GetPath(separator)}";
  873.         }
  874.  
  875.         #endregion
  876.  
  877.         #region Private
  878.  
  879.         private void ReadValidPaths(string line)
  880.         {
  881.             List<int> numbers = ConvertLine(line);
  882.             if (Level == 0)
  883.             {
  884.                 foreach (int n in numbers)
  885.                 {
  886.                     ValidPaths.Add(new List<Node>() { new Node(numbers.IndexOf(n), n)} );
  887.                 }
  888.                 ////value = FindMax(numbers, IsOdd);
  889.             }
  890.             else
  891.             {
  892.                 int prevLevel = Level - 1;
  893.                 foreach (var aa in ValidPaths.ToList())
  894.                 {
  895.                     var node = aa.Last();
  896.                     //var ii =
  897.  
  898.                     int child1 = numbers[node.Index];
  899.                     int child2 = numbers[node.Index + 1];
  900.  
  901.                     var n1 = new Node(numbers.IndexOf(child1), child1);
  902.                     var n2 = new Node(numbers.IndexOf(child2), child2);
  903.  
  904.                     if (IsEven(Level))
  905.                     {
  906.                         if (IsOdd(child1))
  907.                         {
  908.                             var l = new List<Node>(ValidPaths[prevLevel]);
  909.                             l.Add(n1);
  910.                             ValidPaths.Add(l);
  911.                             ////ValidPaths[prevLevel].Add(new Node(numbers.IndexOf(child1), child1));
  912.                         }
  913.  
  914.                         if (IsOdd(child2))
  915.                         {
  916.                             var l = new List<Node>(ValidPaths[prevLevel]);
  917.                             l.Add(n2);
  918.                             ValidPaths.Add(l);
  919.                             ////ValidPaths[prevLevel].Add(new Node(numbers.IndexOf(child2), child2));
  920.                         }
  921.                     }
  922.  
  923.                     if (IsOdd(Level))
  924.                     {
  925.                         if (IsEven(child1))
  926.                         {
  927.                             var l = new List<Node>(ValidPaths[prevLevel]);
  928.                             l.Add(n1);
  929.                             ValidPaths.Add(l);
  930.                             ////ValidPaths[prevLevel].Add(new Node(numbers.IndexOf(child1), child1));
  931.                         }
  932.  
  933.                         if (IsEven(child2))
  934.                         {
  935.                             var l = new List<Node>(ValidPaths[prevLevel]);
  936.                             l.Add(n2);
  937.                             ValidPaths.Add(l);
  938.                             ////ValidPaths[prevLevel].Add(new Node(numbers.IndexOf(child2), child2));
  939.                         }
  940.                     }
  941.                 }              
  942.  
  943.                 //value = IsEven(Level) ? GetValidChild(child1, child2, IsOdd) :
  944.                 //                        GetValidChild(child1, child2, IsEven);
  945.             }
  946.  
  947.             ////Level++;
  948.  
  949.             //indexOfValue = numbers.IndexOf(value);
  950.             //SetNode(indexOfValue, value);
  951.         }
  952.  
  953.         /// <summary>
  954.         /// Finds and adds valid node value to path, prepares for next line iteration
  955.         /// </summary>
  956.         /// <param name="line"></param>
  957.         private void AddNodeValueToPath(string line)
  958.         {
  959.             List<int> numbers = ConvertLine(line);
  960.             int value, indexOfValue;
  961.             if (Level == 0)
  962.             {
  963.                 value = FindMax(numbers, IsOdd);
  964.             }
  965.             else
  966.             {
  967.                 int child1 = numbers[Index];
  968.                 int child2 = numbers[Index + 1];
  969.  
  970.                 value = IsEven(Level) ? GetValidChild(child1, child2, IsOdd) :
  971.                                         GetValidChild(child1, child2, IsEven);
  972.             }
  973.  
  974.             Level++;
  975.  
  976.             indexOfValue = numbers.IndexOf(value);
  977.             SetNode(indexOfValue, value);
  978.         }
  979.  
  980.         /// <summary>
  981.         /// Increases level, sets current node index and adds value to path
  982.         /// </summary>
  983.         /// <param name="index"></param>
  984.         /// <param name="value"></param>
  985.         private void SetNode(int index, int value)
  986.         {
  987.             Index = index;
  988.             Path.Add(value);
  989.         }
  990.  
  991.         /// <summary>
  992.         /// Finds larger even or odd child (assuming that the tree path is valid)
  993.         /// </summary>
  994.         /// <param name="child1"></param>
  995.         /// <param name="child2"></param>
  996.         /// <param name="isNumberEvenOrOdd"></param>
  997.         /// <returns></returns>
  998.         private int GetValidChild(int child1, int child2, IsNumberEvenOrOdd isNumberEvenOrOdd)
  999.         {
  1000.             if (isNumberEvenOrOdd(child1) && isNumberEvenOrOdd(child2))
  1001.             {
  1002.                 return GetLargerChild(child1, child2);
  1003.             }
  1004.             else if (isNumberEvenOrOdd(child1))
  1005.             {
  1006.                 return child1;
  1007.             }
  1008.             else
  1009.             {
  1010.                 return child2;
  1011.             }
  1012.         }
  1013.        
  1014.         private List<int> ConvertLine(string line) => line.Split(Separator).Select(x => int.Parse(x)).ToList();
  1015.  
  1016.         private int FindMax(List<int> list, Func<int, bool> query) => list.Where(query).Max();
  1017.  
  1018.         private int GetLargerChild(int child1, int child2) => child1 > child2 ? child1 : child2;
  1019.  
  1020.         private bool IsEven(int value) => value % 2 == 0;
  1021.  
  1022.         private bool IsOdd(int value) => !IsEven(value);
  1023.  
  1024.         #endregion
  1025.     }
  1026. }
  1027.  
  1028. using System;
  1029. using System.Collections.Generic;
  1030. using System.Linq;
  1031. using System.Text;
  1032. using System.Threading.Tasks;
  1033.  
  1034. namespace Sandbox
  1035. {
  1036.     public class Node
  1037.     {
  1038.         public int Index { get; private set; }
  1039.  
  1040.         public int Value { get; private set; }
  1041.  
  1042.         public Node(int index, int value)
  1043.         {
  1044.             Index = index;
  1045.             Value = value;
  1046.         }
  1047.     }
  1048. }
RAW Paste Data
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
 
Top