public Permutation Insert(int position, int letter, IEnumerable <int> positionsHigherLetters) { int maximum; bool lettersIncreased = false; NumSequenceBasic newNumSequenceBasic; if (Maximum >= letter) { lettersIncreased = true; maximum = Maximum + 1; } else { maximum = letter; } NumSequenceBasic numSequenceBasicTemp = NumSequenceBasic.InsertLetter (position - LowestPosition, letter); if (lettersIncreased) { newNumSequenceBasic = numSequenceBasicTemp.Change(CorrectPositions(positionsHigherLetters), +1); } else { newNumSequenceBasic = numSequenceBasicTemp; } return(patternFactory.GetPattern(newNumSequenceBasic, HighestPosition + 1, maximum)); }
public override PatternBasic Insert(int position, int letter) { NumSequenceBasic newNumSequenceBasic = NumSequenceBasic.InsertLetter(position - LowestPosition, letter); return(PatternFactory.GetPattern(newNumSequenceBasic, HighestPosition + 1)); }
public override Permutation Insert(int position, int letter) { int maximum; bool lettersIncreased = false; NumSequenceBasic newNumSequenceBasic; if (Maximum >= letter) { maximum = Maximum + 1; lettersIncreased = true; } else { maximum = letter; } NumSequenceBasic numSequenceBasicTemp = NumSequenceBasic.InsertLetter (position - LowestPosition, letter); if (lettersIncreased) { newNumSequenceBasic = IncreaseHigherLetters(numSequenceBasicTemp, letter, position - LowestPosition); } else { newNumSequenceBasic = numSequenceBasicTemp; } return(patternFactory.GetPattern(newNumSequenceBasic, HighestPosition + 1, maximum)); }
public bool IsPermutation(NumSequenceBasic numSequenceBasic) { if (numSequenceBasic == null) { return(false); } HashSet <int> letters = new HashSet <int>(); int length = numSequenceBasic.Length; for (int i = 0; i < length; i++) { int letter = numSequenceBasic.GetLetter(i); if (letters.Contains(letter) || letter >= length) { return(false); } else { letters.Add(letter); } } return(true); }
public override Permutation InsertPosition(int position) { NumSequenceBasic newNumSequenceBasic = NumSequenceBasic.InsertLetter(position - LowestPosition, Maximum + 1); return(PatternFactory.GetPattern(newNumSequenceBasic, HighestPosition + 1, Maximum + 1)); }
public bool IsPatternBasic(NumSequenceBasic numSequenceBasic) { if (numSequenceBasic == null) { return(false); } return(true); }
public PatternBasic ChangePositive(IEnumerable <int> positions, int difference) { NumSequenceBasic newNumSequenceBasic; IEnumerable <int> correctedPositions = CorrectPositions(positions); newNumSequenceBasic = NumSequenceBasic.Change(correctedPositions, difference); return(patternFactory.GetPattern(newNumSequenceBasic, highestPosition)); }
public bool IsPermutation(NumSequenceBasic numSequenceBasic) { if (numSequenceBasic == null) { return(false); } return(true); }
public Permutation GetPattern(NumSequenceBasic numSequenceBasic, int highestPosition, int maximum) { if (isPermutation.IsPermutation(numSequenceBasic)) { return(new Permutation(numSequenceBasic, highestPosition, maximum)); } return(null); }
public PatternBasic GetPattern(NumSequenceBasic numSequenceBasic, int highestPosition) { if (isPatternBasic.IsPatternBasic(numSequenceBasic)) { return(new PatternBasic(numSequenceBasic, highestPosition)); } return(null); }
protected void FillNumSequenceLetters(NumSequenceBasic numSequenceBasic, string[] letters) { int letter; for (int i = letters.Length - 1; i >= 0; i--) { int.TryParse(letters[i], out letter); numSequenceBasic.InsertLetterMutable(0, letter); } }
public Permutation Delete(int position, IEnumerable <int> positionsHigherLetters) { NumSequenceBasic numSequenceBasicTemp = DeleteInternal(position); NumSequenceBasic newNumSequenceBasic = numSequenceBasicTemp. Change(CorrectPositions(positionsHigherLetters), -1); return(patternFactory.GetPattern(newNumSequenceBasic, HighestPosition - 1, Maximum - 1)); }
public T CreatePattern(ulong[] words, byte letterSize, int length) { factoryBuilder.SetLength(length); factoryBuilder.SetLetterSize(letterSize); factoryBuilder.SetWords(words); INumSequenceBasicWsBuilder builder; factoryBuilder.TryGetBuilder(out builder); NumSequenceBasic numSequenceBasic = factoryNumSequence.CreateNumSequenceBasic(builder); return(ConstructPattern(numSequenceBasic, length - 1, length - 1)); }
public T CreatePattern(string[] letters, byte letterSize) { factoryBuilder.SetLength(0); factoryBuilder.SetLetterSize(letterSize); factoryBuilder.SetWords(new ulong[] { 0 }); INumSequenceBasicWsBuilder builder; factoryBuilder.TryGetBuilder(out builder); NumSequenceBasic numSequenceBasic = factoryNumSequence.CreateNumSequenceBasic(builder); FillNumSequenceLetters(numSequenceBasic, letters); return(ConstructPattern(numSequenceBasic, letters.Length - 1, letters.Length - 1)); }
private IEnumerable <int> FindPositionsToBeAltered(NumSequenceBasic numSequenceBasic, int letter, int avoidedPosition) { List <int> positions = new List <int>(); for (int i = 0; i < numSequenceBasic.Length; i++) { if (avoidedPosition != i) { if (numSequenceBasic.GetLetter(i) >= letter) { positions.Add(i); } } } return(positions); }
public override Permutation Delete(int position) { NumSequenceBasic newNumSequenceBasic; int letter = NumSequenceBasic.GetLetter(position - LowestPosition); NumSequenceBasic numSequenceBasicTemp = NumSequenceBasic. DeleteLetterPosition(position - LowestPosition); if (letter == Maximum) { newNumSequenceBasic = numSequenceBasicTemp; } else { newNumSequenceBasic = DecreaseHigherLetters(numSequenceBasicTemp, letter, position - LowestPosition); } return(patternFactory.GetPattern(newNumSequenceBasic, HighestPosition - 1, Maximum - 1)); }
public Permutation ComputeInversion() { if (inversionSet) { return(inversion); } else { NumSequenceBasicFactory factory = new NumSequenceBasicFactory(); NumSequenceBasic numSequenceBasic = factory.GetNumSequenceDefault(LetterSize, Length, false); for (int i = LowestPosition; i <= HighestPosition; i++) { numSequenceBasic.SetLetterMutable(NumSequenceBasic.GetLetter(i), i); } inversionSet = true; inversion = patternFactory.GetPattern(numSequenceBasic, HighestPosition, Maximum); return(inversion); } }
public override PatternBasic Delete(int position) { NumSequenceBasic newNumSequenceBasic = DeleteInternal(position); return(PatternFactory.GetPattern(newNumSequenceBasic, HighestPosition - 1)); }
private Permutation(NumSequenceBasic numSequenceBasic, int highestPosition, int maximum) : base(numSequenceBasic, maximum) { this.highestPosition = highestPosition; inversionSet = false; }
private NumSequenceBasic CorrectNumSequence(NumSequenceBasic numSequenceBasic, int difference, IEnumerable <int> positions) { return(numSequenceBasic.Change(positions, difference)); }
public override PatternBasic Clone() { return(PatternFactory.GetPattern(NumSequenceBasic.Clone(), HighestPosition)); }
public PatternBasic(NumSequenceBasic numSequenceBasic, int highestPosition) : base(numSequenceBasic) { this.highestPosition = highestPosition; }
protected PatternIm(NumSequenceBasic numSequenceBasic) { this.numSequenceBasic = numSequenceBasic; }
private NumSequenceBasic DecreaseHigherLetters(NumSequenceBasic numSequenceBasic, int letter, int avoidedPosition) { return(CorrectNumSequence(numSequenceBasic, -1, FindPositionsToBeAltered(numSequenceBasic, letter, avoidedPosition))); }
protected abstract T ConstructPattern(NumSequenceBasic numSequenceBasic, int highestPosition, int maximum);
protected override Permutation ConstructPattern(NumSequenceBasic numSequenceBasic, int highestPosition, int maximum) { return(patternFactory.GetPattern(numSequenceBasic, highestPosition, maximum)); }
public override Permutation Switch(int positionFrom, int positionTo) { NumSequenceBasic newNumSequenceBasic = SwitchInternal(positionFrom, positionTo); return(PatternFactory.GetPattern(newNumSequenceBasic, HighestPosition, Maximum)); }