Inspiré par Est-ce que le début est égal à la fin

Étant donné une chaîne set un entier n, affichez une valeur true / falsey indiquant si le nth caractère dans sest égal au nth à partir du dernier caractère dans s.

Contribution

Une chaîne non vide et un entier. Vous pouvez utiliser une indexation basée sur 0 ou une indexation basée sur 1. L'entier est garanti valide sur la base de la chaîne. Par exemple, si la chaîne est "supercalifragalistic123", l'entier peut être compris entre 1 et 23 pour l'indexation basée sur 1 et 0 à 22 pour l'indexation basée sur 0. Veuillez noter que cela npeut être plus grand que la moitié de la longueur de s.

L'entrée est limitée à l'ASCII imprimable.

Sortie

Une valeur truey / falsey basée sur le fait que la nvaleur e en ssoit égale à la nvaleur th de la dernière valeur en s.

Veuillez noter que le dernier caractère est en position 0 pour l'indexation basée sur 0 et en position 1 pour l'indexation basée sur 1. Considérez-le comme comparant la chaîne à son inverse.

Cas de test

0 indexé

"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 indexé

"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

Gelée , 5 4 octets

=UƓị

Essayez-le en ligne!

Il ne devrait pas y avoir de réponses plus courtes dans Jelly. Un programme aurait besoin d'une comparaison, d'une inversion / négation, d'un appel d'index et d'un octet pour le flux de contrôle ( Ɠdans ce cas), ce qui représente jusqu'à quatre octets.

Comment ça marche

 =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 octet grâce à @ ais523, en utilisant Ɠ

JavaScript (ES6), 26 octets

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

Alternativement:

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

Celui-ci fonctionne presque, mais échoue lorsque n == 0(parce que s.slice(-1,0) == ""):

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

Une autre solution de 26 octets que @RickHitchcock a souligné:

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

MATL , 5 octets

tP=w)

Essayez-le en ligne!

Explication:

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 octets

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

Essayez-le en ligne!

Ou le même bytecount:

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

Essayez-le en ligne!

Explication:

C'est assez simple. Le premier prend une chaîne set un entier ncomme entrées et vérifie l'égalité du nième élément par s(n)rapport à l' élément "last-n + 1".

Le second vérifie le nième élément s(n)contre le nième élément sinversé.

05AB1E , 7 5 octets

-2 octets grâce à Adnan

ÂøsèË

Essayez-le en ligne! ou essayez tous les tests

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

Essayez-le en ligne!

Haskell, 22 octets

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

0-basd. Exemple d'utilisation: "letter" # 1-> True.

Essayez-le en ligne!

Alice , 24 octets

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

Essayez-le en ligne!

L'entrée se compose de la chaîne sur une ligne et du nombre sur la deuxième ligne. La sortie est Jabberwockysi les caractères sont les mêmes et rien d'autre.

Explication

Ce programme est principalement en mode ordinal, avec une commande en mode cardinal. Linéarisé, le programme est le suivant:

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 octets

-2 octets grâce à Adnan.

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

Essayez-le en ligne!

Cubix , 22 octets

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

1-indexé, prend comme entrée index, stringséparés par un espace.

Essayez-le en ligne

Cubifié

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

Explication

C'est principalement linéaire. La logique principale est

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.

On branche ensuite avec ?to Output 1si le résultat est 0 et 0sinon.

Java 8, 43 42 octets

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

Essayez-le ici.

C #, 28 27 octets

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

Un octet enregistré grâce à @KevinCruijssen.

Compile en a Func<string, Func<int, bool>>.

CJam , 8 octets

l~_W%.==

Essayez-le en ligne!

L'index indexé 0 passe en premier.

R 51 octets

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

Fonction anonyme, utilise l'indexation basée sur 1

Rubis, 22 20 18 octets

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

Clojure, 27 octets

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

Wow, c'était plus court que ce à quoi je m'attendais.

APL (Dyalog) , 10 5 octets

⊃=⊃∘⌽

Il s'agit d'une fonction tacite, à laquelle il faut attribuer un nom tel que f←⊃=⊃∘⌽, puis appelé as int f string.

Merci à @ Adám pour un énorme 5 octets.

Comment ça marche:

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

Essayez-le en ligne!

La réponse de 22 octets a été éditée. Si vous voulez le voir, consultez l'historique des révisions.

V , 26, 16 , 13 octets

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

Essayez-le en ligne!

Hexdump:

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

1 indexé.

Explication:

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

Pour référence, ma réponse originale était:

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

Essayez-le en ligne! (0 indexé)

Hexdump:

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

Mathematica, 34 octets

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

Perl 6 , 27 octets

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

Essaye-le

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

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

Version en ligne

Pyth , 8 7 octets

q@zQ@_z

Avec l'entrée inversée: d'abord l'index, puis la chaîne. Il est indexé 0.

Explications:

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

Essayez-le en ligne!

Lua, 46 octets

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

Essayez-le en ligne!

J, 6 octets

-4 octets grâce à FrownyFrog

{(=|.)

Voir l'explication de la réponse originale - l'idée est assez similaire, mais cela se fait avec un crochet dyadique dont le verbe droit est lui-même un crochet monadique.

Essayez-le en ligne!

réponse originale (10 octets)

{=/@(,:|.)

,:|. argument de droite en haut de l'argument de droite inverse

=/ sont-ils égaux par élément?

{ prendre de cette liste booléenne l'index indiqué par l'argument de gauche

Essayez-le en ligne!

C, 36 35 octets

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

Utilise naturellement l'indexation 0.

Essayez-le en ligne!

Japt , 10 9 8 octets

gV ¥Ug~V

Essayez-le en ligne!

QBIC , 18 octets

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

Explication

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

q~_2$=@@~==

Mauvais. Trop de manipulation de pile.

> <> (avec cet interprète), 25 octets

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

Cela ne fonctionne pas dans TIO: l'interpréteur TIO n'inverse pas la nouvelle pile lors de l' exécution de l' [instruction, mais le terrain de jeux pour poissons le fait - comparez les "abcde"5[ooooo;courses ici et ici , par exemple.

L'entrée de chaîne provient de STDIN, et nous supposons que n est déjà sur la pile. Utilise l'indexation 1.

Le poisson obtient le n ième caractère avec [:}]&qui siphonne les premiers n choses sur la pile dans une nouvelle pile inversée, un peu qui manipule, met alors les choses en arrière et enregistre le n ième caractère dans le registre. Il inverse ensuite toute la pile et refait la même chose, et renvoie 1 si les deux caractères sont égaux et 0 sinon.

Cela semble fonctionner chez TIO , pour 26 octets:

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

C, 73 octets

Compile tel quel avec GCC 6.3.1 (pas de fanions). Quelques brouillages inutiles inclus.

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

Usage

$./a.out abcdcba 6

Truthy = rien, falsey = ordures.

Lua , 35 octets

Utilise l'indexation 1.

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

Essayez-le en ligne!