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(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 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 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(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(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(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(int i, string s) : base(i, Helfer.Assemble(s), true)
{
outputStringConverter = arg => Helfer.Arrayausgabe("Erwartet: ", arg);
ergStringConverter = arg => Helfer.Arrayausgabe("Ausgabe: ", arg);
CompareOutErg = Helfer.ArrayVergleich;
AddSolver(Solve);
AddSolver(Solve_NumSpaceComplexity);
}
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);
}
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;
}
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 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 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();
}
}
public override string ToString() => Helfer.Arrayausgabe <int>("Eingabe: ", arr, true) + "\nTarget: " + target;
public override string ToString() => Helfer.Arrayausgabe <int>(erg) + ((exp != null) ? "\nExpression: " + exp : "");
public override string ToString() => Helfer.Arrayausgabe(arr) + "\nWert: " + value;
public override string ToString() => Helfer.Arrayausgabe(arr) + "\nLinelength: " + len;
public override string ToString() => minSum + "\n" + (trace == null ? "<NULL>" : Helfer.Arrayausgabe("Trace => ", trace, false, " => ")) + (mat == null? "":Helfer.Matrix <int> .MatrixAusgabe("", mat, (minSum + "").Length + 1));
public InOut(string s, int i) : base(Convert(s), i, true)
{
inputStringConverter = arg => Helfer.Arrayausgabe <int>("Eingabe: ", arg, true);
AddSolver(Get_MaxProfit);
}
public InOut(string s, string s2, int i) : base(Helfer.Assemble(s), new Output(Helfer.Assemble(s2), i), true)
{
inputStringConverter = arg => Helfer.Arrayausgabe("Eingabe: ", arg);
AddSolver(FindContigousSubarray);
HasMaxDur = false;
}
public override string ToString() => "\n" + Helfer.Arrayausgabe <int>(arr) + "\nElement: " + el;
public override string ToString() => Helfer.Arrayausgabe <string>(root.Retrieve(new List <string>(), "").ToArray <string>());
public InOut(int[] i, Output o) : base(i, o, true)
{
inputStringConverter = arg => Helfer.Arrayausgabe <int>("Eingabe: ", arg);
copiedInputProvider = Helfer.ArrayCopy <int>;
AddSolver(RmDuplicates);
}
public override string ToString() => Helfer.Arrayausgabe("Subarray: ", arr) + "\n+Summe: " + sum;
public override string ToString() => "\n" + Helfer.Arrayausgabe <int>(arr) + "\nLength: " + len;