Why Numeric literal formats in Swift? - Purpose & Use Cases

The Big Idea

What if you could write numbers exactly how you think about them, without confusion or mistakes?

The Scenario

Imagine you need to write a program that uses many numbers, like phone numbers, prices, or measurements. You type each number exactly as it looks, but some are very long or have different bases like binary or hexadecimal. It becomes hard to read and easy to make mistakes.

The Problem

Writing numbers only in one format, like plain decimal, makes your code confusing and error-prone. You might misread a long number or forget to convert a binary value correctly. Changing formats manually takes time and can cause bugs.

The Solution

Numeric literal formats let you write numbers in different ways directly in your code, like binary, octal, decimal, or hexadecimal. This makes numbers clearer and easier to understand, so you avoid mistakes and save time.

Before vs After

✗ Before

let number = 255
let binary = 11111111  // but this is just a number, not binary
let hex = 255

✓ After

let number = 255
let binary = 0b11111111
let hex = 0xff

What It Enables

You can write and read numbers in the format that makes the most sense, making your code clearer and less error-prone.

Real Life Example

When programming a game, you might use hexadecimal to set colors or binary to control hardware flags. Numeric literal formats let you write these numbers naturally and clearly.

Key Takeaways

Manual number writing is confusing and error-prone.

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

This makes code easier to read, write, and maintain.

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