मुझे अपना सैंडविच कब मिलेगा?

37

यहाँ छवि विवरण दर्ज करें

निम्नलिखित में से किसी एक इनपुट को देखते हुए: 

मीठा प्याज चिकन Teriyaki
ओवन भुना हुआ चिकन
टर्की ब्रेस्ट
इतालवी बीएमटी
टूना
ब्लैक फॉरेस्ट हैम
मीटबॉल मारिनारा
1-7 (या 0-6) से उस सप्ताह के दिन का प्रतिनिधित्व करते हुए एक नंबर का उत्पादन करें, जो आपको सबसे कम संख्या के रूप में सोमवार से शुरू होता है। पसंदीदा (यानी "इतालवी बीएमटी") होने पर इनपुट सभी लोअरकेस या अपरकेस हो सकते हैं। कोई इंटरनेट की अनुमति नहीं है।

code-golf  string  kolmogorov-complexity 
— geokavel
स्रोत
8
वास्तव में यह कैसे Kolmogorov जटिलता नहीं देखते हैं। पाठ इनपुट है ... संख्या आउटपुट हैं।
— जियोकॉवेल
5
रविवार को "मीटबॉल मारिनारा" या "मीटबॉल मरीना रा" भी कहते हैं?
— आउटगॉल्फ
17
मैं बहुत यकीन है कि यह माना जाता है कर रहा हूँ Marinara लेकिन Keming छवि में बहुत भयंकर है ...
— totallyhuman
6
यदि यह किसी के लिए उपयोगी है: क्रमशः प्रत्येक इनपुट में aप्लस की संख्या e[5,4,3,2,1,3,6] है।
— जियोकॉवेल
22
— jpmc26

जवाबों:

85

पायथन 2 , 38 30 28 बाइट्स

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

इसे ऑनलाइन आज़माएं!

दुर्भाग्य से अभी भी अभी तक सबसे अच्छा पायथन 2 उत्तर की तुलना में एक बाइट लंबा है; हालांकि, enklact-approach का उपयोग नहीं कर रहा है ।

अब मैं एक बाइट से भी छोटा हूँ, जो मेरे हर सवाल का जवाब देता है !

यह कैसे काम करता है?

बहुत सारी क्रूरता के बाद, मुझे एक अभिव्यक्ति मिली, जिसके परिणामस्वरूप एक संख्या है, जिसमें सिर्फ सही अंक हैं।
मैंने देखा कि दिए गए स्ट्रिंग की लंबाई के केवल एक विशिष्ट अंक को देखकर 3 बाइट्स ( %10) की आवश्यकता है । इसलिए मैंने नंबर के लिए एक और पायथन प्रोग्राम ( पास्टिबिन लिंक ) लिखा, जो उन नंबरों की खोज करता है जो सप्ताह के दिन तक इनपुट स्ट्रिंग्स की लंबाई को सीधे मैप करते हैं।

जादू की संख्या इस तरह दिखती है: 6793**164 = 28714733692312345620167113260575862840674216760386883406587492336415023761043044176257567032312859371641211117824224067391750766520256112063756278010050204239810862527958109285342869876264808102743173594017101607983288521836082497514383184553444755034407847810524083812459571382103831904835921560285915349760536969265992879312869538914200854305957428078269094250817029486005437991820466986793657301214564264748923199288698278615871481529585816783654841131577178922192383679718074693535597651237893794976519274268917335387876260270630339777501802739852278932279775510324916969726203688466311848240746465178859847331248655567344801(प्रभावशाली 629 दशमलव अंकों वाली संख्या)

और जैसा कि आप देख सकते हैं, संख्या [२ 20, २०, १३, ११, ४, १६, १,] से [०, १, २, ३, ४, ५, ६] तक आवश्यक मानचित्रण प्रदान करती है (पायथन तार ० हैं अनुक्रमित):

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

मेरे कार्यक्रम भी अन्य भाव जो आवश्यक संपत्ति के साथ संख्या उपज है, हालांकि वे और अधिक (28 से 29 के बजाय) का प्रतिनिधित्व करने के बाइट्स ले पाया: 19439**540, 34052**726, 39311**604, 44873**182, 67930**164और 78579**469। (वे सभी लिंक्ड प्रोग्राम द्वारा पाए गए एक्सप्रेशन हैं; इसके निष्पादन में कई घंटे लग गए।)

वैकल्पिक फ़ंक्शन जिसे 28 बाइट्स की आवश्यकता होती है: lambda S:`7954<<850`[len(S)]
वैकल्पिक फ़ंक्शन जिसे 29 बाइट्स की आवश्यकता होती है: lambda S:`9699<<2291`[len(S)]
वैकल्पिक फ़ंक्शन जिसे 30 बाइट्स की आवश्यकता होती है: lambda S:`853<<4390`[len(S)+9]
वैकल्पिक फ़ंक्शन जिन्हें 31 बाइट्स की आवश्यकता होती है:lambda S:`1052<<3330`[len(S)+8]

यह कैसे काम करता है? मैंने वह नंबर कैसे उत्पन्न किया? (30 बाइट उत्तर)

30 बाइट का जवाब था lambda S:`3879**41`[len(S)%10]।

इनपुट स्ट्रिंग की लंबाई को देखते हुए [28, 20, 13, 11, 4, 16, 17], मैंने देखा कि बेस दस में सभी अंतिम अंक अलग-अलग हैं, जिसके परिणामस्वरूप सूची में है [8, 0, 3, 1, 4, 6, 7]। इसलिए मुझे केवल उस सूची से सप्ताह के सभी सात दिनों की सूची में मैपिंग की आवश्यकता थी [0, 1, 2, 3, 4, 5, 6]।

मेरा पहला दृष्टिकोण बस मैपिंग करने के लिए एक स्ट्रिंग का उपयोग करता है: lambda S:"13*24*560"[len(S)%10]हालांकि स्ट्रिंग को ग्यारह बाइट्स ( "13*24*560") की आवश्यकता होती है ।
इसलिए मैंने अंकगणितीय अभिव्यक्तियों का परीक्षण करने के लिए एक पायथन प्रोग्राम ( पास्टिबिन लिंक ) लिखा, जिसके परिणामस्वरूप मिलान अंक के साथ पूर्णांक होता है, जिससे इस कार्यक्रम को आगे बढ़ाने की उम्मीद होती है। मैं इस प्रकार बहुत दूर आया `3879**41`(केवल दस बाइट्स, मेरे कार्यक्रम का एकमात्र और सबसे छोटा अभिव्यक्ति है)।

बेशक, कई अलग-अलग संभावित अभिव्यक्तियां हैं जो एक कोशिश कर सकते हैं; मैं बस भाग्यशाली हो गया कि a**bएक बहुत छोटे परिणाम के रूप में एक था जो मेरी ज़रूरत के अनुसार फिट था।

बस, किसी को भी उत्सुक के लिए 3879**41 = 1372495608710279938309112732193682350992788476725725221643007306215781514348937145528919415861895033279220952836384201346579163035594383625990271079 = 1.372... * 10**147।

एक अन्य मान्य फ़ंक्शन जो मैंने वैकल्पिक अभिव्यक्तियों की खोज के दौरान पाया, जिसके लिए दुर्भाग्य से 32 बाइट्स की आवश्यकता होती है: lambda S:`7**416`[len(S)%10+290]

— जोनाथन फ्रेच
स्रोत
1
आपने वह नंबर कैसे उत्पन्न किया? : ओ
— पूरी तरह से
10
@icrieverytim ब्रूट बल।
— जोनाथन फ्रीच
-9114**28एक छोटा पूर्णांक है * जो काम भी करता है (* पूर्ण शब्दों में न सिर्फ इसलिए कि यह नकारात्मक है - 629 के बजाय 111 अंक)। हालांकि बाइट्स पर नहीं बचा है।
— जोनाथन एलन
4
हर बार एक समय में मैं एचएनजी में पीसीजी के सवालों की जांच करता हूं, और आमतौर पर गोल्फिंग भाषाओं को खोजने के लिए निराश हूं कि शीर्ष तीन स्पॉट हैं। आज मैं निराश नहीं था। धन्यवाद!
— सिडनी
4
@icrieverytim ಠ_ಠ यह केवल एक ही संख्या है लेकिन एक और अधिक के शिफ्ट फैक्टर के साथ आधा है
— ಠ_ Hyper
49

पायथन 2 , 29 बाइट्स

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

इसे ऑनलाइन आज़माएं!

व्याख्या

मैजिक स्ट्रिंग, enklactअद्वितीय अक्षरों के साथ पहले कॉलम की तलाश में पाया गया था।

पहला कॉलम जाता है SOTITBMजो उपयोगी नहीं है 'क्योंकि इसमें डुप्लिकेट हैं। दूसरे और तीसरे वाले भी काम कर रहे हैं, क्योंकि वे नहीं करते हैं wvutuleऔर eeranaaक्रमशः। चौथा स्तंभ, हालांकि काम करता है क्योंकि इसमें सभी अद्वितीय पत्र हैं।

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
— totallyhuman
स्रोत
18

पायथन , 26 बाइट्स

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

इसे ऑनलाइन आज़माएं!

धन्यवाद के ऋण के साथ (मेरे दूसरे सीधे कोड-गोल्फ प्रयास के लिए) जोनाथन फ्रेच के जवाब के लिए - मैंने एक अलग अक्षर के बजाय स्ट्रिंग की लंबाई का उपयोग करने के लिए नहीं सोचा होगा!

यह कोड डी ब्रूजन अनुक्रम और शतरंज के लिए प्रोग्रामिंग के साथ मेरे अनुभव से निकला है ।

शतरंज में, आप अक्सर कई 64-बिट पूर्णांकों के साथ काम करते हैं, जहां प्रत्येक बिट इंगित करता है कि शतरंजबोर्ड पर संबंधित वर्ग के बारे में कुछ सही या गलत है, जैसे "यहां एक सफेद टुकड़ा है" या "इस वर्ग में एक मोहरा है"।

इसलिए यह उपयोगी है कि जल्दी से और सस्ते में परिवर्तित 2**nकरने में सक्षम हो n। C और C ++ में, ऐसा करने का सबसे तेज़ तरीका 64-बिट डी ब्रुइजन अनुक्रम द्वारा गुणा करना है - nबिट्स द्वारा शिफ्टिंग के बराबर - फिर राइट-शिफ्ट 58 (पहले छह बिट्स को अंतिम रूप देने के लिए - सुनिश्चित करें कि आप ' एक अहस्ताक्षरित int का उपयोग करके या आप 1s आधा समय प्राप्त करेंगे) और एक तालिका में इस 0..63 नंबर को देखें, nजो आपको उसी सीमा में देता है, लेकिन शायद ही कभी एक ही नंबर हो।

यह एक तरह से संबंधित है। से बदल रहा है के बजाय 2**nकरने के लिए n, तथापि, हम परिवर्तन के लिए से चाहते हैं nकुछ अन्य 3-बिट संख्या के लिए। इसलिए, हम अपने 3-बिट नंबरों को एक जादू 31-बिट संख्या में छिपाते हैं (28-बिट शिफ्ट के लिए बिट्स 28-30 की आवश्यकता होती है, नंबरिंग 0. से शुरू होती है)

मैंने यह देखने के लिए कि मूल्यों को गिराने के लिए आवश्यक संख्या उत्पन्न की, जहां (जहां आउटपुट सेट के रूप में 0..6 और 1..7 दोनों की कोशिश की गई)। सौभाग्य से, अतिव्यापी मान (14, 16, और 17) बाहर काम करने के लिए होते हैं! और चूंकि पहला त्रि-बिट है 000और अगला है 001, इसलिए हमें बाईं ओर 7 बिट्स की आवश्यकता नहीं है, जिसके परिणामस्वरूप कम अंक हैं -> स्रोत के कम बाइट्स।

आवश्यक संख्या है 000xxxx001110101011xxxx100xxxx, जहां x का 1 या 0 हो सकता है और यह इन विशेष उप के लिए परिणाम को प्रभावित नहीं करता है - मैंने उन्हें केवल संख्या को कम करने के लिए 0 पर सेट किया है, लेकिन अंतिम 8 xs में से किसी को भी प्रभावित नहीं करना चाहिए स्रोत कोड की लंबाई। सभी xs को 0 पर सेट करना, और प्रारंभ को छोड़ना, दशमलव में 1923136 (या हेक्स में 1D5840 देता है, लेकिन फिर आपको 0x उपसर्ग - शर्म की आवश्यकता है!) और अंत में 7 अंतिम तीन बिट्स को मास्क करता है, आप भी कर सकते हैं! 8% का उपयोग करें, लेकिन तब आपको अजगर के ऑपरेटर पूर्ववर्ती नियमों के कारण कोष्ठक की आवश्यकता होगी।

tl; dr: 1923136 प्रत्येक तीन-बिट संयोजनों को 0 से 6 तक सही स्थानों पर कूटता है, जो कि इन सैंडविच के नामों के स्थान पर आते हैं, और फिर एक सही बदलाव के बाद अंतिम तीन बिट्स लेने की बात है।

— माइकल बोगर
स्रोत
मेरे बिट मास्क दृष्टिकोण के समान काफी, लेकिन इससे भी बेहतर।
— ब्रूनो कोस्टा
12

जेली , 10 बाइट्स

यह सब "एनक्लैक्ट" व्यवसाय के साथ क्या है?

⁽ṃXị“Ð$¥»i

पात्रों की एक सूची लेने और सप्ताह के 1 दिन सोमवार / सोमवार को लौटने के लिए एक विवादास्पद लिंक।

इसे ऑनलाइन आज़माएं! या परीक्षण-सूट देखें

कैसे?

⁽ṃ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
— जोनाथन एलन
स्रोत
आपको -7761/retinalकॉम्बो कैसे मिला ?
— एमीना
3
एक लूप लिखा जो "शब्द" बनाने के माध्यम से चला और यह देखते हुए कि क्या वे शब्दकोश में मौजूद हैं। "रेटिनल" -32249 और 32250 (की सीमा ⁽..) के बीच एकमात्र था
— जोनाथन एलन
... थोड़ी सी गलती - ⁽..वास्तव में रेंज [-31349,32250] - [- 99,999] (अन्य नंबर भी हैं जो तीन या उससे कम बाइट्स के साथ प्रतिनिधित्व कर सकते हैं ) 7!!याȷ76
— जोनाथन एलन
9

C (gcc) , 72 71 56 46 41 39 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— cleblanc
स्रोत
i;char x[]="enklact";से छोटा है i,x[]={101,110,107,108,97,99,116};।
— जोनाथन फ्रीच
के बारे में पोस्ट करने के लिए गया था: char*x="enklact"यह और भी छोटा है: इसे ऑनलाइन आज़माएं!
— 15
इसके अलावा, आप हटा सकते हैं i=0।
— जोनाथन फ्रेच
यहां तक ​​कि छोटे संस्करण का उपयोग करके index: इसे ऑनलाइन आज़माएं!
— स्कूटनीट
@scottinet अच्छा लगा! मैंने पहले कभी भी इंडेक्स () का उपयोग नहीं किया है। धन्यवाद
— क्लेब्लांक
7

MATL , 16 15 बाइट्स

O5OHlO7KI6vjYm)

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

व्याख्या

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

मुझे लगा कि मैं कुछ अन्य विकल्पों को पोस्ट करूंगा

जावास्क्रिप्ट 38 बाइट्स

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

स्पष्टीकरण: बिट-मास्क चट्टानें?

जावास्क्रिप्ट 27 बाइट्स

s=>"240350671"[s.length%10]
— ब्रूनो कोस्टा
स्रोत
दूसरा विकल्प 29 बाइट्स लंबे समय तक भूल गयाa=
— ब्रूनो कोस्टा
a=भाग की आवश्यकता क्यों है ? शैगी का जवाब देखिए ।
— जियोकॉवेल
1
@BrunoCosta इस साइट पर, हमें आपको अपने कार्यों के नाम की आवश्यकता नहीं है। अनाम काम करते हैं, इसलिए आपको इसकी आवश्यकता नहीं है a=।
— R
1
@BrunoCosta शांत है, यह वास्तव में आप पर निर्भर है। आप इसे हेडर बाइट की गिनती में भी नहीं गिन सकते हैं, और इसे आसानी से परीक्षण के लिए स्निपेट में शामिल कर सकते हैं।
— R
1
@MichaelBoger अनजाने में मुझे नहीं लगता कि क्योंकि यह काम करने के लिए कोड की न्यूनतम राशि है क्योंकि मुझे विश्वास है कि यह कुछ लाइनों के साथ हैa=s=>{b=s.Length;return(271474896&7<<b)>>b}
— ब्रूनो कोस्टा
4

जेली , 11 बाइट्स

4ị“-ƭɼoṚ0»i

इसे ऑनलाइन आज़माएं!

स्पष्टीकरण:

4ị“-ƭɼoṚ0»i
4ị          4th element of z
  “-ƭɼoṚ0»i First index in "enklactate"
— आउटगोल्फर को एरिक करें
स्रोत
2
@ Mr.Xcoder जब तक मैं अपनी स्ट्रिंग enklactateके enklactलिए उपयोग नहीं करता हूं , इस स्थिति में यह 11 से नीचे लाता है;)
— आउटगॉल्फ
5
ओह, फ़ज के sakes के लिए, क्यों है enklactate जेली के शब्दकोश में?
— 16
3
@icrieverytim यह नहीं है, enkएक तार है और lactateएक शब्द है। संपादित करें: बस पुष्टि की, enklactateशब्दकोश में नहीं है।
— आउटगॉल्फ
1
@icrieverytim मुझे लगता है कि यह सिर्फ लैक्टेट है ।
— श्री एक्सकोडर
2
ऐ मां, मैं जेली के शब्दकोश का मजाक उड़ाना चाहता था ... शायद अगली बार। : पी
— 16 अक्टूबर को पूरी तरह से
3

जाप , 12 बाइट्स

0-अनुक्रमित, लोअरकेस में इनपुट लेता है।

`kÇXsm`bUg#

झसे आज़माओ

व्याख्या

लोअरकेस स्ट्रिंग का प्रभावशाली इनपुट U

`kÇXsm`

संकुचित स्ट्रिंग kotinsm।

bUg#

सूचकांक bमें चरित्र का पहला इंडेक्स ( g) 26 ( #) में प्राप्त करें U। (याय, इंडेक्स रैपिंग!)

पूर्णांक परिणाम का निहित उत्पादन।

विकल्प

ऊपर (और बाकी सब!) के समान, बस शीर्षक 3 इनपुट के लिए अनुमति देने के बजाय, सूचकांक 3 पर पात्रों का उपयोग करना।

`klact`bUg3

झसे आज़माओ

— झबरा
स्रोत
कहाँ enजाना होगा? : पी
— पूरी तरह से
1
@icrieverytim: यह एक संकुचित स्ट्रिंग है; enएक unprintable करने के लिए संकुचित है।
— झबरा
7
मुझे लगता है कि मैं bUgआपके कोड में देखता हूं ।
— shenles
3

05AB1E , 11 बाइट्स

मैजिक ऑक्टोपस Urn के लिए 1 बाइट थ्रू द आउटकॉफ़र और 1 बाइट धन्यवाद के लिए धन्यवाद।

.•ΛΓ2º•I3èk

इसे ऑनलाइन आज़माएं!

— मिस्टर एक्सकोडर
स्रोत
"enklact"->’enkl†¼’
— आउटगॉल्फ
’enkl†¼’->.•ΛΓ2º•
— मैजिक ऑक्टोपस Urn
@MagicOctopusUrn ओह धन्यवाद
— मि। Xcoder
— मैजिक ऑक्टोपस Urn
@MagicOctopusUrn संग्रह में रखेगा, धन्यवाद: पी
— श्री एक्सकोडर
3

जावास्क्रिप्ट (ईएस 6), 25 बाइट्स

0 अनुक्रमित।

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

झसे आज़माओ

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
— जियोकॉवेल
धन्यवाद, @geokavel न जाने कहाँ से मुझे वे 3 अतिरिक्त बाइट्स मिल गए; यहां तक ​​कि गिनती f=केवल इसे 27 कर देगी।
— झबरा
सरल और प्रभावी उपाय। +1 :)
— ब्रायन एच।
@ शिग्गी शायद आपकी तीसरी अतिरिक्त बाइट एक नई अनुगामी थी।
— माइकल बोगर
3

GolfScript , 12 बाइट्स

{+}*93&(5?7%

इसे ऑनलाइन आज़माएं!

करने के लिए आदानों (उनके कोड अंक का योग के माध्यम से) नक्शे 0के लिए 6।

व्याख्या

कुछ समय पहले मैंने एक गोल्फस्क्रिप्ट स्निपेट ब्रूट फोर्स टूल के साथ लिखा था ...

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

इस प्रकार यह प्रत्येक इनपुट को वांछित परिणाम में बदल देता है:

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

एक्सेल, 28 बाइट्स

enklactविधि का उपयोग :

=FIND(MID(A1,4,1),"enklact")
— Wernisch
स्रोत
आप इसे Google शीट में परिवर्तित करके 2 बाइट्स को छोड़ सकते हैं और ")
— टेलर स्कॉट
2

पर्ल 6 , 22 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— मस्सा
स्रोत
perl 2017.07 स्वीकार करता है tr/enklact/^6/.comb[3]जो 22 बाइट होगा, लेकिन tio.run जाहिर तौर पर अभी तक नहीं है।
— मस्सा
(tio.run रन perl6 v2017.6)
— मस्सा
1
जब तक एक दुभाषिया मौजूद है जो 22 बाइट संस्करण चला सकता है, यह मान्य है।
— झबरा
2

सीजेएम , 11 बाइट्स

l1b93&(5#7%

इसे ऑनलाइन आज़माएं!

मेरे गोल्फस्क्रिप्ट उत्तर का एक बंदरगाह । इनपुट को स्पष्ट रूप से पढ़ने के लिए 1 बाइट की लागत होती है, लेकिन कोड बिंदुओं को समेटने पर हम दो को बचाते हैं।

— मार्टिन एंडर
स्रोत
2

भूसी , 10 बाइट्स

%7^5←n93ṁc

इसे ऑनलाइन आज़माएं!

मेरे गोल्फस्क्रिप्ट उत्तर का एक और बंदरगाह । मुझे यकीन है कि आखिरकार मुझे एक ऐसी भाषा मिल जाएगी जो एक ही बाइट के लिए कोड बिंदुओं को जोड़ सकती है ...

हस्क (पोस्ट-चैलेंज अपडेट), 9 बाइट्स

%7^5←n93Σ

इसे ऑनलाइन आज़माएं!

अब, सीधे कोड अंक का योग Σ करता है । चूंकि मुझे इस चुनौती का जवाब देने के बाद यह एक अनुरोध के अनुसार जोड़ा गया था, मैं इसे अपने प्राथमिक स्कोर के रूप में उपयोग नहीं करने जा रहा हूं।

— मार्टिन एंडर
स्रोत
1

पर्ल 5 , 43 + 1 ( -p) = 44 बाइट्स

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

इसे ऑनलाइन आज़माएं!

ऊपरी मामले के लिए इनपुट के पहले तीन वर्णों की आवश्यकता होती है।

— Xcali
स्रोत
यह सभी अपरकेस, सभी लोअरकेस, या नियमित होना चाहिए।
— जियोकॉवेल
इसे सभी अपरकेस कहते हैं। पहले तीन पात्रों से परे किसी भी चीज को नजरअंदाज किया जाता है।
— Xcali
1

जावा 8, 26 बाइट्स

इसका श्रेय @icrieverytim को है

इनपुट को चार के रूप में लेता है []

s->"enklact".indexOf(s[3])
— रॉबर्टो ग्राहम
स्रोत
आप क्या कर सकते हैं s->"enklact".indexOf(s[3])यदि आप निर्दिष्ट करें कि आप एक चार सरणी के रूप में इनपुट ले लो।
— शौकी
क्या ये ठीक है? मेरे पास कुछ उत्तर हैं जिन्हें इस तरह छोटा किया जा सकता है
— रॉबर्टो ग्राहम
1

हास्केल , 36 बाइट्स

-9 बाइट्स H.PWiz को धन्यवाद।

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

इसे ऑनलाइन आज़माएं!

वैकल्पिक समाधान, 45 बाइट्स

इस का उपयोग करता है indexOfमें समारोह Data.Listके रूप में elemIndex।

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

इसे ऑनलाइन आज़माएं!

— totallyhuman
स्रोत
1
— H.PWiz
@ H.PWiz ओह, साफ-सुथरी गाली break। धन्यवाद!
— 22
1
— २२:०२ पर H.PWiz
@ H.PWiz Haha, मुझे यह कैसे याद होगा। XD
— 22
1

सी ++, 119 118 77 76 73 बाइट्स

-41 बाइट्स के लिए धन्यवाद पीटर
कॉर्डेस -1 बाइट की बदौलत जैचार्जी
-3 बाइट्स के लिए माइकल बोगर को धन्यवाद

स्ट्रिंग इंडेक्स 3 में, प्रत्येक सैंडविच के लिए चरित्र अलग है

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

के साथ गोल्फ std::string, कि स्पष्ट था ... मैं क्या सोच रहा था ...

— HatsuPointerKun
स्रोत
1
std::findएक स्ट्रिंग में शाब्दिक (या शायद std::string) जाने के लिए स्पष्ट तरीके की तरह लगता है। मूल रूप से एक ही विचार के रूप में indexया strchrकि सी उत्तर का उपयोग कर रहे हैं, एक डेटा संरचना में जहां 0-5 स्थिति से निहित है।
— पीटर कॉर्ड्स
आप नई लाइन
— इनबेटलाइन
आपको एक स्टोरेज करने की आवश्यकता नहीं है। std::string("enklact").find(p[3])ठीक काम करता है। यह इसे 3 अक्षर नीचे लाता है।
— माइकल बोगर
आप अपने फ़ंक्शन के लिए स्ट्रिंग शाब्दिक पास कर सकते हैं (जी ++ केवल एक चेतावनी उठाता है) इसलिए मेमसीपी सामान की आवश्यकता नहीं है।
— माइकल बोगर
0

गोल्फस्क्रिप्ट, 13 बाइट्स

इसे ऑनलाइन आज़माएं!

'enklact'\3=?

4 वां वर्ण लेता है (जो, प्रत्येक के लिए, अद्वितीय होगा) और इसे स्ट्रिंग में " enklact" देखता है ।

वैकल्पिक रूप से:

'nklact'\3=?)

यह इस तथ्य का लाभ उठाता है कि गोल्फस्क्रिप्ट का ?फ़ंक्शन -1 लौटता है यदि खोजा गया तत्व नहीं मिला है (जो सोमवार के लिए, यह नहीं होगा)। यदि यह अनुमति दी गई थी, तो समाधान को 1 बाइट से कम किया जा सकता है।

— जोशिया विंसलो
स्रोत
0

के (ओके) , 13 बाइट्स

समाधान:

"enklact"?*3_

इसे ऑनलाइन आज़माएं!

उदाहरण:

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

स्पष्टीकरण:

सही-से-बाएँ व्याख्या की गई, इनपुट से 4 तत्व को बाहर निकालें और "एन्क्लूजन" में शून्य-सूचकांक स्थान लौटाएँ:

"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
— streetster
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.