diff --git a/osu.Game.Rulesets.Catch/Difficulty/CatchDifficultyCalculator.cs b/osu.Game.Rulesets.Catch/Difficulty/CatchDifficultyCalculator.cs
index 63570d44b0..83b5b3bb5c 100644
--- a/osu.Game.Rulesets.Catch/Difficulty/CatchDifficultyCalculator.cs
+++ b/osu.Game.Rulesets.Catch/Difficulty/CatchDifficultyCalculator.cs
@@ -31,7 +31,6 @@ namespace osu.Game.Rulesets.Catch.Difficulty
 
         public override double Calculate(Dictionary<string, double> categoryDifficulty = null)
         {
-
             difficultyHitObjects.Clear();
 
             float circleSize = Beatmap.BeatmapInfo.BaseDifficulty.CircleSize;
@@ -83,7 +82,6 @@ namespace osu.Game.Rulesets.Catch.Difficulty
             // Traverse hitObjects in pairs to calculate the strain value of NextHitObject from the strain value of CurrentHitObject and environment.
             using (List<CatchDifficultyHitObject>.Enumerator hitObjectsEnumerator = difficultyHitObjects.GetEnumerator())
             {
-
                 if (!hitObjectsEnumerator.MoveNext()) return false;
 
                 CatchDifficultyHitObject currentHitObject = hitObjectsEnumerator.Current;
@@ -106,17 +104,17 @@ namespace osu.Game.Rulesets.Catch.Difficulty
         /// This is to eliminate higher influence of stream over aim by simply having more HitObjects with high strain.
         /// The higher this value, the less strains there will be, indirectly giving long beatmaps an advantage.
         /// </summary>
-        protected const double STRAIN_STEP = 750;
+        protected const double strain_step = 750;
 
         /// <summary>
         /// The weighting of each strain value decays to this number * it's previous value
         /// </summary>
-        protected const double DECAY_WEIGHT = 0.94;
+        protected const double decay_weight = 0.94;
 
         protected double CalculateDifficulty()
         {
             // The strain step needs to be adjusted for the algorithm to be considered equal with speed changing mods
-            double actualStrainStep = STRAIN_STEP * TimeRate;
+            double actualStrainStep = strain_step * TimeRate;
 
             // Find the highest strain value within each strain step
             List<double> highestStrains = new List<double>();
@@ -153,17 +151,8 @@ namespace osu.Game.Rulesets.Catch.Difficulty
                 previousHitObject = hitObject;
             }
 
-
-            // Build the weighted sum over the highest strains for each interval
-            double difficulty = 0;
-            double weight = 1;
-            highestStrains.Sort((a, b) => b.CompareTo(a)); // Sort from highest to lowest strain.
-
-            foreach (double strain in highestStrains)
-            {
-                difficulty += weight * strain;
-                weight *= DECAY_WEIGHT;
-            }
+            // calculate maximun strain difficulty
+            double difficulty = StrainCalculator(highestStrains, decay_weight);
 
             return difficulty;
         }
diff --git a/osu.Game.Rulesets.Catch/Difficulty/CatchDifficultyHitObject.cs b/osu.Game.Rulesets.Catch/Difficulty/CatchDifficultyHitObject.cs
index 14f9445c75..f4eefdd7cd 100644
--- a/osu.Game.Rulesets.Catch/Difficulty/CatchDifficultyHitObject.cs
+++ b/osu.Game.Rulesets.Catch/Difficulty/CatchDifficultyHitObject.cs
@@ -36,7 +36,7 @@ namespace osu.Game.Rulesets.Catch.Difficulty
             // We will scale everything by this factor, so we can assume a uniform CircleSize among beatmaps.
             float scalingFactor = NORMALIZED_HITOBJECT_RADIUS / catcherWidthHalf;
 
-            playerPositioningError = ABSOLUTE_PLAYER_POSITIONING_ERROR;// * scalingFactor;
+            playerPositioningError = ABSOLUTE_PLAYER_POSITIONING_ERROR; // * scalingFactor;
             NormalizedPosition = baseHitObject.X * CatchPlayfield.BASE_WIDTH * scalingFactor;
         }
 
diff --git a/osu.Game.Rulesets.Taiko/Difficulty/TaikoDifficultyCalculator.cs b/osu.Game.Rulesets.Taiko/Difficulty/TaikoDifficultyCalculator.cs
index 57e1e65064..197464c10a 100644
--- a/osu.Game.Rulesets.Taiko/Difficulty/TaikoDifficultyCalculator.cs
+++ b/osu.Game.Rulesets.Taiko/Difficulty/TaikoDifficultyCalculator.cs
@@ -122,16 +122,8 @@ namespace osu.Game.Rulesets.Taiko.Difficulty
                 previousHitObject = hitObject;
             }
 
-            // Build the weighted sum over the highest strains for each interval
-            double difficulty = 0;
-            double weight = 1;
-            highestStrains.Sort((a, b) => b.CompareTo(a)); // Sort from highest to lowest strain.
-
-            foreach (double strain in highestStrains)
-            {
-                difficulty += weight * strain;
-                weight *= decay_weight;
-            }
+            // calculate maximun strain difficulty
+            double difficulty = StrainCalculator(highestStrains, decay_weight);
 
             return difficulty;
         }
diff --git a/osu.Game/Rulesets/Difficulty/DifficultyCalculator.cs b/osu.Game/Rulesets/Difficulty/DifficultyCalculator.cs
index 070bc7ddb0..348435b0d0 100644
--- a/osu.Game/Rulesets/Difficulty/DifficultyCalculator.cs
+++ b/osu.Game/Rulesets/Difficulty/DifficultyCalculator.cs
@@ -37,5 +37,20 @@ namespace osu.Game.Rulesets.Difficulty
         }
 
         public abstract double Calculate(Dictionary<string, double> categoryDifficulty = null);
+
+        protected double StrainCalculator(List<double> highestStrains, double decayWeight)
+        {
+            // Build the weighted sum over the highest strains for each interval
+            double difficulty = 0;
+            double weight = 1;
+            highestStrains.Sort((a, b) => b.CompareTo(a)); // Sort from highest to lowest strain.
+
+            foreach (double strain in highestStrains)
+            {
+                difficulty += weight * strain;
+                weight *= decayWeight;
+            }
+            return difficulty;
+        }
     }
 }