Created in the 1430s, All Souls College is the most prestigious college at the University of Oxford. On average, it only accepts two students per year. Some years, no one meets the standard.

Being a part of such a prestigious college has a lot of benefits. It allows you to be amongst a select group of Oxford's finest, enjoy ridiculously nice facilities and libraries, and a guaranteed fully-paid seven-year fellowship.

In order to join, you must pass the Worlds Hardest Exam.

In addition to the entrance Exam, it also requires you to take a specialization exam in one of Classical Studies, Economics, English Literature, History, Philosophy, and Politics. You can see past examination papers here.

This is a real life Chūnin Exam from Naruto and Hunter Exam from Hunter×Hunter.

I wish I could take it. You may have noticed that a computer science specialization exam isn't offered, so I have virtually zero chance of passing. However, it would be so exciting if the computer science exam was available. Imagine being able to test for an opportunity to be one of Oxford's best computer science students in history!

I decided to make the exam of what I think a computer science specialization exam could look like:

Section A: Analysis

1.

01010000011011000110010101100001011100110110010100100000

01100100011001010111001001101001011101100110010100100000

01110100011010000110010100100000011011100110111101110010

01101101011000010110110000100000011001010111000101110101

01100001011101000110100101101111011011100010000001100110

01110010011011110110110100100000011001100110100101110010

01110011011101000010000001110000011100100110100101101110

01100011011010010111000001101100011001010111001100101110

2.

>>>+++[<+++>-]<              
<[>>+>+<<<-]>>>[-<<<+>>>]    

> ,                           
<[->-<+]                    

>>[-]                        
>[-]                        
>[-] >[-] >[-] >[-]

<<<<<                    

[                         
  -                       

  >>,                    
  <[->-<+]                   
  >                        

  >>>[-]              
  <<<<[->>>>+<<<<]             
  >>>>                          

  <<<<                          
  [                             
    >>[-]                       
  ]                             

  <<<<                          
  >>                            

  <<<<<                         

  >>>>>                         
  <                             
  [                             
    -                           
    +                           
  ]                             

  <<                            
  [                             
    >>                          
    [                           
      <<                        
      >                         
      [                         
        -                       
        <+>                     
      ]                         
                                
      >                         

      >                         
      <                         
      [                         
        -                       
        >+<                     
      ]
      >                         
      <                         

      <<<<<                     
      >                         

      >>>>>                     
      <                         
      [                         
        >>>[-]                  
        +++                     
        <[-]                    
      ]
      <<<                       
    ]                           
  ]                             

  >>>>>                         
  [                             
    -                           
    <<<<<                       
    >                           
    <<                          
    >                           
    <++++++++++                
    >                          
    [->+<]                     
    <                          
    ++++++++                   
    >                          
    [->+>+<<]                  
    >>[-<<+>>]                 
    <<                         
    ++++++++++++++++++++++++++ 
    ++++++++++                 
    .                          
    ++++++++.                  
    [-]                        
    [-]                        
    [-]                       
    <[-]                      
  ]                            

  <<<<<                        

  >>>>                         
  <[->+<]                      
  >[-]                         
  <                            
  >>                            
  [-><+>]                      
  <[-]                          

  >>>                           
  +
  <<                            

]                               

>>>>>.                          
+++++++.

Describe what this program does and prove its correctness.

3.

Write a Haskell program for a matmul.

4.

std::vector<SP<IFinderResult>> Fuzzy::getNResults(
    const std::vector<SP<IFinderResult>>& in,
    const std::string& query,
    size_t results) 
{
    std::vector<SSCoreData> scores;
    scores.resize(in.size());

    // to analyze scores, run this op in parallel
    auto THREADS = sysconf(_SC_NPROCESSORS_ONLN);
    if (THREADS < 1)
        THREADS = 8;
    THREADS = std::min(THREADS, MAX_THREADS);

    std::vector<std::thread> workerThreads;
    workerThreads.resize(THREADS);
    size_t workElDone = 0, workElPerThread = in.size() / THREADS;
    for (long i = 0; i < THREADS; ++i) {
        if (i == THREADS - 1) {
            workerThreads[i] = std::thread([&] { 
                workerFn(scores, in, query, workElDone, in.size()); 
            });
            break;
        } else {
            workerThreads[i] = std::thread([&] { 
                workerFn(scores, in, query, workElDone, workElDone + workElPerThread); 
            });
        }
        workElDone += workElPerThread;
    }
    for (auto& t : workerThreads) {
        if (t.joinable())
            t.join();
    }
    workerThreads.clear();
    return getBestResultsStable(scores, results);
}

Find the bug.

Section B: Essay

- Are we in a simulation?

- Abstraction is compression.

- The right data structure is a proof.

- Is autoregression optimal?

- Will brute search always work?

Section C: Design

- Imagine a GPU with no shared memory but 2x L1 bandwidth and 4x register file size. Re-design a tiled convolution or reduction. Justify your tile shape and communication strategy.

- Design a zero-knowledge proof that a given 64-bit integer is the product of two primes without revealing the primes, using only group operations mod a publicly known RSA modulus. Outline completeness, soundness, and ZK arguments.

- Moore's Law seems to be slowing. Or is it? Nevertheless, demand for computational power continues to grow. Propose a radical new approach to computer architecture that could sustain exponential performance improvements for the next decade. Evaluate its feasibility and potential drawbacks.