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)); }