Concrete Block Calculator (Blocks, Mortar Bags and Rebar for a Block Wall)

Enter the length and height of the wall (or the number of courses), the block size and the joint width. The core fill, rebar and price fields can be left blank (then they are not calculated).

Units

What to find Block size

Length (mm)

Height (mm)

Thickness (mm)

Joint width (mm)

Waste factor (%)

Wall length (m)

Wall height

By height (m) By courses

Wall height (m)

Core volume per block (L)

Share of cores to fill (%, optional)

Dry mix per liter of mortar (kg/L)

Bag weight (kg)

Vertical rebar spacing (mm, optional)

Horizontal reinforcement every (courses, optional)

Price per block ($, optional)

Price per bag of mortar ($, optional)

The block and joint are in mm, and the wall is in m. The waste factor is extra for half blocks at the ends, corners and breakage, and it applies to both the blocks and the mortar.

Result and figure

Enter the length and height of the wall on the left, choose the block size and press "Calculate". The number of blocks and the amount of mortar will appear here.

[ CLOSE ]

What you can do on this page
What is this calculation used for?
How to Use
Formulas and figures
Symbols and terms
- Symbols
- Terms
Good to know before you start
How to calculate it in Excel
How to calculate it in Google Sheets
How to calculate it in Python
How to write it in LaTeX and other math languages (copy and paste)
How to have ChatGPT do the calculation
DataChef Features
Related Features
NumberChef Calculators List

What you can do on this page

Enter the length and height of the wall (or the number of courses), choose the block size (8, 6 or 12 in CMU, or your own size) and the joint width, and you get the number of courses, the blocks per course and the blocks needed with waste on the spot
The mortar for the joints is found as "bed joints + head joints" and shown in ft³, pounds and bags (such as 80 lb bags; the bag size can be changed). The number of bags before rounding up is shown too, so you can see where the count comes from
Optionally, you can also get the grout for the cores with vertical rebar (enter the share of cores to fill), the number of vertical bars, the courses with horizontal reinforcement, and the rough total length of rebar
You can switch to the reverse: the length of wall you can build with the blocks you have. Handy for seeing how far leftover blocks will go
Enter the price per block and per bag to get an estimated cost. The page also draws the wall in running bond (courses × blocks). A plain-language explanation of the formulas and copy-and-paste formulas for Excel, Google Sheets and Python are also on this page

This page gives a rough estimate of the materials to buy. The height, thickness, reinforcement, pilasters and footing of a block wall are set by local building codes, and many areas require a permit. The block and rebar counts on this page do not check that a wall is safe, so confirm the design with a designer or contractor. The block count is "base count + waste factor"; half blocks at the ends and corners are not counted one by one. To work out the cement and sand for mixing your own mortar, use the "Mortar and Concrete Mix Calculator", and for the concrete in the footing, use the "Concrete Calculator".

What is this calculation used for?

Ordering materials for a DIY block wall along the property line

For example, for a wall 24 ft long and 4 ft (6 courses) high in 8 in CMU, each course takes $24 \times 12 \div 16 = 18$ blocks, the base count is $6 \times 18 = 108$, and with a 5% waste factor you need $\lceil 108 \times 1.05 \rceil = 114$ blocks.
The joint mortar is $108 \times 0.0391 \approx 4.22$ ft³, about 4.43 ft³ with waste, or about 554 lb of dry mix, so seven 80 lb bags of mortar mix. Working this out before you go to the store also helps you plan the delivery: an 8 in block weighs roughly 30 to 40 lb, so 114 blocks weigh about 2 tons.

Low walls for planters, trash can enclosures or shed bases

Walls two or three courses high are a DIY classic. An 8 ft wall two courses high takes 6 blocks × 2 = 12, or 13 with a 5% waste factor. The joint mortar is $12 \times 0.0391 \approx 0.47$ ft³ (about 0.49 ft³ or 62 lb with waste), so one 80 lb bag of mortar mix is enough.
Small jobs are where people most often buy an extra bag they do not need, so a calculation you can follow from ft³ to pounds to bags is useful.

Checking the block count in a contractor's quote

A quote lists the spec and length, such as "8 in CMU, 5 courses, 32 LF". Counting with these formulas gives 24 blocks per course × 5 courses = 120, or $\lceil 120 \times 1.05 \rceil = 126$ with a 5% waste factor.
If the quote is very different, you can ask how the corners, half blocks, pilasters and ends were counted. (A real quote also includes the footing, rebar, grout, the cap, labor and cleanup, so the block count alone cannot tell you whether the price is fair.)

Ordering rebar and grout for the reinforced cores

For a wall 20 ft long and 5 courses high with vertical bars every 32 in and horizontal reinforcement every 2 courses, there are $\lfloor 240 \div 32 \rfloor + 1 = 8$ vertical bars and $\lceil 5 \div 2 \rceil = 3$ reinforced courses, about $8 \times 3.333 + 3 \times 20 \approx 86.7$ ft in all. The grout for the cores with bars (25% of all cores), at 0.25 ft³ of core per block, is $75 \times 0.25 \times 0.25 \approx 4.69$ ft³ (about 0.17 yd³).
Rebar is sold in set lengths (often 10 ft or 20 ft), and embedment and lap splices add more, so allow extra when you decide how many bars to buy. The reinforcement design itself (spacing, bar size, embedment) follows the local building code and the designer.

How far leftover blocks will go

With 40 blocks left from a job (no waste factor) and a 3-course (24 in) edge wall, each course gets $\lfloor 40 \div 3 \rfloor = 13$ blocks, so you can build $13 \times 16 = 208$ in, about 17.3 ft, with 1 block left over.
Since "how many blocks for how many feet" comes out right away, it helps when you look for a use for leftovers or decide how many more blocks to buy.

Formulas and figures

Number of courses

Figure

Standard notation (the usual math form)

$n_h$ $=$ $\lceil$ $H$ $\div$ $($ $h$ $+$ $j$ $)$ $\rceil$

In words (symbols replaced with words)

④ $n_h$: courses $=$ ③ $\lceil$ ① $H$: wall height $\div$ $($ ② $h$: block height $+$ $j$: joint width $)$ $\rceil$

The formula in words

① Take the $H$: wall height

② divide it by the block height $h$ plus the joint width $j$ (the height of one course) to see how many courses tall it is

③ Round up any decimal (the symbol $\lceil\ \rceil$ means "round up")

④ and you get the $n_h$: courses

Quick example

The number of courses for a wall 40 in (3 ft 4 in) high, built with standard CMU (7-5/8 in high) and 3/8 in joints, is

$n_h$: courses $=$ $\lceil$ wall height (40 in) $\div$ $($ block height (7.625 in) $+$ joint (0.375 in) $)$ $\rceil$

$7.625 + 0.375 = 8$

$40 \div 8 = 5$

$\lceil 5 \rceil = 5$

Key idea

Each block is laid with a joint (a layer of mortar) under it, so one course is "block height + joint width" tall. A standard CMU (7-5/8 in high) with a 3/8 in joint makes exactly 8 in per course. This "block size + joint" is called the module, and the wall height divided by the module is the number of courses. If it does not divide evenly, round up; the built height is then courses × 8 in. Before calculating, put the wall height and the block height in the same unit (4 ft = 48 in, for example).

Blocks per course

Figure

Standard notation (the usual math form)

$n_l$ $=$ $\lceil$ $L$ $\div$ $($ $a$ $+$ $j$ $)$ $\rceil$

In words (symbols replaced with words)

④ $n_l$: blocks per course $=$ ③ $\lceil$ ① $L$: wall length $\div$ $($ ② $a$: block length $+$ $j$: joint width $)$ $\rceil$

The formula in words

① Take the $L$: wall length

② divide it by the block length $a$ plus the joint width $j$ (the length of one block) to see how many blocks long it is

③ Round up any decimal

④ and you get the $n_l$: blocks per course

Quick example

The blocks per course for a wall 20 ft (240 in) long, with standard CMU (15-5/8 in long) and 3/8 in joints, is

$n_l$: blocks per course $=$ $\lceil$ wall length (240 in) $\div$ $($ block length (15.625 in) $+$ joint (0.375 in) $)$ $\rceil$

$15.625 + 0.375 = 16$

$240 \div 16 = 15$

$\lceil 15 \rceil = 15$

Key idea

The length works the same way: one block takes "block length + joint width", which is 16 in for a standard CMU. A 20 ft wall takes exactly 15 blocks; a 22 ft wall (264 in) gives $264 \div 16 = 16.5$, rounded up to 17, and that course is built $17 \times 16 = 272$ in long (cut the end block or adjust the joints). Courses × blocks per course gives the base count. Estimators also use the rule of thumb "a standard CMU with a 3/8 in joint takes $144 \div (16 \times 8) = 1.125$ blocks per square foot of wall". Multiply the wall area (length × height) by 1.125 and check that it is close to this calculator's base count; a big difference often means a unit mix-up (feet and inches). In running bond (each course offset by half a block), every other course has a half block at each end. Two half blocks make one whole block, so the formula above still holds, and cutting blocks or buying half blocks is covered by the waste factor.

Blocks needed with waste

Standard notation (the usual math form)

$N_0$ $=$ $n_h$ $\times$ $n_l$

$N$ $=$ $\lceil$ $N_0$ $\times$ $($ $1$ $+$ $\dfrac{r}{100}$ $)$ $\rceil$

In words (symbols replaced with words)

③ $N_0$: base count $=$ ① $n_h$: courses $\times$ ② $n_l$: blocks per course

⑤ $N$: blocks needed with waste $=$ $\lceil$ $N_0$: base count $\times$ $($ $1$ $+$ ④ $\dfrac{\text{waste factor } r}{100}$ $)$ $\rceil$

The formula in words

① Take the $n_h$: courses

② multiply it by the $n_l$: blocks per course

③ and you get the $N_0$: base count . Then multiply that by 1 plus

④ the waste factor $r$ (%) divided by 100 and round up any decimal

⑤ to get the $N$: blocks needed with waste

Quick example

The blocks needed for a wall of 5 courses × 15 blocks with a 5% waste factor are

$N$: blocks needed $=$ $\lceil$ courses (5) $\times$ per course (15) $\times$ $($ $1$ $+$ 5 ÷ 100 $)$ $\rceil$

$5 \times 15 = 75$

$75 \times \left( 1 + \dfrac{5}{100} \right) = 75 \times 1.05 = 78.75$

$\lceil 78.75 \rceil = 79$

Key idea

The base count, "courses × blocks per course", counts the wall as a plain rectangle. In practice there are also blocks cut in half at the ends in running bond, blocks turned at the corners, and blocks broken in delivery or during the work. Instead of counting each one, this page adds a "waste factor", and 3 to 5% is common. Use more (toward 5%) for walls with many corners or when you cut your own half blocks. Blocks are sold one at a time, so round up. (Check: the wall is $20 \times 40 \div 12 \approx 66.7$ ft², and $66.7 \times 1.125 = 75$, the same as the base count.)

Joint mortar (bed joints + head joints)

Figure

Standard notation (the usual math form)

$V_1$ $=$ $N_0$ $\times$ $t$ $\times$ $j$ $\times$ $\{$ $(a + j)$ $+$ $h$ $\}$

In words (symbols replaced with words)

⑥ $V_1$: joint mortar volume $=$ ① $N_0$: base count $\times$ ② $t$: block thickness $\times$ ③ $j$: joint width $\times$ $\{$ ④ $a + j$: bed joint length $+$ ⑤ $h$: head joint height $\}$

The formula in words

① For each block in the $N_0$: base count , count mortar with a cross-section of

② $t$: block thickness ×

③ $j$: joint width , running along the

④ $a + j$: bed joint length (under the block) and the

⑤ $h$: head joint height (beside the block) . Multiply and add it all up to get the

⑥ $V_1$: joint mortar volume

Quick example

The joint mortar for a wall with a base count of 75 standard 8 in CMU (7.625 in thick, 15.625 × 7.625 in face) and 3/8 in joints is

$V_1$: joint mortar $=$ base count (75) $\times$ thickness (7.625 in) $\times$ joint (0.375 in) $\times$ $\{$ bed joint (15.625 + 0.375 in) $+$ head joint (7.625 in) $\}$

$7.625 \times 0.375 \times (16 + 7.625) \approx 67.55\,\mathrm{in^3}$

$75 \times 67.55 \div 1728 \approx 2.932\,\mathrm{ft^3}$

Key idea

Count the joint mortar as "each block has one bed joint under it and one head joint beside it". The bed joint runs the module length $a + j$ under the block, the head joint runs the block height $h$ beside it, and both have a cross-section of thickness $t$ × joint width $j$. One block's share is $t \times j \times \{(a + j) + h\}$: about 67.6 in³ (0.039 ft³) for an 8 in CMU with a 3/8 in joint, and about 103 in³ (0.060 ft³) for a 12 in CMU. Divide cubic inches by 1,728 ($= 12^3$) to get cubic feet. This formula counts mortar across the full thickness $t$. In real blockwork, mortar is often laid only on the face shells, not over the cores, which uses less; on the other hand, mortar dropped, squeezed out or soaked up by the blocks uses more. Treat the result as a middle estimate, and apply the waste factor in the next formula. The bed and head joints are shown separately in the result.

Core fill (grout in the cores)

Standard notation (the usual math form)

$V_2$ $=$ $N_0$ $\times$ $c$ $\times$ $\dfrac{f}{100}$

In words (symbols replaced with words)

④ $V_2$: core fill $=$ ① $N_0$: base count $\times$ ② $c$: core volume per block $\times$ ③ $\dfrac{\text{share of cores filled } f}{100}$

The formula in words

① Take the $N_0$: base count

② multiply it by the $c$: core volume per block (ft³) to get the volume of all the cores, then multiply by

③ the share of cores filled $f$ (%) divided by 100

④ to get the $V_2$: core fill

Quick example

For a base count of 75 blocks with 0.25 ft³ of core per block, filling only the cores with vertical bars (25% of all cores) takes

$V_2$: core fill $=$ base count (75) $\times$ core volume (0.25 ft³) $\times$ 25 ÷ 100

$75 \times 0.25 \times \dfrac{25}{100} = 75 \times 0.25 \times 0.25 = 4.6875\,\mathrm{ft^3}$

Key idea

The vertical bars of a block wall run through the cores, and those cores are filled with grout (a fluid cement mix; some small projects use mortar) to lock the rebar and blocks together. A standard CMU has two cores, so the cores repeat every 8 in. With vertical bars every 32 in and only those cores filled, that is "1 in 4" = 25%; filling every core (a fully grouted wall) is 100%. The core volume varies by product, so treat the value filled in for each size as a rough guide, and use the maker's core volume or grout table if there is one. The rough values come from the block's actual size and its hollow share: an 8 in CMU is $7.625 \times 7.625 \times 15.625 \approx 908$ in³ (about 0.53 ft³) overall, and hollow units (ASTM C90) are roughly half open space, so about 0.25 ft³ of core. Which cores get bars (the bar spacing) is set by the local building code and the designer.

Weight of dry mix and number of bags

Standard notation (the usual math form)

$V'$ $=$ $($ $V_1$ $+$ $V_2$ $)$ $\times$ $($ $1$ $+$ $\dfrac{r}{100}$ $)$

$W$ $=$ $V'$ $\times$ $\rho$

$B$ $=$ $\lceil$ $W$ $\div$ $b$ $\rceil$

In words (symbols replaced with words)

④ $V'$: mortar with waste $=$ $($ ① $V_1$: joint mortar $+$ ② $V_2$: core fill $)$ $\times$ $($ $1$ $+$ ③ $\dfrac{\text{waste factor } r}{100}$ $)$

⑥ $W$: weight of dry mix $=$ $V'$: mortar with waste $\times$ ⑤ $\rho$: dry mix per ft³

⑧ $B$: bags $=$ $\lceil$ $W$: weight of dry mix $\div$ ⑦ $b$: bag weight $\rceil$

The formula in words

① Add the $V_1$: joint mortar (ft³)

② and the $V_2$: core fill (ft³) , then multiply by 1 plus

③ the waste factor $r$ (%) divided by 100

④ to get the $V'$: mortar with waste (ft³) . Multiply that by the

⑤ $\rho$: dry mix per ft³ (lb/ft³)

⑥ to get the $W$: weight of dry mix (lb) . Divide that by the

⑦ $b$: bag weight (lb) and round up any decimal

⑧ to get the $B$: bags

Quick example

With 2.932 ft³ of joint mortar, 4.6875 ft³ of core fill, a 5% waste factor, 125 lb of dry mix per ft³ and 80 lb bags, the weight and bags are

$V'$: with waste $=$ $($ joints (2.932 ft³) $+$ core fill (4.6875 ft³) $)$ $\times$ $($ $1$ $+$ 5 ÷ 100 $)$

$(2.932 + 4.6875) \times 1.05 \approx 7.620 \times 1.05 \approx 8.000\,\mathrm{ft^3}$

$8.000 \times 125 \approx 1000.06\,\mathrm{lb}$

$1000.06 \div 80 \approx 12.50 \quad \lceil 12.50 \rceil = 13$

Key idea

The mortar amount is the mixed volume, after water is added. What you buy in bags is the dry mix, so multiply by "how many pounds of dry mix make 1 ft³ of mixed mortar" ($\rho$) to get the weight. If the bag says something like "80 lb makes about 0.64 ft³", work it out as $80 \div 0.64 = 125$; if unsure, 125 lb/ft³ is a reasonable guide. Bags are sold one at a time, so round up. (In the US, the grout for the cores is often a separate product, such as bagged masonry grout or ready-mix grout from a truck. To estimate it separately, run the calculator once with core fill only.) If you mix your own mortar from cement and sand, enter the mortar with waste $V'$ as the volume needed in the "Mortar and Concrete Mix Calculator" to get the amount and bags of cement and sand (set its waste factor to 0 there, or the waste is counted twice).

Rough count and length of rebar

Standard notation (the usual math form)

$m_v$ $=$ $\lfloor$ $L'$ $\div$ $p$ $\rfloor$ $+$ $1$

$m_h$ $=$ $\lceil$ $n_h$ $\div$ $k$ $\rceil$

$\ell$ $=$ $m_v$ $\times$ $H'$ $+$ $m_h$ $\times$ $L'$

In words (symbols replaced with words)

③ $m_v$: vertical bars $=$ $\lfloor$ ① $L'$: built length $\div$ ② $p$: vertical bar spacing $\rfloor$ $+$ $1$

⑥ $m_h$: courses with horizontal reinforcement $=$ $\lceil$ ④ $n_h$: courses $\div$ ⑤ $k$: courses between horizontal reinforcement $\rceil$

⑧ $\ell$: rough total rebar length $=$ $m_v$: vertical bars $\times$ ⑦ $H'$: built height $+$ $m_h$: courses with horizontal reinforcement $\times$ $L'$: built length

The formula in words

① Take the $L'$: built length

② divide it by the $p$: vertical bar spacing , round down (the symbol $\lfloor\ \rfloor$ means "round down"), and add 1 for the bar at the start

③ to get the $m_v$: vertical bars . Also, take the

④ $n_h$: courses

⑤ divide by the $k$: courses between horizontal reinforcement and round up

⑥ to get the $m_h$: courses with horizontal reinforcement . The vertical bars times the

⑦ $H'$: built height , plus those courses times the built length, gives the

⑧ $\ell$: rough total rebar length

Quick example

For a wall built 240 in (20 ft) long and 40 in (5 courses) high, with vertical bars every 32 in and horizontal reinforcement every 2 courses, the counts and length are

$m_v = \lfloor 240 \div 32 \rfloor + 1 = 7 + 1 = 8$

$m_h = \lceil 5 \div 2 \rceil = 3$

$\ell = 8 \times 3.333 + 3 \times 20 \approx 26.7 + 60 = 86.7\,\mathrm{ft}$

Key idea

Vertical bars start at one end of the wall and stand at a fixed spacing, so the count is "length ÷ spacing" rounded down, plus 1 for the first bar (for 240 in at 32 in, bars at 0, 32, 64 … 224 in make 8; many designs also add a bar at the far end). Horizontal reinforcement goes in every few courses, as ladder-type joint reinforcement in the bed joints or as bars in bond beam blocks, so the courses divided by "every how many courses" and rounded up gives the number of reinforced courses. The total length is only a very rough guide for how much steel to buy. Real rebar is longer, because of the embedment into the footing, the lap splices between bars, and the work at the top and corners, none of which are in this formula. Bar size, spacing, embedment and other reinforcement details are set by the local building code and the designer.

Estimated cost

Standard notation (the usual math form)

$T$ $=$ $N$ $\times$ $u_1$ $+$ $B$ $\times$ $u_2$

In words (symbols replaced with words)

⑤ $T$: estimated cost $=$ ① $N$: blocks needed with waste $\times$ ② $u_1$: price per block $+$ ③ $B$: bags $\times$ ④ $u_2$: price per bag

The formula in words

① Multiply the $N$: blocks needed with waste

② by the $u_1$: price per block ,

③ multiply the $B$: bags of mortar mix

④ by the $u_2$: price per bag , and add the two

⑤ to get the $T$: estimated cost

Quick example

The cost of 79 blocks at $2.50 each and 13 bags of mortar mix at $10 each is

$T$: estimated cost $=$ blocks (79) $\times$ price ($2.50) $+$ bags (13) $\times$ price ($10)

$79 \times 2.50 + 13 \times 10 = 197.50 + 130 = 327.50$

Key idea

Multiply the prices by the blocks with waste and the bags rounded up. Materials without a price are left out of the cost. Besides blocks and mortar, the footing concrete, rebar, tie wire, grout, cap blocks and tools cost extra. The calculator rounds the cost to the nearest dollar ($328 here).

Reverse: the wall length you can build with the blocks you have

Standard notation (the usual math form)

$M'$ $=$ $\lfloor$ $M$ $\div$ $($ $1$ $+$ $\dfrac{r}{100}$ $)$ $\rfloor$

$L_{\max}$ $=$ $\lfloor$ $M'$ $\div$ $n_h$ $\rfloor$ $\times$ $(a + j)$

In words (symbols replaced with words)

③ $M'$: usable blocks $=$ $\lfloor$ ① $M$: blocks you have $\div$ $($ $1$ $+$ ② $\dfrac{\text{waste factor } r}{100}$ $)$ $\rfloor$

⑥ $L_{\max}$: wall length you can build $=$ $\lfloor$ $M'$: usable blocks $\div$ ④ $n_h$: courses $\rfloor$ $\times$ ⑤ $a + j$: length of one block with joint

The formula in words

① Take the $M$: blocks you have

② divide by 1 plus the waste factor $r$ (%) divided by 100 and round down (setting the waste aside as spares first)

③ to get the $M'$: usable blocks . Divide that by the

④ $n_h$: courses and round down to get the blocks per course, then multiply by the

⑤ $a + j$: length of one block with joint

⑥ to get the $L_{\max}$: wall length you can build

Quick example

With 100 standard CMU (3/8 in joints) and a 5% waste factor, the length of a 5-course (40 in) wall you can build is

$\lfloor 100 \div 1.05 \rfloor = \lfloor 95.23\ldots \rfloor = 95$

$\lfloor 95 \div 5 \rfloor = 19$

$19 \times 16 = 304\,\mathrm{in} \approx 25.3\,\mathrm{ft}$

Key idea

This follows the block count formulas backward. In the reverse, you cannot run short, so round down instead of up. The waste factor is set aside first to keep spares for broken blocks and half blocks. In the example, $5 \times 19 = 95$ blocks are used and 5 are left as spares. If you give the height instead of courses, the courses are found with the same formula (rounded up) as for the block count.

The blocks for a block wall start from "courses (height ÷ 8 in, rounded up) × blocks per course (length ÷ 16 in, rounded up)", with a waste factor added for half blocks, corners and breakage (about 1.125 blocks per square foot of wall). Joint mortar is counted as "one bed joint + one head joint per block", turned into the weight of dry mix, and divided into bags rounded up.

Symbols and terms

Symbols

$a$	ay	The length of one block. 15.625 in (15-5/8 in) for a standard CMU. Use the same unit as the wall when calculating.
$h$	aitch	The height of one block. 7.625 in (7-5/8 in) for a standard CMU. From the first letter of "height".
$t$	tee	The block thickness (the wall thickness). 7.625 in for an 8 in CMU (5.625 in for 6 in, 11.625 in for 12 in). From the first letter of "thickness"; it is also the width of the mortar joint.
$j$	jay	The joint width (the thickness of mortar between blocks). 3/8 in (0.375 in) is standard for blockwork. From the first letter of "joint".
$L$	el	The wall length (ft), from the first letter of "length". For a wall that turns corners, the total of all sides.
$H$	capital aitch	The wall height (ft): the height of the blockwork above the footing.
$n_h$	n sub h	The number of courses (how many rows high). It is found with $n_h = \lceil H \div (h + j) \rceil$.
$n_l$	n sub l	The blocks per course (how many in a row). It is found with $n_l = \lceil L \div (a + j) \rceil$.
$N_0$	N sub zero	The base count: courses × blocks per course, counting the wall as a rectangle.
$r$	ar	The waste factor (%): the extra for half blocks, corners and breakage, applied to both the blocks and the mortar. From the first letter of "rate".
$N$	en	The blocks needed with waste. It is found with $N = \lceil N_0 (1 + r \div 100) \rceil$.
$L'$, $H'$	L prime, H prime	The built length and height (with joints). $L' = n_l (a + j)$ and $H' = n_h (h + j)$; the real size when laid with the rounded-up blocks and courses.
$V_1$	V sub one	The joint mortar volume (ft³): bed joints plus head joints, found with $V_1 = N_0 \, t \, j \{(a + j) + h\}$. From the first letter of "volume".
$c$	see	The volume of the holes (cores) in one block (ft³). It varies by product, so the value filled in for each size is a rough guide. From the first letter of "cavity".
$f$	ef	The share of cores to fill (%). 25% for vertical bars every 32 in with only those cores filled, 100% for all cores. From the first letter of "fill".
$V_2$	V sub two	The core fill volume (ft³). It is found with $V_2 = N_0 \, c \, f \div 100$.
$V'$	V prime	The mortar with waste (ft³). It is found with $V' = (V_1 + V_2)(1 + r \div 100)$.
$\rho$	rho	The weight of dry mix needed for 1 ft³ of mixed mortar (lb/ft³). The default is 125. It is the Greek letter rho, often used for density in physics.
$W$	double-u	The weight of dry mix (lb). It is found with $W = V' \rho$. From the first letter of "weight".
$b$	bee	The weight of one bag (lb). The default is 80 lb. From the first letter of "bag".
$B$	capital bee	The bags needed. It is found with $B = \lceil W \div b \rceil$.
$p$	pee	The vertical bar spacing (in), from the first letter of "pitch".
$m_v$	m sub v	The number of vertical bars. It is found with $m_v = \lfloor L' \div p \rfloor + 1$; v is for "vertical".
$k$	kay	How many courses apart the horizontal reinforcement goes.
$m_h$	m sub h	The number of courses with horizontal reinforcement. It is found with $m_h = \lceil n_h \div k \rceil$; h is for "horizontal".
$\ell$	script el	The rough total rebar length (ft), found with $\ell = m_v H' + m_h L'$. Embedment and lap splices are not included. It is a script l, from "length".
$u_1$, $u_2$	u sub one, u sub two	The price per block and per bag of mortar mix ($), from the first letter of "unit price".
$T$	tee	The estimated cost ($), found with $T = N u_1 + B u_2$. From the first letter of "total".
$M$	em	In the reverse mode, the number of blocks you have.
$M'$	M prime	In the reverse mode, the usable blocks after setting aside the waste factor as spares. It is found with $M' = \lfloor M \div (1 + r \div 100) \rfloor$.
$L_{\max}$	L max	In the reverse mode, the wall length you can build with the blocks you have (with joints).
$\lceil x \rceil$	ceiling of x	The symbol for rounding up to a whole number, called the ceiling function. (Example - $\lceil 16.5 \rceil = 17$, $\lceil 6 \rceil = 6$)
$\lfloor x \rfloor$	floor of x	The symbol for rounding down to a whole number, called the floor function. (Example - $\lfloor 95.23 \rfloor = 95$, $\lfloor 10 \rfloor = 10$)

Terms

concrete block (CMU)	A building block made of cement, sand and fine gravel, used for walls, planter edges and shed foundations. In the US it is called a concrete masonry unit (CMU), and informally a cinder block. The common size is 8 × 8 × 16 in nominal (7-5/8 × 7-5/8 × 15-5/8 in actual), with 6 in and 12 in widths too.
hollow block	A concrete block with holes (cores) running from top to bottom. Most wall blocks are this type. Running rebar through the cores and filling them with grout ties the blocks and the footing together. Hollow units (ASTM C90) are roughly half open space, though the core volume varies by size and product.
stretcher block	The most common shape of concrete block, 15-5/8 × 7-5/8 in on the face with cores running through it. Other shapes include bond beam blocks (with a channel for horizontal bars), corner blocks with one flat end, and half blocks.
mortar joint	The layer of mortar between blocks. 3/8 in is standard for blockwork, and a 15-5/8 × 7-5/8 in block plus a 3/8 in joint makes a neat 16 × 8 in. Horizontal joints are bed joints and vertical ones are head joints.
bed joint	The horizontal layer of mortar between courses. It is spread before the next block is set on top. On this page, each block has one bed joint under it (as long as the block plus the joint).
head joint	The vertical layer of mortar between blocks side by side in a course. On this page, each block has one head joint beside it (as tall as the block).
running bond	Laying each course offset by half a block from the one below, so the head joints do not line up in a straight vertical line. The load spreads out and the wall is stronger. It is the standard for block walls, with a half block at each end of every other course. Lining up the head joints vertically is called stack bond.
module	The block size plus the joint width, the unit that repeats. A standard CMU with a 3/8 in joint makes a 16 × 8 in module; divide the wall length and height by it to get the blocks and courses.
course	One row of blocks in a wall. Courses × the module height (8 in) is the built height.
half block	A block half as long as a stretcher (7-5/8 in), used at the ends of every other course in running bond. You can buy half blocks or cut full blocks. This page does not count them one by one; they are covered by the waste factor.
waste factor	How much more than the net amount you buy, in percent. For a block wall it covers half blocks at the ends, corners, blocks broken in delivery or during the work, and mortar that is dropped or squeezed out. 3 to 5% is common, but it depends on the wall shape and your experience.
grout	A fluid mix of cement, sand and small gravel poured into the cores of a block wall to lock the rebar and blocks together. Which cores are filled (the bar spacing) is set by the reinforcement design. Some small projects fill the cores with mortar instead.
vertical rebar	Steel reinforcing bars running up the wall. They rise from the footing through the block cores, and the cores are then filled with grout. The spacing, bar size and embedment follow the local building code and the designer.
horizontal reinforcement	Steel running along the length of the wall every few courses. It is either ladder- or truss-type joint reinforcement laid in the bed joints, or rebar in bond beam blocks filled with grout. How often it goes in is part of the reinforcement design.
reinforcement design	Where the rebar goes, what size and at what spacing. For block walls it is set by local building codes and the designer; the counts on this page are only a rough materials estimate.
embedment	Setting the end of a rebar far enough into the concrete of the footing that it cannot pull out. Vertical bars are embedded in the footing, so they need to be longer than the wall is high.
lap splice	Joining two rebars by overlapping them by a required length and tying them together. Each splice takes extra steel, which is not included in the rough total length on this page.
mixed volume	Mortar after water is added and it is mixed. The mortar amounts on this page are mixed volumes; multiply by the dry mix per ft³ (lb/ft³) to get the weight of the bagged material.
mortar mix	A bagged dry mix of cement, lime and sand. Just add water and mix. 80 lb bags are common, and the bag shows about how much mortar it makes. To mix cement and sand yourself, use the "Mortar and Concrete Mix Calculator" for the amounts.
footing	The concrete base at the bottom of the wall that carries the blocks. A block wall sits on a continuous footing along its length, with the vertical bars rising from it. Work out the concrete for it with the "Concrete Calculator".
pilaster	A thickened column built into a long or tall wall at intervals to help keep it from falling over. Whether pilasters are needed, and how far apart, is set by local building codes; they are not included in the block count on this page.
cap	The top of a wall or footing. A block wall is often finished with solid cap blocks or a mortar top.
rounding up	Changing a number with a decimal part to the next whole number. Blocks and bags are sold one at a time, so blocks, courses and bags are rounded up.
rounding down	Dropping the decimal part to get a whole number. In the reverse (the length you can build with the blocks you have), round down so you do not run short.

Good to know before you start

Here is what helps you use the calculation on this page with real understanding, not just by pressing the button.

Converting units of length (Grades 4–5)	Knowing that 1 ft = 12 in, and turning a 20 ft wall into 240 in
Volume and its units (Grades 5–6)	Knowing that the volume of a box is length × width × height Knowing that 1 ft³ = 12 × 12 × 12 = 1,728 in³, and turning 5,066 in³ into about 2.93 ft³
Multiplying and dividing decimals (Grade 5)	Understanding decimal calculations such as $15.625 + 0.375$ and $7.625 \times 0.375 \times 23.625$ (a calculator can do the arithmetic)
Percents (Grade 6)	Knowing that "5% more" is the same as "× 1.05" Knowing that "25% of the whole" is the same as "× 0.25"
Rounding (Grades 3–4)	Knowing the difference between rounding up, rounding down and rounding to the nearest Being able to explain in your own words why material counts are rounded up, while the length you can build with what you have is rounded down

How to calculate it in Excel

Copy the whole table below and paste it into cell A1 in Excel. It works as is.

Table to find the number of courses

Wall height (in)	40
Block height (in)	7.625
Joint width (in)	0.375
Courses	=ROUNDUP(B1/(B2+B3),0)

Table to find the blocks per course

Wall length (ft)	20
Block length (in)	15.625
Joint width (in)	0.375
Blocks per course	=ROUNDUP(B1*12/(B2+B3),0)

Table to find the blocks needed with waste

Courses	5
Blocks per course	15
Waste factor (%)	5
Base count	=B1*B2
Blocks needed with waste	=ROUNDUP(B4*(1+B3/100),0)

Table to find the joint mortar

Base count	75
Block length (in)	15.625
Block height (in)	7.625
Block thickness (in)	7.625
Joint width (in)	0.375
Joint mortar (ft³)	=B1B4B5*((B2+B5)+B3)/1728

Table to find the core fill

Base count	75
Core volume per block (ft³)	0.25
Share of cores to fill (%)	25
Core fill (ft³)	=B1B2B3/100

Table to find the weight of dry mix and the bags

Joint mortar (ft³)	2.932
Core fill (ft³)	4.6875
Waste factor (%)	5
Dry mix per ft³ (lb/ft³)	125
Bag weight (lb)	80
Mortar with waste (ft³)	=(B1+B2)*(1+B3/100)
Weight of dry mix (lb)	=B6*B4
Bags	=ROUNDUP(B7/B5,0)

Table to find the rough count and length of rebar

Built length (in)	240
Built height (in)	40
Courses	5
Vertical bar spacing (in)	32
Horizontal reinforcement every (courses)	2
Vertical bars	=ROUNDDOWN(B1/B4,0)+1
Courses with horizontal reinforcement	=ROUNDUP(B3/B5,0)
Rough total rebar length (ft)	=(B6B2+B7B1)/12

Table to find the estimated cost

Blocks needed with waste	79
Price per block ($)	2.5
Bags	13
Price per bag ($)	10
Estimated cost ($)	=B1B2+B3B4

Table to find the wall length you can build with the blocks you have

Blocks you have	100
Waste factor (%)	5
Courses	5
Block length (in)	15.625
Joint width (in)	0.375
Usable blocks	=ROUNDDOWN(B1/(1+B2/100),0)
Blocks per course	=ROUNDDOWN(B6/B3,0)
Wall length you can build (ft)	=B7*(B4+B5)/12

After pasting, the upper rows of column B are your inputs and the last row (or the last few rows) is calculated automatically.
"ROUNDUP(value, 0)" rounds up and "ROUNDDOWN(value, 0)" rounds down to a whole number (the ⌈ ⌉ and ⌊ ⌋ in the formulas).
Feet are turned into inches with "*12", and cubic inches into cubic feet with "/1728" (12 × 12 × 12). B4 in the first table is 5 courses, B4 in the second is 15 blocks, B5 in the third is 79 blocks, B6 in the fourth is about 2.932 ft³, B4 in the fifth is 4.6875 ft³, B8 in the sixth is 13 bags, B8 in the seventh is about 86.7 ft, B5 in the eighth is $327.50, and B8 in the ninth is about 25.3 ft. Just change column B to your own numbers.

How to calculate it in Google Sheets

Copy the whole table below and paste it into cell A1 in Google Sheets. It works as is.

Table to find the number of courses

Wall height (in)	40
Block height (in)	7.625
Joint width (in)	0.375
Courses	=ROUNDUP(B1/(B2+B3),0)

Table to find the blocks per course

Wall length (ft)	20
Block length (in)	15.625
Joint width (in)	0.375
Blocks per course	=ROUNDUP(B1*12/(B2+B3),0)

Table to find the blocks needed with waste

Courses	5
Blocks per course	15
Waste factor (%)	5
Base count	=B1*B2
Blocks needed with waste	=ROUNDUP(B4*(1+B3/100),0)

Table to find the joint mortar

Base count	75
Block length (in)	15.625
Block height (in)	7.625
Block thickness (in)	7.625
Joint width (in)	0.375
Joint mortar (ft³)	=B1B4B5*((B2+B5)+B3)/1728

Table to find the core fill

Base count	75
Core volume per block (ft³)	0.25
Share of cores to fill (%)	25
Core fill (ft³)	=B1B2B3/100

Table to find the weight of dry mix and the bags

Joint mortar (ft³)	2.932
Core fill (ft³)	4.6875
Waste factor (%)	5
Dry mix per ft³ (lb/ft³)	125
Bag weight (lb)	80
Mortar with waste (ft³)	=(B1+B2)*(1+B3/100)
Weight of dry mix (lb)	=B6*B4
Bags	=ROUNDUP(B7/B5,0)

Table to find the rough count and length of rebar

Built length (in)	240
Built height (in)	40
Courses	5
Vertical bar spacing (in)	32
Horizontal reinforcement every (courses)	2
Vertical bars	=ROUNDDOWN(B1/B4,0)+1
Courses with horizontal reinforcement	=ROUNDUP(B3/B5,0)
Rough total rebar length (ft)	=(B6B2+B7B1)/12

Table to find the estimated cost

Blocks needed with waste	79
Price per block ($)	2.5
Bags	13
Price per bag ($)	10
Estimated cost ($)	=B1B2+B3B4

Table to find the wall length you can build with the blocks you have

Blocks you have	100
Waste factor (%)	5
Courses	5
Block length (in)	15.625
Joint width (in)	0.375
Usable blocks	=ROUNDDOWN(B1/(1+B2/100),0)
Blocks per course	=ROUNDDOWN(B6/B3,0)
Wall length you can build (ft)	=B7*(B4+B5)/12

The same formulas as in Excel work as is (ROUNDUP and ROUNDDOWN have the same names). Copy the whole table, paste it into cell A1, and replace the numbers in column B with your own.

How to calculate it in Python

import math

wall_length_ft = 20.0      # wall length (ft)
wall_height_in = 40.0      # wall height (in)
block_length_in = 15.625   # block length (in), 15-5/8
block_height_in = 7.625    # block height (in), 7-5/8
block_thickness_in = 7.625 # block thickness (in), 8 in CMU
joint_in = 0.375           # joint width (in), 3/8
loss_rate = 5              # waste factor (%)
core_ft3 = 0.25            # core volume per block (ft3)
fill_ratio = 25            # share of cores to fill (%)
lb_per_ft3 = 125           # dry mix per ft3 of mortar (lb/ft3)
bag_lb = 80                # bag weight (lb)
rebar_pitch_in = 32        # vertical bar spacing (in)
rebar_every = 2            # horizontal reinforcement every (courses)
price_block = 2.50         # price per block ($)
price_bag = 10             # price per bag ($)

# Put everything in inches and make the module sizes (block + joint)
a = block_length_in
h = block_height_in
t = block_thickness_in
j = joint_in
module_l = a + j
module_h = h + j
wall_length_in = wall_length_ft * 12

courses = math.ceil(wall_height_in / module_h)           # courses (rounded up)
per_course = math.ceil(wall_length_in / module_l)        # blocks per course (rounded up)
blocks_base = courses * per_course                       # base count
blocks_needed = math.ceil(blocks_base * (1 + loss_rate / 100))   # blocks needed with waste
length_actual_in = per_course * module_l                 # built length (in)
height_actual_in = courses * module_h                    # built height (in)

# Joint mortar: each block has a bed joint (length a+j) and a head joint (height h), cross-section t x j. in3 -> ft3 is / 1728
joint_mortar_ft3 = blocks_base * t * j * ((a + j) + h) / 1728
fill_ft3 = blocks_base * core_ft3 * fill_ratio / 100     # core fill
mortar_with_loss_ft3 = (joint_mortar_ft3 + fill_ft3) * (1 + loss_rate / 100)
mortar_lb = mortar_with_loss_ft3 * lb_per_ft3
bags = math.ceil(mortar_lb / bag_lb)                     # bags (rounded up)

# Rough rebar (embedment and lap splices extra)
rebar_v = math.floor(length_actual_in / rebar_pitch_in) + 1
rebar_h = math.ceil(courses / rebar_every)
rebar_length_ft = (rebar_v * height_actual_in + rebar_h * length_actual_in) / 12

cost = blocks_needed * price_block + bags * price_bag

print(f"Courses: {courses}, blocks per course: {per_course}, base count: {blocks_base}")
print(f"Blocks needed with waste: {blocks_needed}")
print(f"Joint mortar: {joint_mortar_ft3:.2f} ft3, core fill: {fill_ft3:.2f} ft3")
print(f"Mortar with waste: {mortar_with_loss_ft3:.2f} ft3 = {mortar_lb:.2f} lb -> {bags} bags")
print(f"Vertical bars: {rebar_v}, horizontal: {rebar_h} courses, rough total: {rebar_length_ft:.1f} ft")
print(f"Estimated cost: ${cost:.2f}")

Runs with the standard library only. math.ceil() rounds up (the ⌈ ⌉ in the formulas) and math.floor() rounds down (the ⌊ ⌋). Replace the sizes, waste factor and prices at the top with your own numbers and run it. To skip core fill or rebar, set fill_ratio to 0 or delete those lines.

How to write it in LaTeX and other math languages (copy and paste)

Number of courses

nₕ = ⌈H ÷ (h + j)⌉

n_h = \left\lceil \frac{H}{h + j} \right\rceil

<math xmlns="http://www.w3.org/1998/Math/MathML" display="block">
  <mrow>
    <msub><mi>n</mi><mi>h</mi></msub>
    <mo>=</mo>
    <mo>&#x2308;</mo>
    <mfrac><mi>H</mi><mrow><mi>h</mi><mo>+</mo><mi>j</mi></mrow></mfrac>
    <mo>&#x2309;</mo>
  </mrow>
</math>

n_h = |~ H / (h + j) ~|

Ceiling[H/(h + j)]

n_h := ceil(H/(h + j));

n_h = ceil(H/(h + j));

n_h = ⌈H/(h + j)⌉

Blocks per course

nₗ = ⌈L ÷ (a + j)⌉

n_l = \left\lceil \frac{L}{a + j} \right\rceil

<math xmlns="http://www.w3.org/1998/Math/MathML" display="block">
  <mrow>
    <msub><mi>n</mi><mi>l</mi></msub>
    <mo>=</mo>
    <mo>&#x2308;</mo>
    <mfrac><mi>L</mi><mrow><mi>a</mi><mo>+</mo><mi>j</mi></mrow></mfrac>
    <mo>&#x2309;</mo>
  </mrow>
</math>

n_l = |~ L / (a + j) ~|

Ceiling[L/(a + j)]

n_l := ceil(L/(a + j));

n_l = ceil(L/(a + j));

n_l = ⌈L/(a + j)⌉

Blocks needed with waste

N₀ = nₕ × nₗ,  N = ⌈N₀ × (1 + r ÷ 100)⌉

N_0 = n_h \times n_l,\quad N = \left\lceil N_0 \left( 1 + \frac{r}{100} \right) \right\rceil

<math xmlns="http://www.w3.org/1998/Math/MathML" display="block">
  <mrow>
    <msub><mi>N</mi><mn>0</mn></msub>
    <mo>=</mo>
    <msub><mi>n</mi><mi>h</mi></msub>
    <mo>&#xD7;</mo>
    <msub><mi>n</mi><mi>l</mi></msub>
    <mo>,</mo>
    <mi>N</mi>
    <mo>=</mo>
    <mo>&#x2308;</mo>
    <msub><mi>N</mi><mn>0</mn></msub>
    <mrow><mo>(</mo><mn>1</mn><mo>+</mo><mfrac><mi>r</mi><mn>100</mn></mfrac><mo>)</mo></mrow>
    <mo>&#x2309;</mo>
  </mrow>
</math>

N_0 = n_h xx n_l,  N = |~ N_0 (1 + r/100) ~|

N0 = nh*nl; Ceiling[N0*(1 + r/100)]

N0 := n_h*n_l;  N := ceil(N0*(1 + r/100));

N0 = n_h*n_l; N = ceil(N0*(1 + r/100));

N_0 = n_h × n_l, N = ⌈N_0 (1 + r/100)⌉

Joint mortar (bed joints + head joints)

V₁ = N₀ × t × j × {(a + j) + h}

V_1 = N_0 \, t \, j \left\{ (a + j) + h \right\}

<math xmlns="http://www.w3.org/1998/Math/MathML" display="block">
  <mrow>
    <msub><mi>V</mi><mn>1</mn></msub>
    <mo>=</mo>
    <msub><mi>N</mi><mn>0</mn></msub>
    <mo>&#xD7;</mo>
    <mi>t</mi>
    <mo>&#xD7;</mo>
    <mi>j</mi>
    <mo>&#xD7;</mo>
    <mrow><mo>{</mo><mrow><mo>(</mo><mi>a</mi><mo>+</mo><mi>j</mi><mo>)</mo></mrow><mo>+</mo><mi>h</mi><mo>}</mo></mrow>
  </mrow>
</math>

V_1 = N_0 * t * j * ((a + j) + h)

N0*t*j*((a + j) + h)

V1 := N0*t*j*((a + j) + h);

V1 = N0*t*j*((a + j) + h);

V_1 = N_0 t j {(a + j) + h}

Core fill (grout in the cores)

V₂ = N₀ × c × f ÷ 100

V_2 = N_0 \, c \, \frac{f}{100}

<math xmlns="http://www.w3.org/1998/Math/MathML" display="block">
  <mrow>
    <msub><mi>V</mi><mn>2</mn></msub>
    <mo>=</mo>
    <msub><mi>N</mi><mn>0</mn></msub>
    <mo>&#xD7;</mo>
    <mi>c</mi>
    <mo>&#xD7;</mo>
    <mfrac><mi>f</mi><mn>100</mn></mfrac>
  </mrow>
</math>

V_2 = N_0 * c * f / 100

N0*c*f/100

V2 := N0*c*f/100;

V2 = N0*c*f/100;

V_2 = N_0 c f/100

Weight of dry mix and number of bags

V′ = (V₁ + V₂) × (1 + r ÷ 100),  W = V′ × ρ,  B = ⌈W ÷ b⌉

V' = (V_1 + V_2)\left( 1 + \frac{r}{100} \right),\quad W = V' \rho,\quad B = \left\lceil \frac{W}{b} \right\rceil

<math xmlns="http://www.w3.org/1998/Math/MathML" display="block">
  <mrow>
    <msup><mi>V</mi><mo>&#x2032;</mo></msup>
    <mo>=</mo>
    <mrow><mo>(</mo><msub><mi>V</mi><mn>1</mn></msub><mo>+</mo><msub><mi>V</mi><mn>2</mn></msub><mo>)</mo></mrow>
    <mrow><mo>(</mo><mn>1</mn><mo>+</mo><mfrac><mi>r</mi><mn>100</mn></mfrac><mo>)</mo></mrow>
    <mo>,</mo>
    <mi>W</mi>
    <mo>=</mo>
    <msup><mi>V</mi><mo>&#x2032;</mo></msup>
    <mo>&#xD7;</mo>
    <mi>&#x3C1;</mi>
    <mo>,</mo>
    <mi>B</mi>
    <mo>=</mo>
    <mo>&#x2308;</mo>
    <mfrac><mi>W</mi><mi>b</mi></mfrac>
    <mo>&#x2309;</mo>
  </mrow>
</math>

V' = (V_1 + V_2)(1 + r/100),  W = V' * rho,  B = |~ W / b ~|

Vd = (V1 + V2)*(1 + r/100); W = Vd*rho; Ceiling[W/b]

Vd := (V1 + V2)*(1 + r/100);  W := Vd*rho;  B := ceil(W/b);

Vd = (V1 + V2)*(1 + r/100); W = Vd*rho; B = ceil(W/b);

V′ = (V_1 + V_2)(1 + r/100), W = V′ ρ, B = ⌈W/b⌉

Rough count and length of rebar

mᵥ = ⌊L′ ÷ p⌋ + 1,  mₕ = ⌈nₕ ÷ k⌉,  ℓ = mᵥ × H′ + mₕ × L′

m_v = \left\lfloor \frac{L'}{p} \right\rfloor + 1,\quad m_h = \left\lceil \frac{n_h}{k} \right\rceil,\quad \ell = m_v H' + m_h L'

<math xmlns="http://www.w3.org/1998/Math/MathML" display="block">
  <mrow>
    <msub><mi>m</mi><mi>v</mi></msub>
    <mo>=</mo>
    <mo>&#x230A;</mo>
    <mfrac><msup><mi>L</mi><mo>&#x2032;</mo></msup><mi>p</mi></mfrac>
    <mo>&#x230B;</mo>
    <mo>+</mo>
    <mn>1</mn>
    <mo>,</mo>
    <msub><mi>m</mi><mi>h</mi></msub>
    <mo>=</mo>
    <mo>&#x2308;</mo>
    <mfrac><msub><mi>n</mi><mi>h</mi></msub><mi>k</mi></mfrac>
    <mo>&#x2309;</mo>
    <mo>,</mo>
    <mi>&#x2113;</mi>
    <mo>=</mo>
    <msub><mi>m</mi><mi>v</mi></msub>
    <msup><mi>H</mi><mo>&#x2032;</mo></msup>
    <mo>+</mo>
    <msub><mi>m</mi><mi>h</mi></msub>
    <msup><mi>L</mi><mo>&#x2032;</mo></msup>
  </mrow>
</math>

m_v = |__ L' / p __| + 1,  m_h = |~ n_h / k ~|,  l = m_v * H' + m_h * L'

mv = Floor[Lp/p] + 1; mh = Ceiling[nh/k]; mv*Hp + mh*Lp

m_v := floor(Lp/p) + 1;  m_h := ceil(n_h/k);  l := m_v*Hp + m_h*Lp;

m_v = floor(Lp/p) + 1; m_h = ceil(n_h/k); l = m_v*Hp + m_h*Lp;

m_v = ⌊L′/p⌋ + 1, m_h = ⌈n_h/k⌉, ℓ = m_v H′ + m_h L′

Estimated cost

T = N × u₁ + B × u₂

T = N u_1 + B u_2

<math xmlns="http://www.w3.org/1998/Math/MathML" display="block">
  <mrow>
    <mi>T</mi>
    <mo>=</mo>
    <mi>N</mi>
    <mo>&#xD7;</mo>
    <msub><mi>u</mi><mn>1</mn></msub>
    <mo>+</mo>
    <mi>B</mi>
    <mo>&#xD7;</mo>
    <msub><mi>u</mi><mn>2</mn></msub>
  </mrow>
</math>

T = N * u_1 + B * u_2

n*u1 + b*u2

T := N*u1 + B*u2;

T = N*u1 + B*u2;

T = N u_1 + B u_2

Reverse: the wall length you can build with the blocks you have

M′ = ⌊M ÷ (1 + r ÷ 100)⌋,  Lmax = ⌊M′ ÷ nₕ⌋ × (a + j)

M' = \left\lfloor \frac{M}{1 + r/100} \right\rfloor,\quad L_{\max} = \left\lfloor \frac{M'}{n_h} \right\rfloor (a + j)

<math xmlns="http://www.w3.org/1998/Math/MathML" display="block">
  <mrow>
    <msup><mi>M</mi><mo>&#x2032;</mo></msup>
    <mo>=</mo>
    <mo>&#x230A;</mo>
    <mfrac><mi>M</mi><mrow><mn>1</mn><mo>+</mo><mi>r</mi><mo>/</mo><mn>100</mn></mrow></mfrac>
    <mo>&#x230B;</mo>
    <mo>,</mo>
    <msub><mi>L</mi><mi>max</mi></msub>
    <mo>=</mo>
    <mo>&#x230A;</mo>
    <mfrac><msup><mi>M</mi><mo>&#x2032;</mo></msup><msub><mi>n</mi><mi>h</mi></msub></mfrac>
    <mo>&#x230B;</mo>
    <mrow><mo>(</mo><mi>a</mi><mo>+</mo><mi>j</mi><mo>)</mo></mrow>
  </mrow>
</math>

M' = |__ M / (1 + r/100) __|,  L_max = |__ M' / n_h __| * (a + j)

Mp = Floor[M/(1 + r/100)]; Floor[Mp/nh]*(a + j)

Mp := floor(M/(1 + r/100));  Lmax := floor(Mp/n_h)*(a + j);

Mp = floor(M/(1 + r/100)); Lmax = floor(Mp/n_h)*(a + j);

M′ = ⌊M/(1 + r/100)⌋, L_max = ⌊M′/n_h⌋ (a + j)

How to have ChatGPT do the calculation

You are a quantity calculation assistant for outdoor construction. Do the following calculation by actually running Python code, and base your answer only on the numbers from the execution result (do not answer by mental math or guessing).

I am building a block wall 20 ft long and 40 in high with standard 8 in CMU (actual size 15-5/8 in long × 7-5/8 in high × 7-5/8 in thick) and 3/8 in mortar joints.
Find each of the following:
1. The number of courses (height ÷ (block height + joint), rounded up) and the blocks per course (length ÷ (block length + joint), rounded up)
2. The base count (courses × blocks per course) and the blocks needed with a 5% waste factor (rounded up)
3. The joint mortar (ft³): for each block in the base count, "thickness × joint × {(block length + joint) + block height}" in cubic inches, divided by 1,728
4. With a 5% waste factor on the joint mortar and 125 lb of dry mix per ft³, how many 80 lb bags of mortar mix are needed (rounded up)

Show the formulas you used and the numbers from the execution result.

How to Use

1

Enter your numbers

Type the numbers you want to calculate with into the input fields
2

Calculate

Press the "Calculate" button
3

Check the result

The result appears on the spot. The same page also explains the idea behind the calculation and the formula

DataChef Features

Easy and Free

Unlimited conversions for free.
No technical knowledge required.
Intuitive and user-friendly operation.

No Registration Required

Available immediately after access.
Can be used without registering personal information.

Safe and Secure

Fully SSL encrypted communication.
Automatic file deletion by clicking "download".

Fast

High-speed site access
and rapid file conversion.

No Watermark

No watermark.
No attribution required.

Commercial Use Available

Free for commercial use.
No need to contact us for commercial use permission.

\(a\)	ay	The length of one block. 15.625 in (15-5/8 in) for a standard CMU. Use the same unit as the wall when calculating.
\(h\)	aitch	The height of one block. 7.625 in (7-5/8 in) for a standard CMU. From the first letter of "height".
\(t\)	tee	The block thickness (the wall thickness). 7.625 in for an 8 in CMU (5.625 in for 6 in, 11.625 in for 12 in). From the first letter of "thickness"; it is also the width of the mortar joint.
\(j\)	jay	The joint width (the thickness of mortar between blocks). 3/8 in (0.375 in) is standard for blockwork. From the first letter of "joint".
\(L\)	el	The wall length (ft), from the first letter of "length". For a wall that turns corners, the total of all sides.
\(H\)	capital aitch	The wall height (ft): the height of the blockwork above the footing.
\(n_h\)	n sub h	The number of courses (how many rows high). It is found with \(n_h = \lceil H \div (h + j) \rceil\).
\(n_l\)	n sub l	The blocks per course (how many in a row). It is found with \(n_l = \lceil L \div (a + j) \rceil\).
\(N_0\)	N sub zero	The base count: courses × blocks per course, counting the wall as a rectangle.
\(r\)	ar	The waste factor (%): the extra for half blocks, corners and breakage, applied to both the blocks and the mortar. From the first letter of "rate".
\(N\)	en	The blocks needed with waste. It is found with \(N = \lceil N_0 (1 + r \div 100) \rceil\).
\(L'\), \(H'\)	L prime, H prime	The built length and height (with joints). \(L' = n_l (a + j)\) and \(H' = n_h (h + j)\); the real size when laid with the rounded-up blocks and courses.
\(V_1\)	V sub one	The joint mortar volume (ft³): bed joints plus head joints, found with \(V_1 = N_0 \, t \, j \{(a + j) + h\}\). From the first letter of "volume".
\(c\)	see	The volume of the holes (cores) in one block (ft³). It varies by product, so the value filled in for each size is a rough guide. From the first letter of "cavity".
\(f\)	ef	The share of cores to fill (%). 25% for vertical bars every 32 in with only those cores filled, 100% for all cores. From the first letter of "fill".
\(V_2\)	V sub two	The core fill volume (ft³). It is found with \(V_2 = N_0 \, c \, f \div 100\).
\(V'\)	V prime	The mortar with waste (ft³). It is found with \(V' = (V_1 + V_2)(1 + r \div 100)\).
\(\rho\)	rho	The weight of dry mix needed for 1 ft³ of mixed mortar (lb/ft³). The default is 125. It is the Greek letter rho, often used for density in physics.
\(W\)	double-u	The weight of dry mix (lb). It is found with \(W = V' \rho\). From the first letter of "weight".
\(b\)	bee	The weight of one bag (lb). The default is 80 lb. From the first letter of "bag".
\(B\)	capital bee	The bags needed. It is found with \(B = \lceil W \div b \rceil\).
\(p\)	pee	The vertical bar spacing (in), from the first letter of "pitch".
\(m_v\)	m sub v	The number of vertical bars. It is found with \(m_v = \lfloor L' \div p \rfloor + 1\); v is for "vertical".
\(k\)	kay	How many courses apart the horizontal reinforcement goes.
\(m_h\)	m sub h	The number of courses with horizontal reinforcement. It is found with \(m_h = \lceil n_h \div k \rceil\); h is for "horizontal".
\(\ell\)	script el	The rough total rebar length (ft), found with \(\ell = m_v H' + m_h L'\). Embedment and lap splices are not included. It is a script l, from "length".
\(u_1\), \(u_2\)	u sub one, u sub two	The price per block and per bag of mortar mix ($), from the first letter of "unit price".
\(T\)	tee	The estimated cost ($), found with \(T = N u_1 + B u_2\). From the first letter of "total".
\(M\)	em	In the reverse mode, the number of blocks you have.
\(M'\)	M prime	In the reverse mode, the usable blocks after setting aside the waste factor as spares. It is found with \(M' = \lfloor M \div (1 + r \div 100) \rfloor\).
\(L_{\max}\)	L max	In the reverse mode, the wall length you can build with the blocks you have (with joints).
\(\lceil x \rceil\)	ceiling of x	The symbol for rounding up to a whole number, called the ceiling function. (Example - \(\lceil 16.5 \rceil = 17\), \(\lceil 6 \rceil = 6\))
\(\lfloor x \rfloor\)	floor of x	The symbol for rounding down to a whole number, called the floor function. (Example - \(\lfloor 95.23 \rfloor = 95\), \(\lfloor 10 \rfloor = 10\))

Concrete Block Calculator (Blocks, Mortar Bags and Rebar for a Block Wall)

Table of Contents

What you can do on this page

What is this calculation used for?

Formulas and figures

Symbols and terms

Symbols

Terms

Good to know before you start

How to calculate it in Excel

How to calculate it in Google Sheets

How to calculate it in Python

How to write it in LaTeX and other math languages (copy and paste)

How to have ChatGPT do the calculation

How to Use

DataChef Features

Related Features

Mortar and Concrete Mix Calculator (Cement, Sand, Gravel, Water and Bags)

From the amount of mortar found here, work out the cement, sand and bags by mix ratio

Concrete Calculator (Cubic Yards, Weight and Bags)

For the volume, weight and bags of concrete for the footing under a block wall

Tile Calculator (How Many Tiles, Boxes and Cost)

The same idea for tiles - divide the area by the area of one tile including the joint

Brick Calculator (Patios, Paths, Garden Edges and Low Walls)

Find the number of bricks and the mortar for laying or stacking bricks, for garden edges and paths

Ramp Length Calculator (Rise and Slope, ADA 1:12)

Get over a step outdoors. Find the ramp length you need from the rise and the slope

Drain Slope and Pipe Fall Calculator (Inches per Foot, 1/n, Percent)

Find the slope and drop of a drain pipe for outdoor work

Fence Calculator (Posts, Panels, Rails and Pickets)

Find the number of posts, panels and footings for a fence on top of a block wall

Recommended

Probability and random number

Averages and statistics

Percentage and ratio

Speed

Density and concentration

Physics and electricity

Unit conversion

Integer and signed number

Fraction, decimal and rounding

Equation and inequality

Polynomial

Square root and nth root

Exponent and logarithm

Complex number

Function and graph

Sequence

Vector

Matrix

Plane geometry

Solid geometry

Date and time

Finance and economics

Web marketing and ad metric

Health and fitness

Sports

Weather

Computer

Household energy and budget

Car

Solar power and battery

Home and DIY

Remove Ads