public InOut(string s, string s2) : base(Convert(s), LinkedList <int> .Assemble(s2), true)
{
inputStringConverter = arg => Helfer.Arrayausgabe("", arg, false, "\n ");
AddSolver((arg, erg) => erg.Setze(LinkedList <int> .Merge_K_Sorted_LinkedLists <int>(arg)), "Merge_K_Sorted_LinkedLists");
copiedInputProvider = arg => Convert(s);
HasMaxDur = false;
}
public InOut(int[] inp, int tar, int[] outp) : base(new Input(inp, tar), outp)
{
ergStringConverter = erg => Helfer.Arrayausgabe <int>("Ausgabe: ", erg);
outputStringConverter = erg => Helfer.Arrayausgabe <int>("Erwartet: ", erg);
CompareOutErg = Helfer.ArrayVergleich <int>;
AddSolver(Solve, "Solver 1");
}
public InOut(string s, string s2) : base(Convert(s), new Output <int>(Helfer.Assemble(s2)), true)
{
inputStringConverter = arg => Helfer.Arrayausgabe("Eingabe: \n", arg);
HasMaxDur = false;
AddSolver(NodeMinStack_Solver);
AddSolver(ArrayMinStack_Solver);
}
public InOut(int k, int x, int y, string coords, String coordsOut) : base(new Input(k, x, y, coords), ConvertToList(coordsOut))
{
outputStringConverter = arg => Helfer.Arrayausgabe("Ausgabe: ", arg.ToArray());
ergStringConverter = arg => Helfer.Arrayausgabe("Ergebnis: ", arg.ToArray());
CompareOutErg = (arg, arg1) => Helfer.ArrayVergleichAnyOrder(arg.ToArray(), arg1.ToArray());
AddSolver(Solver1);
}
public InOut(string s, int i) : base(Helfer.Assemble(s), i, true)
{
inputStringConverter = arg => Helfer.Arrayausgabe <int>("Eingabe: ", arg);
AddSolver((arg, erg) => erg.Setze(MaxProdOfThree_Enumerable(arg), Complexity.LINEAR, Complexity.CONSTANT), "MaxProdOfThree_Enumerable");
AddSolver((arg, erg) => erg.Setze(MaxProdOfThree_SortedArray(arg), Complexity.QUADRATIC, Complexity.CONSTANT), "MaxProdOfThree_SortedArray");
AddSolver((arg, erg) => erg.Setze(MaxProdOfThree_SortedArray(arg), Complexity.LINEAR, Complexity.CONSTANT), "MaxProdOfThree_OnePass");
}
public InOut(string s, string s2) : base(s.Split(','), Convert(s2), true)
{
outputStringConverter = arg =>
{
string sasda = "Erwartet:";
foreach (string[] arr in arg)
{
sasda += "\n" + Helfer.Arrayausgabe <string>(arr);
}
return(sasda);
};
ergStringConverter = arg =>
{
string sasda = "Ergebnis:";
foreach (string[] arr in arg)
{
sasda += "\n" + Helfer.Arrayausgabe <string>(arr);
}
return(sasda);
};
inputStringConverter = arg => Helfer.Arrayausgabe <string>("Eingabe:\n", arg);
CompareOutErg = (arg, arg2) => { for (int i = 0; i < arg.Length; i++)
{
if (!Helfer.ArrayVergleich(arg[i], arg2[i]))
{
return(false);
}
}
return(true); };
AddSolver(SortWords);
AddSolver(WithHashValue);
}
public InOut(string s, string s2, string s3) : base(new Input(s, s2), Helfer.Assemble(s3))
{
outputStringConverter = arg => Helfer.Arrayausgabe("Erwartet: ", arg, true);
ergStringConverter = arg => Helfer.Arrayausgabe("Ausgabe: ", arg, true);
CompareOutErg = Helfer.ArrayVergleichAnyOrder;
AddSolver(FindIntersection_WithHashset);
}
public InOut(string s, int i, string o) : base(new Input(s, i), Helfer.AssembleChar(o))
{
outputStringConverter = arg => Helfer.Arrayausgabe("Erwartet: ", arg, false, ", ", replace, replacement);
ergStringConverter = arg => Helfer.Arrayausgabe("Ausgabe: ", arg, false, ", ", replace, replacement);
CompareOutErg = Helfer.ArrayVergleich;
HasMaxDur = false;
AddSolver(Scheduler);
}
public InOut(string s, int h, string s2) : base(new Input(s, h), Helfer.AssembleChar(s2))
{
ergStringConverter = arg => Helfer.Arrayausgabe <char>("Ergebnis: ", arg);
outputStringConverter = arg => Helfer.Arrayausgabe <char>("Erwartet: ", arg);
CompareOutErg = (arg, arg2) => Helfer.ArrayVergleich <char>(arg, arg2);
AddSolver((arg, erg) => erg.Setze(arg.tree.GetValuesAtHeight(arg.height)), "Iterativ");
}
public InOut(string tree, string arr) :
base(Helfer.AssembleBTreePreOrder(tree, new IntBinaryTree()) as IntBinaryTree, Helfer.Assemble(arr), true)
{
ergStringConverter = arg => Helfer.Arrayausgabe <int>("Ausgabe: ", arg);
outputStringConverter = arg => Helfer.Arrayausgabe <int>("Erwartet: ", arg);
CompareOutErg = Helfer.ArrayVergleich;
AddSolver((arg, erg) => erg.Setze(arg.LargestPathSumfromRootToLeafRecursive()), "Recursive");
}
public InOut(string tree, int node, string cousins) : base(new Input(tree, node), Helfer.Assemble(cousins))
{
ergStringConverter = arg => Helfer.Arrayausgabe("Ergebnis: ", arg);
outputStringConverter = arg => Helfer.Arrayausgabe("Erwartet: ", arg);
CompareOutErg = Helfer.ArrayVergleichAnyOrder;
HasMaxDur = false;
AddSolver(Solver1);
}
public Primary_Arr(O o, N[] n, bool len = false, bool shuffle = false, bool checkOrder = true) : base(o, shuffle ? Helfer.ArrayShuffle(n) : n, true)
{
outputStringConverter = arg => Helfer.Arrayausgabe <N>("Erwartet: ", arg, len);
ergStringConverter = arg => Helfer.Arrayausgabe <N>("Ausgabe: ", arg, len);
if (checkOrder)
{
CompareOutErg = Helfer.ArrayVergleich <N>;
}
else
{
CompareOutErg = Helfer.ArrayVergleichAnyOrder <N>;
}
}
protected static bool ValidateSudoku(Helfer.Matrix <int> mat, Stack <int> last = null, int debug = 1)
{
last = last ?? new Stack <int>();
for (int i = last.Count > 0 ? last.Pop() : 0; i < mat.Length; i++)
{
//while (mat.GetElementAtIndex(i) > 0) if (++i >= mat.Length) return true;
if (mat.GetElementAtIndex(i) > 0)
{
if (Check_Index(mat, i))
{
continue;
}
else if (last.Count == 0)
{
return(false);
}
else
{
i = last.Pop() - 1; //-1 Compensates for i++
}
}
else
{
if (Find_fitting_value(mat, i))
{
last.Push(i);
}
else if (last.Count == 0)
{
return(false);
}
else
{
i = last.Pop() - 1; //-1 Compensates for i++
}
if (debug > 0)
{
Console.WriteLine("index: " + i + "\n" + mat);
}
if (debug > 0)
{
Console.WriteLine(Helfer.Arrayausgabe(last.ToArray()));
}
}
}
if (debug == 0)
{
Console.WriteLine(mat);
}
return(true);
}
public TwoArr(O[] o, N[] n, bool len = false, bool shuffle = false, bool checkOrder = true) : base(shuffle ? Helfer.ArrayShuffle(o) : o, shuffle ? Helfer.ArrayShuffle(n) : n)
{
inputStringConverter = arg => Helfer.Arrayausgabe("Eingabe: ", arg, len);
outputStringConverter = arg => Helfer.Arrayausgabe("Erwartet: ", arg, len);
ergStringConverter = arg => Helfer.Arrayausgabe("Ausgabe: ", arg, len);
if (checkOrder)
{
CompareOutErg = Helfer.ArrayVergleich;
}
else
{
CompareOutErg = Helfer.ArrayVergleichAnyOrder;
}
copiedInputProvider = Helfer.ArrayCopy;
}
public InOut(string input, int output) : base(Helfer.Assemble(input), output, true)
{
inputStringConverter = arg => Helfer.Arrayausgabe <int>("Eingabe: ", arg);
AddSolver(Solve1, "Solver mit HashSet");
AddSolver(Solve2, "Solver mit O(1) Space Complexity");
}
public override string ToString()
{
return(Helfer.Arrayausgabe <int>("Eingabe: ", input) + "\n"
+ "Target: " + target);
}
public Arr_Primary(O[] o, N n, bool len = false, bool shuffle = false) : base(shuffle ? Helfer.ArrayShuffle(o) : o, n, true)
{
inputStringConverter = arg => Helfer.Arrayausgabe <O>("Eingabe: ", arg, len);
copiedInputProvider = Helfer.ArrayCopy <O>;
}
public void SetErgebnis(InOutBase <int[], int> .Ergebnis erg, int start, int end)
{
Console.WriteLine(Helfer.Arrayausgabe(summedList));
erg.Setze(Sum(start, end), Complexity.CONSTANT, Complexity.LINEAR, "Summed Solver");
}
public InOut(string s, int z) : base(Convert(s), z, true)
{
inputStringConverter = arg => Helfer.Arrayausgabe("Eingbae: ", arg);
HasMaxDur = false;
AddSolver(Solve);
}
public override string ToString() => Helfer.Arrayausgabe("", tasks, false, ", ", replace, replacement) + "\nDelay: " + delay;
public override string ToString() => s + "\n" + Helfer.Arrayausgabe <int>("Nums: ", arr);
public InOut(string s, int k, string s2) : base(Helfer.Point.GetPointArray(s + ";-999," + k), Helfer.Point.GetPointArray(s2), true)
{
inputStringConverter = arg => Helfer.Arrayausgabe("Eingabe: \n", arg, false, ", ", null, null, new int[] { 0, arg.Length - 1 }) + "\nK: " + arg[arg.Length - 1].Y;
CompareOutErg = Helfer.ArrayVergleichAnyOrder;
AddSolver(FindClosestPoints);
}
public InOut(int n, int m, BigInteger outp) : base(new int[] { n, m }, outp, true)
{
inputStringConverter = arg => Helfer.Arrayausgabe <int>("Eingabe: ", arg);
AddSolver((arg, erg) => erg.Setze(Num_ways(arg[0], arg[1]), Complexity.LINEAR, Complexity.CONSTANT), "Calculate Permuations");
}
public override string ToString() => "\n M: " + m + "\n Array: " + Helfer.Arrayausgabe(arr, 0, m);
public override string ToString() => Helfer.Arrayausgabe <int>("Eingabe: ", arr, true) + "\nTarget: " + target;
public InOut(string s, bool b) : base(s.Split(','), b, true)
{
inputStringConverter = arg => Helfer.Arrayausgabe("Eingabe: ", arg);
AddSolver(Solver1);
}
public InOut(string inp, int outp) : base(Helfer.Assemble(inp), outp, true)
{
inputStringConverter = arg => Helfer.Arrayausgabe <int>("Eingabe: ", arg);
AddSolver((arg, erg) => erg.Setze(Solve(arg)));
}
public override string ToString() => Helfer.Arrayausgabe <string>(words) + "\nOrder: " + order;
public InOut(string s, string s2) : base(Helfer.Assemble(s), s2, true)
{
inputStringConverter = arg => Helfer.Arrayausgabe <int>("Eingabe: ", arg);
AddSolver(solve);
}
public override string ToString() => Helfer.Arrayausgabe <int>(arr) + "\nKth: " + k;
