Dada una de las siguientes entradas:

Cebolla Dulce Pollo Teriyaki
Pollo Asado al Horno
Pechuga de pavo
BMT italiano
Atún
Jamón Selva Negra
Meatball Marinara

Python 2 , 38 30 28 bytes

lambda S:`6793**164`[len(S)]

Pruébalo en línea!

Desafortunadamente, todavía es un byte más largo que la mejor respuesta de Python 2 hasta ahora; aunque no use el enklactenfoque.

¡Ahora un byte más corto que la respuesta de cada uno !

¿Como funciona?

Después de mucha fuerza bruta, encontré una expresión que da como resultado un número que tiene los dígitos correctos.
Noté que mirar solo un dígito específico de las longitudes de la cadena dada requería 3 bytes ( %10). Así que escribí otro programa de Python ( enlace de Pastebin ) para buscar más números que mapeen directamente las longitudes de las cadenas de entrada al día de la semana.

El número mágico se ve así: 6793**164 = 28714733692312345620167113260575862840674216760386883406587492336415023761043044176257567032312859371641211117824224067391750766520256112063756278010050204239810862527958109285342869876264808102743173594017101607983288521836082497514383184553444755034407847810524083812459571382103831904835921560285915349760536969265992879312869538914200854305957428078269094250817029486005437991820466986793657301214564264748923199288698278615871481529585816783654841131577178922192383679718074693535597651237893794976519274268917335387876260270630339777501802739852278932279775510324916969726203688466311848240746465178859847331248655567344801(un número con unos impresionantes 629 dígitos decimales)

Y como puede ver, el número proporciona la asignación necesaria desde [28, 20, 13, 11, 4, 16, 17] a [0, 1, 2, 3, 4, 5, 6] (las cadenas de Python son 0- indexado):

2871 4 733692 3 1 2 34 5 6 20 1 6711326 0 5758628406742167603868834... [4]^ [11]^ [13]^ [16]^ ^[17] ^[20] ^[28]

Mi programa también encontró otras expresiones que dan números con la propiedad requerida, pero que ahora cobran más bytes para representar (29 en lugar de 28): 19439**540, 34052**726, 39311**604, 44873**182, 67930**164y 78579**469. (Esas son todas las expresiones encontradas por el programa vinculado; su ejecución tomó varias horas).

Función alternativa que requiere 28 bytes: lambda S:`7954<<850`[len(S)]
Función alternativa que requiere 29 bytes: lambda S:`9699<<2291`[len(S)]
Función alternativa que requiere 30 bytes: lambda S:`853<<4390`[len(S)+9]
Función alternativa que requiere 31 bytes:lambda S:`1052<<3330`[len(S)+8]

¿Como funciona? ¿Cómo generé ese número? (Respuesta de 30 bytes)

La respuesta de 30 bytes fue lambda S:`3879**41`[len(S)%10].

Al [28, 20, 13, 11, 4, 16, 17]observar las longitudes de la cadena de entrada , noté que todos los últimos dígitos en base diez difieren, lo que resulta en la lista [8, 0, 3, 1, 4, 6, 7]. Por lo que sólo necesitaba un mapeo de esa lista a la lista de los siete días de la semana, [0, 1, 2, 3, 4, 5, 6].

Mi primer enfoque simplemente usó una cadena para realizar la asignación: lambda S:"13*24*560"[len(S)%10]aunque la cadena requería once bytes ( "13*24*560").
Así que escribí un programa de Python ( enlace de Pastebin ) para probar las expresiones aritméticas que resultan en un número entero con dígitos coincidentes, con la esperanza de desarrollar aún más el programa. Lo que se me ocurrió hasta ahora es `3879**41`(solo diez bytes, la única expresión y, por lo tanto, la más pequeña que encuentra mi programa).

Por supuesto, hay muchas expresiones posibles diferentes que uno podría probar; Tuve la suerte de que hubiera uno en el formulario a**bcon un resultado razonablemente pequeño que se ajustara a mis necesidades.

Sólo para cualquier persona curiosa, 3879**41 = 1372495608710279938309112732193682350992788476725725221643007306215781514348937145528919415861895033279220952836384201346579163035594383625990271079 = 1.372... * 10**147.

Otra función válida que encontré al buscar expresiones alternativas que desafortunadamente requiere 32 bytes: lambda S:`7**416`[len(S)%10+290]

Python 2 , 29 bytes

lambda s:'enklact'.find(s[3])

Pruébalo en línea!

Explicación

La cadena mágica enklactse encontró buscando la primera columna con letras únicas.

La primera columna va SOTITBMque no es útil porque contiene duplicados. El segundo y el tercero tampoco funcionan porque lo son wvutuley eeranaarespectivamente. La cuarta columna, sin embargo, funciona ya que tiene todas las letras únicas.

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

Python , 26 bytes

lambda S:1923136>>len(S)&7

Pruébalo en línea!

Con una deuda de agradecimiento (por mi segundo intento de golf de código directo) a la respuesta de Jonathan Frech : ¡no hubiera pensado usar la longitud de la cuerda en lugar de una letra distintiva!

Este código deriva de mi experiencia con De Bruijn Sequences y programación para ajedrez.

En el ajedrez, a menudo trabajas con varios enteros de 64 bits, donde cada bit indica que algo es verdadero o falso sobre el cuadrado correspondiente en el tablero de ajedrez, como "aquí hay una pieza blanca" o "este cuadrado contiene un peón".

Por lo tanto, es útil poder convertir rápidamente 2**na forma nrápida y económica. En C y C ++, la forma más rápida de hacer esto es multiplicar por una secuencia de De Bruijn de 64 bits, equivalente al desplazamiento por nbits, luego desplazar a la derecha 58 (para poner los primeros seis bits al final) asegúrese de que ' está usando un int sin signo o obtendrá 1s la mitad del tiempo) y busque este número 0..63 en una tabla que le dé el correspondiente nque está en el mismo rango, pero rara vez el mismo número.

Esto está algo relacionado. Sin embargo, en lugar de cambiar de 2**na n, queremos cambiar de nalgún otro número de 3 bits. Entonces, ocultamos nuestros números de 3 bits en un número mágico de 31 bits (un cambio de 28 bits requiere los bits 28-30, con una numeración que comienza en 0.)

Generé el número necesario simplemente viendo qué valores tenían que caer donde (probando tanto 0..6 como 1..7 como la salida establece). Afortunadamente, los valores superpuestos (14, 16 y 17) funcionan. Y dado que el primer tri-bit es 000y el siguiente es 001, no necesitamos los 7 bits más a la izquierda, lo que resulta en menos dígitos -> menos bytes de origen.

El número requerido es 000xxxx001110101011xxxx100xxxx, donde las x pueden ser 1 o 0 y no afecta el resultado de estos subs en particular: los configuro a 0 solo para minimizar el número, pero cambiar cualquiera de las últimas 8 x no debería afectar La longitud del código fuente. Establecer todas las xs en 0 y dejar el inicio, da 1923136 en decimal (o 1D5840 en hexadecimal, pero luego necesita el prefijo 0x, ¡lástima!) El & 7 al final solo enmascara los últimos 3 bits, también podría use% 8, pero necesitaría paréntesis debido a las reglas de precedencia de operadores de Python.

tl; dr: 1923136 codifica cada una de las combinaciones de tres bits del 0 al 6 en exactamente los lugares correctos en los que estos nombres de sándwich se colocan en su lugar, y luego se trata de tomar los últimos tres bits después de un desplazamiento a la derecha.

Jalea , 10 bytes

^{¿Qué pasa con todo este negocio "enklact"?}

⁽ṃXị“Ð$¥»i

Un enlace monádico que toma una lista de caracteres y devuelve el lunes = 1 día de la semana.

Pruébalo en línea! o ver el conjunto de pruebas

¿Cómo?

⁽ṃ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

C (gcc) , 72 71 56 46 41 39 bytes

f(char*s){s=index(s="enklact",s[3])-s;}

Pruébalo en línea!

MATL , 16 15 bytes

O5OHlO7KI6vjYm)

Pruébalo en línea! O verificar todos los casos de prueba .

Explicación

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

Perl 5 , 24 bytes

Código de 23 bytes + 1 para -p.

/[Svrl\s](?!a)/;$_="@+"

-4 bytes gracias a @nwellnhof !

Pruébalo en línea!

Pensé en publicar otras alternativas.

Javascript 38 bytes

a=s=>(271474896&7<<s.Length)>>s.Length

Explicación: ¿Rocas con máscara de bits?

Javascript 27 bytes

s=>"240350671"[s.length%10]

Jalea , 11 bytes

4ị“-ƭɼoṚ0»i

Pruébalo en línea!

Explicación:

4ị“-ƭɼoṚ0»i
4ị          4th element of z
  “-ƭɼoṚ0»i First index in "enklactate"

Japt , 12 bytes

0 indexado, toma la entrada en minúsculas.

`kÇXsm`bUg#

Pruébalo

Explicación

Entrada implícita de cadena en minúsculas U

`kÇXsm`

La cuerda comprimida kotinsm.

bUg#

Obtenga el primer índice ( b) del personaje en index ( g) 26 ( #) en U. (¡Sí, ajuste de índice!)

Salida implícita del resultado entero.

Alternativa

Igual que el anterior (¡y todos los demás!), Solo usando los caracteres en el índice 3 en su lugar, permitiendo la entrada de mayúsculas y minúsculas.

`klact`bUg3

Pruébalo

05AB1E , 11 bytes

Ahorré 1 byte gracias a Erik the Outgolfer y 1 byte gracias a Magic Octopus Urn.

.•ΛΓ2º•I3èk

Pruébalo en línea!

JavaScript (ES6), 25 bytes

0 indexado.

s=>"enklact".search(s[3])

Pruébalo

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>

GolfScript , 12 bytes

{+}*93&(5?7%

Pruébalo en línea!

Asigna las entradas (a través de la suma de sus puntos de código) 0a 6.

Explicación

Encontrado con una herramienta de fuerza bruta del fragmento de GolfScript que escribí hace un tiempo ...

{+}*  # Sum all code points.
93&   # ... AND 93.
(     # Decrement.
5?    # ... raised to the fifth power.
7%    # ... modulo 7.

Así es como esto transforma cada una de las entradas al resultado deseado:

                                 {+}*   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

Excel, 28 bytes

Usando el enklactmétodo:

=FIND(MID(A1,4,1),"enklact")

Perl 6 , 22 bytes

tr/enklact/^6/.comb[3]

Pruébalo en línea!

CJam , 11 bytes

l1b93&(5#7%

Pruébalo en línea!

Un puerto de mi respuesta GolfScript . Cuesta 1 byte leer la entrada explícitamente, pero ahorramos dos al sumar los puntos de código.

Casco , 10 bytes

%7^5←n93ṁc

Pruébalo en línea!

Otro puerto de mi respuesta GolfScript . Estoy seguro de que eventualmente encontraré un lenguaje que pueda sumar los puntos de código para un solo byte ...

Husk (actualización posterior al desafío), 9 bytes

%7^5←n93Σ

Pruébalo en línea!

Ahora, Σ tiene puntos de código suma directamente. Dado que esto se agregó por solicitud después de responder este desafío, no lo voy a usar como mi puntaje principal.

Pyth , 13 bytes

x"enklact"@w3

Verifique todos los casos de prueba.

Alternativa:

x."atÖÅû"@w3

3 puede ser sustituido por cualquiera de los siguientes valores: [3, 4, 11, 13, 21, 24, 25, 26]

Pyke , 12 bytes

3@"enklact"@

Pruébalo aquí!

Protón , 23 bytes

s=>'enklact'.find(s[3])

Pruébalo en línea!

:PAGS

Perl 5 , 43 + 1 ( -p) = 44 bytes

for$i(S,O,TUR,I,TUN,B,M){$"++;$_=$"if/^$i/}

Pruébalo en línea!

Requiere que los primeros tres caracteres de entrada sean mayúsculas.

Java 8, 26 bytes

Crédito a @icrieverytim

Toma la entrada como un char []

s->"enklact".indexOf(s[3])

Haskell , 36 bytes

-9 bytes gracias a H.PWiz.

f s=length$fst$span(/=s!!3)"enklact"

Pruébalo en línea!

Solución alternativa, 45 bytes.

Esto utiliza la indexOffunción en Data.Listcomo elemIndex.

import Data.List
(`elemIndex`"enklact").(!!3)

Pruébalo en línea!

C ++, 119 118 77 76 73 bytes

-41 bytes gracias a Peter Cordes
-1 byte gracias a Zacharý
-3 bytes gracias a Michael Boger

En el índice de cadena 3, el carácter para cada emparedado es diferente

#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);
}

Jugar al golf con std::stringeso era obvio ... ¿qué estaba pensando?

C # (.NET Core) , 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()));}}

Correr en línea

Golfscript, 13 bytes

Pruébalo en línea!

'enklact'\3=?

Toma el cuarto carácter (que, para cada uno, será único) y lo busca en la cadena " enklact".

Alternativamente:

'nklact'\3=?)

Esto aprovecha el hecho de que la ?función de Golfscript devuelve -1 si no se encuentra el elemento buscado (que, para el lunes, no lo hará). Si esto se permitiera, la solución podría reducirse en 1 byte.

Dyalog APL, 13 bytes

'enklact'⍳4⌷⍞

Pruébalo en línea!

K (oK) , 13 bytes

Solución:

"enklact"?*3_

Pruébalo en línea!

Ejemplos:

> "enklact"?*3_"Black Forest Ham"
5
> "enklact"?*3_"Turkey Breast"
2

Explicación:

Interpretado de derecha a izquierda, extraiga el cuarto elemento de la entrada y devuelva la ubicación de índice cero en la lista "enklact":

"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