Shallow clones with depth in Git - Time & Space Complexity

Time Complexity: Shallow clones with depth

O(depth)

Understanding Time Complexity

When using git to copy a repository, the time it takes depends on how much history we download.

We want to understand how limiting history with shallow clones affects the work git does.

Scenario Under Consideration

Analyze the time complexity of the following git command.

git clone --depth 5 https://example.com/repo.git

This command copies only the latest 5 commits from the repository, skipping older history.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Downloading commit objects and related files for each commit.
• How many times: Exactly 5 times, matching the depth limit.

How Execution Grows With Input

The work git does grows with the number of commits it downloads.

Input Size (depth)	Approx. Operations
5	Download 5 commits and their files
50	Download 50 commits and their files
500	Download 500 commits and their files

Pattern observation: The work increases directly with the depth number; more commits mean more work.

Final Time Complexity

Time Complexity: O(depth)

This means the time git takes grows linearly with the number of commits you choose to download.

Common Mistake

[X] Wrong: "Shallow cloning always downloads the entire repository instantly."

[OK] Correct: Even shallow clones must download each commit up to the depth limit, so time grows with that number.

Interview Connect

Understanding how shallow clones limit work helps you explain efficient ways to handle large repositories in real projects.

Self-Check

"What if we remove the depth option and clone the full history? How would the time complexity change?"

Practice

1. What does the --depth option do when used with git clone?

easy

A. It compresses the repository to save disk space.

B. It clones all branches including remote ones.

C. It creates a shallow clone with limited commit history.

D. It initializes a new empty repository.

Solution

1. Step 1: Understand the purpose of --depth

   The --depth option limits the number of commits cloned, creating a shallow copy.

2. Step 2: Compare with other clone types

   Unlike a full clone, a shallow clone saves time and space by copying recent commits only.

3. Final Answer:

   It creates a shallow clone with limited commit history. -> Option C

4. Quick Check:

   Shallow clone = limited history [OK]

Hint: Remember: --depth limits commit history depth [OK]

Common Mistakes:

• Thinking --depth clones all branches
• Confusing shallow clone with compression
• Assuming it creates an empty repo

2. Which of the following is the correct syntax to clone a repository with a depth of 5 commits?

easy

A. git clone --depth=5 https://example.com/repo.git

B. git clone -depth 5 https://example.com/repo.git

C. git clone --depth 5 https://example.com/repo.git

D. git clone --deep 5 https://example.com/repo.git

Solution

1. Step 1: Recall correct git clone syntax for depth

   The correct syntax uses --depth with an equals sign or a space and the number, like --depth=5 or --depth 5. Both are valid.

2. Step 2: Identify incorrect options

   git clone -depth 5 https://example.com/repo.git uses a single dash which is invalid. git clone --deep 5 https://example.com/repo.git uses an invalid flag --deep.

3. Final Answer:

   git clone --depth=5 https://example.com/repo.git -> Option A

4. Quick Check:

   Correct syntax = --depth=5 or --depth 5 [OK]

Hint: Use --depth=5 or --depth 5 for shallow clone [OK]

Common Mistakes:

• Using '=' instead of space after --depth (both valid but some prefer equals)
• Typing -depth instead of --depth
• Using --deep instead of --depth

3. What will be the output of the following commands?

git clone --depth 2 https://example.com/repo.git
cd repo
git log --oneline

medium

A. Shows commits from all branches.

B. Shows the full commit history.

C. Shows no commits because depth is too low.

D. Shows only the last 2 commits in the log.

Solution

1. Step 1: Understand shallow clone effect on history

   Using --depth 2 clones only the last 2 commits, so git log shows those.

2. Step 2: Analyze git log --oneline output

   This command lists commits in short form, limited to the shallow clone's depth.

3. Final Answer:

   Shows only the last 2 commits in the log. -> Option D

4. Quick Check:

   Depth 2 clone shows 2 commits [OK]

Hint: Shallow clone limits log to depth commits [OK]

Common Mistakes:

• Expecting full history in shallow clone
• Thinking no commits show if depth is low
• Assuming all branches' commits appear

4. You ran git clone --depth 3 https://example.com/repo.git but later need the full history. What should you do to fix this?

medium

A. Run git fetch --unshallow inside the cloned repo.

B. Delete the repo and clone again without --depth.

C. Run git clone --depth 0 to get full history.

D. Run git pull --depth=full to fetch all commits.

Solution

1. Step 1: Understand how to convert shallow clone to full

   Inside the shallow clone, running git fetch --unshallow downloads the full commit history.

2. Step 2: Evaluate other options

   Deleting the repo and cloning again without --depth works but is inefficient. Options C and D use invalid syntax or commands.

3. Final Answer:

   Run git fetch --unshallow inside the cloned repo. -> Option A

4. Quick Check:

   Use git fetch --unshallow to get full history [OK]

Hint: Use git fetch --unshallow to complete shallow clone [OK]

Common Mistakes:

• Trying to reclone instead of fetching full history
• Using invalid git pull options
• Assuming --depth 0 is valid

5. You want to clone a large repository but only need the last 10 commits of the main branch and no other branches. Which command achieves this efficiently?

hard

A. git clone --depth=10 https://example.com/repo.git

B. git clone --depth 10 --single-branch --branch main https://example.com/repo.git

C. git clone --branch main https://example.com/repo.git

D. git clone --shallow-since=10days https://example.com/repo.git

Solution

1. Step 1: Identify options to limit clone depth and branches

   Use --depth 10 to limit commits and --single-branch --branch main to clone only main branch.

2. Step 2: Check other options for correctness

   git clone --depth=10 https://example.com/repo.git clones all branches shallowly. git clone --branch main https://example.com/repo.git clones full history of main. git clone --shallow-since=10days https://example.com/repo.git uses invalid flag.

3. Final Answer:

   git clone --depth 10 --single-branch --branch main https://example.com/repo.git -> Option B

4. Quick Check:

   Depth + single branch = efficient clone [OK]

Hint: Combine --depth with --single-branch for focused clone [OK]

Common Mistakes:

• Not using --single-branch clones all branches
• Using invalid flags like --shallow-since
• Assuming --depth=10 clones only main branch