01011011101111011111... 시퀀스에 대한 인터뷰 질문입니다. 코드 품질의 척도로서의 미적분은 어떻습니까?

I found it very fast because this way was preferred by my interviewer. Mostly it's not about solution of the task. You just need to know how generators work and that's it.
I think this is O(N^2) classical problem (or not?). I can show you the algo on TypeScript lang. It's like JavaScript but with types.

export function* strangeZeroOneSequence(length: number): Generator<number> {
  for (let counter = 0; counter < length; counter++) {
    let iterator = 0;
    yield iterator;

    while (iterator <= counter) {
      yield 1;
      iterator++;
    }
  }
}

Computer programming it's constantly about test cases

describe("Check strangeZeroOneSequence", () => {
  it("01 sequence", () => {
    const generator = strangeZeroOneSequence(1);
    const array = [...generator];
    expect(array).toStrictEqual([0, 1]);
  });
  it("01011011101111 sequence", () => {
    const generator = strangeZeroOneSequence(4);
    const array = [...generator];
    console.warn(array);
    expect(array.join("")).toBe("01011011101111");
  });
});

Ok, you can play with it by yourself and leave any comments about it.
I want to stop now with it, and you can look at the complexity estimation of this algo in the bottom of this article. I move to the solution #2.

Because it's one direct way to solve it. Let's remember about powers of two in table view, but let's skip first power 2^0=1

And etc.

Column "Binary" is exactly the pattern, but inverted by somehow. We need replace first 1 from the left to 0 and every next 0 to 1 . How can we do this, but without any loops? Is there any way?

I could start from this, but who's gonna read me if I create an article with just 10 lines of code? =)

export function strangeZeroOneSequence(length: number): string {
  let [result, sequence] = ['', '01'];
  for (let i = 0; i < length; i++) {
    result += sequence;
    sequence += '1';
  }
  return result;
}

You can use test cases from
Some of you already knew the answer from the beginning. Not anytime you have a simple and expressive solution.

Probably you have yours solution - would you share it?

Is it O(N^2) , or could we estimate it a little better? Yes we can and no, we shouldn't! Estimation O(N^2) is good enough.
You need to move to real math if you want to make a more precise estimation.
And I can give you just a little notch to open this shade for you. How can we estimate the time-complexity of this algo but with more accuracy than O(N^2) ?
Let's make 2 sequences and then graphically visualize it.

n -> gap of zeros in the sequence
b -> count of algo iteration that we save per every run

So we can make a plot, where n , b on x , y axes. Just two dimensional Decart system.