An IBL Introduction to Discrete Mathematics

All string's from the alphabet \({A,B,C}\) in alphabetical order:

There are \(3^4 = 81\) strings of length four of {A,B,C}.

With 5 options for each of the three letters we pick, there are \(5 \times 5 \times 5\text{,}\) or 125 options.

Suppose we wish to build a string of length \(s\) over an alphabet of \(n\) distinct letters. Essentially, we must fill \(s\) open slots with a single elements chosen from \(n\) options. Thus there are \(n\) options for the first slot, \(n\) options for the second, and so on until we arrive at \(n\) options for slot \(s\text{.}\) If we label each slot with a subscript to denote its index, we can clear see that the number of strings that can be built is:

If such a case, it would not matter in what order each item is auctioned off. The amount of outcomes could then be calculated as:

There are three slots (auctioneers) and each of the three items can be placed in any of those slots, we then have \(3^3\) amount of possible outcomes for who gets what at the auction.

There are 9 students in class. Each student can either get a grade of A,B,C,D,F which equals to 5 options.

So the total amount of outcomes are \(5 \cdot 5 \cdot 5 \cdot 5 \cdot 5 \cdot 5 \cdot 5 \cdot 5 \cdot 5 = 1953125\)

The answer to this question depends on some initial assumptions. This solution assumes that the order in which Guido selects ingredients does not matter — they're all going to the same place, after all.

We first assign letters to the ingredients. Since there are four ingredients, we initially consider the alphabet \(\{A,B,C,D\}\text{.}\) Since Guido can choose the same ingredient multiple times, there are \(4^5\) different orders in which he can choose. However, we assumed that, e.g., \(AABCD\) and \(ABCDA\) represent the same dessert. So we need to remove some of these permutations.

The easiest way to achieve this is to reframe the problem. Since each string with the same number of copies of each letter corresponds to the same dessert, we need only concern ourselves with strings in which the four letters always appear in order. That is, we wish to count strings such as \(AABBD\) but not those like \(ACABD\text{.}\)

To count these strings, we need only count how many ways Guido could construct such a sequence. To do so he would always choose a certain number of As, then of Bs, Cs, and Ds. He must always choose some number of each letter (even if that number is zero). Thus, we could model this procedure as placing three “next letter” instructions somewhere in eight places. We arrive at these numbers by noting that three such instructions are required to move through the whole alphabet and that five total letters must be chosen. It follows that the desired count is the same as the number of, e.g., 8-bit binary strings with exactly three ones.

This count happens to be

1: 4 letters, no repeats, {A,B,C,D} so the total number of outcomes are \(4 \cdot 3 \cdot 2 \cdot 1 = 4! = 24\)

2: 5 letters, no repeats, {A,B,C,D,E} so the total number of outcomes are \(5 \cdot 4 \cdot 3 \cdot 2 \cdot 1 = 5! = 120\)

3: 26 letters, no repeats, {entire english alphabet} so the total number of outcomes are \(26 \cdot 25 \cdot 24 \cdot \ldots \cdot 3 \cdot 2 \cdot 1 = 26! = 4.0329146e+26\)

There are six such strings, namely: ABC, ACB, BAC, BCA, CAB, and CBA. This can be counted by noting that we have three choices for the first letter, then two for the next, and finally only one for the final letter.

An arrangement of n letters from an alphabet of n characters such that no letter is repeated can be given by the formula:

Where n denotes the total number of characters in the alphabet and each subsequent slot for a letter is denoted by n minus the amount of letters already used previously.

We begin by listing all strings of length four from the alphabet \({A,B,C,D}\) in alphabetical order:

• ABCD

• ABDC

• ACBD

• ACDB

• ADBC

• ADCB

• BACD

• BADC

• BCAD

• BCDA

• BDAC

• BDCA

• CABD

• CADB

• CBAD

• CBDA

• CDAB

• CDBA

• DABC

• DACB

• DBAC

• DBCA

• DCAB

• DCBA

Now we would like to group all of the strings that have the same two first letters where order matters (so \(AB\) is distinct from \(BA\)). We predict that there will be two members in each group since the first two letters will have already been chosen, leaving only two options for the third position and one option for the fourth. We also predict that there will be twelve different groups since there will be four options for the first letter and 3 options for the second. Listing the strings, we see that this is exactly what occurs:

1. 1. ABCD

   2. ABDC

2. 1. ACBD

   2. ACDB

3. 1. ADBC

   2. ADCB

4. 1. BACD

   2. BADC

5. 1. BCAD

   2. BCDA

6. 1. BDAC

   2. BDCA

7. 1. CABD

   2. CADB

8. 1. CBAD

   2. CBDA

9. 1. CDAB

   2. CDBA

10. 1. DABC

    2. DACB

11. 1. DBAC

    2. DBCA

12. 1. DCAB

    2. DCBA

There are 5 options for the first letter we pick, 4 options for the second letter, and 3 for the third. \(5 \cdot 4 \cdot 3=60\text{,}\) so we have 60 options.

There are 6 outcomes of a race between Allen, Betty, and Charles. For 1st place, there are 3 possible winners. After 1st place, in 2nd place, 2 possible placements. In 3rd place, only 1 possible placement. \(3 \times 2 \times 1 = 3! = 6\text{.}\)

Let's use the first letter of their first names to represent the person.

For each podium (arrangement of first three people in the race) there are 2 ways to arrange the people in places 4 and 5.

To find the total outcomes we can use 5! where first palce we have 5 options, 2nd 4 options, etc. Then we will divide that total by the two ways to arrange the first three.

We end up with the equation \(\frac{5!}{2!} = 60\text{.}\) So there are 60 ways to arrange the first 3 people in the race.

There are 12 strings can be made using all the letters of the word “meet”. The strings are 4 characters long. The first step is to choose where the letter 'm' goes. 4 choose 1 = 4 positions to choose from. Then, choose where the letters 'e' go. 3 choose 2 = 3. Finally, choose where 't' goes. 1 choose 1 = 1. So, \(4 \times 3 \times 1 = 12\) strings.

Based on our previous work, we can conclude that there are \(12!\) total different permutations of how to arrange the workers if we claim that each job position is completely unique (which in the real world is in fact true, no two job positions are completely identical). But for the sake of exercise, let's pretend that there are only four distinct catagories of job that will get doled out to twelve employees:

• Four administrative positions (labeled \(a_1, a_2, a_3, a_4\)).

• Three research positions (labeled \(b_1, b_2, b_3\)).

• Three managerial positions (labeled \(c_1, c_2, c_3\)).

• Two design positions (labeled \(d_1, d_2\)).

There are \(12!\) total permutations, but within that list some are copies of the others since all positions of the same type are in fact indistinguishible from one another. For example, \(a_1a_2a_3a_4b_1b_2 \ldots\) is the same as \(a_2a_1a_4a_3b_1b_2 \ldots\text{.}\) We then see that for a collection of orderings where the indices of the \(a\)'s, \(b\)'s, \(c\)'s, and \(d\)'s are the same (the spots in the list are occupied by the same letter types just the subscripts might differ) that there are in fact \(4!=24\) different orderings for the \(a\)'s, \(3!=6\) different orderings for the \(b\)'s, \(3!=6\) different orderings for the \(c\)'s, and \(2!=2\) different orderings for the \(d\)'s. Thus there are:

possible ways to assign the twelve employees to the different positions.