Calculate the NRR for league tables in tournaments like the World Cup, IPL, or Big Bash.
Total runs your team has scored in the tournament.
Use standard cricket format (e.g. 20.4 for 20 overs, 4 balls).
Total runs scored by opponents against your team.
Use standard cricket format (e.g. 50.0).
Your Net Run Rate is:
0.000
Team Run Rate
0.00
Opponent Run Rate
0.00
How is Net Run Rate (NRR) Calculated in Cricket?
Net Run Rate (NRR) is the preferred method for breaking ties in multi-team cricket tournaments, such as the ICC World Cup, T20 World Cup, and league formats like the IPL (Indian Premier League). It serves as a statistical method to rank teams that finish with the same number of points.
Unlike a simple run rate, the Net Run Rate accounts for both your team's scoring ability and your bowling economy. Essentially, it measures how much faster you score compared to how fast your opponents score against you.
The NRR Formula
The calculation involves subtracting the average runs conceded per over from the average runs scored per over.
NRR = (Total Runs Scored ÷ Total Overs Faced) – (Total Runs Conceded ÷ Total Overs Bowled)
Step-by-Step Calculation Guide
Calculate Team Run Rate: Divide the total runs your team has scored in the tournament by the total overs your team has faced.
Calculate Opponent Run Rate: Divide the total runs scored by your opponents (runs conceded by you) by the total overs your team has bowled.
Subtract: Subtract the Opponent Run Rate from the Team Run Rate.
Important Rules for NRR
Decimal Overs: In cricket, an over consists of 6 balls. When calculating NRR, overs like "20.4" (20 overs and 4 balls) must be converted to true decimals. 4 balls is 4/6 of an over, or 0.666. So, 20.4 overs becomes 20.666 mathematically.
All Out Rule: If a team is bowled out (loses all 10 wickets) before their full quota of overs is played, the calculation assumes they faced the full quota. For example, if a team is all out for 150 in 35 overs during a 50-over match, the NRR calculation uses 50 overs, not 35.
Abandoned Matches: Matches that are abandoned with no result usually do not count toward NRR calculations.
Example Scenario
Let's say Team A has played 2 matches:
Match 1: Scored 300 in 50 overs. Conceded 250 in 50 overs.
Match 2: Scored 200 in 40 overs. Conceded 210 in 40.2 overs.
Total Runs Scored: 500 Total Overs Faced: 90 Total Runs Conceded: 460 Total Overs Bowled: 90.33 (50 + 40.333)
Using the calculator above, you can input these aggregate totals to determine if Team A has a positive or negative NRR.
function convertOversToBalls(oversInput) {
// Convert standard cricket notation (e.g., 10.4) to balls
// 10.4 means 10 overs and 4 balls
var strVal = oversInput.toString();
var parts = strVal.split('.');
var overs = parseInt(parts[0]) || 0;
var balls = 0;
if (parts.length > 1) {
// Ensure the decimal part is treated correctly (e.g. .1 is 1 ball, .10 is 10 balls which is invalid but we parse simply)
// Standard input is usually single digit for balls
balls = parseInt(parts[1]);
// Handle cases where user types 10.04 (rare, but treat as 4 balls) or 10.4
if (parts[1].length === 1) {
balls = parseInt(parts[1]);
} else if (parts[1].length >= 2) {
// If user types 10.40, assume 4 balls. If 10.04 assume 4 balls.
balls = parseInt(parts[1]);
}
}
// Validation: balls cannot be >= 6 in standard notation (e.g. 10.6 becomes 11.0)
// However, for calculation safety, we just convert everything to decimal overs base 6
return (overs * 6) + balls;
}
function calculateNRR() {
// Get input values
var runsScored = parseFloat(document.getElementById('totalRunsScored').value);
var oversFacedStr = document.getElementById('totalOversFaced').value;
var runsConceded = parseFloat(document.getElementById('totalRunsConceded').value);
var oversBowledStr = document.getElementById('totalOversBowled').value;
// Basic Validation
if (isNaN(runsScored) || !oversFacedStr || isNaN(runsConceded) || !oversBowledStr) {
alert("Please fill in all fields with valid numbers.");
return;
}
// Convert Overs to Decimal for Division
// Note: 20.3 overs = 20 + 3/6 overs = 20.5
// Helper to parse "20.3"
var getDecimalOvers = function(valStr) {
var parts = valStr.split('.');
var whole = parseInt(parts[0]);
var remainder = parts[1] ? parseInt(parts[1]) : 0;
// If user enters 20.10, usually means 20.1. But cricket notation strictly uses .1 through .5
// To be safe, we treat the number after decimal as ball count.
// Logic: If decimal > 5, it's invalid cricket notation mathematically, but we calculate anyway.
return whole + (remainder / 6);
};
var decimalOversFaced = getDecimalOvers(oversFacedStr);
var decimalOversBowled = getDecimalOvers(oversBowledStr);
if (decimalOversFaced === 0 || decimalOversBowled === 0) {
alert("Overs cannot be zero.");
return;
}
// 1. Calculate Runs Scored per Over
var runRateFor = runsScored / decimalOversFaced;
// 2. Calculate Runs Conceded per Over
var runRateAgainst = runsConceded / decimalOversBowled;
// 3. NRR
var nrr = runRateFor – runRateAgainst;
// Display Results
var resultEl = document.getElementById('nrrResult');
var resultContainer = document.getElementById('result-container');
// Formatting output
var sign = nrr > 0 ? "+" : "";
resultEl.innerText = sign + nrr.toFixed(3);
// Color coding
if (nrr > 0) {
resultEl.style.color = "#2e7d32"; // Green
} else if (nrr < 0) {
resultEl.style.color = "#c62828"; // Red
} else {
resultEl.style.color = "#333";
}
document.getElementById('teamRunRate').innerText = runRateFor.toFixed(2);
document.getElementById('opponentRunRate').innerText = runRateAgainst.toFixed(2);
resultContainer.style.display = 'block';
}