Quando prendo il mio panino?


37

enter image description here

Dato uno dei seguenti input:

Pollo alla cipolla dolce Teriyaki
Pollo Al Forno
Petto di tacchino
BMT italiana
tonno
Prosciutto della Foresta Nera
Polpetta Marinara
emetti un numero compreso tra 1 e 7 (o 0-6) che rappresenta il giorno della settimana in cui ricevi quell'affare, a partire da lunedì come numero più basso. L'ingresso può essere tutto minuscolo o maiuscolo, se preferito (ad esempio "italian bmt"). Nessuna connessione Internet consentita.


8
Non vedo davvero come questa complessità di Kolmogorov. Il testo è l'input ... i numeri sono l'output.
geokavel,

5
Domenica dice anche "Polpetta di Marinara" o "Polpetta di Marina Ra"?
Erik the Outgolfer,

17
Sono abbastanza sicuro che dovrebbe essere Marinara ma il keming nell'immagine è piuttosto terribile ...
totalmente umano

6
Se è utile a chiunque: il numero di apiù il numero di ein ogni input è [5,4,3,2,1,3,6] rispettivamente.
geokavel,

Risposte:


85

Python 2 , 38 30 28 byte

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

Provalo online!

Sfortunatamente ancora un byte più lungo della migliore risposta Python 2 finora; sebbene non usi l' enklactapproach.

Ora un byte in meno rispetto alla risposta di everytim !

Come funziona?

Dopo molta forza bruta, ho trovato un'espressione che risulta in un numero che ha le cifre giuste.
Ho notato che guardando solo una cifra specifica delle lunghezze della stringa data richiesto 3 byte ( %10). Così ho scritto un altro programma Python ( link Pastebin ) per cercare ulteriormente i numeri che mappano direttamente la lunghezza delle stringhe di input al giorno della settimana.

Il numero magico è simile al seguente: 6793**164 = 28714733692312345620167113260575862840674216760386883406587492336415023761043044176257567032312859371641211117824224067391750766520256112063756278010050204239810862527958109285342869876264808102743173594017101607983288521836082497514383184553444755034407847810524083812459571382103831904835921560285915349760536969265992879312869538914200854305957428078269094250817029486005437991820466986793657301214564264748923199288698278615871481529585816783654841131577178922192383679718074693535597651237893794976519274268917335387876260270630339777501802739852278932279775510324916969726203688466311848240746465178859847331248655567344801(un numero con 629 cifre decimali impressionanti)

E come puoi vedere, il numero fornisce la mappatura necessaria da [28, 20, 13, 11, 4, 16, 17] a [0, 1, 2, 3, 4, 5, 6] (le stringhe di Python sono 0- indicizzato):

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

Il mio programma ha anche trovato altre espressioni che danno i numeri con la proprietà necessaria, anche se prendono più byte per rappresentare (29 invece di 28): 19439**540, 34052**726, 39311**604, 44873**182, 67930**164e 78579**469. (Queste sono tutte le espressioni trovate dal programma collegato; la sua esecuzione è durata diverse ore.)

Funzione alternativa che richiede 28 byte: lambda S:`7954<<850`[len(S)]
Funzione alternativa che richiede 29 byte: lambda S:`9699<<2291`[len(S)]
Funzione alternativa che richiede 30 byte: lambda S:`853<<4390`[len(S)+9]
Funzione alternativa che richiede 31 byte:lambda S:`1052<<3330`[len(S)+8]

Come funziona? Come ho generato quel numero? (Risposta a 30 byte)

La risposta di 30 byte è stata lambda S:`3879**41`[len(S)%10].

Osservando le lunghezze della stringa di input [28, 20, 13, 11, 4, 16, 17], ho notato che tutte le ultime cifre nella base dieci differiscono, risultando nell'elenco [8, 0, 3, 1, 4, 6, 7]. Così ho solo bisogno di una mappatura da tale elenco per l'elenco di tutti i sette giorni della settimana, [0, 1, 2, 3, 4, 5, 6].

Il mio primo approccio ha semplicemente usato una stringa per eseguire il mapping:, lambda S:"13*24*560"[len(S)%10]sebbene la stringa richiedesse undici byte ( "13*24*560").
Così ho scritto un programma Python ( link Pastebin ) per testare le espressioni aritmetiche che danno come risultato un numero intero con cifre corrispondenti, sperando di approfondire ulteriormente il programma. Ciò che mi è venuto in mente finora è `3879**41`(solo dieci byte, l'unica e quindi la più piccola espressione che il mio programma trova).

Naturalmente, ci sono molte diverse espressioni possibili che si potrebbero provare; Ho appena avuto la fortuna che ce n'era uno nella forma a**bcon un risultato ragionevolmente piccolo che si adattava alle mie esigenze.

Solo per chiunque sia curioso, 3879**41 = 1372495608710279938309112732193682350992788476725725221643007306215781514348937145528919415861895033279220952836384201346579163035594383625990271079 = 1.372... * 10**147.

Un'altra funzione valida che ho trovato durante la ricerca di espressioni alternative che purtroppo richiede 32 byte: lambda S:`7**416`[len(S)%10+290]


1
Come hai generato quel numero? : o
totalmente umano il

10
@icrieverytim Forza bruta.
Jonathan Frech,

-9114**28è un numero intero più piccolo * che funziona anche (* in termini assoluti non solo perché è negativo - 111 cifre anziché 629). Non risparmia sui byte però.
Jonathan Allan,

4
Ogni tanto controllo le domande del PCG in HNQ e di solito sono deluso nel trovare le lingue del golf tra i primi tre posti. Oggi non sono rimasto deluso. Grazie!
Sidney,

4
@icrieverytim ಠ_ಠ è lo stesso numero ma dimezzato con un fattore di spostamento di un altro ಠ_ಠ: P
HyperNeutrino,

49

Python 2 , 29 byte

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

Provalo online!

Spiegazione

La corda magica enklact, è stata trovata cercando la prima colonna con lettere uniche.

La prima colonna va SOTITBMche non è utile perché contiene duplicati. Anche il secondo e il terzo non funzionano perché sono wvutulee eeranaarispettivamente. La quarta colonna, tuttavia, funziona in quanto ha tutte le lettere uniche.

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

18

Python , 26 byte

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

Provalo online!

Con un debito di ringraziamento (per il mio secondo tentativo di code-golf dritto) a Jonathan Frech la risposta - non avrei pensato di usare la lunghezza della stringa anziché una lettera distintiva!

Questo codice deriva dalla mia esperienza con le sequenze di De Bruijn e la programmazione per gli scacchi.

Negli scacchi, spesso lavori con diversi numeri interi a 64 bit, dove ogni bit indica qualcosa di vero o falso sul quadrato corrispondente sulla scacchiera, come "qui c'è un pezzo bianco" o "questo quadrato contiene un pedone".

È quindi utile essere in grado di convertire rapidamente 2**nin modo nrapido ed economico. In C e C ++, il modo più rapido per farlo è moltiplicare per una sequenza di De Bruijn a 64 bit - equivalente allo spostamento per nbit - quindi spostare a destra 58 (per inserire i primi sei bit per ultimo - assicurarsi di ' stai usando un int senza segno o otterrai 1s la metà del tempo) e cerca questo numero 0..63 in una tabella che ti dia il corrispondente nche è nello stesso intervallo, ma raramente lo stesso numero.

Questo è un po 'correlato. Invece di passare da 2**na n, tuttavia, vogliamo passare da nun altro numero a 3 bit. Quindi, nascondiamo i nostri numeri a 3 bit in un numero magico a 31 bit (uno spostamento di 28 bit richiede i bit 28-30, con la numerazione che inizia da 0.)

Ho generato il numero necessario semplicemente vedendo quali valori dovevano cadere (provando sia 0..6 che 1..7 come set di output). Fortunatamente, i valori sovrapposti (14, 16 e 17) sembrano risolversi! E poiché il primo tri-bit è 000e il successivo è001 , non abbiamo bisogno dei 7 bit più a sinistra, con il risultato di meno cifre -> meno byte di sorgente.

Il numero richiesto è 000xxxx001110101011xxxx100xxxx, dove le x possono essere 1 o 0 e non influisce sul risultato per questi particolari sottotitoli - li ho impostati su 0 solo per minimizzare il numero, ma la modifica di uno qualsiasi degli ultimi 8 x non dovrebbe influire la lunghezza del codice sorgente. Impostando tutte le xs su 0 e lasciando l'inizio, si ottiene 1923136 in decimale (o 1D5840 in esadecimale, ma poi è necessario il prefisso 0x - peccato!) Il & 7 alla fine maschera solo gli ultimi 3 bit, si potrebbe anche usa% 8, ma allora avresti bisogno di parentesi a causa delle regole di precedenza dell'operatore di Python.

tl; dr: 1923136 codifica ciascuna delle combinazioni di tre bit da 0 a 6 esattamente nei punti giusti in cui questi nomi di sandwich si trovano al loro posto, e quindi si tratta di prendere gli ultimi tre bit dopo uno spostamento a destra.


Abbastanza simile al mio approccio con la maschera da bit, ma anche meglio.
Bruno Costa,

12

Gelatina , 10 byte

Cosa c'è in tutto questo business "enklact"?

⁽ṃXị“Ð$¥»i

Un collegamento monadico che prende un elenco di caratteri e restituisce il lunedì = 1 giorno della settimana.

Provalo online! o vedi la suite di test

Come?

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

Come hai trovato la -7761/retinalcombo?
Emigna,

3
Ha scritto un ciclo che scorreva creando "parole" e vedendo se esistessero nel dizionario. "retinale" era l'unico tra -32249 e 32250 (il range di ⁽...)
Jonathan Allan,

... leggero errore - l'intervallo di ⁽..è in realtà [-31349,32250] - [- 99.999] (ci sono anche altri numeri che uno può rappresentare con tre o meno byte come 7!!oȷ76 )
Jonathan Allan,


7

MATL , 16 15 byte

O5OHlO7KI6vjYm)

Provalo online! Oppure verifica tutti i casi di test .

Spiegazione

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


5

Ho pensato di pubblicare un paio di altre alternative

Javascript 38 byte

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

Spiegazione: rocce con maschera bit?

Javascript 27 byte

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

la seconda alternativa è lunga 29 byte dimenticataa=
Bruno Costa

Perché è a=necessaria la parte? Guarda la risposta di Shaggy .
geokavel,

1
@BrunoCosta Su questo sito, non ti chiediamo di nominare le tue funzioni. Quelli anonimi funzionano, quindi non è necessario a=.
R

1
@BrunoCosta che bello, dipende davvero da te. Inoltre, non puoi semplicemente contarlo nel conteggio dei byte dell'intestazione e includerlo nello snippet per semplificare il test.
Rɪᴋᴇʀ

1
@MichaelBoger Sicuramente non penso che possa farlo perché la quantità minima di codice per farlo funzionare credo che sia qualcosa del generea=s=>{b=s.Length;return(271474896&7<<b)>>b}
Bruno Costa

4

Gelatina , 11 byte

4ị“-ƭɼoṚ0»i

Provalo online!

Spiegazione:

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

2
@ Mr.Xcoder a meno che non lo utilizzi enklactateinvece che enklactper la mia stringa, nel qual caso lo porta a 11;)
Erik the Outgolfer,

5
Oh, per amor di fondente, perché enklactate nel dizionario di Jelly?
totalmente umano il

3
@icrieverytim Non è, enkè una stringa ed lactateè una parola. EDIT: appena confermato, enklactatenon è nel dizionario.
Erik the Outgolfer,

1
@icrieverytim Penso che sia solo lattato .
Mr. Xcoder,

2
Oh maaan, volevo trovare un modo per deridere il dizionario di Jelly ... Forse la prossima volta. : P
totalmente umano il

3

Japt , 12 byte

0-indicizzato, accetta input in minuscolo.

`kÇXsm`bUg#

Provalo


Spiegazione

Immissione implicita di una stringa minuscola U

`kÇXsm`

La stringa compressa kotinsm.

bUg#

Ottieni il primo indice ( b) del carattere in index ( g) 26 ( #) in U. (Sì, avvolgimento indice!)

Output implicito del risultato intero.


Alternativa

Come sopra (e tutti gli altri!), Usando invece i caratteri nell'indice 3, consentendo l'inserimento del case del titolo.

`klact`bUg3

Provalo


Dov'è finito en? : P
totalmente umano il

1
@icrieverytim: questa è una stringa compressa; enè compresso in un non stampabile.
Shaggy,

7
Penso di vedere un bUgnel tuo codice.
Shenles,


3

JavaScript (ES6), 25 byte

0-indicizzati.

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

Provalo

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>


1
Questo è di 25 byte !
geokavel,

Grazie @geokavel. Non so da dove ho preso quei 3 byte extra; anche il conteggio lo f=renderebbe solo 27.
Shaggy

soluzione semplice ed efficace. +1 :)
Brian H.

@Shaggy Forse il tuo terzo byte extra era una nuova riga finale.
Michael Boger,

3

GolfScript , 12 byte

{+}*93&(5?7%

Provalo online!

Mappa gli input (tramite la somma dei loro punti di codice) 0su 6.

Spiegazione

Trovato con uno strumento di forza bruta snippet GolfScript che ho scritto qualche tempo fa ...

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

Ecco come questo trasforma ciascuno degli input nel risultato desiderato:

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

2

Excel, 28 bytes

Using the enklact method:

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

You can drop 2 bytes by converting this to Google Sheets and dropping the ")
Taylor Scott

2

Perl 6, 22 bytes

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

Try it online!


perl 2017.07 accepts tr/enklact/^6/.comb[3] which would be 22 bytes, but tio.run apparently does not have it yet.
Massa

(tio.run runs perl6 v2017.6)
Massa

1
As long as an interpreter exists that can run the 22 byte version, it's valid.
Shaggy


2

Husk, 10 bytes

%7^5←n93ṁc

Try it online!

Another port of my GolfScript answer. I'm sure eventually I'll find a language that can sum the code points for a single byte...

Husk (post-challenge update), 9 bytes

%7^5←n93Σ

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.





1

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

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

Try it online!

Requires the first three characters of input to be upper case.


It has to be all uppercase, all lowercase, or regular.
geokavel

Call it all uppercase, then. Anything beyond the first three characters is ignored.
Xcali

1

Java 8, 26 bytes

Credit to @icrieverytim

Takes input as a char[]

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

You can do s->"enklact".indexOf(s[3]) if you specify that you take input as a char array.
shooqie

Is that okay? I've a few answers that can be shortened like that
Roberto Graham


1

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...


1
std::find in a string literal (or maybe a std::string) seems like the obvious way to go. Basically the same idea as index or strchr that the C answers are using, in a data structure where the 0-5 is implicit from the position.
Peter Cordes

You can remove the newline inbetween lines 2 and 3.
Zacharý

You don't need a variable to store enklact. std::string("enklact").find(p[3]) works fine. This brings it down 3 characters.
Michael Boger

You CAN pass string literals to your function (g++ only raises a warning) so the memcpy stuff isn't needed.
Michael Boger

0

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

Run online


0

Golfscript, 13 bytes

Try it online!

'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.



0

K (oK), 13 bytes

Solution:

"enklact"?*3_

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
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.