第n个字符等于最后一个字符的第n个字符吗？

22

受启发于起点是否等于终点

给定一个字符串s和一个整数n，输出有关nth中的char 是否s等于nin中结尾char中的th 的真/假s。

输入项

非空字符串和整数。您可以使用基于0的索引或基于1的索引。整数基于字符串保证有效。例如，如果字符串是“ supercalifragalistic123”，则对于基于1的索引，整数可以为1到23，对于基于0的索引可以为0到22。请注意，n长度可以大于的一半s。

输入仅限于可打印的ASCII。

输出量

真假值，取决于中的nth值是否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 
— 史提芬
source
— 斯蒂芬
将其n作为代码点可以接受吗？（对于深奥的语言，例如
— 脑筋急转弯
@DJMcMayhem当然。
— 斯蒂芬，

Answers:

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，使用 Ɠ

— 火烈鸟241
source
帖子原始版本的4字节解决方案失败：ịµU=
— CalculatorFeline
您可以通过将其变为单声道而不是二进阶（并从标准输入而不是参数中获取n）来将其提高到四个字节：在线尝试！当您在控制流上浪费一个字节，在上浪费一个字节时，此技术通常很有用³，因为它Ɠ花费一个字节，但是却³隐含了一个字节，并且通常为您提供更大的控制流灵活性。
@ ais512好主意，我实际上从未在答案中使用过输入，因为隐式参数往往更有效。
— fireflame241
14

JavaScript（ES6），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)

@RickHitchcock指出的另一个26字节解决方案：

s=>n=>s[n]==s[s.length+~n]
— ETH生产
source
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
source
1
很聪明的办法！
— 路易斯·门多
3
@LuisMendo谢谢！那很安静，补语是来自您的:)
— DJMcMayhem
现在我们来看看Jelly是否可以击败xD
— Stephen
5

八度，22字节

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

在线尝试！

或相同的字节数：

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

在线尝试！

说明：

这很简单。第一个将字符串s和整数n作为输入，并s(n)针对“ last-n + 1”元素检查第n 个元素是否相等。

第二个将s(n)第n个元素与s反转的第n个元素进行比较。

— 斯蒂夫·格里芬
source
5

05AB1E，7 5字节

-2个字节感谢Adnan

ÂøsèË

在线尝试！或尝试所有测试

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

在线尝试！

— 赖利
source
ÂøsèË保存两个字节
— Adnan's
@Adnan谢谢！我知道有一种1字节的方式添加反向副本，我只是不记得它是如何标记的。
— 莱利
@ComradeSparklePony我忘了更新它，以包括Adnan的建议。
— 莱利
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
— 硝化龙
source
@MartinEnder Jabberwocky吗？
— 斯蒂芬
3
@StephenS Jabberwocky。
— Martin Ender
@StephenS顺便说一句，如果您只是在随机帖子中提及我，我不会收到通知。只有在我的帖子是我的帖子或者我已经评论了自己（并且我认为如果我编辑了该帖子）时，Ping才起作用。通常，您最好在聊天过程中对我执行ping操作。
— Martin Ender
@MartinEnder我有点知道，但是对ping并不重要。感谢您的确认和链接：)
— Stephen
4

Cubix，22字节

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

1索引，输入为index，string用空格隔开。

在线尝试

集中化

    . .
    @ .
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.

然后，如果结果为0，则分支?到Output 1，0否则返回。

3

C＃，28 27个字节

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

感谢@KevinCruijssen，节省了一个字节。

编译为Func<string, Func<int, bool>>。

— 致命编码器
source
您可以通过更改s.Length-n-1为保存一个字节s.Length+~n。
— Kevin Cruijssen
@KevinCruijssen谢谢，很好的技巧永远不会想到这一点。
— TheLethalCoder
1
我会说实话，我是从JS回答我的评论中得到的。:)字节操作并不是我真正的专长。
— 凯文·克鲁伊森
3

R 51字节

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

匿名函数，使用基于1的索引

— 弹力球
source
1
43个字节：function(s,n)(s=utf8ToInt(s))[n]==rev(s)[n]
— 朱塞佩
3

Clojure，27个字节

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

哇，这比我预期的要短。

— 尼古妮
source
3

APL（Dyalog），10 5 字节

⊃=⊃∘⌽

这是一个默认函数，需要为其指定一个名称，例如f←⊃=⊃∘⌽，然后将其命名为int f string。

感谢@Adám提供多达5个字节。

怎么运行的：

⊃=⊃∘⌽  ⍝ 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字节的答案已被删除。如果要查看它，请查看修订历史记录。

— J·萨莱
source
“它以一种非常规的方式获取输入” –以2元素输入作为APL中的左，右参数是完全标准的，并且总是可以接受的，除非OP出于某些奇怪的原因而特别禁止这样做。
— 约拿（Jonah）
@Jonah是的，聊天中的人启发了我。我按原样保留它是因为OP没有明确指出是否可以。当我回到PC时，我将对其进行编辑，以便较短的答案首先出现。
— J.Sallé17年
关于“隐式假设”：实际上，即使单调调用此函数也可以工作，然后将其1用作默认的left参数。在线尝试！函数不承担任何作用；之所以对它们进行二元应用，是因为它们既有左参数又有右参数。
— 亚当
@Adám我认为发生这种情况的原因是，当以单调方式调用时，⊃采用参数的第一个元素？无论如何，我将进行澄清。
— J.Sallé17年
3

V，26，16，13字节

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

在线尝试！

十六进制转储：

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索引）

十六进制转储：

00000000: c0f1 7824 787c f178 7624 6868 70d3 a82e  ..x$x|.xv$hhp...
00000010: a9b1 2f31 0af1 6c6c 5330                 ../1..llS0
— DJMcMayhem
source
在线尝试！ 这有点短。男人Àñx$x|ñ感觉像太多的字符。我只尝试了一个正则表达式，但结果却像24一样长！
— nmjcman101
1
@ nmjcman101事实证明，它可能比使用更新功能的要短得多。
— DJMcMayhem
哦，我没练习，我几乎不能再读V
— nmjcman101 '17
@ nmjcman101我已经发布了解释（并且打了更多的
— 高尔夫球
2

Mathematica，34个字节

s=StringTake;s[#,{#2}]==s[#,{-#2}]&
— J42161217
source
StringTake[#, #2]接受的第一个 #2字符#。StringPart在这种情况下会很好地工作。#~(s=StringPart)~-#2==s@##&
— JungHwan Min
我的错。固定！
— J42161217 '17
#~s~{#2}==#~s~{#2}&永远会屈服True……
— JungHwan Min
最终固定....！
— J42161217
1
其实，你可以采取List的StringS作为输入，这样#[[#2]]==#[[-#2]]&就足够了
— JungHwan民
2

Perl 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
source
2

Pyth，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

在线尝试！

— 吉姆
source
2

J，6个字节

-4字节归功于FrownyFrog

{(=|.)

参见原始答案说明-想法很相似，但这是通过二元钩完成的，其右动词本身就是一元钩。

在线尝试！

原始答案（10个字节）

{=/@(,:|.)

,:|. 右arg在反向右arg的顶部

=/ 它们在元素上是否相等？

{ 从该布尔列表中获取由左arg指示的索引

在线尝试！

— 约拿
source
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.
— 施滕伯格
source
1

> <>（使用此解释器），25个字节

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

它在TIO中不起作用：TIO解释器在执行[指令时不会反转新堆栈，但是fish操场可以— "abcde"5[ooooo;在此处和此处比较运行例如。

字符串输入取自STDIN，我们假设n已在堆栈中。使用1索引。

鱼使用来获得第n个字符[:}]&，该字符将堆栈中的前n个东西虹吸到一个新的反向堆栈中，对其进行一点操作，然后将其放回并保存 n寄存器个字符。然后，它反转整个堆栈并再次执行相同操作，如果两个字符相等，则返回1，否则返回0。

这似乎在TIO上有效，为26个字节：

i:0(?v
]&=n;>~{:}[{:}]&r[{
— 不是树
source
1

C，73个字节

使用GCC 6.3.1进行原样编译（无标志）。包括一些不必要的混淆。

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

用法

$./a.out abcdcba 6

真=无，假=垃圾。

— 西格瓦尔德姆
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.