Enriching Students’ Combinatorial Reasoning through the Use of Loops and Conditional Statements in Python

Abstract

When solving counting problems, students often struggle with determining what they are trying to count (and thus what problem type they are trying to solve and, ultimately, what formula appropriately applies). There is a need to explore potential interventions to deepen students’ understanding of key distinctions between problem types and to differentiate meaningfully between such problems. In this paper, we investigate undergraduate students’ understanding of sets of outcomes in the context of elementary Python computer programming. We show that four straightforward program conditional statements seemed to reinforce important conceptual understandings of four canonical combinatorial problem types. We also suggest that the findings in this paper represent one example of a way in which a computational setting may facilitate mathematical learning.

Appendices

Appendix 1

Here we provide a more detailed discussion of selection with repetition problems, which is a standard approach (e.g., Mazur 2010; Tucker 2002). The following question is an example of this type of problem (adapted from Tucker 2002, p. 195): “Suppose I have 6 types of hot dogs, and I want to buy three hot dogs for lunch. In how many ways could I do this?” One way to solve such a problem highlights a clever way to encode outcomes and make sense of the more general formula. If we consider an actual menu with 6 types of hot dogs and then consider placing xs on the menu to indicate which hot dogs we want to buy, we can end up with a menu like the one in Table 6. We listed out a few different possibilities in the first 6 rows of the menu.

Table 6 Representation of several outcomes of the Hot Dog problem

Notice that for each of the six rows in the menu, we could encode the outcomes as strings of three xs and five |s. For example, the entry in the first row, which represents three regular dogs, could be encoded as the string xxx | | | | |. The entry in the second row, which represents two regular dogs and a super dog, could be encoded as xx | x | | | |. The entry in the fifth row, which represents one super, one footlong, and one Dodger dog, is encoded as | x | x | | x |. In this way, counting the total number of outcomes is a matter of counting strings of length 8 that contain 3 xs and 5 bars. To count this, we can simply choose 3 of the 8 positions in which to place xs, and then the remaining positions must be bars (see Lockwood et al. 2018 for an extended discussion of interpreting such a situation as a combination problem). Thus, there are C(8,3) ways to buy 3 hot dogs from 6 types of hot dogs, where repetition is allowed. Note that more generally, if there are n types of objects, and we want to select r with repetition, there will be r xs and n – 1 bars (one fewer than the number of types). Thus the general formula to solve this kind of problem is C(n + r – 1,r).

An equivalent way to frame this question is to ask, “How many strictly non-decreasing sequences of length three are there from a set of 6 distinct elements?” Notice that these outcomes would be 111, 112, 113, 114, 115, 116, 122, 123, 124, 125, 126, 133, 134, 135, 136, 144, 145, 146, 155, 156, 166, 222, 223, 224, 225, 226, 233, 234, 235, 236, 244, 245, 246, 255, 256, 266, 333, 334, 335, 336, 344, 345, 346, 355, 356, 366, 444, 445, 446, 455, 456, 466, 555, 556, 566, 666. For any of these outcomes, though, they correspond to an arrangement of three xs and five bars, where the numbers in the 3-element sets represent in which categories the xs go. For example, 111 corresponds to xxx | | | | |, 223 corresponds to | x x | x | | |, and 366 corresponds to | | x | | | x x. This perspective of encoding outcomes offers another way to count these problems. If we think about code like that in Table 2, then, we can see how the greater than or equal to symbols in the conditional if statements exactly correspond to this question of counting strictly non-decreasing sequences. This code generates exactly the set of outcomes we listed above (in the same order).

Fig. 24

Code that counts selection with repetition problems

Appendix 2

Here, we provide a more thorough discussion of the code presented in the lower left corner of the two-by-two table (Tucker 2002), and in particular in Table 2 of the body of the paper. That is, we will explain why the code in Fig. 25 counts arrangements with no repetition. This is intended to provide clarity for readers who are unfamiliar with programming or who are unfamiliar with Python syntax. The other programs used in this paper rely on the same concepts, although there may be more for loops and different additional conditional statements. In explaining the code, we will introduce for loops and conditional statements, which are important in framing the students’ work. For clarity, we have labeled the line numbers in the code.

Fig. 25

Code that counts arrangements with unrestricted repetition

The code begins by defining an ordered list, “Numbers = [1,2,3,4,5].” The list contains the integers 1, 2, 3, 4, and 5, and is ordered as written. The command in line (2), “Counter = 0,” creates a new integer variable, called Counter, that we will use to count the number of outcomes our code produces. Each time we produce a new outcome, we will increase the value of Counter by 1 (this occurs in Line (7)). Line (3) begins a for loop. The command “for i in Numbers:” will do a series of commands for each element in the set Numbers. In Python, indentation is an important element of specifying commands, and it helps to determine whether commands are nested. The series of commands is relayed in the instructions nested within the for loop, where instructions are considered nested within a loop while they are indented further (to the right) than the loop. The nesting ends when the program reaches a line that is not indented further to the right. In this case, lines (4) through (7) are nested within the for loop, and will be carried out for each i in Numbers, whereas line (8) is not nested within the for loops. Hence, the command “for i in Numbers:” will carry out the nested commands five times, once per element in Numbers in the order in which they appear (in this case, the numerical order 1, 2, 3, 4, and 5).

For each i in Numbers, the nested instructions will be carried out with i designated as a given value. For example, the first time lines (4) through (7) are carried out will be when the value of i is 1. Similarly, the command “for j in Numbers:” will carry out the instructions nested within it (lines (5) through (7)) for each value of j in Numbers. That is, lines (5) through (7) are carried out a total of 25 times (one time for each ordered pair (i,j), where both i and j are elements of Numbers).

For each value of i in Numbers and j in Numbers, the program will follow the command “if j != i:,” which we refer to as a conditional statement. That is, as long as the condition j != i is met, the program will follow the instructions nested within the conditional statement (lines (6) and (7)). If the condition is not met, then the program will skip over these instructions (in this case, as the remaining instructions are nested inside, the program will do nothing). Lines (6) and (7) accomplish two things: first, the ordered pair (i, j) is printed; and second, the value of Counter is increased by 1.¹² Hence, the program will follow the instructions to print (i,j) and to increment the counter for only those pairs (i, j) where j is not equal to i.

In sum, for each value in Numbers, the program will iterate through every value in Numbers, printing each pair of distinct numbers as well as keeping track of the total number of pairs that has been printed. Due to the conditional statement, these pairs are precisely those without repetition, showing we are counting and listing the desired outcomes. Line (8), “print(Counter),” prints the value of Counter after all previous instructions have been followed, giving the total number of arrangements of the numbers 1 through 5, where repetition is not allowed.