C#-Code

static void Main(string[] args)
        {
            int c = 1;

            // Die gesuchte Zahl
            int input = 10; 
            for (int i = 0; i < 20; i++)
            {
                int y = 0;
                int x = i;
                while (x >= 0)
                {
                    if (c == input)
                    {
                        Console.WriteLine("Gesuchte Zeile:" + (y+1) + "Gesuchte Spalte:" + (x+1));
                    }
                    c++;
                    x--;
                    y++;
                }

            }

            
        }

C#-Code

using System;
using System.Collections.Generic;
using System.Windows; //WindowBase.dll

namespace TYP199 {
  class Program {
    static void Main() {
      int n = 8;
      int[,] a = {
        { 1, 2, 4 },
        { 3, 5, 8 },
      };

      Point? point = Find(n, a);
      Console.Write($"N = {n} -> ZN = {point?.X}, SN = {point?.Y}");
      Console.ReadKey(true);
    }

    static Point? Find<T>(T needle, T[,] heystack) {
      for(int i = 0; i < heystack.GetLength(0); i++) {
        for(int ii = 0; ii < heystack.GetLength(1); ii++) {
          if(EqualityComparer<T>.Default.Equals(heystack[i, ii], needle)) {
            return new Point(i, ii);
          }
        }
      }

      return null;
    }
  }
}

C#-Code

using System;

namespace ConsoleFindIndex2DArray
{
    static class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("----- Ermittlung von Zeilen- und Spaltennummer eines unendlich 2D-Array-Feldes im Diagonal-Schema------");
            do
            {
                Console.Write("Geben Sie eine Zahl größer als 0 ein: ");
                ulong l;
                if (ulong.TryParse(Console.ReadLine(), out l) && l > 0)
                {
                    ulong row, column;
                    FindIndexInDiagonalSchema(l, out row, out column);
                    Console.WriteLine($"Zeile: {row}\tSpalte: {column}");
                }

            } while (true);
        }

        static void FindIndexInDiagonalSchema(ulong l, out ulong row, out ulong column)
        {
            double d = Math.Truncate((-0.5 + Math.Sqrt(0.25 + 2 * l)));
            ulong step = (ulong)d + 1;
            ulong v = (step * step + step) / 2;//Gausssche Summenformel
            while (v <= l)
            {
                v += ++step;
            }

            ulong dif = l - (v - step + 1);
            row = dif;
            column = step - (dif + 1);
        }
    }
}

C#-Code

using System;
using static System.Console;

/*  
Ermittlung von Zeilen- und Spaltennummer eines Array-Feldes

Die Felder eines 2D-Arrays seien nach folgendem "Diagonal-Schema" nummeriert:

 1 2 4 7 . . .
 3 5 8 . . . .
 6 9 . . . . .
10 . . . . . .
 . . . . . . usw.

Man schreibe ein Programm, das für eine gegebene Feldnummer N die Zeilen- (ZN) 
und die Spaltennummer (SN) zurückgibt. Zeilen- und Spaltennummerierungen 
beginnen wie üblich mit 0.

Beispiele: N =  8 -> ZN = 1, SN = 2
           N = 31 -> ZN = 2, SN = 5 
*/

class MAIN    {
    static void Main()    {
        uint N = 0;
        bool bo_exit = false;

        WriteLine(give_1_numbers(100));

        while (!bo_exit)    {
            bool bo_input_ok = false;
            while (!bo_input_ok)    {
                Write("give me N (> 0): ");
                bo_input_ok = uint.TryParse(ReadLine(), out N) && (N > 0);
            }

            Algorith alg = new Algorith(N);
            WriteLine($"N = {N,2} -> ZN = {alg.ZN}, SN = {alg.SN}");

            InversAlgorith inv_alg = new InversAlgorith(alg.ZN, alg.SN);
            WriteLine($"ZN = {alg.ZN}, SN = {alg.SN} -> N = {inv_alg.N}");

            WriteLine("press any key (exit ESC)");
            bo_exit = ReadKey(true).Key == ConsoleKey.Escape;
        }
    }

    class Algorith    {
        public uint ZN, SN;
        public Algorith(uint N) {
            uint s = 0, value = 1;
            while (value <= N)
                value += s++;
            this.ZN = N - value + s - 1;
            this.SN = s - 2 - this.ZN;
        }
    }

    class InversAlgorith    {
        public uint N;
        public InversAlgorith(uint ZN, uint SN) {
            uint s = 0, value = 1;
            while(s <= SN + ZN)
                value += s++;
            this.N = value + ZN;
        }
    }

    static string give_1_numbers(uint bis)    {
        System.Text.StringBuilder sb = new System.Text.StringBuilder();
        sb.AppendLine("numbers of diagonal elements");
        for (uint i = 0; i < bis; i++)        {
            if (i > 0 && i % 10 == 0)
                sb.AppendLine();
            InversAlgorith ia = new InversAlgorith(i, i);
            sb.Append($"{ia.N.ToString("n0"), 10}");            
        }
        return sb.ToString();
    }
}

C#-Code

namespace Csharp_199_2DArray
{
    using System;

    public class Program
    {
        static void Main(string[] args)
        {
            string inputString;
            // loop to enter and check several numbers in a row
            do
            {
                Console.Write("Enter integer number or 'Q' to quit: ");
                inputString = Console.ReadLine();
                if(int.TryParse(inputString,out int inputNumber))
                {
                    CalculateArrayIndexes(inputNumber, out int resultColumn, out int resultRow);
                    Console.WriteLine($"Number={inputNumber}  -> Result: Column={resultColumn} Row={resultRow}");
                }
            } while (inputString.ToLower() != "q");
        }

        static void CalculateArrayIndexes(int inputNumber, out int resultColumn, out int resultRow)
        {
            resultColumn = 0;
            resultRow = 0;

            // value to be added when stepping from one diagonal to the next one
            var addValue = 1;
            // first and last value in a diagonal
            var firstValueOfDiagonal = 1;
            var lastValueOfDiagonal = 1;

            var continueSearch = true;
            while (continueSearch)
            {
                // check if given number is on this diagonal
                if (  inputNumber >= firstValueOfDiagonal 
                    && inputNumber <= lastValueOfDiagonal)
                {
                    // calculate the index values and terminate loop
                    resultColumn = lastValueOfDiagonal - inputNumber;
                    resultRow = inputNumber - firstValueOfDiagonal;
                    continueSearch = false;
                }
                else
                {
                    // step to next diagonal
                    firstValueOfDiagonal += addValue;
                    lastValueOfDiagonal += addValue + 1;
                    addValue++;
                }
            }
        }
    }
}