Inspired by start sona eşit mi

Bir dize sve bir tamsayı nverildiğinde , içindeki karakterin, içindeki karakterin sonunda gelen nkaraktere seşit olup olmadığına dair bir hakikat / falsey çıkar .ns

Giriş

Boş olmayan bir dize ve bir tam sayı. 0 tabanlı dizin veya 1 tabanlı dizin kullanabilirsiniz. Tamsayı dizeye göre geçerli olması garanti edilir. Örneğin, dizge "supercalifragalistic123" ise, tamsayı 1 tabanlı dizinleme için 1 ila 23 ve 0 tabanlı dizinleme için 0 ila 22 olabilir. Unutmayın ki nuzunluğu yarısından büyük olabilir s.

Giriş, yazdırılabilir ASCII ile sınırlıdır.

Çıktı

Olmadığına bağlı olarak bir truthy / Falsey değeri nde inci değerinde seşittir nson değerden th s.

Lütfen son karakterin 0 tabanlı indeksleme için 0 ve 1 tabanlı indeksleme için 1 pozisyonda olduğunu unutmayın. İpi tersine çevirerek düşünün.

Test Kılıfları

0 endeksli

"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 endeksli

"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

Jöle , 5 4 bayt

=UƓị

Çevrimiçi deneyin!

Jelly'te daha kısa cevaplar olmamalıdır. Bir programın karşılaştırılması, ters çevirme / olumsuzlama, bir dizin çağrısı ve kontrol akışı için bir bayta ( Ɠbu durumda) ihtiyacı vardır, bu da dört bayta kadar ekler.

Nasıl çalışır

 =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

@ Ais523 sayesinde -1 bayt, Ɠ

JavaScript (ES6), 26 bayt

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

Alternatif:

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

Bu neredeyse çalışıyor, ancak ne zaman başarısız oluyor n == 0(çünkü s.slice(-1,0) == ""):

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

@RickHitchcock'un belirttiği 26 baytlık bir çözüm daha :

s=>n=>s[n]==s[s.length+~n]

MATL , 5 bayt

tP=w)

Çevrimiçi deneyin!

Açıklama:

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 

Octave , 22 bayt

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

Çevrimiçi deneyin!

Veya aynı bytecount:

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

Çevrimiçi deneyin!

Açıklama:

Oldukça dümdüz. İlki, bir dize sve bir tamsayı alır nve n'th öğesini kontrol eder.s(n) eşitlik için "last-n + 1" öğesine göre .

İkincisi s(n), n'ci elemanı sters çevrilmiş n'ci elemanı ile kontrol eder .

05AB1E , 7 5 bayt

Adnan sayesinde -2 bayt

ÂøsèË

Çevrimiçi deneyin! veya Tüm testleri deneyin

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

Çevrimiçi deneyin!

Haskell, 22 bayt

s#n=s!!n==reverse s!!n

0-basd. Kullanım örneği: "letter" # 1-> True.

Çevrimiçi deneyin!

Alice , 24 bayt

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

Çevrimiçi deneyin!

Giriş, bir satırdaki dize ve ikinci satırdaki sayıdan oluşur. Çıktı, Jabberwockykarakterler aynıysa ve başka bir şey yoksa.

açıklama

Bu program çoğunlukla sıra modunda, kardinal modda bir komut ile. Doğrusallaştırılmış program aşağıdaki gibidir:

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

Python , 24 22 bayt

Adnan sayesinde -2 bayt.

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

Çevrimiçi deneyin!

Cubix , 22 bayt

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

1-endeksli, girdi alır index, stringbir boşluk ile birbirlerinden ayrılmıştır.

Çevrimiçi deneyin

Cubified

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

açıklama

Bu çoğunlukla doğrusaldır. Ana mantık

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.

Sonra birlikte şube ?için Oıkış 1sonucu 0 ve eğer 0aksi.

Java 8, 43 42 bayt

s->n->s.charAt(n)==s.charAt(s.length()+~n)

Burada dene.

C #, 28 27 bayt

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

@KevinCruijssen sayesinde bir bayt kaydedildi.

A derler Func<string, Func<int, bool>>.

CJam , 8 bayt

l~_W%.==

Çevrimiçi deneyin!

0 dizinli dizin önce gider.

R 51 bayt

function(s,n){s=el(strsplit(s,''));s[n]==rev(s)[n]}

Anonim işlev, 1 tabanlı endeksleme kullanır

Ruby, 22 20 18 bayt

->s,n{s[n]==s[~n]}

Clojure, 27 bayt

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

Vay, bu beklediğimden daha kısaydı.

APL (Dyalog) , 10 5 bayt

⊃=⊃∘⌽

Bu, gibi bir ad atanması gereken f←⊃=⊃∘⌽ve sonra adı verilen tam bir işlevdir int f string.

Bir kuyruklu 5 bayt için @ Adám'a teşekkürler.

Nasıl çalışır:

⊃=⊃∘⌽  ⍝ 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)⍵'

Çevrimiçi deneyin!

22 baytlık cevap düzenlendi. Görmek istiyorsanız revizyon geçmişini kontrol edin.

V , 26, 16 , 13 bayt

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

Çevrimiçi deneyin!

HexDump:

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

1 endekslendi.

Açıklama:

ä$                  " 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

Başvuru için asıl cevabım şuydu:

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

Çevrimiçi deneyin! (0 dizinlenmiş)

HexDump:

00000000: c0f1 7824 787c f178 7624 6868 70d3 a82e  ..x$x|.xv$hhp...
00000010: a9b1 2f31 0af1 6c6c 5330                 ../1..llS0

Mathematica, 34 Bayt

s=StringTake;s[#,{#2}]==s[#,{-#2}]&

Perl 6, 27 bytes

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

Test it

{ # 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)

    ]
}

PHP>=7.1, 36 Bytes

[,$t,$p]=$argv;echo$t[$p]==$t[~+$p];

Online Version

Pyth, 8 7 bytes

q@zQ@_z

With the input reversed: first the index, then the string. It is 0-indexed.

Explanations:

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

Try it online!

Lua, 46 bytes

function f(s,n)return s:byte(n)==s:byte(-n)end

Try it online!

J, 6 bytes

-4 bytes thanks to FrownyFrog

{(=|.)

See original answer explanation -- idea is similar enough, but this is accomplished with a dyadic hook whose right verb is itself a monadic hook.

Try it online!

original answer (10 bytes)

{=/@(,:|.)

,:|. right arg on top of reverse right arg

=/ are they elementwise equal?

{ take from that boolean list the index indicated by the left arg

Try it online!

C, 36 35 bytes

#define f(s,n)s[n]==s[strlen(s)+~n]

Uses 0-based indexing, naturally.

Try it online!

Japt, 10 9 8 bytes

gV ¥Ug~V

Try it online!

QBIC, 18 bytes

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

Explanation

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

CJam, 11 bytes

q~_2$=@@~==

Bad. Too much stack manipulation.

><> (with this interpreter), 25 bytes

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

It doesn't work in TIO: the TIO interpreter doesn't reverse the new stack when doing the [ instruction, but the fish playground does — compare "abcde"5[ooooo; run here and here, for example.

The string input is taken from STDIN, and we assume n is already on the stack. Uses 1-indexing.

The fish gets the nth character with [:}]&, which siphons off the first n things on the stack into a new, reversed stack, manipulates that a bit, then puts the things back and saves the nth character in the register. It then reverses the whole stack and does the same again, and returns 1 if the two characters are equal, and 0 otherwise.

This seems to work at TIO, for 26 bytes:

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

C, 73 bytes

Compiles as-is with GCC 6.3.1 (no flags). Some unnecessary obfuscation included.

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

Usage

$./a.out abcdcba 6

Truthy = nothing, falsey = garbage.

Lua, 35 bytes

Uses 1-indexing.

s,n=...print(s:byte(n)==s:byte(-n))

Try it online!