Better late then never I suppose :) but here are a few hints:
Hint 1: A Consider fast way to find an index in an array
Hint 2: When you find the right index, it's a matter of splicing to get your solution
Hint 3: Remove Tree from your approach and you have the answer to hint #1

Incredibly fun kata!

This was a tremendously fun kata to solve; my thanks to the author and contributors. Additionally: Major props for such a well documented Details section on this kata!

I second hobovsky: It's a fantastic practice and technique to print the test cases out from codewars; simple as printing the data to the screen; doing so you will see an example where a nested loop; for python (you will also get the tape, and proper output too; a gerat way to debug):

def interpreter(code, tape):
    print("Code:", code) 
    print("Tape:", tape)
    return []  #  nested example code is '*[>[*]]' 

Great kata, but an example of what 'multiple arguments' would make this kata eve better, as the provided link (to mathIsFun.com) does not cover what is meant by multiple arguments in function composition.

Eample of 'multiple arguments'

1. Define f(a) as 2a+1 and Define g(c,d) as c-3d
2. We see that the function g takes multiple arguments (two in this example)
3. Now the composition of g into f (i.e fog): is f(g(x,y)) = f(x-3y) = 2(x-3y) + 1

• Note: Another way to write the composition is (fog)(x,y) as g is acted on first, which takes multiple arguments

Happy learning and happy coding!

I second natan: Study higher order functions (and maybe think of things like objects perhaps)

Really fun Kata! Just an absolute blast to solve!

Thank you fello coder and codewarrior, your thoughtful comment really brightens my day :)

To manage non-commands: interpret method (of class EsolangBrainF) needs to have a self.incCmdTapePointer() before the continue statement

Seeing a few questions on the bracket cmds, I thought I might try to offer (a rather verbose) explanation of these commands.
Nomenclature: The string of commands (e.g. '>') I call 'code-tape' and the string of 0's and 1's (e.g. '10010') I call data-tape.
Additionally, 'code pointer' points to the current cmd to execute

• Cmd "Left Bracket" (i.e.'['):
  • "Left Bracket" command executes if the value of current cell on the data-tape is a '0'
    (otherwise move onto the next command)
  • Move to the right in the code-tape till matching right bracket is found; once found, consume
    the right bracket token (hence we jump to the code-cell directly to the right of the matching
    right bracket)
• Cmd "Right Bracket" (i.e.']'):
  • "Right Bracket" command executes if the value of current cell on the data-tape is not '0'
    (otherwise, just move onto the next command)
  • Move to the left in the code tape till matching left-bracket is found. Once matching left bracket
    is found, stay at the bracket cmd on the command tape (i.e. don't consume it like the other bracket cmd)
• Lastly, your code needs to be able to manage nested brackets

I am just getting into this Kata myself (so I haven't solved it yet) but I'd be happy to share things that I am looking into, if that might help:

• Expression Trees
• Pratt Parser
• Shunting Yard Algorithm

Article about recursive decent: http://www.engr.mun.ca/~theo/Misc/exp_parsing.htm#shunting_yard
Article on the Pratt Parser: http://effbot.org/zone/simple-top-down-parsing.htm
Article on the Pratt Parser: http://journal.stuffwithstuff.com/2011/03/19/pratt-parsers-expression-parsing-made-easy/

Happy Learning and Coding :D