काम

इस चुनौती में, आपका कार्य एक प्रोग्राम या फ़ंक्शन लिखना है जो एक स्ट्रिंग में होता है और एक सत्य या गलत मूल्य के आधार पर आउटपुट करता है कि क्या इनपुट का पहला चरित्र और अंतिम स्ट्रिंग समान हैं।

इनपुट

आप किसी भी तरह से उचित तरीके से इनपुट ले सकते हैं। हालांकि, यह मानते हुए कि इनपुट पूर्वनिर्धारित चर में मौजूद है, अनुमति नहीं है। फ़ाइल, कंसोल, कमांड लाइन, इनपुट फ़ील्ड आदि से पढ़ना या फ़ंक्शन तर्क के रूप में इनपुट लेना अनुमत है।

उत्पादन

आप चर को परिणाम देने के अलावा किसी भी उचित प्रारूप में आउटपुट कर सकते हैं। एक फ़ाइल, कंसोल, कमांड लाइन, मोडल बॉक्स, फ़ंक्शन returnस्टेटमेंट आदि को लिखने की अनुमति है।

अतिरिक्त नियम

इनपुट खाली स्ट्रिंग भी हो सकता है, जिसके लिए आपको एक गलत मूल्य वापस करना चाहिए।
सिंगल-चार इनपुट स्ट्रिंग्स का एक सत्य परिणाम होना चाहिए।
आपका कार्यक्रम केस-संवेदी होना चाहिए। helloHएक गलत मूल्य का उत्पादन करना चाहिए।
आपके पास केवल एक ट्रू मान और एक फाल्सी मूल्य हो सकता है। उदाहरण के लिए, falseएक इनपुट स्ट्रिंग के 0लिए और दूसरे इनपुट स्ट्रिंग के लिए आउटपुट के रूप में फाल्सी मूल्यों की अनुमति नहीं है।
मानक खामियों की अनुमति नहीं है।

परीक्षण के मामलों

Input    ->    Output

"10h01"        Truthy
"Nothing"      Falsey
"Acccca"       Falsey
"wow!"         Falsey
"wow"          Truthy
"H"            Truthy
""             Falsey

यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे छोटा कोड जीतता है!

code-golf string decision-problem

— अर्जुन
स्रोत

इनपुट में कौन से वर्ण दिखाई दे सकते हैं? मुद्रण योग्य ASCII?

— मार्टिन एंडर

@MartinEnder Printable ASCII। हालाँकि, मुझे नहीं लगता कि यह बहुत मायने रखता है।

— अर्जुन

बेशक यह मायने रखता है। कुछ भाषाएं गैर-एएससीआईआई अक्षर या अशक्त बाइट्स को संसाधित नहीं कर सकती हैं, और एक regex में मैं किसी भी मुद्रण योग्य ASCII चरित्र के साथ मेल कर सकता हूं ., लेकिन यह लाइनफीड से मेल नहीं खाएगा। सामान्य तौर पर, यदि आप स्वयं को स्ट्रिंग टैग का उपयोग करते हुए पाते हैं, तो निर्दिष्ट करें कि इनपुट में कौन से वर्ण दिखाई दे सकते हैं।

— मार्टिन एंडर

@MartinEnder ठीक है। भविष्य में ध्यान रखेंगे।

— अर्जुन

सुझाया गया टेस्ट केस:AbAb => false

— caird coinheringaahing

5

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

=ṚḢ

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

— आउटग्रॉफर को एरिक करें
स्रोत

17

पायथन 3 , 23 बाइट्स

s=input()
s[0]!=s[-1]<e

आउटपुट एक्ज़िट कोड के माध्यम से है, इसलिए 0 (सफलता) सत्य है और 1 (विफलता) मिथ्या है। यदि यह स्वीकार्य है, तो एक बाइट को बचाया जा सकता है।

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

यह काम किस प्रकार करता है

सबसे पहले, यदि s एक खाली स्ट्रिंग है, s[0]तो IndexError को बढ़ाएगा , जिससे प्रोग्राम विफल हो जाएगा।

गैर-खाली एस के लिए , यदि पहले और अंतिम अक्षर समान हैं , तो फाल्स काs[0]!=s[-1] मूल्यांकन करेंगे , इसलिए प्रोग्राम साफ और तुरंत बाहर निकलता है।

अंत में, यदि पात्र अलग-अलग हैं, तो True परs[0]!=s[-1] मूल्यांकन करेंगे , जिससे कंपेयरन का प्रदर्शन किया जा सकेगा। चूँकि e अपरिभाषित है, इसलिए एक NameError उठाती है ।s[-1]<e

यदि अजगर 2 के साथ पीछे की संगतता वांछित नहीं है,

s[0]!=s[-1]<3

के रूप में अच्छी तरह से काम करता है, एक पूर्णांक के साथ एक स्ट्रिंग की तुलना में एक TypeError उठाता है ।

— डेनिस
स्रोत

— मेमने के

1

हाँ, एक नियमित कार्य भी एक बाइट को बचाएगा। हालांकि एक्ज़िट कोड के माध्यम से आउटपुट एक स्थापित आम सहमति है, लेकिन फ़ंक्शन के लिए गैर-त्रुटि / त्रुटि हालांकि नहीं है। मैंने अपने उत्तर में प्रस्ताव से जोड़ा है।

— डेनिस

पायथन आरईपीएल का उपयोग करने के बारे में क्या?

— OldBunny2800

मुझे नहीं लगता कि इससे मदद मिलती है। यह अभी भी एक बाहर निकलने का कोड नहीं है।

— डेनिस

9

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

a=>a.endsWith(a[0])

— गंजा बंटा
स्रोत

वाह। मुझे यह भी नहीं पता था कि endsWithस्ट्रिंग ऑब्जेक्ट का एक तरीका मौजूद है । अच्छा! :)

— अर्जुन

मैं कैसे भूल गया endsWith()! मैं इसका उपयोग करने के लिए एक अवसर की प्रतीक्षा कर रहा हूं।

— झबरा

7

मैथेमेटिका, 15 बाइट्स

#&@@#===Last@#&

वर्णों की एक सरणी लेता है। इनपुट खाली होने पर त्रुटियां फेंकता है लेकिन इसे अनदेखा किया जा सकता है।

— जंगहवान मिन
स्रोत

4

तथ्य यह ===है कि खाली मामला संभालती है अच्छा काम :)

— ग्रेग मार्टिन

7

05AB1E , 4 बाइट्स

S¬Q¤

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

S    # Split the input into individual characters
 ¬   # Get the first character
  Q  # Check all characters for equality to the first
   ¤ # Get the last value i.e. head == tail

— रिले
स्रोत

1

ÂâćüQअधिक भ्रमित होना और एक बाइट हासिल करना!

— मैजिक ऑक्टोपस Urn

ćsθQएक और 4-बटर है।

— मैजिक ऑक्टोपस Urn

7

रेटिना , १३ 12 बाइट्स

^(.)(.*\1)?$

इसे ऑनलाइन आज़माएं! परीक्षण सूट शामिल है। संपादित करें: @Kobi के लिए 1 बाइट धन्यवाद सहेजा गया।

— नील
स्रोत

7

सी ++, 39 बाइट्स

[](auto s){return s[0]&&s[0]==s.back();}

पूर्ण कार्यक्रम:

#include <string>
#include <iostream>

using namespace std;

int main()
{
    string t = "";
    auto f = [](auto s){return s[0]&&s[0]==s.back();};
    cout << f(t);
}

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

— जोहान डू टिट
स्रोत

1

मैं सी में सबसे अच्छा नहीं कर रहा हूँ ++ (मैं आम तौर पर सी का उपयोग करें), लेकिन आप के उदाहरण को बदल सकता है s[0]करने के लिए *sदोनों एक बाइट को बचाने के लिए?

— एमडी एक्सएफ

1

@MDXF, जो केवल C प्रकार सरणियों के साथ काम करेगा।

— जोहान डू टिट

6

ब्रेकीलॉग , 4 बाइट्स

h~t?

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

व्याख्या

h       The head of the Input...
 ~t?    ...is the tail of the Input

— Fatalize
स्रोत

1

मुझे वास्तव में इनपुट के लिए उन बाधा चर को लागू करने के लिए चक्कर लगाने की आवश्यकता है; इसका मतलब है कि हम दो में ऐसा करने में सक्षम होंगे।

6

जावा, 81 77 बाइट्स

-4 बाइट्स, धन्यवाद @ केविनक्रूजसेन

ऑनलाइन प्रयास करें

boolean f(String s){int l=s.length();return l>0&&s.charAt(l-1)==s.charAt(0);}

रिटर्न trueअगर वे बराबर अन्यथा, कर रहे हैं false, falseखाली स्ट्रिंग के लिए

ऐरे संस्करण, 60 बाइट्स

boolean f(char[]s){int l=s.length;return l>0&&s[0]==s[l-1];}

— Khaled.K
स्रोत

इंट की बजाय लंबी क्यों?

— corvus_192

@ corvus_192 एक यूनिकोड वर्ण 1-6 बाइट्स हो सकता है।

— खालिद.के

दो वर्णों के बीच का अंतर अधिकतम हो सकता है Charcter.MAX_VALUE - Character.MIN_VALUE, जो 65535 है

— corvus_192

@ corvus_192 मैं देख रहा हूं, मैंने इसे अभी ठीक कर लिया है

— खालिद.के

1

@KevinCruijssen आखिरी के लिए, s.charAt(l-1)==s.charAt(0)दो बाइट्स बचाएगा।

— जॉली जोकर

6

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

एक बाइट को बचाने के लिए @ डेनिस का धन्यवाद !

lambda x:""<x[:1]==x[-1]

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

— अदनान
स्रोत

5

ब्रेनफक , 43 बाइट्स

+>,[<,[>[->+<<->],]]<[[-]-<]-[----->+<]>--.

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

व्याख्या

मुख्य लूप है [>[->+<<->],]। प्रत्येक पुनरावृत्ति के बाद, वर्तमान स्थिति के दाईं ओर सेल स्ट्रिंग का पहला बाइट है, और बाईं ओर का सेल सबसे हाल ही में संभाला गया चरित्र और पहले के बीच का अंतर है। <[[-]-<]अंतिम परिणाम -1 को नॉनज़रो में परिवर्तित करता है, और बाकी क्रमशः -1 और 0 को 48 और 49 ("0" और "1") में परिवर्तित करता है।

— Nitrodon
स्रोत

5

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

cएक लेता है Stringऔर एक लौटता है Bool।

c s=take 1s==[last s]

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

यदि खाली तारों के लिए नहीं, तो यह 16 बाइट्स के साथ हो सकता है c s=s!!0==last s।
take 1sएक सूची देता है जो खाली रहने sतक sका पहला तत्व है, जिस स्थिति में यह खाली है।
last s खाली स्ट्रिंग पर त्रुटि होगी, लेकिन हास्केल का आलस्य इसे बचाता है: एक तत्व वाला एक स्ट्रिंग हमेशा खाली स्ट्रिंग से अलग होता है, इसके तत्व का मूल्यांकन किए बिना।

— अर्जन जोहान्सन
स्रोत

5

MATL, 5 बाइट्स

&=PO)

MATL ऑनलाइन पर यह कोशिश करो !

व्याख्या

       % Implicitly grab input as a string (of length N)
&=     % Perform an element-wise equality check yielding an N x N matrix
P      % Flip this matrix up-down
O)     % Get the last value in the matrix (column-major ordering)
       % Implicitly display the result

इस मामले में, कि एक खाली इनपुट स्ट्रिंग को संभाला जाना चाहिए, तब निम्नलिखित (8 बाइट्स) की तरह कुछ काम करेगा

&=POwhO)

यह समाधान बस 0एन एक्स एन मैट्रिक्स के सामने एक को प्रस्तुत करता है जैसे कि एक खाली इनपुट के लिए, जब मैट्रिक्स होता है 0 x 0, तब भी एक 0मूल्य होता है जिसे तब पकड़ा जाता है0)

इसे MATL ऑनलाइन पर आज़माएं

— सवर
स्रोत

बहुत चालाक दृष्टिकोण!

— लुइस मेंडो

इसके अलावा 5 बाइट्स 5L)d~:।

— Sanchises

2

बस एक हेड-अप: न तो मेरी टिप्पणी और न ही आपका जवाब खाली इनपुट को संभालता है। इसने (मेरी राय में) ईमानदारी से टिप्पणी के खिलाफ तर्क दिया है, इसलिए मैं इस आवश्यकता को बदलने की अपेक्षा करता हूं। हालाँकि, जैसा कि यह खड़ा है, यह प्रविष्टि अमान्य है।

— १ch

1

(निश्चित रूप से, आप tn?&=PO)}Fखाली इनपुट से निपटने के लिए कर सकते हैं ; निश्चित नहीं है कि क्या अधिक कुशल तरीका है)

— १17

4

जाप , 6 बाइट्स

tJ ¥Ug

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

— ल्यूक
स्रोत

हम्म, खाली स्ट्रिंग के लिए काम नहीं करता (देना चाहिए false)। मुझे लगता है कि आप इसे ठीक कर सकते हैंtJ ¥Ug

— ETHproductions

4

एपीएल (डायलॉग) , 4 बाइट्स

⊃⌽=⊃

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

व्याख्या

  =                     Compare
   ⊃                    The first element of the right argument with
 ⌽                      The right argument reversed
                        This will return an array of the length of the reversed argument. Each element in the resulting array will be either 0 or 1 depending on whether the element at that position of the reversed argument equals the first element of the original right argument
                        So with argument 'abcda', we compare 'a' with each character in 'adcba' which results in the array 1 0 0 0 1
⊃                       From this result, pick the first element.

यहीं कारण है कि यह खाली तारों पर काम करता है। ⊃एक रिक्त स्ट्रिंग पर लागू करने से एक स्थान लौटता है । लेकिन एक खाली स्ट्रिंग को उलटना अभी भी एक खाली स्ट्रिंग देता है, इसलिए एक खाली स्ट्रिंग की तुलना गैर-रिक्त स्ट्रिंग (इस मामले में ) से एक खाली संख्यात्मक वेक्टर देता है। और ⊃एक खाली संख्यात्मक वेक्टर रिटर्न के लिए आवेदन करना 0। इसलिए खाली स्ट्रिंग रिटर्न पास करना 0।

— क्रिति लिथोस क्रिकि
स्रोत

यह वास्तव में अच्छा जवाब है, लेकिन आपकी व्याख्या सही नहीं है। यह हो सकता है सही के लिए (⊃⌽)=⊃या ⊢/=⊃, लेकिन उन में से कोई भी सही परिणाम दे। इसके बजाय ⌽=⊃उलटे हुए स्ट्रिंग की तुलना उसके पहले चरित्र से करता है, और फिर उसी का पहला तत्व चुनता है। यदि स्ट्रिंग खाली है, तो यह रिक्त स्ट्रिंग की जगह की तुलना करते हुए समाप्त होता है, जो एक खाली बूलियन सूची देता है, जिसमें से (coerced) पहला तत्व ⊃है 0- खाली स्ट्रिंग के लिए सही उत्तर। आपकी अभिव्यक्ति समतुल्य होने के ⊃⊃=⌽कारण =है।

— एडम

@ Adám मेरी व्याख्या में गलती देखने में मेरी मदद करने के लिए धन्यवाद।

— कृतिका लिथोस

आपका स्वागत है। अब आपका नोट सही नहीं है। ⊃⌽=⊃के रूप में ही नहीं है (⊃⌽)=⊃। यह अधिक महंगा है, क्योंकि यह सिर्फ पहले और आखिरी के बजाय सभी तत्वों की तुलना करता है। इसके अलावा यह काम नहीं करेगा ओपी का उपयोग स्ट्रिंग्स के बजाय संख्याओं में किया गया था।

— आदम

The first argument reversed → The right argument reversed

— आदम

आप यह भी समझाना चाहेंगे कि यह खाली तारों पर क्यों काम करता है।

— प्रवेश

4

जावा, 52 43 बाइट्स

s->!s.isEmpty()&&s.endsWith(""+s.charAt(0))

इसे काम करने के लिए, इसे एक फंक्शन में फीड करें जैसे कि लैम्बडा "गो" बनाता है:

private static boolean f(Function<String, Boolean> func, String value) {
  return func.apply(value);
}

1

आप s.endsWith(""+s.charAt(0))इसके बजाय 9 वर्णों का उपयोग कर सकते हैंs.charAt(0)==s.charAt(s.length()-1)

— स्पेसबिसन

s->""!=s&&s.endsWith(""+s.charAt(0))

— जॉली जोकर

1

@ जॉलीजॉकर जो काम नहीं करता है: new String()लैम्ब्डा में खिलाने की कोशिश करें । यह एक अपवाद फेंक देगा। संदर्भ शब्दार्थ यहाँ काम नहीं करते हैं।

2

@KevinCruijssen && का लघु परिचलन प्रभाव एक खाली स्ट्रिंग के लिए

— charAt

4

रूबी, 26 24 बाइट्स

@Philomory की बदौलत दो बाइट्स बचाए !

->e{!!e[0]>0&&e[0]==e[-1]}

कोडगॉल्फ पर पहली पोस्ट -))

— marmeladze
स्रोत

1

PPCG में आपका स्वागत है!

— मार्टिन एंडर

1

PPCG में आपका स्वागत है! अच्छा पहला गोल्फ। भविष्य के लिए शुभकामनाएँ!

— अर्जुन

1

आप 4 बाइट बचा सकते हैं बस कर रहे हैं e[0]&&e[0]==e[-1], क्योंकि अगर eखाली है, e[0]तो शून्य होगा। वास्तव में, यह सोचने के लिए आओ, यह nilअच्छा नहीं है क्योंकि यह गलत है लेकिन तुलनात्मक नहीं है कि तुलना वापस आती है; फिर भी, जोड़ने के बाद भी !!आप 2 वर्णों को सहेज रहे हैं।

— दार्शनिक

3

PHP> = 7.1, 23 बाइट्स

बराबर के लिए 1 प्रिंट करता है और अगर चरित्र अलग है तो कुछ भी नहीं

<?=$argn[0]==$argn[-1];

— जार्ग हुल्सरमन
स्रोत

3

स्विफ्ट, 57 बाइट्स

var s=readLine()!,a=Array(s.characters);a[0]==a.last ?1:0

— लीना
स्रोत

कोड को संपादित किया।

— लीना

PPCG में आपका स्वागत है! क्या स्पेस a.lastजरूरी है?

— हाइपरएनुट्रिनो

या तो मैं a.last के आसपास कोष्ठक जोड़ सकता हूँ या मैं a.last के बाद स्थान जोड़ सकता हूँ

— Leena

3

सी #, 38 30 बाइट्स

s=>s!=""&&s[0]==s[s.Length-1];

@Raznagul की बदौलत 8 बाइट्स बचाए।

— TheLethalCoder
स्रोत

1

इसकी लंबाई की जाँच करने के बजाय sइसकी तुलना करें ""। इसके अलावा, आप ?:-Operator की जरूरत नहीं है । उपयोग करने &&का एक ही परिणाम है।

— रज़नागुल १५'१ul

@raznagul अच्छा स्पॉट धन्यवाद, मैं जाँच नहीं कर सकता कि यह इस समय काम करता है इसलिए उम्मीद है कि यह करता है! इसके अलावा &एक ही प्रभाव नहीं होगा ?

— TheLethalCoder

@LeathalCoder: नहीं बस &काम नहीं करता है। &&पहली अभिव्यक्ति झूठी होने पर दूसरी अभिव्यक्ति मान्य नहीं है। &सेकंड के साथ अभिव्यक्ति हमेशा मान्य होती है और IndexOutOfRangeExceptionखाली स्ट्रिंग परीक्षण मामले पर विफल रहती है ।

— राजनागुल

@raznagul ओह यस ... ब्रेन फार्ट।

— TheLethalCoder

शायद इसकी थोड़ी देर हो गई है लेकिन आप 5 बाइट बचा सकते हैं यदि आप s.Last()इसके बजाय का उपयोग करते हैंs[s.Length-1]

— Bojan B

3

आर, 40 बाइट्स

function(x)x>""&&rev(y<-charToRaw(x))==y

नाइट्रोडन को -2 बाइट्स के लिए धन्यवाद।

मिकी के लिए धन्यवाद -8 बाइट्स।

परीक्षा:

f=function(x)x>""&&rev(y<-charToRaw(x))==y
test <- c("10h01", "Nothing", "Acccca", "wow!", "wow", "H", "")
sapply(test, f)
all(sapply(test, f) == c(T, F, F, F, T, T, F))

आउटपुट:

> f=function(x)x>""&&rev(y<-charToRaw(x))==y
> test <- c("10h01", "Nothing", "Acccca", "wow!", "wow", "H", "")
> sapply(test, f)
  10h01 Nothing  Acccca    wow!     wow       H         
   TRUE   FALSE   FALSE   FALSE    TRUE    TRUE   FALSE 
> all(sapply(test, f) == c(T, F, F, F, T, T, F))
[1] TRUE

— djhurio
स्रोत

2

आप कोष्ठक के एक सेट को निकाल सकते हैं rev(y<-el(strsplit(x,"")))==y।

— नाइट्रोडॉन

1

अनाम कार्य भी स्वीकार्य हैं, इसलिए आप इसे हटा सकते हैंf=

— मिकी

1

और तुलना के लिए स्ट्रिंग को विभाजित करने के लिए charToRaw का उपयोग किया जा सकता है function(x)x>""&&rev(y<-charToRaw(x))==y

— मिकी

3

> <> , 39 33 बाइट्स

 2i&01. >~&-?v1v
  i:1+?!^01. >0>n;

यह पहली बार> <> का उपयोग कर और कोड गोल्फ दोनों खेल रहा है, इसलिए उपयोगी सुझाव की सराहना की जाएगी।

कोड तीन बुनियादी वर्गों में है।

2i&01. Pushes an arbitrary number (2 in this case, this causes an empty string to print 0) onto the stack and puts the input's first character in the register.

>i:1+?!^01. Main loop. Pushes the next character onto the stack. If the string has been read completely, then go to the last section

>~&-?v1v
     >0>n;  Compare the first and last characters. Print 1 if they're the same, 0 if not

— AGourd
स्रोत

हैलो! PPCG में आपका स्वागत है! अच्छा पहला गोल्फ! भविष्य के लिए शुभकामनाएँ! :)

— अर्जुन

3

Google शीट, 33 बाइट्स

सच इनपुट के लिए सेल [A1]और आउटपुट से इनपुट लेता है 1और 0फाल्सी इनपुट के लिए।

=(A1<>"")*Exact(Left(A1),Right(A1

यह ध्यान दिया जाता है कि जनक Exact(और मेंRight( Google पत्रक के रूप में जैसे ही उपयोगकर्ता ने सूत्र पाठ को इनपुट किया है और उस सेल को छोड़ने के लिए एंटर दबाया है, के रूप में पेरेंटेटिकल को अंदर छोड़ दिया इसे स्वचालित रूप से सही किया गया है।

उत्पादन

— टेलर स्कॉट
स्रोत

क्या एक्सेल का संस्करण मायने रखता है? 2013 की मेरी प्रति में, यह विफल रहता है क्योंकि आप &उस तरह का उपयोग नहीं कर सकते हैं । साथ ही, इसे A=aसत्य मानता है। सबसे कम मैं 38 बाइट्स प्राप्त कर सकता हूं: =AND(EXACT(LEFT(A1),RIGHT(A1)),A1<>"")या विकल्प =IFERROR(CODE(A1)=CODE(RIGHT(A1)),1=0)।

— इंजीनियर टोस्ट

मैंने इसे एक्सेल ऑनलाइन (16.0.9222.5051) में आज़माया और यह किसी भी गैर-त्रुटि इनपुट के TRUEलिए वापस आ गया । ( स्क्रीनशॉट ) क्या यह सभी परीक्षण मामलों के लिए आपकी कॉपी में काम करता है? ExcelGuy का एक उत्तर है जो समान कारणों से ऊपर की तरह मेरा है।

— इंजीनियर टोस्ट

1

@EngineerToast आप पूरी तरह से सही हैं, मैं का उपयोग कर किया जाना चाहिए था *बजाय &द्विआधारी और बयान के लिए है, लेकिन है कि अभी भी छोड़ देता है "A"="a"मुद्दा है, जो मैं पूरी तरह से अनदेखी की थी। वह सब और थोड़ी सी भी सुधार मुझे =EXACT(LEFT(A1),RIGHT(A1))*(A1<>"")35 के लिए ले जाता है , लेकिन मैंने भाषा को Google पत्रक में बदल दिया है, जिसने मुझे Exactबयान में टर्मिनल डबल पैतृक को छोड़ने की अनुमति दी , =(A1<>"")*Exact(Left(A1),Right(A133 बाइट्स के लिए प्रतिपादन

— टेलर स्कॉट

3

आर, 50 43 41 40 64

एक कॉल करने योग्य फ़ंक्शन के लिए 41 बाइट्स के साथ दूसरा समाधान - @ niczky12 और @Giuseppe के लिए धन्यवाद - एक्स = "के लिए संशोधित"

r=function(x,y=utf8ToInt(x))ifelse(x=="","FALSE",(y==rev(y))[1])

पहले 50 बाइट के साथ लेकिन चुनौती के लिए नहीं

function(x){charToRaw(x)[1]==rev(charToRaw(x))[1]}

— रिकार्डो कैमोन
स्रोत

जब स्ट्रिंग खाली हो, तो आप एस के उत्पादन के charToRawसाथ बदल सकते हैं । utf8ToIntNA

— niczky12

आप {}फ़ंक्शन बॉडी के चारों ओर घुंघराले ब्रेसिज़ भी निकाल सकते हैं ।

— Giuseppe

मुझे लगता (y==rev(y))[1]है कि एक बाइट से छोटा है

— Giuseppe

इस चुनौती के लिए केवल एक ट्रू और एक फाल्सी मूल्य का उपयोग करने की आवश्यकता होती है, लेकिन यह NAखाली स्ट्रिंग के लिए लेकिन उत्पादन करता FALSEहै "ab"। इसे ऑनलाइन आज़माएं! ।

— अर्जन जोहान्सन

@ ,RjanJohansen आपकी टिप्पणी के लिए धन्यवाद, इसलिए "ab" को FALSE नहीं देना चाहिए?

— रिकाडर्डो कैमोन

2

ऑक्टेव, 16 बाइट्स

@(s)s(1)==s(end)

यह sइनपुट के रूप में एक स्ट्रिंग लेता है , और s(1)आखिरी के साथ पहले तत्व की तुलना करता है s(end)।

यह हो सकता है @(s)s(1)-s(end)अगर यह स्वैप true/falseकरने के लिए ठीक था false/true।

— स्टीवी ग्रिफ़िन
स्रोत

2

ग्नू ग्रीप , 12 बाइट्स

^(.)(.*\1)?$

विस्तारित या पीसीआरई मोड में चलाएं।

मुझे नहीं पता कि यह धोखा माना जाता है या नहीं।

— eush77
स्रोत

क्या यह रिक्त स्ट्रिंग मामले को संभालता है?

— ताली

@ConfusedMr_C हां, खाली स्ट्रिंग ⇒ कोड 1.

— eush77

2

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

f=शुरुआत में जोड़ें और जैसे आह्वान करें f(arg)।

_=>_[0]==_.slice(-1)

f=_=>_[0]==_.slice(-1)

i.oninput = e => o.innerHTML = f(i.value);

<input id=i><pre id=o></pre>

स्निपेट का विस्तार करें

व्याख्या

यह फ़ंक्शन एक तर्क में लेता है _। फ़ंक्शन बॉडी में, यह _[0]==_.slice(-1)जाँचता है कि क्या _( 0th index पर) का पहला तत्व इसके अंतिम तत्व के बराबर है, और उचित trueया falseबूलियन देता है।

— अर्जुन
स्रोत

2

एसआईओएस , 81 बाइट्स

loadLine
a=256
c=get a
lblb
t=s
s=get a
a+1
if s b
t-c
if t d
i+1
lbld
printInt i

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

— लीक नन
स्रोत

2

आम लिस्प, 83 74 61 58 बाइट्स

मूल: 83 बाइट्स

मैंने अभी कॉमन लिस्प सीखना शुरू किया है, इसलिए मुझे लगता है कि मैं एक ड्राइविंग रेंज में एक पुटर ला रहा हूं। यहाँ किसी प्रकार का पुनरावर्ती मैक्रो मैजस्ट्री या सरणी हेरफेर संभव होना चाहिए जो मैं नहीं देख रहा हूं।

यह एक अनाम फ़ंक्शन है जो एक स्ट्रिंग को इसके इनपुट के रूप में स्वीकार करता है:

(lambda (s) (let ((n (- (length s) 1))) (when (> n 0) (eq (char s 0) (char s n)))))

prettified:

(lambda (s)
  (let ((n (- (length s) 1)))
    (when (> n 0)
      (eq (char s 0)
          (char s n)))))

एक चालाक समाधान देखना पसंद करेंगे!

संशोधन 1: 74 बाइट्स

उन मानक पुस्तकालय कार्यों से प्यार होगा!

बदसूरत:

(lambda (s) (when (> (length s) 0) (eq (elt s 0) (elt (reverse s) 0))))

सुंदर हे:

(lambda (s)
  (when (> (length s) 0)
    (eq (elt s 0)
        (elt (reverse s) 0))))

संशोधन 1.5: 61 बाइट्स

व्हाइटस्पेस!

(lambda(s)(when(>(length s)0)(eq(elt s 0)(elt(reverse s)0))))

संशोधन 2: 58 बाइट्स

बदसूरत:

(lambda(s)(and(>(length s)0)(not(mismatch s(reverse s)))))

सुंदर हे:

(lambda (s)
  (and (> (length s) 0)
       (not (mismatch s (reverse s)))))

अभी के लिए इतना ही! मुझे लगता है कि मैं पहले से ही होशियार हूं।

— shadowtalker
स्रोत

1

के ifबजाय andऔर के (mismatch(reverse s)s)बजाय (mismatch s(reverse s))

— सुझाव

2

AWK, 29 34 बाइट्स

यह थोड़ा धोखा हो सकता है, क्योंकि इसमें विकल्प के साथ AWK को शामिल करने की आवश्यकता होती है:

`-F ''`

GNU Awk में आप लंबे-लंबे पर्यायवाची शब्दों का उपयोग कर सकते हैं:

`--field-separator=''`

इसलिए मैंने इसके लिए खाते में कुल 5 बाइट जोड़े।

बदसूरत:

NR==1{a=$1}END{print(a==$NF)}

सुंदर हे:

NR == 1
{
    a = $1
}

END
{
    print(a == $NF)
}

— shadowtalker
स्रोत

1

मेरा मानना है कि नियम यह है कि आप झंडे / विकल्पों का उपयोग कर सकते हैं, लेकिन आपको उन्हें बाइट की गिनती में शामिल करने की आवश्यकता है।

— अर्जन जोहान्सन

क्या शुरुआत अंत के बराबर होती है?

काम

इनपुट

उत्पादन

अतिरिक्त नियम

परीक्षण के मामलों

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

पायथन 3 , 23 बाइट्स

यह काम किस प्रकार करता है

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

मैथेमेटिका, 15 बाइट्स

05AB1E , 4 बाइट्स

रेटिना , १३ 12 बाइट्स

सी ++, 39 बाइट्स

ब्रेकीलॉग , 4 बाइट्स

व्याख्या

जावा, 81 77 बाइट्स

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

ब्रेनफक , 43 बाइट्स

व्याख्या

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

MATL, 5 बाइट्स

जाप , 6 बाइट्स

एपीएल (डायलॉग) , 4 बाइट्स

व्याख्या

जावा, 52 43 बाइट्स

रूबी, 26 24 बाइट्स

PHP> = 7.1, 23 बाइट्स

स्विफ्ट, 57 बाइट्स

सी #, 38 30 बाइट्स

आर, 40 बाइट्स

> <> , 39 33 बाइट्स

Google शीट, 33 बाइट्स

उत्पादन

आर, 50 43 41 40 64

ऑक्टेव, 16 बाइट्स

ग्नू ग्रीप , 12 बाइट्स

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

व्याख्या

एसआईओएस , 81 बाइट्स

आम लिस्प, 83 74 61 58 बाइट्स

मूल: 83 बाइट्स

संशोधन 1: 74 बाइट्स

संशोधन 1.5: 61 बाइट्स

संशोधन 2: 58 बाइट्स

AWK, 29 34 बाइट्स