public void AddInfluencer(TekField f) { if (!Influencers.Contains(f)) // don't add more than once { Influencers.Add(f); } }
private void __SetBorder(TekFieldView p, TekField neighbour, TekFieldView.TekBorder border) { if (neighbour.Area == null) { if (p.Field.Area == null) { p.Borders[(int)border] = TekFieldView.TekBorderStyle.tbsNone; } else { p.Borders[(int)border] = TekFieldView.TekBorderStyle.tbsNone; // tbsExternal; } } else if (p.Field.Area == null) { p.Borders[(int)border] = TekFieldView.TekBorderStyle.tbsNone; // tbsExternal; } else { if (neighbour.Area.AreaNum == p.Field.Area.AreaNum) { p.Borders[(int)border] = TekFieldView.TekBorderStyle.tbsInternal; } else { p.Borders[(int)border] = TekFieldView.TekBorderStyle.tbsExternal; } } }
public override bool HeuristicApplies(TekBoard board, TekField field) { foreach (TekRegion region in TekRegion.GetCompactRegions(field)) { foreach (TekField f in region.GetBorderFields()) { try { int[] tryValues = f.PossibleValues.ToArray(); // setting value will empty possiblevalues array foreach (int value in tryValues) { f.Value = value; if (region.GetTotalPossibleValues().Count < region.Fields.Count) { AddHeuristicFields(region.Fields); AddAffectedFields(f); AddValue(value); } } if (AffectedFields.Count > 0) { return(true); } } finally { f.Value = 0; } } } return(false); }
private void AddOnce(List <TekField> list, TekField field) { if (!list.Contains(field)) { list.Add(field); } }
public bool IsCompact() { if (Fields.Count == 0) { return(false); } int i = 0; while (i < Fields.Count) { TekField field1 = Fields[i++]; if (field1.Value != 0) { continue; } int j = i; while (j < Fields.Count) { if (Fields[j].Value == 0 && !Fields[j].Influencers.Contains(field1)) { return(false); } j++; } } return(true); }
private int ComputeDistance(TekField field1, TekField field2, List <TekField> chain) { if (field1.Influencers.Contains(field2)) { return(1); } else { int value = ComputeDistance(field1, field2); if (value >= 0) { return(value); } else { int minDistance = Int32.MaxValue - 1; foreach (TekField f in field1.Influencers) { if (chain.Contains(f) && !ChainBackTracking.Contains(f)) { ChainBackTracking.Add(f); value = ComputeDistance(f, field2, chain); if (value < minDistance) { minDistance = value; } ChainBackTracking.Remove(f); } } return(1 + minDistance); } } }
private bool ParseValue(string input, TekBoard board) { int row, col, value; Match match = valuePattern.Match(input); if (match.Success && Int32.TryParse(match.Groups["row"].Value, out row) && Int32.TryParse(match.Groups["col"].Value, out col) && Int32.TryParse(match.Groups["value"].Value, out value) ) { if (!board.IsInRange(row, col) || value <= 0 || value > Const.MAXTEK) { ParseError("Invalid value line {0}: ({1},{2}", input, row, col); } TekField field = board.Fields[row, col]; field.Value = value; field.Initial = match.Groups["initial"].Value == "i"; return(true); } else { return(false); } }
protected bool IsTriplet(TekField field1, TekField field2, TekField field3, bool inSameArea = true) // hidden triplets are ignored { if (inSameArea && (field1.Area != field2.Area || field1.Area != field3.Area || field2.Area != field3.Area)) { return(false); } if (field1.TotalPossibleValues(field2, field3).Count != 3) { return(false); } // 2 or 3 values per field if (field1.PossibleValues.Count < 2 || field1.PossibleValues.Count > 3) { return(false); } if (field2.PossibleValues.Count < 2 || field2.PossibleValues.Count > 3) { return(false); } if (field3.PossibleValues.Count < 2 || field3.PossibleValues.Count > 3) { return(false); } return(true); }
public void PlayNotes(TekField field, params int[] values) { for (int i = 0; i < values.Length; i++) { PlayNote(field, values[i]); } }
public void ExcludeValues(TekField field, params int[] values) { for (int i = 0; i < values.Length; i++) { ExcludeValue(field, values[i]); } }
public override bool HeuristicApplies(TekBoard board, TekField field) { List <TekArea> AdjacentAreas = field.Area.GetAdjacentAreas(); foreach (TekArea area in AdjacentAreas) { foreach (int value in field.PossibleValues) { bool possible = false; Region.Clear(); foreach (TekField f in area.Fields) { if (f.ValuePossible(value)) { if (field.Influencers.Contains(f)) { Region.AddField(f); } else { possible = true; break; } } } if (!possible && Region.Fields.Count > 0) { AddAffectedField(field); AddValue(value); AddHeuristicFields(Region.Fields); } } } return(AffectedFields.Count > 0 && HeuristicValues.Count > 0); }
public void AddNeighbour(TekField f) { if (!Neighbours.Contains(f)) // don't add more than once { Neighbours.Add(f); } }
private bool BruteForceSolve() { if (SortedCandidates.Count == 0) { return(Board.IsSolved()); } TekField Field0 = SortedCandidates[0]; if (Field0.PossibleValues.Count == 0) { return(Board.IsSolved()); } for (int i = 0; i < Field0.PossibleValues.Count; i++) { SetFieldValue(Field0, Field0.PossibleValues[i]); if (BruteForceSolve()) { return(true); } else // backtrack { SetFieldValue(Field0, 0); } } // if we get here, this branch has no solution return(false); }
public bool IsInvalidThreePairs(TekField field3) { if (Fields.Count != 2) { return(false); } return(IsInvalidThreePairs(Fields[0], Fields[1], field3)); }
protected bool IsInvalidThreePairs(TekField field1, TekField field2, TekField field3) { if (field1.CommonPossibleValues(field2, field3).Count != 2 || !IsPair(field1, field2) || !IsPair(field1, field3) || !IsPair(field2, field3)) { return(false); } return(field1.Influencers.Contains(field2) && field1.Influencers.Contains(field3) && field2.Influencers.Contains(field3)); }
public virtual void AddField(TekField f) { if (Fields.Contains(f)) // don't add more than once { return; } Fields.Add(f); Sort(); }
private void ExportExcludes(TekField field, StreamWriter wr) { wr.Write(EXCLUDESFORMAT1, field.Row, field.Col); foreach (int value in field.ExcludedValues) { wr.Write(EXCLUDESFORMAT2, value); } wr.WriteLine(); }
public void ExcludeValue(TekField field, int value) { PushMove(field.Row, field.Col, TekMove.tmExclude, value); field.ExcludeValue(value, true); if (field.Notes.Contains(value)) { PlayNote(field, value); } }
public void PlayClear(TekField field) { PushMove(field.Row, field.Col, TekMove.tmClear, field.Value); field.ClearNotes(); if (!field.Initial) { field.Value = 0; } }
private void ExportNotes(TekField field, StreamWriter wr) { wr.Write(NOTESFORMAT1, field.Row, field.Col); foreach (int value in field.Notes) { wr.Write(NOTESFORMAT2, value); } wr.WriteLine(); }
public void ExcludeValues(TekMoves moves, TekField field) { foreach (int value in HeuristicValues) { if (field.ValuePossible(value)) { moves.ExcludeValue(field, value); } } }
public override void AddField(TekField f) { base.AddField(f); if (f.Area != null) { return; // or exception } f.Area = this; SetInfluencers(); }
public bool IsTriplet(TekField field3, bool inSameArea = true) { if (Fields.Count != 2) { return(false); } else { return(IsTriplet(Fields[0], Fields[1], field3, inSameArea)); } }
public override bool HeuristicApplies(TekBoard board, TekField field) { if (field.PossibleValues.Count == 1) { AddHeuristicField(field); AddAffectedField(field); AddValue(field.PossibleValues[0]); return(true); } return(false); }
private void AddField(TekBoard board, TekField field) { List <TekField> chain = FindChain(field); if (chain == null) { chain = new List <TekField>(); Chains.Add(chain); } chain.Add(field); }
public int ComputeDistance(TekField field1, TekField field2) { List <TekField> chain = FindChain(field1); if (chain == null || !chain.Contains(field2)) { return(-1); } int[,] table = Distances[Chains.IndexOf(chain)]; return(table[chain.IndexOf(field1), chain.IndexOf(field2)]); }
private HeuristicAction _tryValue(TekField field, int value) { try { field.Value = value; } catch (ETekFieldInvalid) { return(HeuristicAction.haExcludeValue); } return(HeuristicAction.haNone); }
public bool IsPair(TekField field) // hidden pairs are ignored { if (Fields.Count != 1) { return(false); } else { return(IsPair(Fields[0], field)); } }
private void initFields(int rows, int cols) { Fields = new TekField[rows, cols]; for (int r = 0; r < Rows; r++) { for (int c = 0; c < Cols; c++) { Fields[r, c] = new TekField(r, c); } } EatExceptions = _EatExceptions; }
public override bool HeuristicApplies(TekBoard board, TekField field) { Stopwatch s = Stopwatch.StartNew(); if (BruteForceSolve()) { s.Stop(); timeElapsed = s.Elapsed; board.LoadValues(Board.CopyValues()); return(true); } return(false); // can't be solved }