Numeric literal formats in Swift

Introduction

Numeric literals let you write numbers directly in your code. They help you tell the computer exact values to use.

When you want to assign a number to a variable or constant.

When you need to write numbers in different bases like binary or hexadecimal.

When you want to make large numbers easier to read by adding underscores.

When you want to specify floating-point numbers with decimals.

When you want to use scientific notation for very big or very small numbers.

Syntax

Swift

let decimal = 1234
let binary = 0b1001
let octal = 0o17
let hex = 0x1F
let floatNum = 12.34
let expNum = 1.2e3
let readableNum = 1_000_000

Numeric literals can be decimal, binary (start with 0b), octal (0o), or hexadecimal (0x).

Underscores (_) can be used inside numbers to improve readability without changing the value.

Examples

A simple decimal number.

Swift

let decimal = 42

A binary number representing 10 in decimal.

Swift

let binary = 0b1010

A hexadecimal number representing 255 in decimal.

Swift

let hex = 0xFF

Using underscores to make a large number easier to read.

Swift

let largeNumber = 1_000_000

Sample Program

This program shows different numeric literal formats in Swift and prints their decimal values.

Swift

import Foundation

let decimal = 100
let binary = 0b1100100
let octal = 0o144
let hex = 0x64
let floatNum = 123.45
let expNum = 1.2345e2
let readableNum = 1_000_000

print("Decimal: \(decimal)")
print("Binary: \(binary)")
print("Octal: \(octal)")
print("Hexadecimal: \(hex)")
print("Float: \(floatNum)")
print("Exponential: \(expNum)")
print("Readable number: \(readableNum)")

Important Notes

All numeric literals represent the same value regardless of format when printed as decimal.

Floating-point literals can use decimal points or exponential notation.

Underscores do not affect the value but help you read large numbers easily.

Summary

Numeric literals let you write numbers in decimal, binary, octal, or hexadecimal.

You can use underscores to make numbers easier to read.

Floating-point numbers can be written with decimals or scientific notation.

Practice

1. Which of the following is a valid binary numeric literal in Swift?

easy

A. 0b1010

B. 0x1010

C. 1010b

D. 0o1010

Solution

1. Step 1: Understand binary literal format in Swift

   Binary literals start with 0b followed by 0s and 1s.

2. Step 2: Check each option

   0b1010 uses 0b prefix correctly. 0x1010 is hexadecimal, C is invalid, A is octal.

3. Final Answer:

   0b1010 -> Option A

4. Quick Check:

   Binary literals start with 0b = D [OK]

Hint: Binary literals always start with 0b prefix [OK]

Common Mistakes:

• Confusing binary (0b) with hexadecimal (0x)
• Placing the b suffix after the number
• Using octal prefix 0o for binary

2. Which of the following is the correct way to write the number one million using underscores in Swift?

easy

A. 1_00_0000

B. 1000_000

C. 10_00_000

D. 1_000_000

Solution

1. Step 1: Understand underscore usage in numeric literals

   Underscores can be placed anywhere between digits to improve readability.

2. Step 2: Check each option for correct grouping

   1_000_000 groups digits in thousands correctly. Others have irregular grouping which is allowed but uncommon and confusing.

3. Final Answer:

   1_000_000 -> Option D

4. Quick Check:

   Use underscores to separate thousands = A [OK]

Hint: Use underscores every three digits for clarity [OK]

Common Mistakes:

• Placing underscores at the start or end of number
• Using inconsistent grouping that confuses readers
• Thinking underscores change the value

3. What is the output of the following Swift code?

let number = 1.5e2
print(number)

medium

A. 150.0

B. 1.5e2

C. 15.0

D. SyntaxError

Solution

1. Step 1: Understand scientific notation in Swift

   1.5e2 means 1.5 x 10², which equals 150.0.

2. Step 2: Evaluate the print output

   Printing the number shows the decimal value 150.0, not the literal string.

3. Final Answer:

   150.0 -> Option A

4. Quick Check:

   1.5e2 = 150.0 [OK]

Hint: e2 means multiply by 10 squared [OK]

Common Mistakes:

• Thinking print shows the literal string '1.5e2'
• Confusing e2 with e-2 (which divides)
• Assuming integer output instead of floating-point

4. Identify the error in this Swift numeric literal:

let value = 0b1021

medium

A. Should use 0x prefix for binary

B. Binary literals cannot contain digits other than 0 or 1

C. Missing underscore for readability

D. Floating-point literals cannot use binary format

Solution

1. Step 1: Check digits allowed in binary literals

   Binary literals only allow digits 0 and 1 after the 0b prefix.

2. Step 2: Analyze the given literal

   The literal contains digit 2, which is invalid for binary (only 0s and 1s allowed).

3. Final Answer:

   Binary literals cannot contain digits other than 0 or 1 -> Option B

4. Quick Check:

   Binary digits only 0 or 1 = C [OK]

Hint: Binary digits must be only 0 or 1 [OK]

Common Mistakes:

• Thinking underscores are mandatory
• Confusing binary prefix 0b with hexadecimal 0x
• Assuming floating-point literals can be binary

5. You want to represent the decimal number 255 in Swift using hexadecimal and octal literals. Which pair of literals correctly represents 255?

hard

A. 0xFF and 0o255

B. 0x255 and 0o255

C. 0xFF and 0o377

D. 0x377 and 0oFF

Solution

1. Step 1: Convert decimal 255 to hexadecimal

   255 decimal equals FF in hexadecimal, so 0xFF is correct.

2. Step 2: Convert decimal 255 to octal

   255 decimal equals 377 in octal, so 0o377 is correct.

3. Final Answer:

   0xFF and 0o377 -> Option C

4. Quick Check:

   255 decimal = 0xFF hex & 0o377 oct [OK]

Hint: Hex FF = 255 decimal; Oct 377 = 255 decimal [OK]

Common Mistakes:

• Confusing octal digits with decimal digits
• Using decimal digits after 0x prefix
• Mixing up hexadecimal and octal prefixes