/// <inheritdoc /> public override IEnumerable <PipelineWorkUnit <IntrospectiveMethodInfo> > GenerateImplementation(PipelineWorkUnit <IntrospectiveMethodInfo> workUnit) { var permutations = new List <IntrospectiveMethodInfo>(); var definition = workUnit.Definition; // Generate permutation definitions var parameterPermutations = _permutationGenerator.Generate(definition); for (int i = 0; i < parameterPermutations.Count; ++i) { var permutation = parameterPermutations[i]; var method = TargetType.DefineMethod ( $"{workUnit.GetUniqueBaseMemberName()}_permutation_{i}", Public | Final | Virtual | HideBySig | NewSlot, CallingConventions.Standard, definition.ReturnType, permutation.ToArray() ); var methodInfo = new IntrospectiveMethodInfo(method, definition.ReturnType, permutation, definition); permutations.Add(methodInfo); } GenerateTopLevelMethodImplementation(definition, permutations); // Pass the permutations on for further processing foreach (var permutation in permutations) { yield return(new PipelineWorkUnit <IntrospectiveMethodInfo>(permutation, workUnit)); } }
public string LargestTimeFromDigits(int[] arr) { int?max_hm = null; PermutationGenerator.Generate(arr, a => { int h = a[0] * 10 + a[1]; int m = a[2] * 10 + a[3]; if (h <= 23 && m <= 59) { int hm = h * 100 + m; if (max_hm.HasValue) { if (hm > max_hm) { max_hm = hm; } } else { max_hm = hm; } } }); if (max_hm.HasValue) { return(String.Format("{0:00}:{1:00}", max_hm / 100, max_hm % 100)); } else { return(String.Empty); } }
public IList <int> DiffWaysToCompute(string input) { List <int> results = new List <int>(); Token[] tokenized = Tokenize(input); PermutationGenerator.Generate(tokenized, tokens => { for (int i = 0; i < tokens.Length; i++) { Token token = tokens[i]; token.EvaluatedValue = null; } for (int i = 0; i < tokens.Length; i++) { Token token = tokens[i]; Token prev = token.Prev; int l_value = prev?.EvaluatedValue ?? token.LValue; Token next = token.Next; int r_value = next?.EvaluatedValue ?? token.RValue; token.EvaluatedValue = token.Op(l_value, r_value); while (prev != null && prev.EvaluatedValue != null) { prev.EvaluatedValue = token.EvaluatedValue; prev = prev.Prev; } while (next != null && next.EvaluatedValue != null) { next.EvaluatedValue = token.EvaluatedValue; next = next.Next; } Console.Write(token); if (i == tokens.Length - 1) { results.Add(token.EvaluatedValue.Value); Console.Write(" = "); Console.Write(token.EvaluatedValue.Value); } else { Console.Write(" -> "); } } Console.WriteLine(); }); results.Sort(); return(results); }
/// <inheritdoc /> protected override void GenerateImplementation(IntrospectiveMethodInfo member, string symbolName, string uniqueMemberIdentifier) { var generatedMethods = new List <IntrospectiveMethodInfo>(); // Generate permutation definitions var permutations = _permutationGenerator.Generate(member); for (int i = 0; i < permutations.Count; ++i) { var permutation = permutations[i]; var method = TargetType.DefineMethod ( $"{uniqueMemberIdentifier}_{i}", Public | Final | Virtual | HideBySig | NewSlot, CallingConventions.Standard, member.ReturnType, permutation.ToArray() ); var methodInfo = new IntrospectiveMethodInfo(method, member.ReturnType, permutation, member); generatedMethods.Add(methodInfo); } // Generate native implementations for the permutations foreach (var permutation in generatedMethods) { var uniqueIdentifier = Guid.NewGuid().ToString().Replace("-", "_"); var memberIdentifier = $"{member.Name}_{uniqueIdentifier}"; uniqueMemberIdentifier = memberIdentifier; if (permutation.RequiresLowering()) { _loweredMethodGenerator.GenerateImplementationForDefinition(permutation, symbolName, uniqueMemberIdentifier); } else { _methodGenerator.GenerateImplementationForDefinition(permutation, symbolName, uniqueMemberIdentifier); } } // Generate a definition for the top-level method var topLevelMethod = TargetType.DefineMethod ( symbolName, Public | Final | Virtual | HideBySig | NewSlot, member.ReturnType, member.ParameterTypes.ToArray() ); GenerateTopLevelMethodImplementation(member, topLevelMethod, permutations, generatedMethods); TargetType.DefineMethodOverride(topLevelMethod, member.GetWrappedMember()); }
public IList <int[]> GeneratePermutations(int[] values) { var permutationGenerator = new PermutationGenerator(values); return(permutationGenerator.Generate()); }