Morseova abeceda – .NET – Fórum – Programujte.com

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace MorseConverter
{
    class Program
    {
        static void Main(string[] args)
        {
            Dictionary<char, String> morse = new Dictionary<char, String>()
            {
                {'A' , ".-"},
                {'B' , "-..."},
                {'C' , "-.-."},
                {'D' , "-.."},
                {'E' , "."},
                {'F' , "..-."},
                {'G' , "--."},
                {'H' , "...."},
                {'I' , ".."},
                {'J' , ".---"},
                {'K' , "-.-"},
                {'L' , ".-.."},
                {'M' , "--"},
                {'N' , "-."},
                {'O' , "---"},
                {'P' , ".--."},
                {'Q' , "--.-"},
                {'R' , ".-."},
                {'S' , "..."},
                {'T' , "-"},
                {'U' , "..-"},
                {'V' , "...-"},
                {'W' , ".--"},
                {'X' , "-..-"},
                {'Y' , "-.--"},
                {'Z' , "--.."},
                {'0' , "-----"},
                {'1' , ".----"},
                {'2' , "..---"},
                {'3' , "...--"},
                {'4' , "....-"},
                {'5' , "....."},
                {'6' , "-...."},
                {'7' , "--..."},
                {'8' , "---.."},
                {'9' , "----."},
            };
            Dictionary<String, String> morse1 = new Dictionary<String, String>()
            {
                {".-" , "A"},
                {"-..." , "B"},
                {"-.-." , "C"},
                {"-.." , "D"},
                {"." , "E"},
                {"..-." , "F"},
                {"--." , "G"},
                {"...." , "H"},
                {".." , "I"},
                {".---" , "J"},
                {"-.-" , "K"},
                {".-.." , "L"},
                {"--" , "M"},
                {"-." , "N"},
                {"---" , "O"},
                {".--." , "P"},
                {"--.-" , "Q"},
                {".-." , "R"},
                {"..." , "S"},
                {"-" , "T"},
                {"..-" , "U"},
                {"...-" , "V"},
                {".--" , "W"},
                {"-..-" , "X"},
                {"-.--" , "Y"},
                {"--.." , "Z"},
                {"-----" , "0"},
                {".----" , "1"},
                {"..---" , "2"},
                {"...--" , "3"},
                {"....-" , "4"},
                {"....." , "5"},
                {"-...." , "6"},
                {"--..." , "7"},
                {"---.." , "8"},
                {"----." , "9"},
            };

            Console.WriteLine("Zadejte text určený pro převod:");
            String input = Console.ReadLine();
            input = input.ToUpper();

            for (int i = 0; i < input.Length; i++)
            {
                if (i > 0)
                    Console.Write('/');

                char c = input[i];
                if (morse.ContainsKey(c))
                    Console.Write(morse[c]);
            }
            for (int i = 0; i < input.Length; i++)
            {
                if (i > 0)
                    Console.Write('/');

                string c = input[i];
                if (morse1.ContainsKey(c))
                    Console.Write(morse1[c]);
            }

            Console.WriteLine();

            Console.WriteLine("Stisknutím libovolné klávesy aplikaci ukončíte...");
            Console.ReadKey(false);
        }
    }
}

Zdravím, mám tento kód, je to převod textu na Morse i obráceně.

Vše funguje, jen ten řádek "string c = input[i];" pořád hlásí error - Typ char nejde implicitně převést na typ string - jak to poladit, aby program fungoval tak, jak si představuju...?  

            for (int i = 0; i < input.Length; i++)
            {
                if (i > 0)
                    Console.Write('/');

                char c = input[i];-----------------------------------
                if (morse.ContainsKey(c))
                    Console.Write(morse[c]);
            }
            for (int i = 0; i < input.Length; i++)
            {
                if (i > 0)
                    Console.Write('/');

                string c = input[i]; --------------------------------
                if (morse1.ContainsKey(c))
                    Console.Write(morse1[c]);
            }

tohle je cast tveho kodu. Pomuze ti to?

#2 peter beru zpet, spatne jsem to pochopil
Ale, zkus se zeptat googlu? google = net convert char to string

Blbý je, že jsem relativně začátečník, spíš bych ocenil "příměnjší" pomoc.   

#4 Montezo
a co tak se naučit číst?

Připojen obrázek.

odpověď ti musí být jasná už bez otevření odkazu.

A mimochodem měl by ses nad tím kódem zamyslet, hlavně nad tím, jestli je nutné mít dva slovníky. Chybí ti selský rozum.

A mimochodem měl by ses nad tím kódem zamyslet, hlavně nad tím, jestli je nutné mít dva slovníky. Chybí ti selský rozum.

> hele, je mi jasné, že to nutné není.

Ale 

A] jak ten kód "donutit", aby to jednou převáděl zprava doleva, a podruhé zleva doprava. 

B] to máš jak s tankama. Tigery měly komplikované, drahé a na výrobu a údržbu náročné převodoky. T-34 se řadili kladivem... kdo vyhrál, víme. 

Okej, a jak ten ToString napasovat na můj problém?

#6 Montezo
string c = input[i];" pořád hlásí error - Typ char nejde implicitně převést na typ string

string c = input[i].ToString(); <= začni znova od prvních lekcí!

A Dictionary není pro tento případ vhodné, použij třeba pole [,]

B Místo aby jsi věci dělal pořádně, hledáš argumenty proč to děláš správně i když je to na prd.

začni znova od prvních lekcí!

Každej ti řekne, že suchopární šprtání teorie je k ničemu. Nutná je praxe.

#8 Montezo
No právě, musíš se našprtat jednu lekci a to co ses našprtal si vyzkoušet. Tímto způsobem se musíš naučit alespoň úplné základy. Ty ses pořád nenaučil ani cca první dvě lekce.

Navíc když ti tu někdo napíše, že to děláš blbě, tak mu to vyvracíš, místo aby ses poučil.

Snažil jsem se ti tu dát i příklad, na kterém by ses naučil pár základů a ty ses i na to v-sral. Takových příkladů jsme ti mohli dát víc, možná už by jsi uměl alespon ty základy.

Víš, kdybych se se vším matlal jak nějakej obrýlenej cifršpion, tak neni nikdy nic hotový.

A proces betatestingu & počet bugů nalezenjch až za chodu aplikace - jako Apache4j - mi dává zapravdu, že nejsem jediný.

Tak mi popiš, co kam vecpat, a já to udělám.

#10 Montezo
Víš, kdybych se se vším matlal jak nějakej obrýlenej cifršpion, tak neni nikdy nic hotový.

a ty máš něco hotové? Že ses nepochlubil.

 A proces betatestingu & počet bugů nalezenjch až za chodu aplikace - jako Apache4j - mi dává zapravdu, že nejsem jediný.

hlavně když si si našel další argument proč dělat všechno na hovno

 Tak mi popiš, co kam vecpat, a já to udělám.

a jaký to má smysl? 

a jaký to má smysl? 

> budu mít vzorovej příklad, a ten ten použiji v podobných případech.    

#12 Montezo

dobrá, napiš ten program znovu, tak že bude převádět pouze jedním směrem: A..Z,0..9 na morseovku

K řešení využij stávající Dictionary, vzorových příkladů pro vyřešení už máš na této diskuzi dost.

Až to budeš mít, tak to sem hoď.

Zde:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace MorseConverter
{
    class Program
    {
        static void Main(string[] args)
        {
            Dictionary<char, String> morse = new Dictionary<char, String>()
            {
                {'A' , ".-"},
                {'B' , "-..."},
                {'C' , "-.-."},
                {'D' , "-.."},
                {'E' , "."},
                {'F' , "..-."},
                {'G' , "--."},
                {'H' , "...."},
                {'I' , ".."},
                {'J' , ".---"},
                {'K' , "-.-"},
                {'L' , ".-.."},
                {'M' , "--"},
                {'N' , "-."},
                {'O' , "---"},
                {'P' , ".--."},
                {'Q' , "--.-"},
                {'R' , ".-."},
                {'S' , "..."},
                {'T' , "-"},
                {'U' , "..-"},
                {'V' , "...-"},
                {'W' , ".--"},
                {'X' , "-..-"},
                {'Y' , "-.--"},
                {'Z' , "--.."},
                {'0' , "-----"},
                {'1' , ".----"},
                {'2' , "..---"},
                {'3' , "...--"},
                {'4' , "....-"},
                {'5' , "....."},
                {'6' , "-...."},
                {'7' , "--..."},
                {'8' , "---.."},
                {'9' , "----."},
            };
           
            Console.WriteLine("Zadejte text určený pro převod:");
            String input = Console.ReadLine();
            input = input.ToUpper();

            for (int i = 0; i < input.Length; i++)
            {
                if (i > 0)
                    Console.Write('/');

                char c = input[i];
                if (morse.ContainsKey(c))
                    Console.Write(morse[c]);
            }

            Console.WriteLine();

            Console.WriteLine("Stisknutím libovolné klávesy aplikaci ukončíte...");
            Console.ReadKey(false);
        }
    }
}

A co s tím dál? 

trochu jsem ti to upravil, hlavně přidal TryGetValue, je to lepší: 

using System;
using System.Collections.Generic;

namespace MorseConverter
{
    class Program
    {
        static void Main(string[] args)
        {
            Dictionary<char, String> morse = new Dictionary<char, String>()
            {
                {'A' , ".-"},
                {'B' , "-..."},
                {'C' , "-.-."},
                {'D' , "-.."},
                {'E' , "."},
                {'F' , "..-."},
                {'G' , "--."},
                {'H' , "...."},
                {'I' , ".."},
                {'J' , ".---"},
                {'K' , "-.-"},
                {'L' , ".-.."},
                {'M' , "--"},
                {'N' , "-."},
                {'O' , "---"},
                {'P' , ".--."},
                {'Q' , "--.-"},
                {'R' , ".-."},
                {'S' , "..."},
                {'T' , "-"},
                {'U' , "..-"},
                {'V' , "...-"},
                {'W' , ".--"},
                {'X' , "-..-"},
                {'Y' , "-.--"},
                {'Z' , "--.."},
                {'0' , "-----"},
                {'1' , ".----"},
                {'2' , "..---"},
                {'3' , "...--"},
                {'4' , "....-"},
                {'5' , "....."},
                {'6' , "-...."},
                {'7' , "--..."},
                {'8' , "---.."},
                {'9' , "----."},
            };

            Console.WriteLine("Zadejte text určený pro převod:");
            string input = Console.ReadLine().ToUpper();

            for (int i = 0; i < input.Length; i++)
            {
                if (i > 0) Console.Write('/');
                if(morse.TryGetValue(input[i], out string str)) Console.Write(str);
            }

            Console.WriteLine();

            Console.WriteLine("Stisknutím libovolné klávesy aplikaci ukončíte...");
            Console.ReadKey(false);
        }
    }
}

teď to udělej obráceně

using System;
using System.Collections.Generic;

namespace MorseConverter
{
    class Program
    {
        static void Main(string[] args)
        {
            Dictionary<char, String> morse = new Dictionary<char, String>()
            {
                                {".-" , 'A'},
                {"-..." , 'B'},
                {"-.-." , 'C'},
                {"-.." , 'D'},
                {"." , 'E'},
                {"..-." , 'F'},
                {"--." , 'G'},
                {"...." , 'H'},
                {".." , 'I'},
                {".---" , 'J'},
                {"-.-" , 'K'},
                {".-.." , 'L'},
                {"--" , 'M'},
                {"-." , 'N'},
                {"---" , 'O'},
                {".--." , 'P'},
                {"--.-" , 'Q'},
                {".-." , 'R'},
                {"..." , 'S'},
                {"-" , 'T'},
                {"..-" , 'U'},
                {"...-" , 'V'},
                {".--" , 'W'},
                {"-..-" , 'X'},
                {"-.--" , 'Y'},
                {"--.." , 'Z'},
                {"-----" , '0'},
                {".----" , '1'},
                {"..---" , '2'},
                {"...--" , '3'},
                {"....-" , '4'},
                {"....." , '5'},
                {"-...." , '6'},
                {"--..." , '7'},
                {"---.." , '8'},
                {"----." , '9'},
            };

            Console.WriteLine("Zadejte text určený pro převod:");
            string input = Console.ReadLine().ToUpper();

            for (int i = 0; i < input.Length; i++)
            {
                if (i > 0) Console.Write('/');
                if(morse.TryGetValue(input[i], out string str)) Console.Write(str);
            }

            Console.WriteLine();

            Console.WriteLine("Stisknutím libovolné klávesy aplikaci ukončíte...");
            Console.ReadKey(false);
        }
    }
}

#17 Montezo
neříkej mi, že ti tohle vzalo VS!

(jestli jsi to nepochopil, tak převod .../---/... na SOS

neříkej mi, že ti tohle vzalo VS!

VS jsem ani nezkoušel, ale vycházel jsem z úvahy, že je to jen mezikrok. Tak, co je teda finální krok?

#19 Montezo
tak po tomhle se už na tebe asi vyseru!

mělo to být takto nějak: 

using System;
using System.Collections.Generic;

namespace MorseConverter
{
    class Program
    {
        static void Main()
        {
            Dictionary<String, String> morse = new Dictionary<String, String>()
            {
                {".-" , "A"},
                {"-..." , "B"},
                {"-.-." , "C"},
                {"-.." , "D"},
                {"." , "E"},
                {"..-." , "F"},
                {"--." , "G"},
                {"...." , "H"},
                {".." , "I"},
                {".---" , "J"},
                {"-.-" , "K"},
                {".-.." , "L"},
                {"--" , "M"},
                {"-." , "N"},
                {"---" , "O"},
                {".--." , "P"},
                {"--.-" , "Q"},
                {".-." , "R"},
                {"..." , "S"},
                {"-" , "T"},
                {"..-" , "U"},
                {"...-" , "V"},
                {".--" , "W"},
                {"-..-" , "X"},
                {"-.--" , "Y"},
                {"--.." , "Z"},
                {"-----" , "0"},
                {".----" , "1"},
                {"..---" , "2"},
                {"...--" , "3"},
                {"....-" , "4"},
                {"....." , "5"},
                {"-...." , "6"},
                {"--..." , "7"},
                {"---.." , "8"},
                {"----." , "9"}
            };


            Console.WriteLine("Zadejte text určený pro převod:");
            string input = Console.ReadLine();

            if(!string.IsNullOrEmpty(input))
            {   //rozdělí kody oddělené mezerou nebo lomítkem
                string[] words = input.Split(new char[] { ' ', '/' }, StringSplitOptions.RemoveEmptyEntries);

                foreach(string word in words)
                {
                    if (morse.TryGetValue(word, out string str)) Console.Write(str);
                    else Console.WriteLine("neplatné zadání");
                }
            }

            Console.WriteLine();

            Console.WriteLine("Stisknutím libovolné klávesy aplikaci ukončíte...");
            Console.ReadKey(false);
        }
    }
}

using System;
using System.Collections.Generic;

namespace MorseConverter
{
    class Program
    {
        static void Main()
        {
            Dictionary<String, String> morse = new Dictionary<String, String>()
            {
                {".-" , "A"},
                {"-..." , "B"},
                {"-.-." , "C"},
                {"-.." , "D"},
                {"." , "E"},
                {"..-." , "F"},
                {"--." , "G"},
                {"...." , "H"},
                {".." , "I"},
                {".---" , "J"},
                {"-.-" , "K"},
                {".-.." , "L"},
                {"--" , "M"},
                {"-." , "N"},
                {"---" , "O"},
                {".--." , "P"},
                {"--.-" , "Q"},
                {".-." , "R"},
                {"..." , "S"},
                {"-" , "T"},
                {"..-" , "U"},
                {"...-" , "V"},
                {".--" , "W"},
                {"-..-" , "X"},
                {"-.--" , "Y"},
                {"--.." , "Z"},
                {"-----" , "0"},
                {".----" , "1"},
                {"..---" , "2"},
                {"...--" , "3"},
                {"....-" , "4"},
                {"....." , "5"},
                {"-...." , "6"},
                {"--..." , "7"},
                {"---.." , "8"},
                {"----." , "9"}
            };


            Console.WriteLine("Zadejte text určený pro převod:");
            string input = Console.ReadLine();

            if (!string.IsNullOrEmpty(input))
            {   //rozdělí kody oddělené mezerou nebo lomítkem
                string[] words = input.Split(new char[] { ' ', '/' }, StringSplitOptions.RemoveEmptyEntries);

                foreach (string word in words)
                {
                    if (morse.TryGetValue(word, out string str)) Console.Write(str);
                    else Console.WriteLine("Neplatné zadání");
                }
            }

            Console.WriteLine();

            Console.WriteLine("Stisknutím libovolné klávesy aplikaci ukončíte...");
            Console.ReadKey(false);
            Dictionary<char, String> morse = new Dictionary<char, String>()
            {
                {'A' , ".-"},
                {'B' , "-..."},
                {'C' , "-.-."},
                {'D' , "-.."},
                {'E' , "."},
                {'F' , "..-."},
                {'G' , "--."},
                {'H' , "...."},
                {'I' , ".."},
                {'J' , ".---"},
                {'K' , "-.-"},
                {'L' , ".-.."},
                {'M' , "--"},
                {'N' , "-."},
                {'O' , "---"},
                {'P' , ".--."},
                {'Q' , "--.-"},
                {'R' , ".-."},
                {'S' , "..."},
                {'T' , "-"},
                {'U' , "..-"},
                {'V' , "...-"},
                {'W' , ".--"},
                {'X' , "-..-"},
                {'Y' , "-.--"},
                {'Z' , "--.."},
                {'0' , "-----"},
                {'1' , ".----"},
                {'2' , "..---"},
                {'3' , "...--"},
                {'4' , "....-"},
                {'5' , "....."},
                {'6' , "-...."},
                {'7' , "--..."},
                {'8' , "---.."},
                {'9' , "----."},
            };

            Console.WriteLine("Zadejte text určený pro převod:");
            string input = Console.ReadLine().ToUpper();

            for (int i = 0; i < input.Length; i++)
            {
                if (i > 0) Console.Write('/');
                if (morse.TryGetValue(input[i], out string str)) Console.Write(str);
            }

            Console.WriteLine();

            Console.WriteLine("Stisknutím libovolné klávesy aplikaci ukončíte...");
            Console.ReadKey(false);
        }
    }
}

Inu dobrá, zkusil jsem to "slepit", ale opět mám chyby:  https://postimg.cc/0bMv3t4f

A tady máš to řešení se zmíněným polem, aby si neřekl, že něco nakousnu.. 

using System;

namespace ConsoleApp5
{
    internal class Program
    {
        static void Main()
        {
            while(true)
            {
                Console.WriteLine("Zadejte text určený pro převod:");
                string line = Console.ReadLine();
                if (string.IsNullOrEmpty(line)) break;
                else
                {
                    Console.WriteLine();

                    if (line[0] == '.' || line[0] == '-') //detekce jestli je zadáním Morseovka
                    {
                        string[] vs = line.Split(' ', StringSplitOptions.RemoveEmptyEntries); //mezerami oddělené Mo. kody

                        for (int i = 0; i < vs.Length; i++)
                        {
                            Console.Write(Morse.DecodeMorseCode(vs[i]));
                        }
                    }
                    else //zadání není Mo., takže se bude kodovat text do Morseovky
                    {
                        for (int i = 0; i < line.Length; i++)
                        {
                            Console.Write(Morse.EncodeToMorseCode(line[i]));
                            Console.Write(" "); //oddělovač kodu
                        }
                    }

                    Console.WriteLine();
                }
            }
        }
    }

//v příkladu ignoruji, že Morseovka může obsahovat i jiné znaky
    static class Morse
    {
        #region ONLY READ
        private static readonly string[,] MorseCodes = new string[,]
            {
                {"A" , ".-"},
                {"B" , "-..."},
                {"C" , "-.-."},
                {"D" , "-.."},
                {"E" , "."},
                {"F" , "..-."},
                {"G" , "--."},
                {"H" , "...."},
                {"I" , ".."},
                {"J" , ".---"},
                {"K" , "-.-"},
                {"L" , ".-.."},
                {"M" , "--"},
                {"N" , "-."},
                {"O" , "---"},
                {"P" , ".--."},
                {"Q" , "--.-"},
                {"R" , ".-."},
                {"S" , "..."},
                {"T" , "-"},
                {"U" , "..-"},
                {"V" , "...-"},
                {"W" , ".--"},
                {"X" , "-..-"},
                {"Y" , "-.--"},
                {"Z" , "--.."},
                {"0" , "-----"},
                {"1" , ".----"},
                {"2" , "..---"},
                {"3" , "...--"},
                {"4" , "....-"},
                {"5" , "....."},
                {"6" , "-...."},
                {"7" , "--..."},
                {"8" , "---.."},
                {"9" , "----."}
            };
        #endregion
        public static string EncodeToMorseCode(char c)
        {
            var uc = char.ToUpper(c);
            int len = MorseCodes.GetLength(0);
            for (int i = 0; i < len; i++)
            {
                if (uc == MorseCodes[i, 0][0]) return MorseCodes[i, 1];
            }
            return uc.ToString();
        }

        public static string DecodeMorseCode(string m)
        {
            int len = MorseCodes.GetLength(0);
            for (int i = 0; i < len; i++)
            {
                if (m == MorseCodes[i, 1]) return MorseCodes[i, 0];
            }
            return "?";
        }
    }
}

nedělám si iluze, že ty si z toho něco vezmeš, dávám to tu pro lidi, kteří narazí na toto "vlákno"

#21 Montezo
takže ti to nic nedalo, jsem si jistý, že orangutan už by to uměl.

Skvělé, děkuji za pomoc, teď už to jen rozkuchat... 

verze s foreach:

using System;

namespace ConsoleApp5
{
    internal class Program
    {
        const char ODDELOVAC = ' '; //já píši konstanty velkými písmeny, je to zvyk z C++
        static void Main()
        {
            while(true)
            {
                Console.WriteLine("Zadejte text určený pro převod:");
                string line = Console.ReadLine();
                if (string.IsNullOrEmpty(line)) break;
                else
                {
                    Console.WriteLine();

                    if (line[0] == '.' || line[0] == '-') //detekce jestli je zadáním Morseovka
                    {
                        string[] words = line.Split(ODDELOVAC, StringSplitOptions.RemoveEmptyEntries); //mezerami oddělené Mo. kody

                        foreach (string word in words)
                        {
                            Console.Write(Morse.DecodeMorseCode(word));
                        }
                    }
                    else //zadání není Mo., takže se bude kodovat text do Morseovky
                    {
                        foreach(char c in line)
                        {
                            Console.Write(Morse.EncodeToMorseCode(c));
                            Console.Write(ODDELOVAC); //oddělovač kodu
                        }
                    }

                    Console.WriteLine();
                }
            }
        }
    }
    //mors. kody jsou z netu, neručím že jsou bez chyb
    static class Morse
    {
        #region ONLY READ
        private static readonly string[,] MorseCodes = new string[,]
            {
                {"A" , ".-"},
                {"B" , "-..."},
                {"C" , "-.-."},
                {"D" , "-.."},
                {"E" , "."},
                {"F" , "..-."},
                {"G" , "--."},
                {"H" , "...."},
                {"I" , ".."},
                {"J" , ".---"},
                {"K" , "-.-"},
                {"L" , ".-.."},
                {"M" , "--"},
                {"N" , "-."},
                {"O" , "---"},
                {"P" , ".--."},
                {"Q" , "--.-"},
                {"R" , ".-."},
                {"S" , "..."},
                {"T" , "-"},
                {"U" , "..-"},
                {"V" , "...-"},
                {"W" , ".--"},
                {"X" , "-..-"},
                {"Y" , "-.--"},
                {"Z" , "--.."},
                {"0" , "-----"},
                {"1" , ".----"},
                {"2" , "..---"},
                {"3" , "...--"},
                {"4" , "....-"},
                {"5" , "....."},
                {"6" , "-...."},
                {"7" , "--..."},
                {"8" , "---.."},
                {"9" , "----."},
                {"?", "..--.."},
                {",", "--..--"},
                {".", ".-.-.-"},
                {";", "-.-.-."},
                {"/", "-..-."},
                {"=", "-...-"},
                {"-", "-....-"},
                {"\'", ".----."},
                {"(", "-.--."},
                {")", "-.--.-"},
                {"\"", ".-..-."},
                {":", "---..."},
                {"_", "..--.-"},
                {"+", ".-.-."},
                {"@", ".--.-."}
            };
        #endregion
        public static string EncodeToMorseCode(char c)
        {
            var uc = char.ToUpper(c);
            int len = MorseCodes.GetLength(0);
            for (int i = 0; i < len; i++)
            {
                if (uc == MorseCodes[i, 0][0]) return MorseCodes[i, 1];
            }
            return uc.ToString();
        }

        public static string DecodeMorseCode(string m)
        {
            int len = MorseCodes.GetLength(0);
            for (int i = 0; i < len; i++)
            {
                if (m == MorseCodes[i, 1]) return MorseCodes[i, 0];
            }
            return "<neznámý>";
        }
    }
}

V čem je "verze s foreach" lepší? 

#26 Montezo
je to jen kratší, menší pravděpodobnost chyb při vhodnem pojmenovani

za urcitych podminek je vykonnejsi for, ale na to mas jeste cas

#20 BDS
Já tě nechápu, proč mu vůbec odepisuješ. Jak moc dobře vidíš, to co tu pošle za kody to většinou má asi odněkud poslepovaný nebo okopčený a dopsaný pár věcí. Absolutně nechápu jak někdo může bejt takovej vocas a ignorovat doslova error co mu vyjede VS či jiný IDEčko a místo toho opět tu bude 2 dny se dohadovat. Jako pokud ani doteď nebyl schopnej se řídit errorama co mu píše IDE tak to prostě nemá smysl.

Já bych mu dal radši nějakej timeout aspon na tejden vždy po novým příspěvku, protože tohle už není možný.

Jako taky jsem býval kdysi začátečník a psal jsem tu (když se zpětně podívám) chujoviny, ale většinou to skončilo 2-3 příspěvkama, kde mě lidi bud nasměrovali nebo odkázaly někam mimo, kde ten problém byl řešen. Ale tohle je doslova ztracenej případ, on se tu s tebou/ s náma bude hádat, že on to tak chce tak to prostě tak udělá, i když je to špatně namísto toho aby sklopil uši, poslechl a opravdu se to doučil. Dnes je na netu desetitisíci násobně víc examplů a na vše dokumentace, že vůbec nechápu proč se na takovýhle začátečnický věci vůbec může dovolit zeptat než aby prohledal google.

#28 Mutagen
dokud nepřijde z normálním dotazem tak na něj už seru. Jeden den se 2x zeptá jak převede char na string, vs mu přesně napíše kde je chyba a ten blbec s tím běží na diskuzi...

Je to přesně jak píšeš, on se neptá jako začátečník, ale jako idiot.

#28 Mutagen
Seš si jist, že jako IDE nepoužívá Notepad?

#30 Kit
to by ho částečně omlouvalo, ale ne, používá VS dával tu i snímek  vlastně několik.. a všechny blbě, za 3 měsíce neumí ani používat "tlačítka" tohoto fóra

"Je to přesně jak píšeš, on se neptá jako začátečník, ale jako idiot."

Odkdy je snaha o osvojení know-how idiocie?   

PS: prostě raději nahrávám screeny na externí hostingy, to je vše. Více mi to vyhovuje.   

#33 Montezo
.ejuvohyv kat ot im ežotorp ,uktápzop ijugaeR :laspan hcybydk okaJ

Ty jsi Jozef Pátrovič, programátor.

#33 Montezo
Screeny raději neposílej, jsou pro mne obtížně čitelné. Kód buď přímo sem, anebo na nějaký cloud, nejlépe s kompilátorem.

#31 BDS
K čemu je takový snímek, když si s ním kompilátor neporadí?

#36 Kit     se ptej Monteza

#34 BDS
Jo aha https://zeny.iprima.cz/csmt/legendarni-patrovic-je-zpet-cim-sokuje-v-talentove-soutezi-tentokrat

Hmm, mě blbý TV show nikdy nebraly, jméno Pátrovič vidím poprvé v životě.   

#38 Montezo
Já také pořady tohoto typy nesleduju, ale Pátroviče znám, teď už dva.

using System;    // zvolí, z jakých prvků .NET mohu čerpat.

namespace x30x12x2021   //  označuje část kódu
{
    internal class Program
    {
        static void Main()  // metoda Main nic nevrací (protože void)
        {
            while (true)
            {
                Console.WriteLine("Zadejte text určený pro převod:");
                string line = Console.ReadLine();
                if (string.IsNullOrEmpty(line)) break;  //if do stringu zadám mezeru anebo nic, program se zastaví
                else
                {
                    Console.WriteLine();

                    if (line[0] == '.' || line[0] == '-') //if do pole [line] bylo zadáno . nebo - , provede se tato část kódu
                    {
                        string[] vs = line.Split(' ', StringSplitOptions.RemoveEmptyEntries); // jako "oddělevač" pro Split slouží znak mezery

                        for (int i = 0; i < vs.Length; i++) // for situaci, kdy nastavím i na 0, i je menší než proměnná vs.Length, proměnnou i navýšám o jedna
                        {
                            Console.Write(Morse.DecodeMorseCode(vs[i]));  // NEVÍM
                        }
                    }
                    else //pokud nebyla splněna podmínka v "if" větvi - čili je na vstupu něco jiného, než . anebo -,splní se tato větev
                    {
                        for (int i = 0; i < line.Length; i++)  // for situaci, kdy nastavím i na 0, i je menší než proměnná line.Length, proměnnou i navýšám o jedna
                        {
                            Console.Write(Morse.EncodeToMorseCode(line[i]));   // NEVÍM
                            Console.Write(" "); //oddělovač kódu
                        }
                    }

                    Console.WriteLine();
                }
            }
        }
    }

    static class Morse
    {
        #region ONLY READ
        private static readonly string[,] MorseCodes = new string[,]
            {
                {"A" , ".-"},
                {"B" , "-..."},
                {"C" , "-.-."},
                {"D" , "-.."},
                {"E" , "."},
                {"F" , "..-."},
                {"G" , "--."},
                {"H" , "...."},
                {"I" , ".."},
                {"J" , ".---"},
                {"K" , "-.-"},
                {"L" , ".-.."},
                {"M" , "--"},
                {"N" , "-."},
                {"O" , "---"},
                {"P" , ".--."},
                {"Q" , "--.-"},
                {"R" , ".-."},
                {"S" , "..."},
                {"T" , "-"},
                {"U" , "..-"},
                {"V" , "...-"},
                {"W" , ".--"},
                {"X" , "-..-"},
                {"Y" , "-.--"},
                {"Z" , "--.."},
                {"0" , "-----"},
                {"1" , ".----"},
                {"2" , "..---"},
                {"3" , "...--"},
                {"4" , "....-"},
                {"5" , "....."},
                {"6" , "-...."},
                {"7" , "--..."},
                {"8" , "---.."},
                {"9" , "----."}
            };
        #endregion
        public static string EncodeToMorseCode(char c)
        {
            var uc = char.ToUpper(c);
            int len = MorseCodes.GetLength(0);
            for (int i = 0; i < len; i++)
            {
                if (uc == MorseCodes[i, 0][0]) return MorseCodes[i, 1];
            }
            return uc.ToString();
        }

        public static string DecodeMorseCode(string m)
        {
            int len = MorseCodes.GetLength(0);
            for (int i = 0; i < len; i++)
            {
                if (m == MorseCodes[i, 1]) return MorseCodes[i, 0];
            }
            return "?";
        }
    }
}

Když si teda ten kód rozebereme:

A] tu vs.Length vezmu kde?

B] "Console.Write(Morse.DecodeMorseCode(vs[i])); " je definována na konci programu. To je asi ten "vnořený cyklus" jak tu byl zmíněn, že?

C] kde vezmu proměnnou "line.Length"?

D] ta "Console.Write(Morse.EncodeToMorseCode(line[i]));" je definována na konci programu. To je asi ten "vnořený cyklus" jak tu byl zmíněn, že?

E] "private static readonly string[,] MorseCodes = new string[,]" tohle znamená co přesně?

PS: může být více namespace v jednom kódu? A pokud ano, k čemu je to pak vlastně dobré?

#40 Montezo 

using System;    // zvolí, z jakých prvků .NET mohu čerpat.

namespace x30x12x2021   //  označuje část kódu
{
    internal class Program
    {
        static void Main()  // metoda Main nic nevrací (protože void)
        {
            while (true) //nekonečná smyčka
            {
                Console.WriteLine("Zadejte text určený pro převod:");
                string line = Console.ReadLine();
                if (string.IsNullOrEmpty(line)) break;  //pokud je line prázdný, nebo null, tak se smyčka while ukončí
                else
                {
                    Console.WriteLine();

                    if (line[0] == '.' || line[0] == '-') //if do pole [line] bylo zadáno . nebo - , provede se tato část kódu
                    {
                        string[] vs = line.Split(' ', StringSplitOptions.RemoveEmptyEntries); // jako "oddělevač" pro Split slouží znak mezery

                        for (int i = 0; i < vs.Length; i++) // for situaci, kdy nastavím i na 0, i je menší než proměnná vs.Length, proměnnou i navýšám o jedna
                        {
                            Console.Write(Morse.DecodeMorseCode(vs[i]));  // zavolá metodu třídy Morse DecodeMorseCode a parametrem ji předá např ---
                        }
                    }
                    else //pokud nebyla splněna podmínka v "if" větvi - čili je na vstupu něco jiného, než . anebo -,splní se tato větev
                    {
                        for (int i = 0; i < line.Length; i++)  // for situaci, kdy nastavím i na 0, i je menší než proměnná line.Length, proměnnou i navýšám o jedna
                        {
                            Console.Write(Morse.EncodeToMorseCode(line[i]));   // zavolá metodu třídy Morse EncodeToMorseCode a parametrem ji předá znak stringu line
                            Console.Write(" "); //oddělovač kódu
                        }
                    }

                    Console.WriteLine();
                }
            }
        }
    }
    
    //A] Je to vlastnost každého pole (v C#)
    //B] viz. komenář
    //C] viz. A
    //D] viz. komenář
    //E] je definováno 2D pole stringů, které je neviditelné zvenčí, statické a pouze pro čtení (více: nastuduj modifikátory)

    static class Morse
    {
        #region ONLY READ
        private static readonly string[,] MorseCodes = new string[,]
            {
                {"A" , ".-"},
                {"B" , "-..."},
                {"C" , "-.-."},
                {"D" , "-.."},
                {"E" , "."},
                {"F" , "..-."},
                {"G" , "--."},
                {"H" , "...."},
                {"I" , ".."},
                {"J" , ".---"},
                {"K" , "-.-"},
                {"L" , ".-.."},
                {"M" , "--"},
                {"N" , "-."},
                {"O" , "---"},
                {"P" , ".--."},
                {"Q" , "--.-"},
                {"R" , ".-."},
                {"S" , "..."},
                {"T" , "-"},
                {"U" , "..-"},
                {"V" , "...-"},
                {"W" , ".--"},
                {"X" , "-..-"},
                {"Y" , "-.--"},
                {"Z" , "--.."},
                {"0" , "-----"},
                {"1" , ".----"},
                {"2" , "..---"},
                {"3" , "...--"},
                {"4" , "....-"},
                {"5" , "....."},
                {"6" , "-...."},
                {"7" , "--..."},
                {"8" , "---.."},
                {"9" , "----."}
            };
        #endregion
        public static string EncodeToMorseCode(char c)
        {
            var uc = char.ToUpper(c);
            int len = MorseCodes.GetLength(0);
            for (int i = 0; i < len; i++)
            {
                if (uc == MorseCodes[i, 0][0]) return MorseCodes[i, 1];
            }
            return uc.ToString();
        }

        public static string DecodeMorseCode(string m)
        {
            int len = MorseCodes.GetLength(0);
            for (int i = 0; i < len; i++)
            {
                if (m == MorseCodes[i, 1]) return MorseCodes[i, 0];
            }
            return "?";
        }
    }
}

může být více namespace v jednom kódu? A pokud ano, k čemu je to pak vlastně dobré?

Může, je to oddělení kódu, například můžeš definovat třídu se stejným názvem, odlišnými vlastnostmi v různých namespace. Více: studium namespace - jmenných prostorů.

Namespace se pouzivalo kdysi u funkcionalniho programovani.
Dneska se to resi spis pres objektove programovani pomoci trid.

#43 peter
Namespace se v hojné míře používá i v objektovém programování.

#7 BDS
Ahoj, můžu se zeptat, proč není slovník vhodný? Měl by to být přímo ukázkový příklad - hodnota  A odpovídá klíči X... Jsem začátečník, tak se možná ptam blbě...

#45 Karloscz
Protože, slovník má pouze metodu TryGetValue, nemá TryGetKey.
Slovník je vhodný pro jednosměrné získání (např. znak->kód) , naopak s tím polem stringů (případně by to šlo ještě lépe s nějakým jiným objektem obsahující znak a kód v nějaké kolekci, nebo poli). To pole stringů jsem zvolil, proto aby to bylo pro začátečníka pochopitelné.

#45 Karloscz
Slovník je vhodný.

#47 Kit
Tak ukaž, jak šikovně na tu konverzi s jedním slovníkem tam a zpět.

Vytvoris 2 promenne typu slovnik? Treba jen chtel rici, ze by take pouzil slovnik. Jenom jinak, nezapisoval by do nej obe konverze.

Montezo promin ale od takovych to zacatku.... je server naucim.cz ale tam si to uz hold zaplatis, proste si zaplatis ucitele ktery se ti bude venovat nejakou tu hodku venovat aby jsi pochopil vse na co se tady ptas.