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(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(Helfer.AssembleBTreePreOrder(s), Helfer.AssembleBTreePreOrder(s2), true)
{
copiedInputProvider = arg => arg.CopyIt();
HasMaxDur = false;
AddSolver(LevelTree);
AddSolver(Bullshit_Solution);
}
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 Tree_Serialization()
{
testcases.Add(new InOut <char>(Helfer.AssembleBTreeCharPreOrder("abcf//ksz//kql//kqk/elstw/gh/legpwgw/"), c => c + "", s => s[0]));
testcases.Add(new InOut <int>(Helfer.AssembleBTreePreOrder("/"), i => i + "", int.Parse));
testcases.Add(new InOut <char>(Helfer.AssembleBTreeCharPreOrder("a,b,c,/,/,/,f,g,/"), c => c + "", s => s[0]));
testcases.Add(new InOut <int>(Helfer.AssembleBTreePreOrder("5,6,8,/,/,/,5,4,/"), i => i + "", int.Parse));
}
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(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(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(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 FList1(int[] nums)
{
summedList = Helfer.ArrayCopy(nums);
for (int i = 1; i < summedList.Length - 2; i++)
{
summedList[i] += summedList[i - 1];
}
}
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 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 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;
}
//SOL
public static int Solve(int num)
{
string sNum = Math.Abs(num) + "";
int sign = num < 0 ? -1 : 1;
num = Helfer.GetNumber(sNum[sNum.Length - 1]);
for (int i = sNum.Length - 2; i >= 0; i--)
{
int tmp = num * 10 + Helfer.GetNumber(sNum[i]);
if (tmp <= num)
{
return(0);
}
num = tmp;
}
return(num);
}
public InOut(string s, char c) : base(Helfer.AssembleBTreeChar(s, new BinaryCompleteTree <char>()), c, true)
{
inputStringConverter = arg => "Binary Tree: " + arg.PrintIterative(TraverseType.LevelOrder);
AddSolver((arg, erg) => erg.Setze(arg.GetDeepestNodeIt().Val), "Iterativ");
AddSolver((arg, erg) => erg.Setze(arg.GetDeepestNodeRecursive().Val), "Recursive");
}
public InOut(string s, string s2) : base(Helfer.Assemble(s), s2, true)
{
inputStringConverter = arg => Helfer.Arrayausgabe <int>("Eingabe: ", arg);
AddSolver(solve);
}
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 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() => s + "\n" + Helfer.Arrayausgabe <int>("Nums: ", arr);
public Input(int s, string arr)
{
this.s = s;
this.arr = Helfer.Assemble(arr);
}
public Input(string s, char n, char n1)
{
tree = Helfer.AssembleBTreeCharPreOrder(s);
this.n = Search(n, tree.GetRoot());
this.n1 = Search(n1, tree.GetRoot());
}
public InOut(string s, string s2) : base(Helfer.Assemble(s), Helfer.Assemble(s2), true)
{
AddSolver(SolveMultiplePasses);
}
/*
* Hi, here's your problem today. This problem was recently asked by Apple:
*
* Given a list of strings, find the list of characters that appear in all strings.
*
* Here's an example and some starter code:
*
* def common_characters(strs):
# Fill this in.
#
# print(common_characters(['google', 'facebook', 'youtube']))
# ['e', 'o']
*/
public InOut(string s, string s2) : base(Helfer.AssembleString(s), Helfer.AssembleChar(s2), true)
{
AddSolver(Find_Common_Characters);
}
public Input(string preorder, string preorder2)
{
tree = Helfer.AssembleBTreePreOrder(preorder);
sub = Helfer.AssembleBTreePreOrder(preorder2);
}
public InOut(string s, string s2) : base(Helfer.AssembleBTree(s, new BinaryCompleteTree <int>(), true, -1), s2, true)
{
AddSolver((arg, erg) => erg.Setze(arg.PrintIterative(TraverseType.LevelOrder, arg.GetLargestBst((i, i2) => i.CompareTo(i2)), "")), "Rekursiv");
}
public Count_Number_of_Unival_Subtrees()
{
testcases.Add(new InOut <int>(Helfer.AssembleBTree("0102210222211", new BinaryCompleteTree <int>(), true), 5));
testcases.Add(new InOut <char>(Helfer.AssembleBTreeChar("aaa//aa///////A", new BinaryCompleteTree <char>()), 3));
testcases.Add(new InOut <char>(Helfer.AssembleBTreeChar("acb//bb///////b", new BinaryCompleteTree <char>()), 5));
}
