क्या nth char अंतिम char से nth बराबर है?

22

प्रारंभ से अंत के बराबर प्रेरित करता है

एक स्ट्रिंग sऔर एक पूर्णांक को देखते हुए n, एक सच्‍ची / फाल्‍सी का उत्‍पादन करते हैं कि क्‍या nth char s, nवें के अंत में char के बराबर होती है s।

इनपुट

एक गैर-खाली स्ट्रिंग और एक पूर्णांक। आप 0-आधारित इंडेक्सिंग या 1-आधारित इंडेक्सिंग का उपयोग कर सकते हैं। पूर्णांक स्ट्रिंग के आधार पर मान्य होने की गारंटी है। उदाहरण के लिए, यदि स्ट्रिंग "सुपरकैलिफ़ैरलिस्टिक123" है, तो पूर्णांक अनुक्रमण के लिए पूर्णांक 1 से 23 तक हो सकता है, और 0-आधारित अनुक्रमण के लिए 0 से 22 हो सकता है। कृपया ध्यान दें कि nलंबाई की आधी से बड़ी हो सकती है s।

इनपुट मुद्रण योग्य ASCII तक सीमित है।

उत्पादन

एक सत्य / गलत मूल्य के आधार पर कि क्या nवें मूल्य में अंतिम मूल्य से वें के sबराबर होता nहै s।

कृपया ध्यान दें कि अंतिम चार्ट 0-आधारित अनुक्रमण के लिए 0 स्थिति में है और 1-आधारित अनुक्रमण के लिए स्थिति 1 है। इसे स्ट्रिंग से इसके विपरीत की तुलना करने के रूप में सोचें।

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

0 अनुक्रमित

"1", 0         Truthy 1 == 1
"abc", 1       Truthy b == b
"aaaaaaa", 3   Truthy a == a
"[][]", 1      Falsey ] != [
"[][]", 0      Falsey [ != ]
"ppqqpq", 2    Truthy q == q
"ababab", 5    Falsey a != b
"12345", 0     Falsey 1 != 5
"letter", 1    Truthy e == e
"zxywv", 3     Falsey w != x

1 अनुक्रमित

"1", 1         Truthy 1 == 1
"abc", 2       Truthy b == b
"aaaaaaa", 4   Truthy a == a
"[][]", 2      Falsey ] != [
"[][]", 1      Falsey [ != ]
"ppqqpq", 3    Truthy q == q
"ababab", 6    Falsey a != b
"12345", 1     Falsey 1 != 5
"letter", 2    Truthy e == e
"zxywv", 4     Falsey w != x
code-golf  string 
— स्टीफन
स्रोत
— स्टीफन
क्या nकोड-बिंदु के रूप में लेना स्वीकार्य होगा ? (मस्तिष्क-
— सपाट
@DJMcMayhem ज़रूर
— स्टीफन

जवाबों:

11

जेली , 5 4 बाइट्स

=UƓị

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

जेली में कोई छोटा जवाब नहीं होना चाहिए। एक कार्यक्रम को तुलना, उलट / नकार, एक सूचकांक कॉल और नियंत्रण प्रवाह ( Ɠइस मामले में) के लिए एक बाइट की आवश्यकता होगी , जो चार बाइट्स तक जोड़ता है।

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

 =UƓị 
       - (implicit) input string
 =     - equals (vectorizing by characters because a string is a charlist)
  U    - the reversed string
    ị  - get the element at the index of:
   Ɠ   - the input index

-1 बाइट, @ ais523 का उपयोग करके धन्यवाद Ɠ

— fireflame241
स्रोत
पोस्ट के मूल संस्करण से 4 बाइट समाधान विफल:ịµU=
— कैलक्यूलेटरफलाइन
आप इसे डाईएडिक (और एक तर्क के बजाय मानक इनपुट से n लेने के बजाय) को मोनडिक बनाकर चार बाइट्स में सुधार कर सकते हैं : इसे ऑनलाइन आज़माएं! यह तकनीक अक्सर उपयोगी होती है जब आप नियंत्रण प्रवाह पर एक बाइट को बर्बाद कर रहे होते हैं और एक अतिरिक्त बाइट पर खर्च होता है ³, क्योंकि Ɠलागत एक बाइट होती है लेकिन ³अंतर्निहित होती है और अक्सर आपको अधिक नियंत्रण प्रवाह लचीलापन देती है।
@ ais512 अच्छा विचार है, मैंने वास्तव में उत्तर में पहले कभी इनपुट का उपयोग नहीं किया है क्योंकि निहित तर्क अधिक कुशल हैं।
— फायरफ्लेम २४१
14

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

s=>n=>s[n]==s.substr(~n,1)

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

s=>n=>s[n]==s.slice(~n)[0]

यह लगभग काम करता है, लेकिन जब n == 0(क्योंकि s.slice(-1,0) == "") विफल रहता है :

s=>n=>s[n]==s.slice(~n,-n)

एक और 26-बाइट समाधान जो @RickHitchcock ने बताया:

s=>n=>s[n]==s[s.length+~n]
— ETHproductions
स्रोत
3
का अच्छा उपयोग ~, हालांकि इसके लिए कभी नहीं होगा।
— स्टीफन
10

MATL , 5 बाइट्स

tP=w)

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

स्पष्टीकरण:

t   % Duplicate the input

Stack:
    ['ppqqpq' 'ppqqpq']

P   % Reverse the top element of the stack

Stack:
    ['ppqqpq' 'qpqqpp']

=   % Equals. Push an array of the indices that are equal

Stack:
    [[0 1 1 1 1 0]]

w   % Swap the top two elements

Stack:
    [[0 1 1 1 1 0], 3]

)   % Grab the a'th element of b
— DJMcMayhem
स्रोत
1
बहुत चालाक दृष्टिकोण!
— लुइस मेंडू
3
@LuisMendo थैंक्यू! यही कारण है कि पूरक आप से :) आ शांत है
— DJMcMayhem
अब हम देखते हैं कि क्या जेली इस xD को हरा सकती है
— स्टीफन
5

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

@(s,n)s(n)==s(end-n+1)

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

या एक ही bytecount:

@(s,n)s(n)==flip(s)(n)

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

स्पष्टीकरण:

यह काफी सीधा है। पहले एक इनपुट के रूप में एक स्ट्रिंग sऔर एक पूर्णांक लेता है और समानता के लिए "अंतिम-एन + 1" तत्व के खिलाफ nn'th तत्व की जांच करता है s(n)।

दूसरा उलटा n'th तत्व के s(n)खिलाफ n'th तत्व की जाँच करता sहै।

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

05AB1E , 7 5 बाइट्स

-2 बाइट्स अदनान को धन्यवाद

ÂøsèË

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

     # Add a reversed copy on top of the original string
 ø    # Zip
  sè  # Extract the nth element
    Ë # Check if they are equal

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

— रिले
स्रोत
ÂøsèËदो बाइट्स बचाता है
— अदनान
@ अदनान धन्यवाद! मुझे पता था कि एक उलटी कॉपी को जोड़ने के लिए 1 बाइट तरीका था, मुझे अभी याद नहीं है कि यह कैसे लेबल किया गया था।
— रिले
@ComradeSparklePony मैं इसे अदनान के सुझाव को शामिल करने के लिए अपडेट करना भूल गया।
— रिले
5

एलिस , 24 बाइट्स

/t.~e?/-mom
\I!RtI&1n;@/

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

इनपुट में एक लाइन पर स्ट्रिंग और दूसरी लाइन पर नंबर होते हैं। आउटपुट है Jabberwockyअगर वर्ण समान हैं, और अन्यथा कुछ भी नहीं।

व्याख्या

यह प्रोग्राम ज्यादातर ऑर्डिनल मोड में होता है, जिसमें कार्डिनल मोड में एक कमांड होती है। रैखिक, कार्यक्रम इस प्रकार है:

I.ReI&1m;mt!~t?&-no

I  % Input first line
   % STACK: ["ppqqpq"]
.  % Duplicate top of stack
   % STACK: ["ppqqpq", "ppqqpq"]
R  % Reverse top of stack
   % STACK: ["ppqqpq", "qpqqpp"]
e  % Push empty string
   % STACK: ["ppqqpq", "qpqqpp", ""]
I  % Input next line
   % STACK: ["ppqqpq", "qpqqpp", "", "3"]
&  % (cardinal mode) Pop stack and repeat next command that many times
   % STACK: ["ppqqpq", "qpqqpp", ""], ITERATOR: [3]
1  % Append "1" to top of stack
   % STACK: ["ppqqpq", "qpqqpp", "111"]
m  % Truncate so the top two strings on the stack have the same length
   % STACK: ["ppqqpq", "qpq", "111"]
;  % Discard top of stack
   % STACK: ["ppqqpq", "qpq"]
m  % Truncate again
   % STACK: ["ppq", "qpq"]
t  % Extract last character
   % STACK: ["ppq", "qp", "q"]
!  % Move top of stack to tape
   % STACK: ["ppq", "qp"]
~  % Swap
   % STACK: ["qp", "ppq"]
t  % Extract last character
   % STACK: ["qp", "pp", "q"]
?  % Copy data from tape onto top of stack
   % STACK: ["qp', "pp", "q", "q"]
&  % Iterator: effectively a no-op in ordinal mode when the top of the stack is a 1-character string
   % STACK: ["qp", "pp", "q"], ITERATOR: ["q"]
-  % Remove occurrences: here, result is "" iff the characters are equal
   % STACK: ["qp", "pp", ""]
n  % Logical Not (for a consistent truthy value)
   % STACK: ["qp", "pp", "Jabberwocky"]
o  % Output top of stack
— Nitrodon
स्रोत
@MartinEnder Jabberwocky?
— स्टीफन
3
@ स्टीफन जॉबरवॉकी।
— मार्टिन एंडर
@StephenS Btw, अगर आप अभी मुझे यादृच्छिक पदों पर उल्लेख करते हैं तो मुझे सूचनाएं नहीं मिलती हैं। पिंग केवल तभी काम करते हैं यदि पोस्ट मेरी है या मैंने खुद टिप्पणी की है (और मुझे लगता है कि अगर मैंने पोस्ट को संपादित किया है)। आप आमतौर पर मुझसे चैट में पिंग कर रहे हैं।
— मार्टिन एंडर
@MartinEnder मुझे इस तरह का पता था, लेकिन यह आपको पिंग करने के लिए पर्याप्त महत्वपूर्ण नहीं था। पुष्टि और लिंक के लिए धन्यवाद :)
— स्टीफन
5

पायथन , 24 22 बाइट्स

-2 बाइट्स अदनान को धन्यवाद।

lambda s,n:s[n]==s[~n]

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

— totallyhuman
स्रोत
3
मुझे लगता है कि आप की जगह ले सकता -n-1से ~n।
— अदनान
केवल पायथन 2 ही क्यों? Python3 पर काम करना ठीक लगता है, आपको इसे सिर्फ 'Python' में बदलना चाहिए।
— सागिस्प्स
@sagiksp यह TIO में डिफ़ॉल्ट टेम्प्लेट आउटपुट है
— फेलिप नारदी बतिस्ता
ओह, समझ में आता है।
— sagiksp
@sagiksp हाँ, यह TIO से टेम्पलेट है लेकिन अद्यतन किया गया है। :)
— बिलकुल अमानवीय
4

क्यूबिक्स , 22 बाइट्स

..@.IAp):tBvpptc?1.\O0

1 अनुक्रमित, इनपुट लेता है के रूप में index, string, एक रिक्ति से अलग कर दिया।

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

Cubified

    . .
    @ .
I A p ) : t B v
p p t c ? 1 . \
    O 0
    . .

व्याख्या

यह ज्यादातर रैखिक है। मुख्य तर्क है

IAp):tBpptc

IA           Get the first input as an int and the rest as a string.
  p):        Move the index to the top of the stack, increment it, and copy it.
     t       Look up the appropriate character in the string.
      Bpp    Reverse the stack and put the index and character back on top.
         t   Look up the appropriate character in the reversed string.
          c  XOR the two characters.

हम तो साथ शाखा ?को Output 1यदि परिणाम 0 और है 0अन्यथा।

3

सी #, 28 27 बाइट्स

s=>n=>s[n]==s[s.Length+~n];

@KevinCruijssen को एक बाइट धन्यवाद दिया।

के संकलन करता है Func<string, Func<int, bool>>।

— TheLethalCoder
स्रोत
आप को बदलने के द्वारा एक बाइट बचा सकते हैं s.Length-n-1करने के लिए s.Length+~n।
— केविन क्रूज़सेन
@KevinCruijssen धन्यवाद, अच्छी चाल कभी सोचा भी नहीं होगा।
— TheLethalCoder
1
मैं पूरी तरह से ईमानदार रहूंगा, मुझे यह जेएस जवाब की टिप्पणी से मिला। :) बाइट-ऑपरेशन वास्तव में मेरी विशेषज्ञता नहीं हैं।
— केविन क्रूज़सेन
3

क्लोजर, 27 बाइट्स

#(nth(map =(reverse %)%)%2)

वाह, यह मेरी अपेक्षा से कम था।

— NikoNyrh
स्रोत
3

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

⊃=⊃∘⌽

यह एक टैसिट फ़ंक्शन है, जिसे एक नाम निर्दिष्ट करने की आवश्यकता होती है जैसे कि f←⊃=⊃∘⌽, और फिर कहा जाता है int f string।

@ एक बाइट 5 बाइट्स के लिए @ Adám को धन्यवाद।

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

⊃=⊃∘⌽  ⍝ Main function; tacit. 
       ⍝ Inputs are ⍺ = 1 (left) and ⍵ = 'abca' (right).
⊃      ⍝ ⍺⊃⍵, meaning 'pick the ⍺-th element of ⍵'
 =     ⍝ Compare to
    ⌽  ⍝ ⌽⍵, meaning 'invert ⍵'
  ⊃    ⍝ Again, ⍺⊃⍵, but:
   ∘   ⍝ Compose. This turns ⌽ into the right argument for ⊃,
       ⍝ which becomes 'pick the ⍺-th element from ⌽(the inverse of)⍵'

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

22 बाइट उत्तर को संपादित किया गया था। यदि आप इसे देखना चाहते हैं, तो संशोधन इतिहास देखें।

— जे। सल्ल
स्रोत
"यह एक गैर पारंपरिक तरीके से इनपुट लेता है" - एपीएल में बाएं और दाएं आर्ग के रूप में 2 तत्व इनपुट लेना पूरी तरह से मानक और हमेशा स्वीकार्य है जब तक कि ओपी विशेष रूप से इसे कुछ विचित्र कारण के लिए मना नहीं करता है।
— योना
@ जोना हां, चैट में लोगों ने मुझे उस बारे में बताया। मैंने इसे छोड़ दिया क्योंकि ओपी स्पष्ट रूप से निर्दिष्ट नहीं करता है कि यह ठीक है या नहीं। मैं संपादित करूँगा कि जब मैं अपने पीसी पर वापस जाऊंगा तो सबसे छोटा जवाब पहले दिखाई देगा।
— जे। सेले
"अंतर्निहित रूप से माना जाता है" के बारे में: वास्तव में, यह फ़ंक्शन तब भी काम करेगा जब इसे विवादास्पद रूप से कहा जाएगा, और फिर 1डिफ़ॉल्ट रूप से तर्क के रूप में उपयोग करने के लिए दिखाई देगा । इसे ऑनलाइन आज़माएं! कार्य कुछ भी नहीं मानते हैं; उन्हें रंगाई से लागू किया जा रहा है क्योंकि उन्हें एक बाएं और दाएं तर्क दिए गए हैं।
— 16
@ Adám मुझे लगा कि ऐसा इसलिए हुआ, क्योंकि जब इसे अद्वैत कहा जाता है, ⊃तो तर्क का पहला तत्व क्या है? वैसे भी, मैं स्पष्ट करने के लिए संपादित करूँगा।
— जे। सेले
3

वी , 26, 16 , 13 बाइट्स

ä$Àñã2xñVpøˆ±

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

Hexdump:

00000000: e424 c0f1 e332 78f1 5670 f888 b1         .$...2x.Vp...

1 अनुक्रमित।

स्पष्टीकरण:

ä$                  " Duplicate this line horizontally
  Àñ   ñ            " Arg1 times...
    ã               "   Move to the center of this line
     2x             "   And delete two characters
        V           " Select this whole line
         p          " And replace it with the last pair of characters we deleted
          ø         " Count the number of matches of the following regex...
           <0x88>   "   Any character
                 ±  "   Followed by itself

संदर्भ के लिए, मेरा मूल उत्तर था:

Àñx$x|ñxv$hhpÓ¨.©±/1
ñllS0

इसे ऑनलाइन आज़माएं! (0 अनुक्रमित)

Hexdump:

00000000: c0f1 7824 787c f178 7624 6868 70d3 a82e  ..x$x|.xv$hhp...
00000010: a9b1 2f31 0af1 6c6c 5330                 ../1..llS0
— DJMcMayhem
स्रोत
इसे ऑनलाइन आज़माएं! यह थोड़ा छोटा है। मनुष्य Àñx$x|ñबहुत अधिक पात्रों की तरह महसूस करता है। मैंने केवल एक रेक्सक्स की कोशिश की, लेकिन यह 24 घंटों की तरह समाप्त हो गया!
— nmjcman101
1
@ nmjcman101 ने बताया कि नई सुविधाओं का उपयोग करने से यह बहुत कम हो सकता है।
— डीजेमेकमेम
अरे वाह, मैं अभ्यास से बाहर हूँ, मैं मुश्किल से वी भी पढ़ सकता हूँ
— nmjcman101
@ nmjcman101 मैं एक स्पष्टीकरण पोस्ट किया है (और एक छोटे से अधिक golfed)
— DJMcMayhem
2

गणितज्ञ, 34 बाइट्स

s=StringTake;s[#,{#2}]==s[#,{-#2}]&
— J42161217
स्रोत
StringTake[#, #2]का पहला #2 अक्षर लेता है #। StringPartइस मामले में अच्छा काम करेगा। #~(s=StringPart)~-#2==s@##&
— जुंगह्वान मिन
मेरा गलत तय!
— J42161217
#~s~{#2}==#~s~{#2}&हमेशा पैदावार करेगा True...
— जुंगह्वान मिन
अंतिम तय! ....
— J42161217
1
वास्तव में, यदि आप एक ले जा सकते हैं Listके Stringइनपुट के रूप में है, इसलिए #[[#2]]==#[[-#2]]&पर्याप्त होगा
— JungHwan मिन
2

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

{[eq] $^a.comb[$^b,*-1-$b]}

झसे आज़माओ

{ # bare block lambda with two placeholder parameters ｢$a｣ and ｢$b｣

  [eq]        # reduce using string equality operator

    $^a       # declare first positional parameter

    .comb\    # split that into individual characters

    [         # index into that sequence

      $^b,    # declare and use second parameter

      *-1-$b  # closure that subtracts one and the 
              # second parameter of the outer block
              # (｢*｣ is the parameter of this closure)

    ]
}
— ब्रैड गिल्बर्ट b2gills
स्रोत
2

पायथ , 8 7 बाइट्स

q@zQ@_z

इनपुट उलट होने के साथ: पहले सूचकांक, फिर स्ट्रिंग। यह 0-अनुक्रमित है।

स्पष्टीकरण:

q@zQ@_z
 @zQ        Get the nth (Qth) character
     _z     Reverse the string
    @       Get the nth character of the reversed string. Implicit input of the index
q           Test equality

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

— जिम
स्रोत
2

जे, 6 बाइट्स

-4 बाइट्स FrownyFrog के लिए धन्यवाद

{(=|.)

मूल उत्तर स्पष्टीकरण देखें - विचार समान है, लेकिन यह एक डाइएडिक हुक के साथ पूरा किया जाता है, जिसकी दाहिनी क्रिया स्वयं एक मोनडिक हुक है।

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

मूल उत्तर (10 बाइट्स)

{=/@(,:|.)

,:|. दायाँ arg, उल्टा दाएँ arg के ऊपर

=/ क्या वे तत्व के बराबर हैं?

{ उस बूलियन सूची से ले जाएं जो बाईं ओर से संकेतित सूचकांक है

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

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

QBIC , 18 बाइट्स

?_s;,:,1|=_sA,-a,1

व्याख्या

?        =     PRINT -1 if equal, 0 otherwise, between
 _s     |      A substring of
   ;,:,1          A$ string (read from cmd line), from the n'th pos, length 1
 _sA,-a,1      And a substring of A$, n'th pos from the right, also 1 length
               The second Substring is auto-terminated because EOF.
— steenbergh
स्रोत
1

> <> ( इस दुभाषिया के साथ ), 25 बाइट्स

i:0(?v
]&=n;>~{:}[:}]&r[}

यह TIO में काम नहीं करता है: TIO दुभाषिया [निर्देश करते समय नए स्टैक को उल्टा नहीं करता है , लेकिन मछली खेल का मैदान करता है - उदाहरण के लिए, यहाँ और यहाँ"abcde"5[ooooo; रन की तुलना करें ।

स्ट्रिंग इनपुट STDIN से लिया गया है, और हम मानते हैं कि n पहले से ही स्टैक पर है। 1-अनुक्रमण का उपयोग करता है।

मछली को n वें चरित्र मिलता है [:}]&, जो स्टैक पर पहली एन चीजों को एक नए, उल्टा स्टैक में डुबोता है, थोड़ा सा हेरफेर करता है, फिर चीजों को वापस डालता है और रजिस्टर में एन वें चरित्र को बचाता है । यह तब पूरे स्टैक को उलट देता है और फिर से वही करता है, और 1 लौटाता है यदि दोनों वर्ण समान हैं, और 0 अन्यथा।

यह 26 बाइट्स के लिए TIO पर काम करता है :

i:0(?v
]&=n;>~{:}[{:}]&r[{
— पेड़ नहीं
स्रोत
1

सी, 73 बाइट्स

संकलन के रूप में जीसीसी 6.3.1 (कोई झंडे नहीं) के साथ है। कुछ अनावश्यक आक्षेप शामिल हैं।

main(c,v)char**v;{c=atoi(v[2]);putchar((*++v)[c]-(*v)[strlen(*v+1)-c]);}

प्रयोग

$./a.out abcdcba 6

सत्यं = कुछ भी नहीं, मिथ्या = कचरा।

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