Extended the logic in GapsAroundBiggestSolverMethod to also mark clues as solved.

Author: MeltyPlayer

FinModelUtility/Fin/Fin.Picross Tests/CluesTests.cs

@@ -16,15 +16,15 @@ public void TestAllEmpty() {
     for (var x = 0; x < picrossDefinition.Width; x++) {
       var column = columns[x];
       Assert.AreEqual(1, column.Count);
-      Assert.AreEqual(0, column[0]);
+      Assert.AreEqual(0, column[0].Length);
     }
 
     var rows = clues.Rows;
     Assert.AreEqual(picrossDefinition.Height, rows.Count);
     for (var y = 0; y < picrossDefinition.Height; y++) {
       var row = rows[y];
       Assert.AreEqual(1, row.Count);
-      Assert.AreEqual(0, row[0]);
+      Assert.AreEqual(0, row[0].Length);
     }
   }
 
@@ -40,15 +40,15 @@ public void TestAllFull() {
     for (var x = 0; x < picrossDefinition.Width; x++) {
       var column = columns[x];
       Assert.AreEqual(1, column.Count);
-      Assert.AreEqual(picrossDefinition.Height, column[0]);
+      Assert.AreEqual(picrossDefinition.Height, column[0].Length);
     }
 
     var rows = clues.Rows;
     Assert.AreEqual(picrossDefinition.Height, rows.Count);
     for (var y = 0; y < picrossDefinition.Height; y++) {
       var row = rows[y];
       Assert.AreEqual(1, row.Count);
-      Assert.AreEqual(picrossDefinition.Width, row[0]);
+      Assert.AreEqual(picrossDefinition.Width, row[0].Length);
     }
   }
 }

FinModelUtility/Fin/Fin.Picross/src/PicrossSolver.cs

@@ -99,9 +99,10 @@ private static readonly IReadOnlyList<IPicrossSolverMethod> SOLVER_METHODS_
           new ExtendLastClueSolverMethod(),
           new FillSmallestUnknownsBetweenEmptiesSolverMethod(),
           new GapsAroundFirstClueSolverMethod(),
-          new GapsAroundBiggestSolverMethod(),
+          new GapsAroundKnownCluesSolverMethod(),
           new GapsBetweenNeighboringCluesSolverMethod(),
           new GapsBetweenNeighboringShortCluesSolverMethod(),
+          new MatchingBiggestOrUniqueLengthSolverMethod(),
       ];
 
   private static IEnumerable<IPicrossMove1d> CheckClues_(

FinModelUtility/Fin/Fin.Picross/src/moves/ClueMoves.cs

@@ -8,6 +8,7 @@ public enum PicrossClueMoveSource {
   FREEBIE_PERFECT_FIT,
   FIRST_CLUE,
   ALL_CLUES_SOLVED,
+  ONLY_MATCHING_CLUE,
 }
 
 [Equatable]

FinModelUtility/Fin/Fin.Picross/src/solver/GapsAroundBiggestSolverMethod.cs

@@ -0,0 +1,38 @@
+using fin.picross.moves;
+
+namespace fin.picross.solver;
+
+public class GapsAroundKnownCluesSolverMethod : IPicrossSolverMethod {
+  public IEnumerable<IPicrossMove1d> TryToFindMoves(
+      IPicrossLineState lineState) {
+    var clueStates = lineState.ClueStates;
+    var cellStates = lineState.CellStates;
+    var length = cellStates.Count;
+
+    foreach (var clueState in clueStates) {
+      if (!clueState.Used) {
+        continue;
+      }
+
+      var startI = clueState.StartIndex.Value;
+      var beforeI = startI - 1;
+      var afterI = startI + clueState.Length;
+
+      if (beforeI >= 0 &&
+          cellStates[beforeI].Status == PicrossCellStatus.UNKNOWN) {
+        yield return new PicrossCellMove1d(
+            PicrossCellMoveType.MARK_EMPTY,
+            PicrossCellMoveSource.EMPTY_AROUND_KNOWN_CLUE,
+            beforeI);
+      }
+
+      if (afterI < length &&
+          cellStates[afterI].Status == PicrossCellStatus.UNKNOWN) {
+        yield return new PicrossCellMove1d(
+            PicrossCellMoveType.MARK_EMPTY,
+            PicrossCellMoveSource.EMPTY_AROUND_KNOWN_CLUE,
+            afterI);
+      }
+    }
+  }
+}

FinModelUtility/Fin/Fin.Picross/src/solver/GapsAroundKnownCluesSolverMethod.cs

@@ -0,0 +1,104 @@
+using fin.picross.moves;
+using fin.util.enumerables;
+
+namespace fin.picross.solver;
+
+public class MatchingBiggestOrUniqueLengthSolverMethod : IPicrossSolverMethod {
+  public IEnumerable<IPicrossMove1d> TryToFindMoves(
+      IPicrossLineState lineState) {
+    var clueStates = lineState.ClueStates;
+    var cellStates = lineState.CellStates;
+    var length = cellStates.Count;
+
+    var biggestUnusedLength = clueStates.Where(c => !c.Used).Max(c => c.Length);
+
+    int startIndex = -1;
+    var inClue = false;
+
+    for (var i = 0; i < length; ++i) {
+      var cell = cellStates[i].Status == PicrossCellStatus.KNOWN_FILLED;
+
+      if (cell && !inClue) {
+        startIndex = i;
+      }
+
+      if (!cell && inClue) {
+        var clueLength = i - startIndex;
+
+        var beforeI = startIndex - 1;
+        var afterI = i;
+
+        foreach (var move in CheckIfMatchingClue_(
+                     clueStates,
+                     biggestUnusedLength,
+                     startIndex,
+                     clueLength,
+                     beforeI < 0 ||
+                     cellStates[beforeI].Status ==
+                     PicrossCellStatus.KNOWN_EMPTY,
+                     cellStates[afterI].Status ==
+                     PicrossCellStatus.KNOWN_EMPTY)) {
+          yield return move;
+        }
+      }
+
+      inClue = cell;
+    }
+
+    if (inClue) {
+      var clueLength = length - startIndex;
+      var beforeI = startIndex - 1;
+      foreach (var move in CheckIfMatchingClue_(
+                   clueStates,
+                   biggestUnusedLength,
+                   startIndex,
+                   clueLength,
+                   cellStates[beforeI].Status == PicrossCellStatus.KNOWN_EMPTY,
+                   true)) {
+        yield return move;
+      }
+    }
+  }
+
+  private static IEnumerable<IPicrossMove1d> CheckIfMatchingClue_(
+      IReadOnlyList<IReadOnlyPicrossClueState> clueStates,
+      int biggestUnusedClueLength,
+      int startI,
+      int clueLength,
+      bool knownEmptyBefore,
+      bool knownEmptyAfter) {
+    var firstClueWithExactLength
+        = clueStates.Where(c => !c.Used)
+                    .FirstOrDefaultAndCount(c => c.Length == clueLength,
+                                            out var matchingClueCount);
+    if (firstClueWithExactLength == null) {
+      yield break;
+    }
+
+    var isBiggest = clueLength == biggestUnusedClueLength;
+
+    if (matchingClueCount == 1 &&
+        (isBiggest || (knownEmptyBefore && knownEmptyAfter))) {
+      yield return new PicrossClueMove(
+          PicrossClueMoveSource.ONLY_MATCHING_CLUE,
+          firstClueWithExactLength.Clue,
+          startI);
+    }
+
+    if (isBiggest) {
+      if (!knownEmptyBefore) {
+        yield return new PicrossCellMove1d(
+            PicrossCellMoveType.MARK_EMPTY,
+            PicrossCellMoveSource.EMPTY_AROUND_KNOWN_CLUE,
+            startI - 1);
+      }
+
+      if (!knownEmptyAfter) {
+        yield return new PicrossCellMove1d(
+            PicrossCellMoveType.MARK_EMPTY,
+            PicrossCellMoveSource.EMPTY_AROUND_KNOWN_CLUE,
+            startI + clueLength);
+      }
+    }
+  }
+}

FinModelUtility/Fin/Fin.Picross/src/solver/MatchingBiggestOrUniqueLengthSolverMethod.cs

@@ -131,30 +131,50 @@ public static void AddTo<T>(this IEnumerable<T> src,
 
 
   public static bool SequenceEqualOrBothEmpty<T>(
-        this IEnumerable<T>? lhs,
-        IEnumerable<T>? rhs) {
-      if (lhs == null && rhs == null) {
-        return true;
+      this IEnumerable<T>? lhs,
+      IEnumerable<T>? rhs) {
+    if (lhs == null && rhs == null) {
+      return true;
+    }
+
+    return (lhs ?? []).SequenceEqual(rhs ?? []);
+  }
+
+  public static IEnumerable<T[]> SplitByNull<T>(
+      this IEnumerable<Nullable<T>> impl) where T : struct {
+    var current = new LinkedList<T>();
+    foreach (var value in impl) {
+      if (value == null) {
+        yield return current.ToArray();
+        current.Clear();
+        continue;
       }
 
-      return (lhs ?? []).SequenceEqual(rhs ?? []);
+      current.AddLast(value.Value);
     }
 
-    public static IEnumerable<T[]> SplitByNull<T>(
-        this IEnumerable<Nullable<T>> impl) where T : struct {
-      var current = new LinkedList<T>();
-      foreach (var value in impl) {
-        if (value == null) {
-          yield return current.ToArray();
-          current.Clear();
-          continue;
-        }
-
-        current.AddLast(value.Value);
-      }
+    yield return current.ToArray();
+  }
 
-      yield return current.ToArray();
+  public static bool AnyTrue(this IEnumerable<bool> impl) => impl.Any(b => b);
+
+  [MethodImpl(MethodImplOptions.AggressiveInlining)]
+  public static T? FirstOrDefaultAndCount<T>(this IEnumerable<T> enumerable,
+                                             Func<T, bool> selector,
+                                             out int count)
+    => enumerable.Where(selector).FirstOrDefaultAndCount(out count);
+
+  [MethodImpl(MethodImplOptions.AggressiveInlining)]
+  public static T? FirstOrDefaultAndCount<T>(this IEnumerable<T> enumerable,
+                                             out int count) {
+    T? firstValue = default!;
+    count = 0;
+    foreach (var value in enumerable) {
+      if (count++ == 0) {
+        firstValue = value;
+      }
     }
 
-    public static bool AnyTrue(this IEnumerable<bool> impl) => impl.Any(b => b);
-  }
+    return firstValue;
+  }
+}