Function declaration syntax in Kotlin - Time & Space Complexity

Time Complexity: Function declaration syntax

O(n)

Understanding Time Complexity

We want to understand how the time it takes to run a function changes as the input changes.

Specifically, we ask: how does the function's work grow when input size grows?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

fun printNumbers(n: Int) {
    for (i in 1..n) {
        println(i)
    }
}

This function prints numbers from 1 up to n.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: The for-loop that prints each number.
• How many times: It runs exactly n times, once for each number.

How Execution Grows With Input

As n grows, the number of print actions grows the same way.

Input Size (n)	Approx. Operations
10	10 print actions
100	100 print actions
1000	1000 print actions

Pattern observation: The work grows directly with n, so doubling n doubles the work.

Final Time Complexity

Time Complexity: O(n)

This means the time to run the function grows in a straight line with the input size.

Common Mistake

[X] Wrong: "The function runs in constant time because it just prints numbers."

[OK] Correct: Printing happens once for each number, so more numbers mean more work.

Interview Connect

Understanding how loops affect time helps you explain your code clearly and shows you know how programs grow with input.

Self-Check

"What if we changed the function to print only even numbers up to n? How would the time complexity change?"

Practice

1. Which of the following is the correct way to declare a simple function named greet in Kotlin that takes no parameters and returns no value?

easy

A. function greet() { println("Hello") }

B. fun greet() { println("Hello") }

C. def greet() { println("Hello") }

D. fun greet { println("Hello") }

Solution

1. Step 1: Identify the correct keyword for function declaration

   Kotlin uses the keyword fun to declare functions. Options using function or def are incorrect.

2. Step 2: Check the function syntax for parameters and braces

   The function must have parentheses even if there are no parameters, so fun greet { println("Hello") } is incorrect because it misses parentheses.

3. Final Answer:

   fun greet() { println("Hello") } -> Option B

4. Quick Check:

   fun + name + () + body = B [OK]

Hint: Remember: Kotlin functions start with 'fun' and need parentheses [OK]

Common Mistakes:

• Using 'function' or 'def' instead of 'fun'
• Omitting parentheses for parameter list
• Missing curly braces for function body

2. Which of the following is the correct syntax to declare a function add that takes two Int parameters and returns their sum as an Int?

easy

A. fun add(a: Int, b: Int): Int { a + b }

B. fun add(a Int, b Int): Int { return a + b }

C. fun add(a: Int, b: Int) -> Int { return a + b }

D. fun add(a: Int, b: Int): Int = a + b

Solution

1. Step 1: Check parameter declaration syntax

   Parameters must be declared as name: Type, so fun add(a Int, b Int): Int { return a + b } is incorrect because it misses colons.

2. Step 2: Verify return type and function body syntax

   fun add(a: Int, b: Int): Int = a + b uses the correct syntax with an expression body and return type. fun add(a: Int, b: Int) -> Int { return a + b } uses '->' which is invalid in Kotlin. fun add(a: Int, b: Int): Int { a + b } misses the return keyword in a block body, so it won't return the sum.

3. Final Answer:

   fun add(a: Int, b: Int): Int = a + b -> Option D

4. Quick Check:

   fun + parameters with colons + : ReturnType + = expression = A [OK]

Hint: Use colons for types and '=' for single-expression functions [OK]

Common Mistakes:

• Omitting colons between parameter names and types
• Using '->' instead of ':' for return type
• Missing 'return' in block body functions

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

fun multiply(x: Int, y: Int): Int {
    return x * y
}

fun main() {
    println(multiply(3, 4))
}

medium

A. 12

B. 34

C. 7

D. Error

Solution

1. Step 1: Understand the multiply function

   The function takes two integers and returns their product using return x * y.

2. Step 2: Calculate the function call multiply(3, 4)

   3 multiplied by 4 equals 12, so the function returns 12.

3. Final Answer:

   12 -> Option A

4. Quick Check:

   3 * 4 = 12 [OK]

Hint: Multiply parameters and check return value [OK]

Common Mistakes:

• Adding instead of multiplying
• Concatenating numbers as strings
• Assuming syntax error due to missing expression body

4. Identify the error in the following Kotlin function declaration:

fun divide(a: Int, b: Int): Int {
    return a / b

medium

A. Missing closing brace '}'

B. Incorrect return type

C. Parameters should not have types

D. Function name is invalid

Solution

1. Step 1: Check function syntax completeness

   The function body starts with '{' but there is no closing '}', so the code is incomplete.

2. Step 2: Verify other syntax parts

   The return type is correct, parameters have types, and the function name is valid, so no other errors.

3. Final Answer:

   Missing closing brace '}' -> Option A

4. Quick Check:

   All blocks need matching braces [OK]

Hint: Count opening and closing braces carefully [OK]

Common Mistakes:

• Forgetting to close function body with '}'
• Misplacing colons in parameters
• Using invalid function names

5. You want to declare a Kotlin function formatName that takes two parameters: firstName and lastName (both Strings), and returns a single String in the format "Last, First". Which of the following is the correct declaration and implementation?

hard

A. fun formatName(firstName: String, lastName: String): Int = "$lastName, $firstName"

B. fun formatName(firstName String, lastName String) = lastName + ", " + firstName

C. fun formatName(firstName: String, lastName: String): String { return "$lastName, $firstName" }

D. fun formatName(firstName: String, lastName: String): String { "$lastName, $firstName" }

Solution

1. Step 1: Check parameter and return type syntax

   Parameters must use name: Type and return type must match. A uses : Int but returns String (type mismatch). B misses colons (firstName String invalid).

2. Step 2: Verify function body syntax

   C has block body { "$lastName, $firstName" } without return, returns Unit not String. D correctly uses block body with return and string interpolation.

3. Final Answer:

   fun formatName(firstName: String, lastName: String): String { return "$lastName, $firstName" } -> Option C

4. Quick Check:

   Correct types + block body with return + interpolation = D [OK]

Hint: Use return keyword in block body functions for clarity [OK]

Common Mistakes:

• Omitting return keyword in block body
• Missing return type declaration
• Incorrect string concatenation or interpolation