## Americas

• United States

# Using the seq command to generate numeric sequences

How-To
Feb 03, 20224 mins
Linux

The Linux seq command generates lists of numbers, but it has many subtleties to master.

The seq command is handy for generating number sequences on Linux.

It requires at least one number as an argument and, given that, it will provide all the numbers from 1 to whatever number you specify. However, that’s just the command’s simplest use. With additional arguments, seq can be surprisingly useful, especially when you use the generated numbers to drive a loop or do a calculation.

The seq command below illustrates the most basic use of this command:

```\$ seq 5
1
2
3
4
5
```

The seq command is also surprisingly fast. When I ask it to show me all of the numbers from 1 to 1,000, it only takes a few seconds to run. The bottom of the number list and timing stats are shown below.

```\$ time seq 1000 | tail -8
993
994
995
996
997
998
999
1000

real    0m0.003s
user    0m0.001s
sys     0m0.003s
```

When you use two arguments with seq, they will be used as the starting and ending numbers in the generated list. Notice that there is no need to start with 1.

```\$ seq 11 17		\$ seq 111 117		\$ seq 1234 1240
11			111				1234
12			112				1235
13			113				1236
14			114				1237
15			115				1238
16			116				1239
17			117				1240
```

You can also specify an increment, so that you only see every Xth number in your series. If you provide a starting number, an increment and an ending number in that order, you can tailor your numbers to suit some particular purpose. Say you want to see all of the leap years between 2024 and 2054. Knowing that 2024 is a leap year, you could use a command like this:

```\$ seq 2024 4 2055
2024
2028
2032
2036
2040
2044
2048
2052
```

That “seq FIRST INCREMENT LAST” syntax gives you a lot of control over the numbers that will be listed.

If you want your list to start with the largest number and end with the smallest, use a negative increment (in other words, a “decrement”) like this:

```\$ seq 100 -10 0
100
90
80
70
60
50
40
30
20
10
0
```

To use the seq command to drive a bash loop, you could use a command like that shown below. The sequence is the list of leap years shown above.

```\$ for yr in `seq 2024 4 2055`
> do
>     echo "\$yr is a leap year"
> done
2024 is a leap year
2028 is a leap year
2032 is a leap year
2036 is a leap year
2040 is a leap year
2044 is a leap year
2048 is a leap year
2052 is a leap year
```

If you want to generate a list of numbers and pad the smaller ones with zeroes so that all of the numbers in your list have the same number of digits, add the -w option like this:

```\$ seq -w 1 11 100
001
012
023
034
045
056
067
078
089
100
```

Each number in the list will have the same number of digits as the largest number.

You can also specify how many zeroes to use as padding. In this next example, we want every number to have at least three digits.

```\$ seq -f "%03g" 10
001
002
003
004
005
006
007
008
009
010
```

You can also ask the seq command to use numbers with decimal points as in this example:

```\$ seq 0.3 0.3 9.9 | column
0.3     1.5     2.7     3.9     5.1     6.3     7.5     8.7     9.9
0.6     1.8     3.0     4.2     5.4     6.6     7.8     9.0
0.9     2.1     3.3     4.5     5.7     6.9     8.1     9.3
1.2     2.4     3.6     4.8     6.0     7.2     8.4     9.6
```

Notice that the starting number, increment, and final number all have decimal points. This command starts with 0.3 and adds 0.3 until it reaches 9.9.

To get the seq command to generate the separators instead of passing the output to the column command, you could do this:

```\$ seq -s "  " 0.3 0.3 9.9
0.3  0.6  0.9  1.2  1.5  1.8  2.1  2.4  2.7  3.0  3.3  3.6  3.9  4.2  4.5  4.8  5.1  5.4  5.7  6.0  6.3  6.6  6.9  7.2  7.5  7.8  8.1  8.4  8.7  9.0  9.3  9.6  9.9
```

This output consists of one long line of numbers, wrapped around as needed to fit your terminal window.

You can use other characters as separators too. Here’s an example using the colon character as the separator when generating a list of leap years:

```\$ seq -s: 2024 4 2050
2024:2028:2032:2036:2040:2044:2048
```

The command below uses a comma as the separator:

```\$ seq -s, 100 -10 0
100,90,80,70,60,50,40,30,20,10,0
```

If you’re curious about how big a number multiplying each of the numbers 1 through 10 would be, use you use a command like this:

```\$ seq -s* 1 10 | bc
3628800
```

That seq command generates the string 1*2*3*4*5*6*7*8*9*10 because we used an asterisk as the separator. When this string is then passed to the calculator, bc, we get the number shown. To add the numbers 1-10 together, use a + sign instead of an *.

```\$ seq -s + 1 10 | bc
55
```

Using tabs as separators is a bit tricky, but you can force it with a command like this one:

```\$ seq -s "`echo -e "t"`" 5 11
5       6       7       8       9       10      11
```

Sandra Henry-Stocker has been administering Unix systems for more than 30 years. She describes herself as "USL" (Unix as a second language) but remembers enough English to write books and buy groceries. She lives in the mountains in Virginia where, when not working with or writing about Unix, she's chasing the bears away from her bird feeders.

The opinions expressed in this blog are those of Sandra Henry-Stocker and do not necessarily represent those of IDG Communications, Inc., its parent, subsidiary or affiliated companies.