[Question]
  [
[![enter image description here](https://i.stack.imgur.com/cfNEC.png)](https://i.stack.imgur.com/cfNEC.png)
Given one of the following inputs: 
```
Sweet Onion Chicken Teriyaki
Oven Roasted Chicken
Turkey Breast
Italian BMT
Tuna
Black Forest Ham
Meatball Marinara
```
 output a number from 1-7 (or 0-6) representing the day of the week that you get that deal, starting with Monday as the lowest number. Input can be all lowercase or uppercase if preferred (i.e "italian bmt"). No internet allowed.
  
[Answer]
# [Python 2](https://docs.python.org/2/), ~~38~~ ~~30~~ 28 bytes
```
lambda S:`6793**164`[len(S)]
```
[Try it online!](https://tio.run/##NY7BasMwEETv/YpFYJCCW0hbUhpID44x6cEEat@SQDbRliiWV0ZS2vrrXVHoYRjmvcsMY7w4fpyq1X6y2J80QrM8Ll5en2az@eL5uLPEslGHqVztRPNNFGHLxjGsL@bcEUNL3ozYGZGL7VfaHw5DJP3vE25vvqMRCk/JpP0e0RpkKOr2zzKmKiyeO6icpxBhg31CNWE8obVQozeMHsXh7tN50GAYyuWQYBRZgPs3yILIpH7w11uIsseflEGm53mplMorqZWafgE "Python 2 – Try It Online")
~~Unfortunately still **one** byte longer than the best Python 2 answer thus far; though not using the `enklact`-approach.~~ 
Now **one byte shorter** than [i cri everytim's answer](https://codegolf.stackexchange.com/a/141677/73111)!
### How does it work?
After a lot of brute force, I found an expression that results in a number which has just the right digits.  
I noticed that looking at only one specific digit of the given string's lengths required 3 bytes (`%10`). So I wrote another Python program ([Pastebin link](https://pastebin.com/4AVvZgKi)) to further search for numbers who directly map the input strings' lengths to the day of the week. 
The magic number looks like this: `6793**164 = 28714733692312345620167113260575862840674216760386883406587492336415023761043044176257567032312859371641211117824224067391750766520256112063756278010050204239810862527958109285342869876264808102743173594017101607983288521836082497514383184553444755034407847810524083812459571382103831904835921560285915349760536969265992879312869538914200854305957428078269094250817029486005437991820466986793657301214564264748923199288698278615871481529585816783654841131577178922192383679718074693535597651237893794976519274268917335387876260270630339777501802739852278932279775510324916969726203688466311848240746465178859847331248655567344801` (a number with an impressive 629 decimal digits) 
And as you can see, the number provides the necessary mapping from [28, 20, 13, 11, 4, 16, 17] to [0, 1, 2, 3, 4, 5, 6] (Python strings are 0-indexed):
`2871 **4** 733692 **3** 1 **2** 34 **5** **6** 20 **1** 6711326 **0** 5758628406742167603868834...
 [4]^ [11]^ [13]^ [16]^ ^[17] ^[20] ^[28]`
My program also found other expressions which yield numbers with the required property, though they take more bytes to represent (29 instead of 28): `19439**540`, `34052**726`, `39311**604`, `44873**182`, `67930**164` and `78579**469`. (Those are all the expressions found by the linked program; its execution took several hours.) 
Alternative function that requires 28 bytes: `lambda S:`7954<<850`[len(S)]`  
Alternative function that requires 29 bytes: `lambda S:`9699<<2291`[len(S)]`  
Alternative function that requires 30 bytes: `lambda S:`853<<4390`[len(S)+9]`  
Alternative function that requires 31 bytes: `lambda S:`1052<<3330`[len(S)+8]`
### How does it work? How did I generate that number? (30 byte answer)
The 30 byte answer was `lambda S:`3879**41`[len(S)%10]`.
Looking at the input string's lengths `[28, 20, 13, 11, 4, 16, 17]`, I noticed that all last digits in base ten differ, resulting in the list `[8, 0, 3, 1, 4, 6, 7]`. So I only needed a mapping from that list to the list of all seven days of the week, `[0, 1, 2, 3, 4, 5, 6]`. 
My first approach simply used a string to perform the mapping: `lambda S:"13*24*560"[len(S)%10]`, though the string required eleven bytes (`"13*24*560"`).  
So I wrote a Python program ([Pastebin link](https://pastebin.com/Tpfcg3LD)) to test for arithmetic expressions which result in an integer with matching digits, hoping to further golf the program. What I came up with thus far is ``3879**41`` (only ten bytes, the only and thereby smallest expression my program finds). 
Of course, there are many different possible expressions one could try; I just got lucky that there was one in the form `a**b` with a reasonably small result that fit my need. 
Just for anyone curious, `3879**41 = 1372495608710279938309112732193682350992788476725725221643007306215781514348937145528919415861895033279220952836384201346579163035594383625990271079 = 1.372... * 10**147`.
Another valid function I found whilst searching for alternative expressions that unfortunately requires 32 bytes: `lambda S:`7**416`[len(S)%10+290]`
[Answer]
# [Python 2](https://docs.python.org/2/), 29 bytes
```
lambda s:'enklact'.find(s[3])
```
[Try it online!](https://tio.run/##NY4xi8JAEIX7@RVDGpPiBL0uYJMD0SIIms6zGM2EDLvOht3RI78@txxc@d734HvTbGPQ7TLsvhdPz3tPmOoVq/P0sNV6EO3LdP28VYtxsoQ7LIoCLj/MhieVoPg1ysOxYsdRZnICp3dO50DJuP@n0L2i4xmbyLmHo5EXUmzaLhMlaLLO4T7ELMEDPaFlsjt5jy1FUYoE2Xvd1B@b2zpNXsyLciorgCFEFBTFv4M1TnlvOJRSLb8 "Python 2 – Try It Online")
## Explanation
The magic string, `enklact`, was found by looking for the first column with unique letters.
The first column goes `SOTITBM` which is not useful 'cause it contains duplicates. The second and third ones also don't work because they are `wvutule` and `eeranaa` respectively. The fourth column, however works as it has all unique letters.
```
lambda s:'enklact'.find(s[3])
lambda s:                      # declare a function that takes a single paramater s
                  .find(    )  # find the index of the first instance of...
                        s[3]   # the fourth (0-indexing) character of s...
         'enklact'             # in the magic string
```
[Answer]
# [Python](https://docs.python.org/), 26 bytes
```
lambda S:1923136>>len(S)&7
```
[Try it online!](https://tio.run/##NY5BS8NAEIXv/ophIbKBVGgLioXmEEPQQyiY3NTDtDvSbTazYXer5tfHQfDweLzvu7xpTmfPm6XZvy8Ox6NB6Hbrx812vb0vS0esu/z2Yan3b6r7JkpwYOsZns72NBBDT8HOOFhVqMOX7FePMZH594L7axhohiqQGNkvCZ1Fhqrt/yyjVOXwNEDjA8UEzzgKagnTEZ2DFoNlDKg@bj59AAOWod5NApNWWYRVCVlUmTZ34XKNSY/4I5m0fC/qPM@LRhup5Rc "Python 2 – Try It Online")
With a debt of thanks (for my second straight code-golf try) to [Jonathan Frech](https://codegolf.stackexchange.com/users/73111/jonathan-frech)'s answer -- I wouldn't have thought to use the string length instead of a distinguishing letter!
This code derives from my experience with [De Bruijn Sequences](https://en.wikipedia.org/wiki/De_Bruijn_sequence "De Bruijn sequences") and programming for chess.
In chess, you often work with several 64-bit integers, where each bit indicates something is true or false about the corresponding square on the chessboard, such as "there is a white piece here" or "this square contains a pawn".
It is therefore useful to be able to quickly convert `2**n` to `n` quickly and cheaply. In C and C++, the quickest way to do this is to multiply by a 64-bit De Bruijn sequence -- equivalent to shifting by `n` bits -- then right-shift 58 (to put the first six bits last -- make sure you're using an unsigned int or you'll get 1s half the time) and look up this 0..63 number in a table that gives you the corresponding `n` which is in the same range, but rarely the same number.
This is kind of related. Instead of changing from `2**n` to `n`, however, we want to change from `n` to some other 3-bit number. So, we hide our 3-bit numbers in a magic 31-bit number (a 28-bit shift requires bits 28-30, with numbering starting at 0.)
I generated the number needed by just seeing what values had to fall where (trying both 0..6 and 1..7 as the output sets). Fortunately, the overlapping values (14, 16, and 17) happen to work out! And since the first tri-bit is `000` and the next is `001`, we don't need the leftmost 7 bits, resulting in fewer digits -> fewer bytes of source.
The required number is `000xxxx001110101011xxxx100xxxx`, where the x's can be 1 or 0 and it doesn't affect the result for these particular subs -- I set them to 0 just to minimize the number, but changing any of the last 8 xs shouldn't affect the source code's length. Setting all the xs to 0, and leaving off the start, gives 1923136 in decimal (or 1D5840 in hex, but then you need the 0x prefix -- shame!) The &7 at the end just masks the last 3 bits, you could also use %8, but then you'd need parentheses due to python's operator precedence rules.
tl;dr: 1923136 encodes each of the three-bit combinations from 0 to 6 in exactly the right spots that these sandwich names happen to fall in place, and then it's a matter of taking the last three bits after a right shift.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 10 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
**What's with all this "enklact" business?**
```
⁽ṃXị“Ð$¥»i
```
A monadic link taking a list of characters and returning the Monday=1 day of the week.
**[Try it online!](https://tio.run/##ATsAxP9qZWxsef//4oG94bmDWOG7i@KAnMOQJMKlwrtp////U3dlZXQgT25pb24gQ2hpY2tlbiBUZXJpeWFraQ "Jelly – Try It Online")** or see the [test-suite](https://tio.run/##y0rNyan8//9R496HO5sjHu7uftQw5/AElUNLD@3O/P9w95ajew63P2paoxIJJCL//w8uT00tUfDPy8zPU3DOyEzOTs1TCEktyqxMzM7k8i8D8oLyE4tLUlNgslwhpUXZqZUKTkWpQHEuz5LEnMzEPAUn3xCgTF4il1NOYnK2glt@UWpxiYJHYi6Xb2piSVJiTo6Cb2JRZl5iUSIA "Jelly – Try It Online")
### How?
```
⁽ṃXị“Ð$¥»i - Link: list of characters, sandwichName  e.g. "Tuna"
⁽ṃX        - base 250 literal                             -7761
   ị       - index into sandwichName (1-indexed & modular) 'n'
    “Ð$¥»  - dictionary word                               "retinal"
         i - index of                                           5
```
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~72~~ ~~71~~ ~~56~~ ~~46~~ ~~41~~ 39 bytes
```
f(char*s){s=index(s="enklact",s[3])-s;}
```
[Try it online!](https://tio.run/##dc8xa8MwEAXg3b/iEBSsEC/NGLI4EJLBBFpvTYeLfHaE5HOR1KQh5K9HFZRu0XbwvvfgVDUoFWNfqhO6mZc3v9Lc0U/pV4LYWFRBzP3H4lNWfnmPI2ouZXErCoAvpzn0pXjpDizm6Xi/EAXYs54Y1ietDDG05PQVjRZSLp919ueE3ib0gbr/Us62387QFWpHiefQLqDVyFA3bX6HMZfV6WMDm8mRD7DFMecawnBEa6HBFKH7G7zHh@otDj5W4@L1Fw "C (gcc) – Try It Online")
[Answer]
# [MATL](https://github.com/lmendo/MATL), ~~16~~ 15 bytes
```
O5OHlO7KI6vjYm)
```
[Try it online!](https://tio.run/##y00syfn/39/U3yPH39zb06wsKzJX8///4PLU1BIF/7zM/DwF54zM5OzUPIWQ1KLMysTsTAA) Or [verify all test cases](https://tio.run/##Nck7CgIxFEbhPqu4rQtQ@ygyg4SAprHzd7xgzAvuxJFZfUxjec6XUGO7N7u1Q7T787hb3re0aUfXrl/mSjb7kunw8lPgTI7Frwhe2aXXpWCu/Pyrch8JvJIW7l@NFdEjkzauS4bSEVOgUxGeKw1IyjDqAzGSgfgMwQ8).
### Explanation
```
O5OHlO7KI6 % Push numbers 0, 5, 0, 2, 1, 0, 7, 4, 3, 6
v          % Concatenate all numbers into a column vector
j          % Push input as a string
Ym         % Mean (of ASCII codes)
)          % Index into the column vector (modular, 1-based, with implicit rounding)
           % Implicit display
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 11 bytes
```
4ị“-ƭɼoṚ0»i
```
[Try it online!](https://tio.run/##AToAxf9qZWxsef//NOG7i@KAnC3Grcm8b@G5mjDCu2n///9Td2VldCBPbmlvbiBDaGlja2VuIFRlcml5YWtp "Jelly – Try It Online")
Explanation:
```
4ị“-ƭɼoṚ0»i
4ị          4th element of z
  “-ƭɼoṚ0»i First index in "enklactate"
```
[Answer]
## [Perl 5](https://www.perl.org/), 24 bytes
**23 bytes code + 1 for `-p`.**
```
/[Svrl\s](?!a)/;$_="@+"
```
-4 bytes thanks to [@nwellnhof](https://codegolf.stackexchange.com/users/9296/nwellnhof)!
[Try it online!](https://tio.run/##NcqxCsIwEADQPV9xFgdFpJOTiFJBdCgF201FzvbAkHgJl1jpzxu7OL/nSewqpfxS92Kv4TbbTnCer6f3TbZbZCmVhPGB1kKJohkFVWGxNXBwQiHCEV@q6onh7DBE6mD/1K0hVqeIViNDUTaqeYuhAQqh8aj6QxShYu34v6Eh0QMaPVZG9XU@jhrS0v8A "Perl 5 – Try It Online")
[Answer]
I thought I would post a couple of other alternatives
# Javascript 38 bytes
```
a=s=>(271474896&7<<s.Length)>>s.Length
```
Explanation: Bit-mask rocks?
# Javascript 27 bytes
```
s=>"240350671"[s.length%10]
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt/), 12 bytes
0-indexed, takes input in lowercase.
```
`kÇXsm`bUg#
```
[Test it](https://ethproductions.github.io/japt/?v=1.4.5&code=YGvHWHNtYGJVZyMa&input=Iml0YWxpYW4gYm10Ig==)
---
## Explanation
Implicit input of lowercase string `U`
```
`kÇXsm`
```
The compressed string `kotinsm`.
```
bUg#
```
Get the first index (`b`) of the character at index (`g`) 26 (`#`) in `U`. (Yay, index wrapping!)
Implicit output of integer result.
---
## Alternative
Same as the above (and everyone else!), just using the characters at index 3 instead, allowing for title case input.
```
`klact`bUg3
```
[Test it](https://ethproductions.github.io/japt/?v=1.4.5&code=YIFrbGFjdGBiVWcz&input=Ikl0YWxpYW4gQk1UIg==)
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 11 bytes
Saved 1 byte thanks to Erik the Outgolfer and 1 byte thanks to Magic Octopus Urn.
```
.•ΛΓ2º•I3èk
```
[Try it online!](https://tio.run/##MzBNTDJM/f9f71HDonOzz002OrQLyPI0Prwi@/9/p5zE5GwFt/yi1OISBY/EXAA "05AB1E – Try It Online")
[Answer]
# JavaScript (ES6), 25 bytes
0-indexed.
```
s=>"enklact".search(s[3])
```
---
## Test it
```
o.innerText=(f=
s=>"enklact".search(s[3])
)(i.value);oninput=_=>o.innerText=f(i.value)
```
```
<select id=i><option selected value="Sweet Onion Chicken Teriyaki">Sweet Onion Chicken Teriyaki</option><option value="Oven Roasted Chicken">Oven Roasted Chicken</option><option value="Turkey Breast">Turkey Breast</option><option value="Italian BMT">Italian BMT</option><option value="Tuna">Tuna</option><option value="Black Forest Ham">Black Forest Ham</option><option value="Meatball Marinara">Meatball Marinara</option></select><pre id=o>
```
[Answer]
## [GolfScript](http://www.golfscript.com/golfscript/), 12 bytes
```
{+}*93&(5?7%
```
[Try it online!](https://tio.run/##NcmxCsIwEIDhPU9xiyI6dBARJ6FC0aEUNC9wxlOPxEu5RqWUPnvs4vj/3yOGe@eU25SlGPKwGpe79Xyx2W9nuR2LfPkSJWiEo8Dhyc6TgCXlHj2b5jPVOWKX6PZXY9/qqYdSafrmlDAwCpS1nUTQlAGdhyoqdQmO@DI1YbpiCFCjsqDiDw "GolfScript – Try It Online")
Maps the inputs (via the sum of their code points) to `0` to `6`.
### Explanation
Found with a GolfScript snippet brute force tool I wrote a while ago...
```
{+}*  # Sum all code points.
93&   # ... AND 93.
(     # Decrement.
5?    # ... raised to the fifth power.
7%    # ... modulo 7.
```
Here is how this transforms each of the inputs to the desired result:
```
                                 {+}*   93&     (            5?   7%
Sweet Onion Chicken Teriyaki     2658    64    63     992436543    0
Oven Roasted Chicken             1887    93    92    6590815232    1
Turkey Breast                    1285     5     4          1024    2
Italian BMT                       965    69    68    1453933568    3
Tuna                              408    24    23       6436343    4
Black Forest Ham                 1446     4     3           243    5
Meatball Marinara                1645    77    76    2535525376    6
```
[Answer]
# Excel, 28 bytes
Using the `enklact` method:
```
=FIND(MID(A1,4,1),"enklact")
```
[Answer]
# [Perl 6](https://perl6.org), 22 bytes
```
tr/enklact/^6/.comb[3]
```
[Try it online!](https://tio.run/##NY2xCsIwFAD3fMUbnARTQejoUEHsUAu2m4i81ieGpEl5iUoQvz1mcby74WZiU6a7Y1gs66M0ypKH1Ra6kM0VlIfRzRE@KXBBVhscQ7GWsizk6KbhvLkkAOkxim/q3kQBWquchd1DjZos9MQqolaifWU6OfSBbv8q@idrilAxZS/qgEahharpc7EoqnzTsHdMPsABJ9EQhgGNgQZZWWT8AQ "Perl 6 – Try It Online (with 24 chars b/c it's an older version)")
[Answer]
## [CJam](https://sourceforge.net/p/cjam), 11 bytes
```
l1b93&(5#7%
```
[Try it online!](https://tio.run/##NcmxCsIwFEbhPU9xQRRxE5HiGkF0CAXN6vA3XjAmvYE0KkV89tjF8ZzPPdDXT43rbrdZLLezZl6v8m1W9fJmLtSKT0L7u3eBhSxnPyJ41b6mOicMhW9/VfaZA4@kM09fnQqih5A2dhKB0hEu0CFlHgod0SvDKB1iJIPsBRk/ "CJam – Try It Online")
A port of [my GolfScript answer](https://codegolf.stackexchange.com/a/150073/8478). It costs 1 byte to read the input explicitly, but we save two when summing the code points.
[Answer]
## [Husk](https://github.com/barbuz/Husk), 10 bytes
```
%7^5←n93ṁc
```
[Try it online!](https://tio.run/##yygtzv7/X9U8zvRR24Q8S@OHOxuT////H1yemlqi4J@XmZ@n4JyRmZydmqcQklqUWZmYnQkA "Husk – Try It Online")
Another port of [my GolfScript answer](https://codegolf.stackexchange.com/a/150073/8478). I'm sure eventually I'll find a language that can sum the code points for a single byte...
## [Husk](https://github.com/barbuz/Husk) (post-challenge update), 9 bytes
```
%7^5←n93Σ
```
[Try it online!](https://tio.run/##yygtzv7/X9U8zvRR24Q8S@Nzi////x9cnppaouCfl5mfp@CckZmcnZqnEJJalFmZmJ0JAA "Husk – Try It Online")
Now, `Σ` *does* sum code points directly. Since this was added per a request after I answered this challenge, I'm not going to use it as my primary score though.
[Answer]
# [Pyth](https://pyth.readthedocs.io), 13 bytes
```
x"enklact"@w3
```
**[Verify all the test cases.](https://pyth.herokuapp.com/?code=x%22enklact%22%40w3&test_suite=1&test_suite_input=Sweet+Onion+Chicken+Teriyaki%0AOven+Roasted+Chicken%0ATurkey+Breast%0AItalian+BMT%0ATuna%0ABlack+Forest+Ham%0AMeatball+Marinara&debug=0)**
Alternative:
```
x."atÖÅû"@w3
```
---
`3` can be substituted by any of the following values: `[3, 4, 11, 13, 21, 24, 25, 26]`
[Answer]
# [Pyke](https://github.com/muddyfish/PYKE), 12 bytes
```
3@"enklact"@
```
[Try it here!](http://pyke.catbus.co.uk/?code=3%40%22enklact%22%40&input=%22Meatball+Marinara%22&warnings=0&hex=0)
[Answer]
# [Proton](https://github.com/alexander-liao/proton), 23 bytes
```
s=>'enklact'.find(s[3])
```
[Try it online!](https://tio.run/##NY4xC8JADIX3/ops14K4uAl1qCA6FEG7iUO0KYY7c@UuKiL@9nql@JbA9wXe64NXL0NXDrFcGRLr8Kpm3rG0eTwtzsWgFDVCCSdzfBEp7IW9wPrGV0sCDQV@o2UzA7N/JnDwGJXa/8PIm0ew9IYqUFIj2Ck6RoGqbiYvON4qdVvY@JAaYYv3kdWEekHnoMbAggHNOcs6H4CX07BPBil9kpp3ORdF9h1@ "Proton – Try It Online")
:P
[Answer]
# [Perl 5](https://www.perl.org/), 43 + 1 (`-p`) = 44 bytes
```
for$i(S,O,TUR,I,TUN,B,M){$"++;$_=$"if/^$i/}
```
[Try it online!](https://tio.run/##K0gtyjH9/z8tv0glUyNYx18nJDRIxxNI@uk46fhqVqsoaWtbq8TbqihlpunHqWTq1/7/75STmJyt4JZflFpcouCRmPsvv6AkMz@v@L@ur6megaHBf90CAA "Perl 5 – Try It Online")
Requires the first three characters of input to be upper case. 
[Answer]
# Java 8, 26 bytes
***Credit to @icrieverytim***
Takes input as a char[]
```
s->"enklact".indexOf(s[3])
```
[Answer]
# [Haskell](https://www.haskell.org/), 36 bytes
*-9 bytes thanks to H.PWiz.*
```
f s=length$fst$span(/=s!!3)"enklact"
```
[Try it online!](https://tio.run/##NY4xC8IwEEb/yjV0qCA6OHepIDqEgnYTh7NebUh6Lcmp9NfHBnH64L1veD0GS87F2EEoHfFT@rwLkocJudiWIct2K0VsHbai4oCGoYQBJw3F5A0LbKBbwVVdPkQCNZuRYd@b1hJDQ97MaI1ag6rfCziPGIQe/0PizctbmqHytKgEToLOIEOlm59nTFstARYOo6cgcMQhMU0od3QONC4p6FHd4hc "Haskell – Try It Online")
## Alternate solution, 45 bytes
This uses the `indexOf` function in `Data.List` as `elemIndex`.
```
import Data.List
(`elemIndex`"enklact").(!!3)
```
[Try it online!](https://tio.run/##NY7BaoRAEAXv@Yp2TgrBS857MSFkIbKw8RYCvmjLNjPTytibXb/eKCGnB1XvUBfMnkNYV4nTmIxeYCjfZbaH4ZC3HDgeted761h9QGeuKPMseyrWCFE6UMRUUz4lUaOShoI@3ceN2eikMio9X6TzrNRwkgVe3CO5088GziNm4/7/sPPmmjwvVCXe1A6OhiBQqurmzyv2rbYOT69j4tnoDXFnNcO@EQLV2FKQ4L7WXw "Haskell – Try It Online")
[Answer]
## C++, ~~119~~ ~~118~~ ~~77~~ ~~76~~ 73 bytes
-41 bytes thanks to Peter Cordes   
-1 byte thanks to Zacharý   
-3 bytes thanks to Michael Boger
At the string index 3, character for every sandwich is different
```
#include<string>
int s(char*p){return std::string("enklact").find(p[3]);}
```
```
std::initializer_list<char*> t{
    "Sweet Onion Chicken Teriyaki",
    "Oven Roasted Chicken",
    "Turkey Breast",
    "Italian BMT",
    "Tuna",
    "Black Forest Ham",
    "Meatball Marinara"
};
for (auto& a : t) {
    std::cout << s(a);
}
```
Golfing with `std::string`, that was obvious ofc... what was i thinking...
[Answer]
# [C# (.NET Core)](https://www.microsoft.com/net/core/platform), 289 bytes
```
using System;class c{delegate int s(string r);static void Main(){s y=x=>{if(x[0]==83)return 1;if(x[0]==79)return 2;if (x[0]==84&x[2]=='r')return 3;if(x[0]==73)return 4;if(x[0]==84)return 5;if(x[0] ==66)return 6;if(x[0]==77)return 7;return 0;};Console.Write(y.Invoke(Console.ReadLine()));}}
```
[Run online](https://tio.run/##TczNqsIwEAXgV5mVJosr/tS2EuLGlaAbFVzIXYR0lGBNJJNKS@mzVy8Yr7vDN@eMph/tPPZ9RcZeYN9QwJvQpSIC3RZY4kUFBGMDEKPg/0qeCwoqGA0PZwrYKmMZbwkaWctla86sPo1/pcxn3GOovIWJ@GC2iDh9IcRqMqhP01cY@mG8z75Gn0/JP@ZJxHlEkDJNo6Zf@yxiJt5hLDqxcpZciaOjNwFZM1rbh7sii7xDVWyMRcY5F13X94fqXuIT "C# (.NET Core) – Try It Online")
[Answer]
# Golfscript, 13 bytes
[Try it online!](http://golfscript.apphb.com/?c=OyJCbGFjayBGb3Jlc3QgSGFtIgonZW5rbGFjdCdcMz0%2F)
```
'enklact'\3=?
```
Takes the 4th character (which, for each, will be unique) and looks it up in the string "`enklact`".
Alternatively:
```
'nklact'\3=?)
```
This takes advantage of the fact that Golfscript's `?` function returns -1 if the element searched for is not found (which, for Monday, it will not). If this were allowed, the solution could be reduced by 1 byte.
[Answer]
# Dyalog APL, 13 bytes
```
'enklact'⍳4⌷⍞
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT////1Hf1EdtE9RT87JzEpNL1B/1bjZ51LP9Ue@8//@Dy1NTSxT88zLz8xScMzKTs1PzFEJSizIrE7MzAQ)
[Answer]
# [K (oK)](https://github.com/JohnEarnest/ok), 13 bytes
**Solution:**
```
"enklact"?*3_
```
[Try it online!](https://tio.run/##y9bNz/7/Xyk1LzsnMblEyV7LOF7JCcjMVnDLL0otLlHwSMxV@v8fAA "K (oK) – Try It Online")
**Examples:**
```
> "enklact"?*3_"Black Forest Ham"
5
> "enklact"?*3_"Turkey Breast"
2
```
**Explanation:**
Interpretted right-to-left, pull out the 4th element from the input and return the zero-index location in the "enklact" list:
```
"enklact"?*3_  / the solution
           3_  / 3 drop, 3_"Turkey Breast" => "key Breast" 
          *    / first, *"key Breast" => "k"
         ?     / lookup right in left
"enklact"      / list to lookup element in
```
]