[Question]
  [
## Challenge
Given an ASCII representation of a Babylonian number as input, output the number in Western Arabic numerals.
## Babylonian Numeral System
How did the Babylonians count? Interestingly, they used a Base 60 system with an element of a Base 10 system. Let's first consider the unit column of the system:
The Babylonians had only three symbols: `T` (or, if you can render it: `íêï`) which represented 1, and `<` (or, if you can render it: `íåã`) which represented 10, and `\` (or, if you render it: `íëä`) which represented zero.
**Note:** Technically, `\` (or `íëä`) isn't zero (because the Babylonians did not have a notion of 'zero'). 'Zero' was invented later, so `\` was a placeholder symbol added later to prevent ambiguity. However, for the purposes of this challenge, it's enough to consider `\` as zero
So, in each column you just add up the value of the symbols, e.g.:
```
<<< = 30
<<<<TTTTTT = 46
TTTTTTTTT = 9
\ = 0
```
There will never be more than five `<` or more than nine `T` in each column. `\` will always appear alone in the column.
Now, we need to extend this to adding more columns. This works exactly the same as any other base sixty, where you multiply the value of the rightmost column by \$60^0\$, the one to the left by \$60^1\$, the one to the left by \$60^2\$ and so on. You then add up the value of each to get the value of the number.
Columns will be separated by spaces to prevent ambiguity.
Some examples:
```
<< <TT = 20*60 + 12*1 = 1212
<<<TT \ TTTT = 32*60^2 + 0*60 + 4*1 = 115204
```
## Rules
* You are free to accept either ASCII input (`T<\`) or Unicode input (`íêïíåãíëä`)
* The inputted number will always be under \$10^7\$
* The `<`s will always be to the left of the `T`s in each column
* `\` will always appear alone in a column
## Winning
Shortest code in bytes wins.
  
[Answer]
# JavaScript (ES6), 44 bytes
Takes input as an array of ASCII characters.
```
a=>a.map(c=>k+=c<1?k*59:c<'?'?10:c<{},k=0)|k
```
[Try it online!](https://tio.run/##y0osSyxOLsosKNHNy09J/Z9m@z/R1i5RLzexQCPZ1i5b2zbZxtA@W8vU0irZRt1e3d7QAMiortXJtjXQrMn@n5yfV5yfk6qXk5@ukaYRraenp2RjY6MUq6mpgAT09RWMDbiwq7UJAQO4FqBaEzNsakNgAGE6UK0lNqUxMeguACnF4QIFG2QjIUoNjQyNcLg3JEQhJkYB4Q6QakNTIwOT/wA "JavaScript (Node.js) ‚Äì Try It Online")
### How?
The Babylonian Numeral System can be seen as a 4-instruction language working with a single register -- let's call it the accumulator.
Starting with \$k=0\$, each character \$c\$ in the input array \$a\$ modifies the accumulator \$k\$ as follows:
* `space`: multiply \$k\$ by \$60\$ (implemented as: add \$59k\$ to \$k\$)
* `<`: add \$10\$ to \$k\$
* `T`: increment \$k\$
* `\`: do nothing; this is the `NOP` instruction of this language (implemented as: add \$0\$ to \$k\$)
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~140~~ ~~138~~ 136 bytes
* Saved two bytes thanks to [ceilingcat](https://codegolf.stackexchange.com/users/52904/ceilingcat).
```
B,a,b,y;l(char*o){y=B=0,a=1;for(char*n=o;*n;n++,B++[o]=b,a*=60)for(b=0;*n&&*n-32;n++)b+=*n-84?*n-60?:10:1;for(B=a;B/=60;y+=*o++*B);B=y;}
```
[Try it online!](https://tio.run/##LY3BboMwEETPzVdYVIm82FFxW6EqyyqSfwGfaHIwDrRIxI5ILgjx7dRJelnNzL6dddsf55ZFSytrOWLP3a8d0gDTSJoyaUlhG4Zn6ilg6tELIbUQ3@FItbQp5RnckZqyuN1sUr/9eL9DUAuK5utzH2ee7Xcq2z3bNFnUb/EQx4gEIVINqGnEeXk9NW3nG2Z4CdPja0Vn2/fB8ett6Bsfc6EAo3GXkVeyBLwMnb@1PFkrdWXE1vnp4BNZyp5XANgOTRMFzquz7TyHafVieFIUrDAmgX8TNTswYx7RvPwB "C (gcc) ‚Äì Try It Online")
[Answer]
# [Perl 6](https://github.com/nxadm/rakudo-pkg), 39 bytes
*-3 bytes thanks to nwellnhof*
```
{:60[.words>>.&{sum .ords X%151 X%27}]}
```
[Try it online!](https://tio.run/##K0gtyjH7n1upoJamYKvwv9rKzCBarzy/KKXYzk5Prbq4NFdBD8RTiFA1NDUEkkbmtbG1/4sTKxXSNJRsbGyU9EqKEvOKNZRCbGJilGztlD5MmjD1w6Se7g@TJnYpaWpacyHU2oSAgQLRekJggFgd6jEx6sQ7SMGGeJOVwM5XiIlRIM49///rpgAA "Perl 6 ‚Äì Try It Online")
Uses the cuneiform characters.
### Explanation:
```
{                                     }   # Anonymous code block
     .words  # Split input on spaces
           >>.&{                    }  # Convert each value to
                sum   # The sum of:
                    .ords # The codepoints
                          X%151 X%27   # Converted to 0,1 and 10 through modulo
 :60[                                ]  # Convert the list of values to base 60
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~¬†13¬†~~ 12 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
·∏≤O%7C%13¬ß·∏Ö60
```
A monadic link accepting a list of characters which yields an integer.
**[Try it online!](https://tio.run/##y0rNyan8///hjk3@qubOqobGh5Y/3NFqZvD//38bG5uQEIUYhRAgAAA "Jelly ‚Äì Try It Online")**
### How?
```
·∏≤O%7C%13¬ß·∏Ö60 - Link: list of characters   e.g. "<<<TT \ TTTT"
·∏≤            - split at spaces                 ["<<<TT", "\", "TTTT"]
 O           - cast to ordinals                [[60,60,60,84,84],[92],[84,84,84,84]]
  %7         - modulo by seven (vectorises)    [[4,4,4,0,0],[1],[0,0,0,0]]
    C        - compliment (1-X)                [[-3,-3,-3,1,1],[0],[1,1,1,1]]
     %13     - modulo by thirteen              [[10,10,10,1,1],[0],[1,1,1,1]]
        ¬ß    - sum each                        [32,0,4]
         ·∏Ö60 - convert from base sixty         115204
```
---
Another 12: [`·∏≤O‚ÅΩ¬°‚Ç¨%:5¬ß·∏Ö60`](https://tio.run/##y0rNyan8///hjk3@jxr3Hlr4qGmNqpXpoeUPd7SaGfz//9/GxiYkRCFGIQQIAA "Jelly ‚Äì Try It Online") (`‚ÅΩ¬°‚Ç¨` is `1013`, so this modulos `1013` by the `O`rdinal values getting `53`, `5`, and `1` for `<`, `T`, `\` respectively then performs integer division, `:` by `5` to get `10`, `1` and `0`)
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 13 bytes
```
8740|√á%4/O60Œ≤
```
[Try it online!](https://tio.run/##MzBNTDJM/f/fwtzEoOZwu6qJvr@ZwblN///b2NiEhHDFcIUAAQA "05AB1E ‚Äì Try It Online")
To make up for [how lazy](https://chat.stackexchange.com/transcript/message/46178902#46178902) I've been with my Jelly answer, here is a submission in 05AB1E xD.
[Answer]
# [Python 2](https://docs.python.org/2/), ~~96~~ ~~93~~ ~~87~~ 85 bytes
```
lambda s:sum(60**i*sum(8740%ord(c)/4for c in v)for i,v in enumerate(s.split()[::-1]))
```
[Try it online!](https://tio.run/##Tci9DsIgFEDh3ae4iymXWK2m0YbgW7BZB2whkpSfAG3i06Nsbud84ZPf3l2Kvo9lkfY1S0gsrZZcO0oNrTXc@m7v40wmPPXaR5jAONiwpjlsdZRbrYoyK5KOKSwmE3ww1p6fiCVE4zJo0nAOXIgGd3/yAxhBiOrlCw "Python 2 ‚Äì Try It Online")
---
Saved:
* -1 byte, thanks to Mr. Xcoder
* -4 bytes, thanks to Poon Levi
* -2 bytes, thanks to Matthew Jensen
[Answer]
# Excel VBA, 121 bytes
Restricted to 32-Bit Office as `^` serves as the `LongLong` type literal in 64-Bit versions
Takes input from cell `A1` and outputs to the vbe immediate window.
```
a=Split([A1]):u=UBound(a):For i=0 To u:v=a(i):j=InStrRev(v,"<"):s=s+(j*10-(InStr(1,v,"T")>0)*(Len(v)-j))*60^(u-i):Next:?s
```
### Ungolfed and Commented
```
a=Split([A1])       '' Split input into array
u=UBound(a)         '' Get length of array
For i=0 To u        '' Iter from 0 to length
v=a(i)              '' Get i'th column of input
j=InStrRev(v,"<")   '' Get count of <'s in input
                    '' Multiply count of <'s by 10; check for any T's, if present
                    ''   add count of T's
t=t+(j*10-(InStr(1,v,"T")>0)*(Len(v)-j))
    *60^(u-i)       '' Multiply by base
Next                '' Loop
?s                  '' Output to the VBE immediate window
```
[Answer]
# [Dyalog APL](https://www.dyalog.com/), ~~33~~ 30 bytes
```
{+/(‚åä10*‚çµ-3)√ó60*+\2=‚çµ}'\ T<'‚ç≥‚åΩ
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///P@1R24RqbX2NRz1dhgZaj3q36hprHp5uZqClHWNkC@TWqscohNioP@rd/KhnL1C5grqNjU1IiAJQFAjUAQ "Dyalog APL ‚Äì Try It Online")
**Edit:** -3 bytes thanks to [ngn](https://codegolf.stackexchange.com/users/24908/ngn)
`'\ T<'‚ç≥` replaces the characters with numbers (their position in the string constant), and `‚åΩ` reverses the input so most significant 'digits' are last. This allows `+\2=` to keep a running count of the desired power of 60 (applied by `60*`) by counting the number of times a space (index 2 in the string constant) is encountered. 
`‚åä10*‚çµ-3` gives the desired power of ten for each character. The order of characters in the string constant and the -3 offset cause '\' and space to go to negative numbers, resulting in fractions when those characters are raised to the power of 10, allowing them to be eliminated by `‚åä`. 
All we have to do now is multiply the powers-of-10 digits by the powers-of-60 place values and sum the lot up with `+/`.
[Answer]
# [Python 2](https://docs.python.org/2/), 62 bytes
```
lambda s:reduce(lambda x,y:x+[10,0,59*x,1]["<\ ".find(y)],s,0)
```
[Try it online!](https://tio.run/##K6gsycjPM/qfZhvzPycxNyklUaHYqig1pTQ5VQPKr9CptKrQjjY00DHQMbXUqtAxjI1WsolRUNJLy8xL0ajUjNUp1jHQ/F9QlJlXopCmoW5jY6OuyYXMtQkBA2TREBhAFoyJQdWoYIMqDzZJIUYBou8/AA "Python 2 ‚Äì Try It Online")
This uses the technique from [Arnauld's answer](https://codegolf.stackexchange.com/a/170553/76162).
[Answer]
# [Canvas](https://github.com/dzaima/Canvas), ~~20~~ ~~17~~ 16 [bytes](https://github.com/dzaima/Canvas/blob/master/files/chartable.md)
```
Ôº≥ÔΩõÔΩõ<‚â°Ôº°√ó¬≤T‚â°ÔºΩ‚àëÔºΩ<ÔΩÉ‚î¥
```
[Try it here!](https://dzaima.github.io/Canvas/?u=JXVGRjMzJXVGRjVCJXVGRjVCJTNDJXUyMjYxJXVGRjIxJUQ3JUIyVCV1MjI2MSV1RkYzRCV1MjIxMSV1RkYzRCUzQyV1RkY0MyV1MjUzNA__,i=JTNDJTNDJTNDVFQlMjAlNUMlMjBUVFRU,v=6)
Explanation:
```
E{          ]     map over input split on spaces
  {       ]         map over the characters
   <‚â°A√ó               (x=="<") * 10
       ¬≤T‚â°            x=="T"
           ‚àë        sum all of the results
             <c‚î¥  and encode from base (codepoint of "<") to 10
```
[Answer]
# APL(NARS ‚éïio‚Üê0), 28 chars, 56 bytes
```
{60‚ä•{+/‚çµ‚ç≥‚ç®10‚ç¥'\T'}¬®‚çµ‚äÇ‚ç®‚çµ‚â†' '}
```
some test with type check:
```
  q‚Üê{60‚ä•{+/‚çµ‚ç≥‚ç®10‚ç¥'\T'}¬®‚çµ‚äÇ‚ç®‚çµ‚â†' '}
  o‚Üê‚éïfmt
  o q '<< <TT'
1212
~~~~
  o q '<<<TT \ TTTT'
115204
~~~~~~
```
Each type result is number.
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), ~~122~~ ~~114~~ ~~107~~ ~~106~~ 83 bytes
```
a=>a.split` `.map(b=>[...b].map(c=>x+=c<'T'?10:c<'U',x=0)&&x).reduce((a,b)=>a*60+b)
```
[Try it online!](https://tio.run/##bc7RCoIwGAXg@55idKFb2pxmQrHZS6yrDJxTwzAVtfDtTQ1FzHP1Dz7O2VN8RCXLpKj3WR5GbcxawVyBqyJNah/4@CUKGDD3hjEO7sNLMrfRmKQqVy8mOXfHVdUbRpCiNAiXUfiWEYRCD1BXtHOIFqBW5lmVpxFO8weM4ZZSukUIzGIY4EA2/4zyIaPumO0sGR8zdXbstFSet5js1cokoLOinzIt01r5G@fA88A03EPzaBG7/QI "JavaScript (Node.js) ‚Äì Try It Online")
I'm a little obsessed with "functional-style" array operations, uses ASCII input, as far as I can tell, JS isn't very good at getting charcodes golfily
I'm keeping this for posterity's sake, but this is a naive/dumb solution, I suggest you check out [Arnauld's answer](https://codegolf.stackexchange.com/a/170553/44998) which is far more interesting an implementation of the challenge
[Answer]
# [Retina](https://github.com/m-ender/retina/wiki/The-Language), ~~29~~ ~~26~~ 23 bytes
```
<
10*T
+`^(.*)¬∂
60*$1
T
```
[Try it online!](https://tio.run/##K0otycxLNPyvqhGcoPDfhsvQQCuESzshTkNPS/PQNi4zAy0VQ66Q//9tbBRsQkK4bGyApEKMQggQAAA "Retina ‚Äì Try It Online") Uses newline separation, but link includes header to use spaces instead for convenience. Edit: Saved 3 bytes with help from @KevinCruijssen. Saved a further 3 bytes thanks to @FryAmTheEggman. Explanation:
```
<
10*T
```
Replace each `<` with 10 `T`s.
```
+`^(.*)¬∂
60*$1
```
Take the first line, multiply it by 60, and add the next line. Then repeat until there is only one line left.
```
T
```
Count the `T`s.
Faster 51-byte version:
```
%`^(<*)(T*).*
$.(10*$1$2
+`^(.+)¬∂(.+)
$.($1*60*_$2*
```
[Try it online!](https://tio.run/##K0otycxLNPyvqhGcoPBfNSFOw0ZLUyNES1NPi0tFT8PQQEvFUMWISxsooaeteWgbiARJqBhqmRloxasYaf3/b2OjYBMSwmVjAyQVYhRCgAAA "Retina ‚Äì Try It Online") Uses newline separation, but link includes header to use spaces instead for convenience. Explanation:
```
%`^(<*)(T*).*
$.(10*$1$2
```
Match each line individually, and count the number of `T`s and 10 times the number of `<`s. This converts each line into its base-60 "digit" value.
```
+`^(.+)¬∂(.+)
$.($1*60*_$2*
```
Base 60 conversion, running a line at a time. The computation is done in decimal for speed.
[Answer]
# [Bash](https://www.gnu.org/software/bash/) (with sed and dc), 50 bytes
```
sed 's/</A+/g
s/T/1+/g
s/ /60*/g
s/\\//g'|dc -ez?p
```
Takes space-delimited input from `stdin`, outputs to `stdout`
[Try it online!](https://tio.run/##S0oszvj/vzg1RUG9WN9G31FbP52rWD9E3xDCUNA3M9ACs2Ji9PXT1WtSkhV0U6vsC/7/twGCEDAAAA "Bash ‚Äì Try It Online")
# Explanation
Uses sed to transform the input with a bunch of regular expression matches until, for example, the input `<<<TT \ TTTT` has been transformed to `A+A+A+1+1+60*60*1+1+1+1+`. Then this input is fed to dc with the explicit input execution command `?`, preceded by `z` (pushes the stack length (0) to the stack so that we have somewhere to ground the addition) and followed by `p` (print).
[Answer]
# [J](http://jsoftware.com/), 34 30 bytes
```
60#.1#.^:2(10 1*'<T'=/])&>@cut
```
[Try it online!](https://tio.run/##y/qfVmyrp2CgYKVg8N/MQFnPUFkvzspIw9BAwVBL3SZE3VY/VlPNziG5tOS/JpeSnoJ6mq2euoKOQq2VQloxF1dqcka@QpqCuo2NjToyxyYEDBBiMcjSCjbIUmDVCjEKYA3/AQ "J ‚Äì Try It Online")
[Answer]
# Dyalog APL, ~~35~~ 32 bytes
```
f‚Üê{‚çµ+('<T\ '‚ç≥‚ç∫)‚å∑10,1,0,59√ó‚çµ}/‚àò‚åΩ0‚àò,
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///P@1R24TqR71btTXUbUJiFNQf9W5@1LtL81HPdkMDHUMdAx1Ty8PTgfK1@o86Zjzq2WsApHSA2hTUbWxsQkIUYhRCgEAdAA "APL (Dyalog Unicode) ‚Äì Try It Online")
[31](https://tio.run/##SyzI0U2pSszMTfz/P@1R24TqR71btTXUbUJiFNQf9W5@1LtL81HPdkMDHUMdAx1Ty8PTgfK1@o86Zjzq2WugA9SjoG5jYxMSohCjEAIE6v/yC0oy8/OK/@sWAwA) in dzaima/APL
[Answer]
# [Noether](https://github.com/beta-decay/Noether), 55 bytes
```
I~sL(si/~c{"<"=}{k10+~k}c{"T"=}{!k}c{" "=}{k60*~k}!i)kP
```
[Try it online!](https://tio.run/##y8tPLclILfr/37Ou2EejOFO/LrlayUbJtrY629BAuy67FsgNAXEVwUwFsIyZgRZQRjFTMzvg/38lGxubkBCFGIUQIFACAA "Noether ‚Äì Try It Online")
Same approach as @Arnauld.
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 26 bytes
```
‚âî‚Å∞Œ∏Ôº¶Ôº≥¬´‚â°Œπ ‚â¶√ó‚Å∂‚Å∞Œ∏<‚â¶‚Å∫œáŒ∏T‚â¶‚äïŒ∏¬ªÔº©Œ∏
```
[Try it online!](https://tio.run/##Zc4xC8IwEAXg2fyKo9MFFHRxsFnESVAomNElxLQNtGmbXHWQ/vYYtIPi2x58dzxdK6871cS4D8FWDtdLGHjOys4DHl0/0oW8dRVyDk@2CA9Luga076ZVMJBBtoOz6j/3J1MSStuasITt/Gt24s8VzZjY5pfJb5YmaG9a48jcZjWxiRVpEuFBBcKB8zxGIYSUcAWZwuLq3qgX "Charcoal ‚Äì Try It Online") Link is to verbose version of code. Explanation:
```
‚âî‚Å∞Œ∏
```
Clear the result.
```
Ôº¶Ôº≥¬´...¬ª
```
Loop over the input characters. The `‚â°` command is wrapped in a block to prevent it from finding a "default" block.
```
‚â°Œπ
```
Switch over the current character...
```
 ‚â¶√ó‚Å∂‚Å∞Œ∏
```
if it's a space then multiply the result by 60...
```
<‚â¶‚Å∫œáŒ∏
```
if it's a `<` then add 10 to the result...
```
T‚â¶‚äïŒ∏
```
if it's a `T` then increment the result.
```
Ôº©Œ∏
```
Print the result.
[Answer]
# [R](https://www.r-project.org/), ~~98~~ 81 bytes
```
(u=sapply(scan(,""),function(x,y=utf8ToInt(x))y%%3%*%(y%%6)))%*%60^(sum(u|1):1-1)
```
[Try it online!](https://tio.run/##jU/baoNAEH33K4YJwkzZQtY2UoJ@QN63bxIQqTSQrKK7IUK/IPHBCv6nf2BWpPTy1Kc5wzln5pxqWoEpICv0@a0yM3w1@YuXx7nVmTkUmi6cvaeVqQhVlCQocOy7Yezb29h/XlFc2MsJowgipZBhBbhw7Q0WMIu7AR0jAxksYqeFJAGl/np@WmB@AF/br0NyE6yfJ7JxnZblsaE6SzUJRBbfsUUTW1dFFTttXAlufP/Jf/DJzZCZHQzXe6rtieyH5K18lDz9P8Z0Bw "R ‚Äì Try It Online")
~~Ridiculously long due to string parsing.~~ Thanks Giusppe for shaving off 16 unnecessary bytes.
Define `y` the bytecode value of unicode input and `R = y("T<\") = y("íêïíåãíëä")`
Observe that `R%%3 = 1,2,0` and `R%%6 = 1,5,0`... so `R%%3 * R%%6 = 1,10,0` !
The rest is easy: sum per column, then dot-product with decreasing powers of 60.
[Answer]
# [Ruby](https://www.ruby-lang.org/), ~~50~~ 46 bytes
```
->a{x=0;a.bytes{|c|x+=[59*x,10,0,1][c%9%5]};x}
```
[Try it online!](https://tio.run/##NYqxCoAgFAD3vkKClrKwoSF69hVt6mBSNEYZKOq3Gxrdchzc9aw27jS2s3SGkkl2q9Xb7bzypqFsGGuDe4IJ7gVT1VgNIkwmRFYCQImLJFgyqZafFJx/A4Kv84k4R3kQ3SbV4bz2J9qZFiG@ "Ruby ‚Äì Try It Online")
A basic port of [Arnauld's answer](https://codegolf.stackexchange.com/a/170553/78274) improved by G B for -4 bytes. 
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 65 64 63 bytes
```
f(s,o)char*s;{for(o=0;*s;s++)o+=*s>32?(93^*s)/9:o*59;return o;}
```
[Try it online!](https://tio.run/##VY9fC4IwFMXf/RSXgbCpUSQ92NS@xB5HICtrD22xa0GIn31NI3Bv55z7h99Rm5tS3vcUC8vUvXMZ8rG3jtpmx4PGPGc2bzJsy/2JVuU5Q7atjjY7VNxdh5czYPnktRng0WlDGYwJwOA@lEhJGP8bsdYQOymjoF5riF1YjYJaQC3E/GJOpyR5W31ZZksXwB/P0wXAPiCRFCWBpoVUS0MKwAJCdTbf@i8 "C (gcc) ‚Äì Try It Online")
[Answer]
# Java 8, ~~64~~ 60 bytes
```
a->{int r=0;for(int c:a)r+=c<33?r*59:c<63?10:84/c;return r;}
```
-4 bytes thanks to *@ceilingcat*.
[Try it online.](https://tio.run/##lY89T8NADIb3/Aqr0wXUUBRAkLtQIWa6tBthMG4KV9JL5TiVqiq/PVwOOoIUD5b88b5@vMUDTrfrr54qbBp4QetOEYB1UvIGqYTFUIYGkKJP5Nc3wFj7Zhf51AiKJViAgxx6nD6ehk3OZ3pTswqqDGO@zMmk6Zwvbh8yMnfp/HqW3d9ckeZSWnbAuuv14Ldv3yvv92t7qO0adp5JLYWt@wi3f4CWx0bKXVK3kuz9SCqnXEJqYoyZJFI/e9InZjyqOA60/yrMKsRI4eocI3VFMZoQzOgr4SsoCviTsIu6/hs)
**Explanation:**
```
a->{            // Method with character-array parameter and integer return-type
  int r=0;      //  Result-integer, starting at 0
  for(int c:a)  //  Loop over each character `c` of the input-array
    r+=         //   Increase the result by:
       c<33?    //    Is the current character `c` a space:
        r*59    //     Increase it by 59 times itself
       :c<63?   //    Else-if it's a '<':
        10      //     Increase it by 10
       :c<85?   //    Else (it's a 'T' or '\'):
        84/c;   //     Increase it by 84 integer-divided by `c`,
                //     (which is 1 for 'T' and 0 for '\')
  return r;}    //  Return the result
```
[Answer]
# [APL (Dyalog Extended)](https://github.com/abrudz/dyalog-apl-extended), 18 [bytes](https://codegolf.meta.stackexchange.com/a/9429/43319 "When can APL characters be counted as 1 byte each?")[SBCS](https://github.com/abrudz/SBCS ".dyalog files using a single byte character set")
Anonymous tacit prefix function.
```
60‚ä•10‚ä•¬®‚â†'<T'‚àò‚çß¬®‚ç§‚äÜ‚ä¢
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT9dNrShJzUtJTfn/38zgUddSQxBxaMWjzgXqNiHqjzpmPOpdDuT2LnnU1faoa9H/tEdtEx719j3qm@rp/6ir@dB640dtE4G84CBnIBni4Rn8P01B3cZGwSYkRJ0LzASyFGIUQoBAHQA "APL (Dyalog Extended) ‚Äì Try It Online")
```
                  ‚ä¢  the argument; "<<<TT \ TTTT"
       ‚â†             mask where different from space; [1,1,1,1,1,0,1,0,1,1,1,1]
                ‚äÜ    enclose runs of 1; ["<<<TT","\","TTTT"]
               ‚ç§     on that
              ¬®      for each one
             ‚çß       Count the occurrences In it of the elements
            ‚àò        of the entire list
        '<T'         ["<","T"]; [[3,2],[0,0],[0,4]]
      ¬®              for each one
   10‚ä•               evaluate as base-10 digits
60‚ä•                  evaluate as base-60 digits
```
[Answer]
# Perl -F// -E, 39 bytes
```
$w+=/</?10:/T/?1:/ /?59*$w:0for@F;say$w
```
This reads the to be converted number from STDIN. 
This is essential the same solution as given by @Arnauld using JavaScript.
[Answer]
## F#, 128 bytes
```
let s(v:string)=Seq.mapFoldBack(fun r i->i*Seq.sumBy(fun c->match c with|'<'->10|'T'->1|_->0)r,i*60)(v.Split ' ')1|>fst|>Seq.sum
```
[Try it online!](https://tio.run/##PU/BasMwDL33K0ShOC5zSS87DNeHwnouNLd1FOMlrVjiZLaaUfC/e7YpewcJvfd4kjovzOjaGPuWwFfzmyeH9sp3p/ZnM@jpMPZfe22@q@5uwQEKhess@fuwfxTSCDVoMjcw8It0C0wyobZ1YE3u4SJUzd0Lrl9rXs2b09QjAQPGt0F1noJ6psUP@W7JPY4jWlKfi3zPoNGCdtcZdgtIyFak1kFZnAQQqggZPhP/U1AwpUeos7Bc@TOtcJl1XuKKq45RSpBNk1qqcIYm4Q8)
Ungolfed it would look like this:
```
let s (v:string) =
    Seq.mapFoldBack(fun r i ->
        i * Seq.sumBy(fun c ->
            match c with
                | '<' -> 10
                | 'T' ->1
                | _ -> 0
        ) r, 
        i * 60) (v.Split ' ') 1
    |> fst
    |> Seq.sum
```
`Seq.mapFoldBack` combines `Seq.map` and `Seq.foldBack`. `Seq.mapFoldBack` iterates through the sequence backwards, and threads an accumulator value through the sequence (in this case, `i`).
For each element in the sequence, the Babylonian number is computed (by `Seq.sumBy`, which maps each character to a number and totals the result) and then multiplied by `i`. `i` is then multiplied by 60, and this value is then passed to the next item in the sequence. The initial state for the accumulator is 1.
For example, the order of calls and results in `Seq.mapFoldBack` for input `<<<TT \ TTTT` would be:
```
(TTTT, 1)     -> (4, 60)
(\, 60)       -> (0, 3600)
(<<<TT, 3600) -> (115200, 216000)
```
The function will return a tuple of `seq<int>, int`. The `fst` function returns the first item in that tuple, and `Seq.sum` does the actual summing.
### Why not use `Seq.mapi` or similar?
`Seq.mapi` maps each element in the sequence, and provides the index to the mapping function. From there you could do `60 ** index` (where `**` is the power operator in F#).
But `**` requires `floats`, not `ints`, which means that you need to either initialise or cast all the values in the function as `float`. The entire function will return a `float`, which (in my opinion) is a little messy.
Using `Seq.mapi` it can be done like this for **139 bytes**:
```
let f(v:string)=v.Split ' '|>Seq.rev|>Seq.mapi(fun i r->Seq.sumBy(fun c->match c with|'<'->10.0|'T'->1.0|_->0.0)r*(60.0**float i))|>Seq.sum
```
[Answer]
# [Tcl](http://tcl.tk/), 134 bytes
```
proc B l {regsub {\\} $l 0 l
lmap c [lreverse $l] {incr s [expr 60**([incr i]-1)*([regexp -all < $c]*10+[regexp -all T $c])]}
expr $s}
```
[Try it online!](https://tio.run/##VY8xDoMwDEX3nOIPGQoVEiydMvUMbJABoqhCMhAlUFWKcvY0RBSpf7Kf7W97UxSd3rCs82i1g/dCiMCQdESizTpB@9OZo8fVCnHhPJZquTNEY1eFJwje6pfbR/i@D@CEGsRoHgwUOrL6ra3TiUv4aVEWDp3@GItHXZa3LqNJVk2RkmSUSqgGIghwJcumvv/R9qCFDCxbcBdi3rSAX5/mY82@pT3PhCUL8Qs "Tcl ‚Äì Try It Online")
In the reversed list, I loop incrementing the result in counting `<` and `T` (with `-all` regexp option) and incrementing a natural as power of 60.
Correct version (see comment)
[Answer]
# [05AB1E (legacy)](https://github.com/Adriandmen/05AB1E/tree/fb4a2ce2bce6660e1a680a74dd61b72c945e6c3b), 10 bytes
```
#√á9%5BO60Œ≤
```
[Try it online!](https://tio.run/##MzBNTDJM/f9f@XC7paqpk7@ZwblN//9/mNTTjcATpoKwwodJE7sUYDwYBgA "05AB1E (legacy) ‚Äì Try It Online")
```
#               # split input on spaces
 √á              # convert each character to its codepoint
  9%            # modulo 9 (maps íåã to 5, íêï to 1, íëä to 0)
    5B          # convert each to base 5 (5 becomes 10, 0 and 1 unchanged)
      O         # sum each column
       60Œ≤      # convert from base 60
```
---
## [05AB1E](https://github.com/Adriandmen/05AB1E), 11 bytes
```
#√á9%5B‚Ç¨O60Œ≤
```
[Try it online!](https://tio.run/##yy9OTMpM/f9f@XC7paqp06OmNf5mBuc2/f//YVJPNwJPmArCCh8mTexSgPFgGAA "05AB1E ‚Äì Try It Online")
Same algorithm, but in modern 05AB1E `O` doesn't work on lists of mixed ints and lists, so we need `‚Ç¨O` instead.
]