using System;

using System.Collections.Generic;

using System.Globalization;

using System.Text;

​

public class Program

{

    public static void Main()

    {

        Program p = new Program();

        bool result = p.AreAnagrams("mamanp","namamg");

        Console.WriteLine(result);

        Program algo1 = new Program();

​

        bool resultStringReversed = algo1.IsPalindromeReworked("bonjour");

        //bool result = algo.IsPalindrome("kayak");

​

​

        //Program algo2 = new Program("hey", "bonjour");

        Program algo2 = new Program();

​

        string resultMerging = algo2.MergingStringReworked("tendrement", "alerte");

        //string resultMerging = algo2.MergingString();

​

​

        //Program algo3 = new ProgramProgram("gksrek", "geeksforgeeks");

        //Program algo3 = new Program("AXY", "YADXCP");

        Program algo3 = new Program();

​

        bool resultSubSequence = algo3.SubSequence("hlba", "BlahBlahBlah");

​

​

​

        Program algo4 = new Program();

​

        string resultTabIntersection = algo4.IntersectionTable([7, 2, 6, 2, 3, 4, 8, 9, 1, 2, 5, 6], [6, 7, 8, 4, 5, 8, 2, 1, 7, 6, 9]);

​

        //Program algo5 = new Program([7, 1, 5, 3, 6, 4]);

        //Program algo5 = new Program([7, 6, 4, 3, 1]);

        Program algo5 = new Program();

​

        string resultMaxProfit = algo5.ProfitMax([2, 6, 9, 3, 8]);

​

        Console.WriteLine(resultStringReversed);

​

        Console.WriteLine(resultMerging);

​

        Console.WriteLine(resultSubSequence);

​

        Console.WriteLine(resultTabIntersection);

​

        Console.WriteLine(resultMaxProfit);

    }

    //ALGO 1

      public bool IsPalindromeReworked(string str)

    {

        string stringReversed = string.Empty;

        char[] chars = str.ToCharArray();

        for (int i = str.Length - 1; i>=0;  i--)

        {

            stringReversed += chars[i];

        }

        if (str == stringReversed)

        {

            return true;

        }

        return false;

    }

        //ALGO 2

     public string MergingStringReworked(string str1, string str2)

    {

        str1 = str1.ToLowerInvariant().Replace(" ", "");

        str2 = str2.ToLowerInvariant().Replace(" ", "");

​

        var sb = new StringBuilder();

        int IndexJ = 0;

        for (int i = 0; i < str1.Length; i++)

        {

            sb.Append(str1[i]);

            if (i < str2.Length)

            {

                sb.Append(str2[IndexJ]);

                IndexJ++;

            }

        }

        if (str1.Length > str2.Length)

        {

            for (int i = IndexJ; i <str2.Length; i++)

            {

                sb.Append(str1[i]);

            }

        }

        else if (str2.Length > str1.Length)

        {

            for (int i = IndexJ; i < str2.Length; i++)

            {

​

                sb.Append(str2[i]);

            }

        }

        return sb.ToString();

    }

        //ALGO 3

    public bool SubSequence(string str1, string str2)

    {

        str1 = str1.ToLowerInvariant().Replace(" ", "");

        str2 = str2.ToLowerInvariant().Replace(" ", "");

​

        if (string.IsNullOrEmpty(str1) || string.IsNullOrEmpty(str2))

        {

            return false;

        }

​

        int i = 0;

        foreach (char c2 in str2)

        {

            if (i < str1.Length && c2 == str1[i])

            {

                i++;

            }

        }

        if (i == str1.Length)

        {

            return true;

        }

​

        return false;

​

    }

​

    //ALGO 4

    public string IntersectionTable(int[] intTab1, int[] intTab2)

    {

        if (intTab1 == null || intTab2 == null)

        {

            throw new ArgumentNullException( "L'un des tableaux est null");

        }

        HashSet<int> ints = [.. intTab1];

        HashSet<int> intTabFinal = new HashSet<int>();

        foreach (var j in intTab2)

        {

            if (ints.Contains(j))

            {

                intTabFinal.Add(j);

            }

        }

        return "[" + string.Join(", ", intTabFinal) + "]";;

    }

​

        //ALGO 5

    int maxProfit = 0;

​

    public string ProfitMax(int[] prices)

    {

​

        int buying = prices[0];

        for (int i = 1; i < prices.Length; i++)

        {

            int selling = prices[i];

            int potentialProfit = selling - buying;

​

            if (potentialProfit > maxProfit)

            {

                maxProfit = potentialProfit;

            }

​

            if (selling < buying && i < prices.Length - 1)

            {

                buying = selling;

            }

        }

        return maxProfit.ToString();

    }

    //------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

    private bool AreAnagrams(string str1, string str2)

    {

        if(str1.Length != str2.Length)

        {

            return false; 

        }

        Dictionary<char,int> dict = new Dictionary<char, int>(); 

        Dictionary<char,int> dict2 = new Dictionary<char,int>();

        //Je parcours chaque caractère dans mon string que je vais ensuite ajouter à mon dictionaire et incrémenter la valeur associée à l'index de la lettre correspondante si jamais pour cet index on a déjà une valeur > 0.

        foreach(char c in str1)

        {

            if(dict.ContainsKey(c))

            {

                dict[c]++;

            }

            else {dict[c] = 1;} 

        }

        foreach(char c in str2)

        {

            if(dict2.ContainsKey(c))

            {

                dict2[c]++;

            }

            else {dict2[c] = 1;}

        }

        // Je compare mes deux dictionaires; si pour chaque Key Value Pair de dict, je n'ai pas dans dict2 la même clé (ex S et M pour l'index 2) et la même valeur (Ex S = 2 et S = 1). 

        // Alors je retourne un false car notre mot n'est pas un anagramme de l'autre, sinon je renvoie true si toutes les itérations ne renvoie pas false.

        foreach (var keyValuePair in dict)

        {

            if(!dict2.ContainsKey(keyValuePair.Key) || !dict2.ContainsValue(keyValuePair.Value))

            {

                return false;

            }   

        }

        //Je m'assure que les deux dictionnaires soient identiques + erreur du return true qui est en dehors du loop 

        foreach (var keyValuePair in dict2)

        {

            if(!dict.ContainsKey(keyValuePair.Key) || !dict.ContainsValue(keyValuePair.Value))

            {

                return false;

            }   

        }

        return true;

    }   

}