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, 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, 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 Primary_IntArr(O o, String s, bool len = false, bool shuffle = false, bool checkOrder = true) : this(o, Helfer.Assemble(s), len, shuffle, checkOrder) { }
public Input(string arrS, int k) { this.arrS = arrS; this.k = k; this.arr = Helfer.Assemble(arrS); }
private static int[] Convert(string s) { temp = Helfer.Assemble(s); return(temp); }
public InOut(string s, int m, string s2) : base(InOut.Convert(s), new Output(m, Helfer.Assemble(s2), temp), true) { AddSolver(Remove_Doubles); }
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 InOut(string s, string s2) : base(Helfer.Assemble(s), Helfer.Assemble(s2), true) { AddSolver(SolveMultiplePasses); }
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 InOut(string s, string s2) : base(Helfer.Assemble(s), Convert(s2)) { AddSolver(SolveLinear); }
public InOut(string s, string s2) : base(Helfer.Assemble(s), s2, true) { inputStringConverter = Helfer.Arrayausgabe; AddSolver(BinarySearchSolve); HasMaxDur = false; }
public InOut(string input, bool output) : base(Helfer.Assemble(input), output) { inputStringConverter = arg => Helfer.Arrayausgabe <int>("Eingabe: ", arg); AddSolver(Solve); }
public InOut(string s, bool inverted, bool outp) : base(BinarySearchTree <int> .GenerateFromLevelOrder(Helfer.Assemble(s), inverted), outp, true) { inputStringConverter = arg => (inverted ? "Inverted":"Normal") + "\nEingabe: " + arg.PrintIterative(TraverseType.LevelOrder); AddSolver((arg, erg) => erg.Setze(arg.ValidateRecursive(), Complexity.QUADRATIC, Complexity.QUADRATIC, "Where n is height of Tree"), "Rekursiv"); AddSolver((arg, erg) => erg.Setze(arg.ValidateIt(), Complexity.QUADRATIC, Complexity.QUADRATIC, "Where n is height of Tree"), "Iterativ"); }
public IntArr_Primary(string s, O o, bool len = false, bool shuffle = false) : this(Helfer.Assemble(s), o, len, shuffle) { }
public TwoIntArr(string arr, string arr1, bool len = false, bool shuffle = false, bool checkOrder = true) : base(Helfer.Assemble(arr), Helfer.Assemble(arr1), len, shuffle, checkOrder) { }
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 Input(int s, string arr) { this.s = s; this.arr = Helfer.Assemble(arr); }
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 InOut(string s, string s2) : base(Helfer.Assemble(s), s2, true) { inputStringConverter = arg => Helfer.Arrayausgabe <int>("Eingabe: ", arg); AddSolver(solve); }
public Input(string nums, string nums2) { this.nums = Helfer.Assemble(nums); this.nums2 = Helfer.Assemble(nums2); }