Merge branch 'add-snakes_and_ladders_min_turns_solution'

Author: rvguradiya

problems/general/snakes_and_ladders_min_turns.md

@@ -0,0 +1,12 @@
+This problem was asked by **Flipkart**.
+
+[Snakes and Ladders](https://en.wikipedia.org/wiki/Snakes_and_ladders) is a game played on a `10 x 10` board, the goal of which is get from square `1` to square `100`. On each turn players will roll a six-sided die and move forward a number of spaces equal to the result. If they land on a square that represents a snake or ladder, they will be transported ahead or behind, respectively, to a new square.
+
+Find the smallest number of turns it takes to play snakes and ladders.
+
+For convenience, here are the squares representing snakes and ladders, and their outcomes:
+
+```json
+snakes = {16: 6, 48: 26, 49: 11, 56: 53, 62: 19, 64: 60, 87: 24, 93: 73, 95: 75, 98: 78}
+ladders = {1: 38, 4: 14, 9: 31, 21: 42, 28: 84, 36: 44, 51: 67, 71: 91, 80: 100}
+```

solutions/general/snakes_and_ladders_min_turns_solution/Approach.java

@@ -0,0 +1,63 @@
+import java.util.HashMap;
+import java.util.Map;
+
+public class Approach {
+
+    public static int minTurnSolution(Map<Integer, Integer> snakes, Map<Integer, Integer> ladders) {
+        int[] dp = new int[100];
+
+        // Initialize dp array with high values (like Infinity)
+        for (int i = 0; i < dp.length; i++) {
+            dp[i] = Integer.MAX_VALUE;
+        }
+
+        // Traverse through each square of the board
+        for (int i = -1; i < 100; i++) {
+            for (int j = i + 1; j <= i + 6 && j < 100; j++) {
+                if (snakes.containsKey(j + 1)) {
+                    dp[j] = Integer.MAX_VALUE; // Skip the snake square
+                } else if (j <= 6) {
+                    dp[j] = 1; // Early game, squares 1-6 can be reached in 1 turn
+                } else {
+                    dp[j] = Math.min(dp[j], dp[i] == Integer.MAX_VALUE ? Integer.MAX_VALUE : dp[i] + 1);
+                }
+
+                // Handle ladder jumps
+                if (ladders.containsKey(j + 1)) {
+                    dp[ladders.get(j + 1) - 1] = Math.min(dp[ladders.get(j + 1) - 1], dp[j]);
+                }
+            }
+        }
+
+        return dp[99];
+    }
+
+    public static void main(String[] args) {
+        // Define the snakes and ladders
+        Map<Integer, Integer> snakes = new HashMap<>();
+        snakes.put(16, 6);
+        snakes.put(48, 26);
+        snakes.put(49, 11);
+        snakes.put(56, 53);
+        snakes.put(62, 19);
+        snakes.put(64, 60);
+        snakes.put(87, 24);
+        snakes.put(93, 73);
+        snakes.put(95, 75);
+        snakes.put(98, 78);
+
+        Map<Integer, Integer> ladders = new HashMap<>();
+        ladders.put(1, 38);
+        ladders.put(4, 14);
+        ladders.put(9, 31);
+        ladders.put(21, 42);
+        ladders.put(28, 84);
+        ladders.put(36, 44);
+        ladders.put(51, 67);
+        ladders.put(71, 91);
+        ladders.put(80, 100);
+
+        // Call the function and print the result
+        System.out.println(minTurnSolution(snakes, ladders)); // Output: 7
+    }
+}

solutions/general/snakes_and_ladders_min_turns_solution/approach.js

@@ -0,0 +1,41 @@
+function minTurnSolution(snakes, ladders) {
+  let dp = Array(100).fill(Infinity);
+  for (let i = -1; i < 100; i++) {
+    for (let j = i + 1; j <= i + 6 && j < 100; j++) {
+      if (j + 1 in snakes) dp[j] = Infinity;
+      else if (j <= 6) dp[j] = 1;
+      else {
+        dp[j] = Math.min(dp[j], dp[i] + 1);
+      }
+      if (j + 1 in ladders)
+        dp[ladders[j + 1] - 1] = Math.min(dp[ladders[j + 1] - 1], dp[j]);
+    }
+  }
+  return dp[99];
+}
+
+snakes = {
+  16: 6,
+  48: 26,
+  49: 11,
+  56: 53,
+  62: 19,
+  64: 60,
+  87: 24,
+  93: 73,
+  95: 75,
+  98: 78,
+};
+ladders = {
+  1: 38,
+  4: 14,
+  9: 31,
+  21: 42,
+  28: 84,
+  36: 44,
+  51: 67,
+  71: 91,
+  80: 100,
+};
+
+console.log(minTurnSolution(snakes, ladders));

solutions/general/snakes_and_ladders_min_turns_solution/approach.py

@@ -0,0 +1,46 @@
+def min_turn_solution(snakes, ladders):
+    dp = [float('inf')] * 100
+    
+    for i in range(-1, 100):
+        for j in range(i + 1, min(i + 7, 100)):
+            if (j + 1) in snakes:
+                dp[j] = float('inf')  # Skip the snake square
+            elif j <= 6:
+                dp[j] = 1  # Early game, first few squares can be reached in 1 turn
+            else:
+                dp[j] = min(dp[j], dp[i] + 1)  # Normal dice roll progression
+            
+            # Handle ladder jumps
+            if (j + 1) in ladders:
+                dp[ladders[j + 1] - 1] = min(dp[ladders[j + 1] - 1], dp[j])
+    
+    return dp[99]
+
+# Snakes and Ladders configuration
+snakes = {
+    16: 6,
+    48: 26,
+    49: 11,
+    56: 53,
+    62: 19,
+    64: 60,
+    87: 24,
+    93: 73,
+    95: 75,
+    98: 78,
+}
+
+ladders = {
+    1: 38,
+    4: 14,
+    9: 31,
+    21: 42,
+    28: 84,
+    36: 44,
+    51: 67,
+    71: 91,
+    80: 100,
+}
+
+# Output the result
+print(min_turn_solution(snakes, ladders))  # Expected Output: 7