GeeksforGeeks Question · Jul 2025 · London

Bloomberg Interview | Set 2 (Video Conference)

Question Details

Click here to see the documentation of the first phone interview.The video conference came after passing the phone interview, it was held on Skype with 2 interviewers from...

Full Details

Click here to see the documentation of the first phone interview. The video conference came after passing the phone interview, it was held on Skype with 2 interviewers from Bloomberg: Freddy and Chad. The call started by both of them introducing themselves, and so did I, and I was, again, asked to say what I know about bloomberg, and why I want to work there. The interviewers then jumped to the first question, it was direct, for the following code, answer the given 9 questions. [sourcecode langauge="C"] #include int main(int argc, char argv[]) { char abc[27]; char ptr = abc; strcpy(abc, "abcdefgxyz"); / * What are the types and values of expressions: * * 1. abc * 2. abc * 3. abc[2] * 4. &abc[3] //&abc[3] = abc + 3sizeof(char) * 5. abc+4 * 6. (abc+5) + 20000 //h long long x = int * 1LL * int * 7. abc[10] //'\0' * 8. abc[12] //memset () * 9. &ptr //char* /

return 0; } [/sourcecode] The second question was as follows: The shown code is built to print out the current date, but for some reason, it doesn’t. You are required to figure out the reason. C #include #include #include char * get_date () { char buf [ 80 ]; time_t now = time ( 0 ); strcpy ( buf , ctime ( & now ));

return buf ; } int main ( int argc , char * argv []) { char * date = get_date (); printf ( "date=%s
" , date );

return 0 ; } At the beginning the code looked fine to me, the only thing I thought would be the problem, is the declaration of the char array buf on the stack instead of the heap. So, I suggested that dynamic allocation should solve the problem and that we should use malloc(80*sizeof(char)) instead of buf[80] The interviewers said it was the correct step, but he still needs a reason. The interviewers gave a hint, that in case a breakpoint was set just before the printf if, the debugger shows that date does hold the correct result, so the problem is in printf. After I had enough time, the interviewer decided to give me the answer to move next. The problem was that when printf is called, it needs a part of the stack, and this may affect the stack-reserved array of characters buf. The next question was a follows: Given an integer n,

return the number of ways it can be represented as a sum of 1s and 2s, order matters. I suggested we use a recursive function to compute it. And then suggested to use some sort of memoization. The code was as follows: CPP ////////////////// // // number of ways // n = 3 // 3 = 1,2 // 1,1,1, // 2,1 int memo [ 1000000 ]; // memset (memo, -1, sizeof(memo)); int ways_of_sum_up ( int n ) { if ( n == 0 )

return 1 ; if ( n < 0 )

return 0 ; if ( memo [ n ] != -1 )

return memo [ n ]; int ans = ways_of_sum_up ( n -1 ) + ways_of_sum_up ( n -2 );

return memo [ n ] = ans ; } I then realized the problem forms linear recurrence, where f(n) = f(n-1) + f(n-2), so it can be solved using matrix exponentiation. I spend around 15 minutes explaining the solution to the interviewers, and they didn’t seem to understand a word of it. f(0) = 1 f(1) = 1 f(n) = f(n-1) + f(n-2) [1 1][f(n)] [f(n)+f(n-1)] [1 0][f(n-1)] [f(n)] [1 1]^m [1 0] x^y = x^(y/2) * x^(y/2) = x^(y/4) * x^(y/4) * x^(y/4) * x^(y/4) = ...... = x^1 ............ x^1 x^5 = x^2 * x^2 * x [1 1]^2 [1 1]^1 x*x [1 0] [1 0] The running time complexity of the solution is O(log(n)), same as the memory complexity. There was another solution that I didn’t have time to say, which has a time complexity of O(n) and a memory complexity of O(1), which models this problem to the fibonacci problem. The last question was so trivial, I was asked to reverse a string in place, I used the 2 pointers, here was the code: CPP ////////// // "hello world" -> "dlrow olleh" void reverse_word ( char * str , int size ) { int p1 , p2 ; p1 = 0 ; p2 = size -1 ; while ( p1 < p2 ){ char tmp = str [ p1 ]; str [ p1 ] = str [ p2 ]; str [ p2 ] = tmp ; p1 ++ ; p2 -- ; } } Finally I was asked to use this code to reverse words within a sentence, in place, here was the code: CPP // "hello world" -> "world hello" // "hello world" -> "dlrow olleh" // "hello there everyone" -> "everyone there hello" // "hello" -> ? void reverse_sentence ( char * str , int size ) { int p1 ; p1 = 0 ; //"hello world" reverse_word ( str , size ); //linear //"dlrow olleh" //"world olleh" //"world hello" for ( int i = 0 ; i < size ; i ++ ){ p1 = i ; while ( p1 < size && str [ p1 ] != ' ' ) p1 ++ ; reverse_word ( str + i * sizeof ( char ), p1 - i ); i = p1 ; } }

Result

Rejected. Summary: The interviewers are not so good with problem solving, they are good implementers just it, so type neat and clean code, use the obvious ideas, don’t do complicated solutions, because they most probably won’t get it. If I made one mistake in this interview, I would say it was using matrix exponentiation rather than the easier linear-time constant-memory solution. Good Luck with that, passing this video conference means you are going to London for an onsite, final interview, so you have another reason to do your best.

Free preview — 6 questions shown. Unlock all Bloomberg questions →

About This Question

This is a reported interview question from a bloomberg interview for a swe role during the phone screen round reported in 2025.

It covers the following topics: Heap, Strings, Dynamic Programming, Matrix, Stack Queue, Recursion, Math, Arrays, Stack .

About Bloomberg Interview Reports

This question was reported by a candidate who interviewed at Bloomberg. LeakCode aggregates interview reports from 10+ sources, including 1Point3Acres, Glassdoor, LeetCode Discuss, Blind, Reddit, Indeed, and Nowcoder. Each report is translated where necessary, deduplicated against existing entries, and tagged by company, role, round type, and reporting date.

Use this question as one calibration data point, not a memorization target. Companies typically rotate their question pools every 2-4 months; the exact wording of a 2024 question may differ from what you encounter today. The underlying pattern, difficulty level, and follow-up depth at Bloomberg are the higher-signal extractions to take from this report.

For broader preparation context, the Bloomberg interview process typically includes a recruiter screen, one or two technical phone screens, and a 4-5 round on-site loop covering coding, system design (at L4+ levels), and behavioral. Reports tagged on LeakCode show the round-by-round distribution and typical difficulty calibration. To browse questions filtered by round type and seniority, use the company hub linked above.

How To Practice This Type of Question

Solve similar problems on LeetCode under timed conditions (25-35 minutes per medium difficulty). The goal is pattern recognition: recognize the underlying technique (sliding window, two-pointer, BFS, memoized recursion, etc.) within 60-90 seconds of reading. Strong candidates verbalize their hypothesis out loud before coding, then iterate based on feedback. Weak candidates dive into implementation immediately, lose time on the wrong approach, and run out of time for follow-ups.

Companies update their question pools every 2-4 months. The exact wording of any given question may have been retired by the time you interview. Focus your prep on the pattern, not the specific problem. The patterns that appear in Bloomberg reports consistently are the ones worth investing in; one-off niche problems are not.

During Your Bloomberg Round

Apply the standard interview round template: clarify requirements (2-3 minutes), state your approach out loud and confirm direction with the interviewer (3-5 minutes), code with narration (15-25 minutes), test with concrete examples including edge cases (5 minutes), discuss optimization or trade-offs if time permits (5 minutes). This template is universally accepted across FAANG and adjacent companies; deviating from it produces weaker interviewer feedback signal.

The single most predictive failure mode in Bloomberg reports tagged "no hire": not asking clarifying questions. Interviewers are explicitly trained to weight this. Strong candidates ask 3-5 clarifying questions even on problems that look obvious; weak candidates dive into code immediately. The clarifying-question check is often the first signal recorded in the interviewer's written notes.