Quick Overview

This question evaluates array manipulation and string parsing competencies, focusing on rotating arrays via modular index arithmetic and locating substring occurrences within a simple CSV while mapping each match to row, column, and character position.

Implement array rotations and CSV keyword search

Company: Warner Bros Discovery

Role: Software Engineer

Category: Coding & Algorithms

Difficulty: medium

Interview Round: Technical Screen

## Problem A — Rotate an array left/right by *k* You are given an integer array `nums` of length `n` and an integer `k`. 1. Implement `rotateLeft(nums, k)` that returns the array after rotating it left by `k` positions. 2. Implement `rotateRight(nums, k)` that returns the array after rotating it right by `k` positions. ### Notes / Constraints - `k` can be larger than `n`; treat `k` as `k % n`. - Handle edge cases like `n = 0` or `n = 1`. - Clarify in your solution whether you modify in-place or return a new array. ### Example - `nums = [1,2,3,4,5]`, `k = 2` - left rotate → `[3,4,5,1,2]` - right rotate → `[4,5,1,2,3]` --- ## Problem B — Find keyword occurrences in a CSV text You are given a CSV document as a single string `csvText`. - Rows are separated by newline characters `\n`. - Columns are separated by commas `,`. - Assume fields do not contain escaped commas or quoted strings (i.e., simple CSV). ### Task Given `csvText` and a keyword `key`, return all occurrences of `key` in the document. For each occurrence, return: - `row`: the 0-based row number - `col`: the 0-based column number - `pos`: the 0-based character index within that cell where the match begins Return results in row-major order. ### Variant Extend the function to accept multiple keywords `keys[]` and return occurrences for any of them (you may also include which keyword matched). ### Example `csvText = "foo,bar\nxxfood,barfoo"`, `key = "foo"` - Row 0, Col 0, Pos 0 ("foo") - Row 1, Col 0, Pos 2 ("xxfood") - Row 1, Col 1, Pos 3 ("barfoo") (Exact output format is up to you; it just needs to include row/col/pos.)

Overview: This question evaluates array manipulation and string parsing competencies, focusing on rotating arrays via modular index arithmetic and locating substring occurrences within a simple CSV while mapping each match to row, column, and character position.

Read the full Warner Bros Discovery Software Engineer interview experience this question came from

Rotate an Array Left or Right by k

You are given an integer array `nums` of length `n`, an integer `k`, and a string `direction` that is either `"left"` or `"right"`. Return a NEW array that is `nums` rotated by `k` positions in the given direction. Rules: - `k` may be larger than `n`; treat it as `k % n`. - Handle edge cases: `n = 0` returns an empty array, `n = 1` returns the array unchanged. - A left rotation by `k` moves the first `k` elements to the end; a right rotation by `k` moves the last `k` elements to the front. Example: `nums = [1,2,3,4,5]`, `k = 2` - direction `"left"` -> `[3,4,5,1,2]` - direction `"right"` -> `[4,5,1,2,3]`

Constraints

  • 0 <= n <= 10^5
  • 0 <= k <= 10^9
  • direction is either "left" or "right"
  • -10^9 <= nums[i] <= 10^9

Examples

Input: ([1, 2, 3, 4, 5], 2, 'left')

Expected Output: [3, 4, 5, 1, 2]

Explanation: Move the first 2 elements [1,2] to the end.

Input: ([1, 2, 3, 4, 5], 2, 'right')

Expected Output: [4, 5, 1, 2, 3]

Explanation: Move the last 2 elements [4,5] to the front.

Hints

  1. Reduce k modulo n first so that rotations larger than the array length wrap correctly.
  2. A left rotation by k is a slice split: nums[k:] + nums[:k].
  3. A right rotation by k is equivalent to a left rotation by n - k: nums[n-k:] + nums[:n-k].
  4. Guard the n == 0 case before computing k % n to avoid a division-by-zero.

Find Keyword Occurrences in Simple CSV

You are given a CSV document as a single string `csvText` and a keyword `key`. - Rows are separated by newline characters `\n`. - Columns are separated by commas `,`. - Fields are simple: no quoted strings and no escaped commas. Return every occurrence of `key` as a triple `[row, col, pos]`, where: - `row` is the 0-based row index, - `col` is the 0-based column index within that row, - `pos` is the 0-based character index inside that cell where the match begins. Matches may overlap (e.g. `key = "aa"` in `"aaa"` matches at positions 0 and 1). Return results in row-major order (rows in order, then columns in order, then by position within a cell). If `key` is empty, return an empty list. Example: `csvText = "foo,bar\nxxfood,barfoo"`, `key = "foo"` -> `[[0,0,0], [1,0,2], [1,1,3]]`

Constraints

  • 0 <= len(csvText) <= 10^5
  • 0 <= len(key) <= 10^3
  • csvText uses '\n' as the row separator and ',' as the column separator
  • Fields contain no quoted strings or escaped commas
  • Matches may overlap

Examples

Input: ("foo,bar\nxxfood,barfoo", "foo")

Expected Output: [[0, 0, 0], [1, 0, 2], [1, 1, 3]]

Explanation: "foo" at row 0 col 0 pos 0; inside "xxfood" at row 1 col 0 pos 2; inside "barfoo" at row 1 col 1 pos 3.

Input: ("abc,abcabc", "abc")

Expected Output: [[0, 0, 0], [0, 1, 0], [0, 1, 3]]

Explanation: Cell 0 has one match; cell 1 ("abcabc") has two non-overlapping matches at pos 0 and 3.

Hints

  1. Split csvText on '\n' to get rows, then split each row on ',' to get cells; the indices of these splits are your row and col.
  2. Within a cell, repeatedly call find(key, start) and advance start to idx + 1 (not idx + len(key)) so overlapping matches are counted.
  3. Stop the inner loop when find returns -1.
  4. Treat an empty key as a special case and return no matches to avoid an infinite loop.

Loading coding console...