C# Online Compiler | .NET Fiddle

<no name> by Anonymous

using System;
using System.Collections.Generic;

namespace ConsoleApp1
{
    public class Program
    {
        public static void Main(string[] args)
        {
            string[] strArray = new string[]{"a","b","c"};
    	//	var result = Array.Equals<string>(strArray, s=> s.);
			//Array.Resize<string>(ref strArray,strArray.Length+1);
			//strArray.SetValue("d",strArray.Length-1);
			//Array.ForEach<string>(strArray, s=> {
			//Console.WriteLine(s);
			//});
			
			
			#region delete any value in array O(n^2) OR O(n)
				bool weFounded= false;
			
				for(var i=0; i< strArray.Length; i++){
				if(strArray[i]== "b"){
					strArray[i]= null;		
					weFounded = true;
				}
				else{
					
					if(weFounded){
					strArray[i-1] = strArray[i];
					strArray[i] = null;
				}}	
				}
			
			Array.ForEach<string>(strArray, s=> {
			Console.WriteLine(s);
			});

			Array.Resize<string>(ref strArray, strArray.Length -1);
			Console.WriteLine(strArray.Length);
				//O(n^2) OR O(N)
			#endregion
				
		
				
			#region pop
			//strArray[strArray.Length-1] = null;
			//Array.Resize<string>(ref strArray, strArray.Length-1);
			//Array.ForEach<string>(strArray, s=> {
			//Console.WriteLine(s);
			//});

			//Console.WriteLine(strArray.Length);
			#endregion
			//delete
			
		//	string[] staticArray = new string[5]{"a","b","c","d","d"};
		//	Array.Resize<string>(ref staticArray, staticArray.Length+1);
		//	staticArray[staticArray.Length-1] = "e";
		//	Array.ForEach<string>(staticArray, s=> {
		//	Console.WriteLine(s);
		//	});
			
		//	var deletedValue = "b";
		//	var deletedIndexoF =  Array.IndexOf(strArray, deletedValue);
		//	var ff=  Array.FindAll<string>(strArray, s=> { return s!=deletedValue;});
			
		//	Array.
			// BIGO(3); => (1)
			// Speed : (3)
			//Array.ForEach<string>(ff, s=> {
			//Console.WriteLine(s);
			//});
        }

        /*
         * Assume T[r] >= T[i], that we will denote as b and a respectively
         * We want to have |a + b - k| <= 2
         * 
         * We will iterate the loop either by the end (r--) decreasing the sum
         * or the begininng (i++), which will increase the sum since T is sorted
         * depending on the value of : |T[i] + T[r] - k| <= 2
         * Which will let us keep the O(n) complexity as explained below.
         * 
         * To keep an O(n) complexity, we need to have in a worst case scenario n loop access.
         * So, imagine that we are given T[] = {1,2,3,4,5}
         * We initiate i = 0 and r = T.Count - 1
         * 
         * If a <= k(5) <= b:
         * 
         *      1 2 3 4 5 
         *      i       r   => |1 + 5 - 2| = 4 <= 2 *=>* False *=>* 4 is > 2 *=>* decrease the sum since (b > k and a <= k + 2)
         *      i     r     => |1 + 4 - 2| = 3 <= 2 *=>* False *=>* 3 is > 2 *=>* decrease the sum since (b > k and a <= k + 2)
         *      i   r       => |1 + 3 - 2| = 2 <= 2 *=>* True  *=>* 2 <= 2   *=>* stop
         *
         * If a <= b <= k(10)
         * 
         *      1 2 3 4 5 
         *      i       r   => |1 + 5 - 10| = 4 <= 2 *=>* False *=>* increase the sum since (b < k and a <= k + 2)
         *        i     r   => |2 + 5 - 10| = 3 <= 2 *=>* False *=>* increase the sum since (b < k and a <= k + 2)
         *          i   r   => |3 + 5 - 10| = 2 <= 2 *=>* True *=>* stop
         *      
         * If k(1) <= a <= b and T[] = {5,6,7,8}
         * 
         *      5 6 7 8  
         *      i     r    => |5 + 8 - 1| = 12 <= 2 *=>* False *=>* decrease the sum since (b > k and a > k + 2)
         *      i   r      => |5 + 7 - 1| = 11 <= 2 *=>* False *=>* increase the sum since (b > k and a > k + 2)
         *      i r        => |5 + 6 - 1| = 10 <= 2 *=>* False *=>* decrease the sum since (b > k and a > k + 2)
         *      ir         => |5 + 5 - 1| = 9  <= 2 *=>* False *=>* Nothing to do anymore
         *   
         * The algorithm explains itself via the function "Question2Explained" below.
        */
        static bool Question2Explained(List<int> T, int k)
        {
            int i = 0;
            int r = T.Count - 1;

            while (i <= r)
            {
                //Test directly at beginning
                bool result = Math.Abs(T[i] + T[r] - k) <= 2;
                Console.WriteLine("| " + T[i] + " + " + T[r] + " - " + k + " | = " + (T[i] + T[r] - k) + " <= 2 ? " + result);
                if (result)
                    return true;

                //Test failed, do we increase i or decrease r?

                //If true, it means that T[i] could be potentially good, but T[r] is too small or too big 
                if (T[i] <= k + 2)
                {
                    //T[r] is too big, we need to reduce the sum
                    if (T[r] >= k)
                    {
                        Console.WriteLine("T[r] (" + T[r] + ") is too large, we must decrease the sum. (r--)");
                        r--;
                    }
                    //T[i] AND T[r] are too small, so we must pump those numbers up by increasing i
                    else
                    {
                        Console.WriteLine("T[i] (" + T[i] + ") is too small, we must increase the sum (i++)");
                        i++;
                    }
                }
                //T[i] is bigger than k (so is T[r]), so we must decrease the sum by decreasing r 
                else
                {
                    Console.WriteLine("T[i] AND T[r] are larger than k, we must decrease r");
                    r--;
                }
            }
            return false;
        }

        static bool Question2Pure(List<int> T, int k)
        {
            int i = 0;
            int r = T.Count - 1;

            while (i <= r)
            {
                if (Math.Abs(T[i] + T[r] - k) <= 2) return true;
                if (T[i] <= k + 2)
                {
                    if (T[r] >= k)
                        r--;
                    else
                        i++;
                }
                else
                    r--;
            }
            return false;
        }
    }
}

​x
 
using System;
using System.Collections.Generic;
​
namespace ConsoleApp1
{
    public class Program
    {
        public static void Main(string[] args)
        {
            string[] strArray = new string[]{"a","b","c"};
        //  var result = Array.Equals<string>(strArray, s=> s.);
            //Array.Resize<string>(ref strArray,strArray.Length+1);
            //strArray.SetValue("d",strArray.Length-1);
            //Array.ForEach<string>(strArray, s=> {
            //Console.WriteLine(s);
            //});
            
            
            #region delete any value in array O(n^2) OR O(n)
                bool weFounded= false;
            
                for(var i=0; i< strArray.Length; i++){
                if(strArray[i]== "b"){
                    strArray[i]= null;      
                    weFounded = true;
                }
                else{
                    
                    if(weFounded){
                    strArray[i-1] = strArray[i];
                    strArray[i] = null;
                }}  
                }
            
            Array.ForEach<string>(strArray, s=> {
            Console.WriteLine(s);
            });
​
            Array.Resize<string>(ref strArray, strArray.Length -1);
            Console.WriteLine(strArray.Length);
                //O(n^2) OR O(N)
            #endregion
                
        
                
            #region pop
            //strArray[strArray.Length-1] = null;
            //Array.Resize<string>(ref strArray, strArray.Length-1);
            //Array.ForEach<string>(strArray, s=> {
            //Console.WriteLine(s);
            //});
​
            //Console.WriteLine(strArray.Length);
            #endregion
            //delete
            
        //  string[] staticArray = new string[5]{"a","b","c","d","d"};
        //  Array.Resize<string>(ref staticArray, staticArray.Length+1);
        //  staticArray[staticArray.Length-1] = "e";
        //  Array.ForEach<string>(staticArray, s=> {
        //  Console.WriteLine(s);
        //  });
            
        //  var deletedValue = "b";
        //  var deletedIndexoF =  Array.IndexOf(strArray, deletedValue);
        //  var ff=  Array.FindAll<string>(strArray, s=> { return s!=deletedValue;});
            
        //  Array.
            // BIGO(3); => (1)
            // Speed : (3)
            //Array.ForEach<string>(ff, s=> {
            //Console.WriteLine(s);
            //});
        }
​
        /*
         * Assume T[r] >= T[i], that we will denote as b and a respectively
         * We want to have |a + b - k| <= 2
         * 
         * We will iterate the loop either by the end (r--) decreasing the sum
         * or the begininng (i++), which will increase the sum since T is sorted
         * depending on the value of : |T[i] + T[r] - k| <= 2
         * Which will let us keep the O(n) complexity as explained below.
         * 
         * To keep an O(n) complexity, we need to have in a worst case scenario n loop access.
         * So, imagine that we are given T[] = {1,2,3,4,5}
         * We initiate i = 0 and r = T.Count - 1
         * 
         * If a <= k(5) <= b:
         * 
         *      1 2 3 4 5 
         *      i       r   => |1 + 5 - 2| = 4 <= 2 *=>* False *=>* 4 is > 2 *=>* decrease the sum since (b > k and a <= k + 2)
         *      i     r     => |1 + 4 - 2| = 3 <= 2 *=>* False *=>* 3 is > 2 *=>* decrease the sum since (b > k and a <= k + 2)
         *      i   r       => |1 + 3 - 2| = 2 <= 2 *=>* True  *=>* 2 <= 2   *=>* stop
         *
         * If a <= b <= k(10)
         * 
         *      1 2 3 4 5 
         *      i       r   => |1 + 5 - 10| = 4 <= 2 *=>* False *=>* increase the sum since (b < k and a <= k + 2)
         *        i     r   => |2 + 5 - 10| = 3 <= 2 *=>* False *=>* increase the sum since (b < k and a <= k + 2)
         *          i   r   => |3 + 5 - 10| = 2 <= 2 *=>* True *=>* stop
         *      
         * If k(1) <= a <= b and T[] = {5,6,7,8}
         * 
         *      5 6 7 8  
         *      i     r    => |5 + 8 - 1| = 12 <= 2 *=>* False *=>* decrease the sum since (b > k and a > k + 2)
         *      i   r      => |5 + 7 - 1| = 11 <= 2 *=>* False *=>* increase the sum since (b > k and a > k + 2)
         *      i r        => |5 + 6 - 1| = 10 <= 2 *=>* False *=>* decrease the sum since (b > k and a > k + 2)
         *      ir         => |5 + 5 - 1| = 9  <= 2 *=>* False *=>* Nothing to do anymore
         *   
         * The algorithm explains itself via the function "Question2Explained" below.
        */
        static bool Question2Explained(List<int> T, int k)
        {
            int i = 0;
            int r = T.Count - 1;
​
            while (i <= r)
            {
                //Test directly at beginning
                bool result = Math.Abs(T[i] + T[r] - k) <= 2;
                Console.WriteLine("| " + T[i] + " + " + T[r] + " - " + k + " | = " + (T[i] + T[r] - k) + " <= 2 ? " + result);
                if (result)
                    return true;
​
                //Test failed, do we increase i or decrease r?
​
                //If true, it means that T[i] could be potentially good, but T[r] is too small or too big 
                if (T[i] <= k + 2)
                {
                    //T[r] is too big, we need to reduce the sum
                    if (T[r] >= k)
                    {
                        Console.WriteLine("T[r] (" + T[r] + ") is too large, we must decrease the sum. (r--)");
                        r--;
                    }
                    //T[i] AND T[r] are too small, so we must pump those numbers up by increasing i
                    else
                    {
                        Console.WriteLine("T[i] (" + T[i] + ") is too small, we must increase the sum (i++)");
                        i++;
                    }
                }
                //T[i] is bigger than k (so is T[r]), so we must decrease the sum by decreasing r 
                else
                {
                    Console.WriteLine("T[i] AND T[r] are larger than k, we must decrease r");
                    r--;
                }
            }
            return false;
        }
​
        static bool Question2Pure(List<int> T, int k)
        {
            int i = 0;
            int r = T.Count - 1;
​
            while (i <= r)
            {
                if (Math.Abs(T[i] + T[r] - k) <= 2) return true;
                if (T[i] <= k + 2)
                {
                    if (T[r] >= k)
                        r--;
                    else
                        i++;
                }
                else
                    r--;
            }
            return false;
        }
    }
}
​

View IL Code