diff --git a/Maths/Combinations.java b/Maths/Combinations.java
index 0fb2437c..cc19ee90 100644
--- a/Maths/Combinations.java
+++ b/Maths/Combinations.java
@@ -7,6 +7,17 @@ public class Combinations {
     assert combinations(10, 5) == 252;
     assert combinations(6, 3) == 20;
     assert combinations(20, 5) == 15504;
+
+    // Since, 200 is a big number its factorial will go beyond limits of long even when 200C5 can be saved in a long
+    // variable. So below will fail
+    // assert combinations(200, 5) == 2535650040l;
+
+    assert combinationsOptimized(100, 0) == 1;
+    assert combinationsOptimized(1, 1) == 1;
+    assert combinationsOptimized(10, 5) == 252;
+    assert combinationsOptimized(6, 3) == 20;
+    assert combinationsOptimized(20, 5) == 15504;
+    assert combinationsOptimized(200, 5) == 2535650040l;
   }
 
   /**
@@ -32,4 +43,32 @@ public class Combinations {
   public static long combinations(int n, int k) {
     return factorial(n) / (factorial(k) * factorial(n - k));
   }
+
+  /**
+   * The above method can exceed limit of long (overflow) when factorial(n) is larger than limits of long variable.
+   * Thus even if nCk is within range of long variable above reason can lead to incorrect result.
+   * This is an optimized version of computing combinations.
+   * Observations:
+   * nC(k + 1) = (n - k) * nCk / (k + 1)
+   * We know the value of nCk when k = 1 which is nCk = n
+   * Using this base value and above formula we can compute the next term nC(k+1)
+   * @param n
+   * @param k
+   * @return nCk
+   */
+  public static long combinationsOptimized(int n, int k) {
+    if (n < 0 || k < 0) {
+      throw new IllegalArgumentException("n or k can't be negative");
+    }
+    if (n < k) {
+      throw new IllegalArgumentException("n can't be smaller than k");
+    }
+    // nC0 is always 1
+    long solution = 1;
+    for(int i = 0; i < k; i++) {
+      long next = (n - i) * solution / (i + 1);
+      solution = next;
+    }
+    return solution;
+  }
 }