public Input(string number, string number2, int Num_base)
{
ausgabe = "Aufgabe: " + number + " + " + number2 + " -- (" + Num_base + ")";
this.number = Helfer.removeChar(number);
this.number2 = Helfer.removeChar(number2);
this.Num_base = Num_base;
}
public InOut(int n, int duplicate, int duplicates) : base(Convert(n, duplicate, duplicates), duplicate, true)
{
inputStringConverter = arg => Helfer.Arrayausgabe("Eingabe: ", arg, true);
outputStringConverter = arg => "Duplikat: " + arg + " x " + duplicates;
AddSolver(Array_Solver_ConstantSpace);
}
public Revers_A_String()
{
testcases.Add(new InOut("Wetter", "retteW"));
string s = Helfer.RandomString(int.MaxValue / 128, true);
testcases.Add(new InOut(s, StackSolvessssssssssssssssssssssssss(s, true)));
}
public static string ConvertToSring(string[][] sarr)
{
string s = Helfer.Arrayausgabe <string>("Added Words: ", sarr[0]) + "\n";
s += Helfer.Arrayausgabe <string>("Search Words: ", sarr[1]);
return(s);
}
public InOut(string n, int duplicate) : base(Helfer.Assemble(n), duplicate, true)
{
inputStringConverter = arg => Helfer.Arrayausgabe("Eingabe: ", arg, true);
outputStringConverter = arg => "Duplikat: " + arg;
AddSolver(Array_Solver_ConstantSpace);
}
public InOut(string s, string bools) : base(Convert(s), Helfer.AssembleBool(bools))
{
outputStringConverter = arg => Helfer.Arrayausgabe <bool>("Erwartet: ", arg);
ergStringConverter = arg => Helfer.Arrayausgabe <bool>("Searches: ", arg);
inputStringConverter = ConvertToSring;
CompareOutErg = Helfer.ArrayVergleich <bool>;
AddSolver(TrieSolver);
}
public InOut(string s, string s2, int len = 16) : base(new Input(s, len), s2.Split(','), true)
{
outputStringConverter = arg => Helfer.Arrayausgabe("Erwartet: \n", arg, false, "\n ");
ergStringConverter = arg => Helfer.Arrayausgabe("Ausgabe: \n", arg, false, "\n ");
CompareOutErg = Helfer.ArrayVergleich;
AddSolver(Solve);
HasMaxDur = false;
}
public InOut(int i, string s) : base(i, Helfer.Assemble2Dim(s), true)
{
outputStringConverter = arg => Helfer._2Dim_Arrayausgabe("Erwartet: ", arg);
ergStringConverter = arg => Helfer._2Dim_Arrayausgabe("Ausgabe: ", arg);
CompareOutErg = Helfer._2Dim_ArrayVergleich;
AddSolver(Solve);
}
public InOut(string s, string s2) : base(Helfer.Matrix <char> .GetCharMatrix(s, ","), GenerateArr(s2), true)
{
outputStringConverter = arg => Helfer.Arrayausgabe <Point>("Erwartet: ", arg);
ergStringConverter = arg => Helfer.Arrayausgabe <Point>("Ausgabe: ", arg);
CompareOutErg = Helfer.ArrayVergleich;
AddSolver(SolveMaze);
HasMaxDur = false;
}
public InOut(int[] s, int[] s2) : base(s, s2)
{
inputStringConverter = arg => Helfer.Arrayausgabe <int>("Eingabe: ", arg) + " ...len: " + arg.Length;
outputStringConverter = arg => Helfer.Arrayausgabe <int>("Erwartet: ", arg);
ergStringConverter = arg => Helfer.Arrayausgabe <int>("Ausgabe: ", arg);
copiedInputProvider = arg => Helfer.ArrayCopy <int>(arg);
CompareOutErg = Helfer.ArrayVergleich <int>;
AddSolver(SolveOnePass_ConstantSpace_TwoPointers);
}
public InOut(string input, string output) : base(Helfer.Assemble(input), Helfer.Assemble(output))
{
copiedInputProvider = Helfer.ArrayCopy <int>;
inputStringConverter = arr => Helfer.Arrayausgabe <int>("Eingabe: ", arr);
outputStringConverter = arr => Helfer.Arrayausgabe <int>("Erwartet: ", arr);
ergStringConverter = arr => Helfer.Arrayausgabe <int>("Ausgabe: ", arr);
CompareOutErg = Helfer.ArrayVergleich <int>;
AddSolver(MoveZeroes);
}
private static void BinarySearchSqrt2(int x, InOut.Ergebnis erg)
{
int it = 0, curr = 0;
if (!Helfer.BinarySearch(0, x / 2, ref curr, ref it, num => (num * num).CompareTo(x)))
{
curr = -1;
}
erg.Setze(curr, it, Complexity.LOGARITHMIC, Complexity.CONSTANT);
}
public override bool Equals(object obj)
{
Output op = obj as Output;
if (len != op.len)
{
return(false);
}
return(Helfer.ArrayVergleich <int>(arr, op.arr));
}
public Sort_Colors()
{
for (int i = 0; i < 10; i++)
{
int[] arr = Helfer.Assemble(0, 2, Helfer.Rand.Next(16, 26));
int[] copy = Helfer.ArrayCopy <int>(arr);
Array.Sort(copy);
testcases.Add(new InOut(arr, copy));
}
}
private static int[] Convert(string s) //NOTE Input array is the Price difference of the Stocks each day Day 1: 9, Day 2: 11; Difference => 11-9 = 2;
{
int[] arr = Helfer.Assemble(s);
for (int i = arr.Length - 1; i > 0; i--)
{
arr[i] = arr[i] - arr[i - 1];
}
arr[0] = 0;
return(arr);
}
public override string ToString()
{
string s = "\n";
s += Helfer.Arrayausgabe <string>("Inserts: ", inserts.ToArray <string>());
s += "\n";
s += Helfer.Arrayausgabe <string>("Searches: ", searches.ToArray <string>());
s += "\n";
s += Helfer.Arrayausgabe <string>("Completes: ", completes.ToArray <string>());
return(s);
}
public static int[] Convert(int n, int duplicate, int duplicates)
{
duplicate = Math.Max(1, Math.Min(n, duplicate));
int[] arr = new int[n + 1];
for (int i = 0; i < arr.Length - 1; i++)
{
arr[i] = i + 1;
}
arr[n] = duplicate;
return(Helfer.ArrayShuffle(arr));
}
public InOut(string s, string s2, string s3) : base(new int[2][] { Helfer.Assemble(s), Helfer.Assemble(s2) }, Helfer.Assemble(s3))
{
copiedInputProvider = arg => new int[2][] { Helfer.ArrayCopy(arg[0]), Helfer.ArrayCopy(arg[1]) };
inputStringConverter = arg => Helfer.Arrayausgabe("Eingabe:+\n", arg[0]) + "\n" + Helfer.Arrayausgabe(arg[1]);
outputStringConverter = arg => Helfer.Arrayausgabe("Erwartet: ", arg);
ergStringConverter = arg => Helfer.Arrayausgabe("Ergebnis: ", arg);
CompareOutErg = Helfer.ArrayVergleich;
AddSolver(MergeSmallerArrayIntoLarger_ConstantSpace);
AddSolver(MergeSmallerArrayIntoLarger_ConstantSpace_StartFromBack);
HasMaxDur = false;
}
private static Pos BinarySearchMatrix2(Helfer.Matrix <int> mat, int tar, ref int iterations, int current = 0)
{
if (Helfer.BinarySearch(0, mat.Length, ref current, ref iterations, (ind) => mat.GetElementAtIndex(ind).CompareTo(tar)))
{
return(new Pos(mat.GetCol(current) + 1, mat.GetRow(current) + 1));
}
else
{
return(new Pos(-1, -1));
}
}
private static bool IsSeperator(char c)
{
switch (c)
{
case '_':
case '.':
case ',':
case ' ': return(true);
default: return(Helfer.GetNumber(c) != -1);
}
}
public override string ToString()
{
string s = "\n";
s += Helfer.Arrayausgabe <bool>("Searches: ", searches.ToArray <bool>());
s += "\nCompletes: [ ";
foreach (IList <string> list in completes)
{
s += Helfer.Arrayausgabe <string>(list.ToArray <string>());
}
s += " ]";
return(s);
}
private static void Solve(string input, InOut.Ergebnis erg)
{
Stack <int> stack = new Stack <int>();
input += " ";
char c;
Operation op = null;
for (int i = 0, number = -1, num2; i < input.Length; i++)
{
c = input[i];
if (Char.IsDigit(c))
{
number = (number == -1 ? Helfer.GetNumber(c) : number * 10 + Helfer.GetNumber(c));
}
else if (c == '(')
{
stack.Push(number);
number = -1;
}
else if (c == ')')
{
number = stack.Pop();
}
else
{
if (number > -1)
{
if (op != null)
{
number = op(number, number);
}
else
{
num2 = number;
number = -1;
}
op = null;
}
if (operators.Keys.Contains(c))
{
op = operators[c];
}
}
}
erg.Setze(stack.Pop());
}
private static void EvalRPN(string input, InOut.Ergebnis erg)
{
Stack stack = new Stack();
char c;
bool num = false;
for (int i = 0, number = 0, sign = 0; i < input.Length; i++)
{
c = input[i];
if ((c == '-' || c == '+') && i + 1 < input.Length && char.IsDigit(input[i + 1]))
{
sign = c == '-' ? -1 : 1;
}
else if (char.IsDigit(c))
{
if (sign == 0)
{
sign = 1;
}
if (num)
{
number = number * 10 + Helfer.GetNumber(c);
}
else
{
number = Helfer.GetNumber(c);
}
num = true;
}
else // Not A Digit
{
if (num) // Push parsed number
{
stack.Push(number * sign);
sign = 0;
num = false;
}
if (operators.Keys.Contains(c))
{
stack.Push(operators[c](stack));
}
}
}
erg.Setze(stack.Pop <int>());
}
private void Testen(string description, search method)
{
Console.WriteLine("-----------------------------------");
Console.WriteLine("Search Element in Array");
Console.WriteLine("---> Method: " + description);
int i = 0;
foreach (int[] arr in ArrTar.Keys)
{
Console.WriteLine("Test: " + ++i);
Console.WriteLine(Helfer.Arrayausgabe("Eingabe: ", arr));
Console.WriteLine("Target: " + ArrTar[arr]);
Console.WriteLine();
Console.WriteLine(method(ArrTar[arr], arr));
}
}
public void Test()
{
Console.WriteLine("-----------------------------------");
Console.WriteLine("Infinite 2D Grid | Find Distance");
int i = 0;
foreach (Point[] points in inOut.Keys)
{
Console.WriteLine("Test: " + ++i);
Console.WriteLine(Helfer.Arrayausgabe("Eingabe: ", points));
Console.WriteLine();
Console.WriteLine("Erwartet: " + inOut[points]);
int outp = Solve(points);
Console.WriteLine("Output: " + outp);
Console.WriteLine("Success: " + (outp == inOut[points] ? "Success":"Failure"));
Console.WriteLine();
}
}
//SOL
public static void TwoSum_BinarySearch(Input inp, InOut.Ergebnis erg)
{
int[] arr = inp.arr;
int tar = inp.target;
int it = 0;
Output outp = new Output(null);
for (int i = 0; i < arr.Length - 1; i++, it++)
{
int curr = 0;
if (Helfer.BinarySearch(i + 1, arr.Length - 1, ref curr, ref it, ind => arr[ind].CompareTo(tar - arr[i])))
{
outp = new Output(new int[] { i + 1, curr + 1 });
outp.exp = arr[i] + " + " + arr[curr] + " = " + tar;
break;
}
}
// log n + log n-1 + log n-2 ... => log (n * (n-1) *(n-2)...) log (n!) => log (n)
erg.Setze(outp, it, Complexity.LINEARITHMIC, Complexity.CONSTANT, "Time is actually Log ((n-1)!)");
}
//SOL
public static void Solve(Input inp, InOut.Ergebnis erg)
{
string[] arr = inp.arr;
int len = inp.len;
int index = 0, ptStart = 0;
List <string> output = new List <string>();
while (index < arr.Length)
{
int currLen = 0;
while (index < arr.Length)
{
if (currLen + arr[index].Length + (index - ptStart) > len)
{
break; // accumulated wordlength + new Word lenght + a Space for each word
}
currLen += arr[index++].Length;
}
//calculate line Spacing
int wordCount = Math.Max(index - ptStart - 1, 1);
int freeSpaces = len - currLen;
int spacePerWord = (index < arr.Length ? freeSpaces / wordCount : 1);
int remainder = (index < arr.Length ? freeSpaces % wordCount : 0); //Will never exceed Number of Words-1 in Line
string buildLine = "";
for (; ptStart < index - 1; ptStart++)
{
buildLine += arr[ptStart] + Helfer.GenerateString(spacePerWord + (remainder-- > 0? 1:0));
}
output.Add(buildLine + arr[ptStart++]);
}
erg.Setze(output.ToArray(), Complexity.LINEAR, Complexity.LINEAR);
}
public override string ToString() => Helfer.Arrayausgabe <string>(root.Retrieve(new List <string>(), "").ToArray <string>());
public override string ToString() => Helfer.Arrayausgabe(arr) + "\nWert: " + value;
public InOut(string s, int i, int i2) : base(new Input(Helfer.Assemble(s), i), i2, true)
{
AddSolver(SimpleBinarySearch);
}
