给定根据此挑战生成的回文，请对其进行去盲化。

测试用例

abcdedcba -> abcde
johncenanecnhoj -> johncena
ppapapp -> ppap
codegolflogedoc -> codegolf

因为这是关于去palindromating的，所以您的代码不能是回文。

请记住，这是code-golf，所以字节最少的代码将获胜。

code-golf restricted-source palindrome

— 倪
source

23

-1表示对不是回文的代码没有任何限制。它对IMO的挑战丝毫没有增加，只用很少的语言就可以了。

— Rɪᴋᴇʀ

25

+1表示限制。它是如此地反映了回教症的挑战……并为依兰族人增加了挑战。我喜欢。在输入将始终具有不均匀长度的假设下，我是否正确？

— 泰特斯

42

基于先前的挑战，非回文限制可能是个玩笑。有人真的基于此否决了吗？

— 路易斯·门多

5

它确实阻止了单字节解决方案。@diynevala +1表示不必要的+1。

— 亚当

5

如果字符串不是开头的回文怎么办？

— Xavon_Wrentaile

14

朱莉娅21 15字节

x->x[1:end/2+1]

在线尝试！（额外的代码用于打印输出）

— Rɪᴋᴇʀ
source

2

end/2很酷的功能

— Downgoat，2016年

@Downgoat是的，丹尼斯向我展示了它。

— Rɪᴋᴇʀ

12

05AB1E，3个字节

2ä¬

使用CP-1252编码。在线尝试！

— 阿德南
source

6

Python 2，23个字节

我无法在手机上进行测试，但这应该可以：

lambda s:s[:-~len(s)/2]

— 卡德
source

2

如果您在android上运行，则可以从Google Play商店使用QPython。这是我发现的最好的东西：）

— Yttsi '16

termux apt-get install python2

— 马特

@Matt如果您只想要Python，那就太过分了。

— mbomb007 '16

@Matt以及如果您可以apt-get在手机上找到它，那可能不是普通的手机。

— 合法的懒惰

@MathManiac termux已从Google Play安装到任何非root用户的Android手机上。没有比这更正常的了。

— 马特

6

Fuzzy Octo鳄梨酱，4字节

2.^/

我花了一段时间寻找这种挑战很短的语言，然后意识到自己很笨，我自己的语言做到了。

— Rɪᴋᴇʀ
source

5

05AB1E，5个字节

Dg;î£

在线尝试！

说明：

D      Duplicate
 g;î   Divide length by two and round up
    £  First b letters of a

— 杂种
source

5

Cheddar，22个 18字节

@.head($0.len/2+1)

如此简单，我认为不需要解释，但如果需要，我将添加一个。

在线尝试

— 下山羊
source

4

Pyth-4个字节

hc2Q

测试套件。

— 马尔蒂森
source

4

JavaScript（ES6），32 26 25字节

感谢Neil，节省了1个字节：

s=>s.slice(0,-s.length/2)

显示代码段

f=
  s=>s.slice(0,-s.length/2)
;
console.log(f('abcdedcba'))
console.log(f('johncenanecnhoj'))
console.log(f('ppapapp'))
console.log(f('codegolflogedoc'))

展开摘要

由于Downgoat，先前的解决方案有 26个字节：

s=>s.slice(0,s.length/2+1)

32个字节：

s=>s.slice(0,(l=s.length/2)+l%2)

— 赫迪
source

1

您可以缩短到仅此，s=>s.slice(0,s.length/2+1)因为长度总是很奇怪

— Downgoat

@Downgoat多亏了您，我发现再多一个字节s=>s.slice(0,s.length/2+.5)也可以使长度均匀。

— Hedi

2

-s.length/2适用于奇数和偶数长度。

— 尼尔

4

WinDbg，87 71字节

db$t0 L1;.for(r$t1=@$t0;@$p;r$t1=@$t1+1){db$t1 L1};da$t0 L(@$t1-@$t0)/2

不插入NULL，而是将长度传递给-16个字节 da

输入通过psuedo-register中的地址传递$t0。例如：

eza 2000000 "abcdedcba"       * Write string "abcdedcba" into memory at 0x02000000
r $t0 = 33554432              * Set $t0 = 0x02000000
* Edit: Something got messed up in my WinDB session, of course r $t0 = 2000000 should work
* not that crazy 33554432.

它的工作原理是将中间字符的右边（如果字符串的长度为偶数，则替换为中间字符的右边）为null，然后从原始的起始内存地址打印该字符串。

db $t0 L1;                                   * Set $p = memory-at($t0)
.for (r $t1 = @$t0; @$p; r $t1 = @$t1 + 1)   * Set $t1 = $t0 and increment until $p == 0
{
    db $t1 L1                                * Set $p = memory-at($t1)
};
da $t0 L(@$t1-@$t0)/2                        * Print half the string

输出：

0:000> eza 2000000 "abcdeedcba"
0:000> r $t0 = 33554432
0:000> db$t0 L1;.for(r$t1=@$t0;@$p;r$t1=@$t1+1){db$t1 L1};da$t0 L(@$t1-@$t0)/2
02000000  61                                               a
02000000  61                                               a
02000001  62                                               b
02000002  63                                               c
02000003  64                                               d
02000004  65                                               e
02000005  65                                               e
02000006  64                                               d
02000007  63                                               c
02000008  62                                               b
02000009  61                                               a
0200000a  00                                               .
02000000  "abcde"

— 牛奶
source

3

Haskell，27个字节

take=<<succ.(`div`2).length

点的免费版

\x->take(div(length x)2+1)x

也是27个字节

— 妮米
source

3

MATL，7 6字节

9LQ2/)

在线尝试！

说明

9L       % Push array [1, 1j]
  Q      % Add 1: transforms into [2, 1+1j]
   2/    % Divide by 2: transforms into [1, 0.5+0.5j]
     )   % Apply as index into implicit input. The array [1, 0.5+0.5j] used as an index
         % is interpreted as [1:0.5+end*0.5]

— 路易斯·门多
source

1

哇，这是将复杂值作为切片参数的一种非常巧妙的方式

— 英里

@miles谢谢！是的，很方便。虚部的工作方式为end，并且数组元素之间的冒号是隐式的

— Luis Mendo

3

果冻，4字节

œs2Ḣ

在线尝试！

说明

œs2      Split input into 2 chunks of similar lengths. For odd-length input,
         the first chunk is the longest
   Ḣ     Keep the first chunk

— 路易斯·门多
source

3

V，12个字节

两种完全不同的解决方案，均为12个字节。

ò"Bx$xh|ò"bP

在线尝试！

Ó./&ò
MjdGÍî

在线尝试！

— DJMcMayhem
source

3

Brachylog，4个字节

@2tr

在线尝试！

说明

@2        Split in half
  t       Take the second half
   r      Reverse it

如果输入的长度为奇数，则由生成的后一半@2是最长的那一半，也就是我们应该返回的那一半（反转后）。

— 致命
source

3

Dyalog APL，9 个字节

⊢↑⍨2÷⍨1+≢

⊢ 论点

↑⍨ 被截断

2÷⍨ 一半

1+ 一加

≢ 长度

在线尝试APL！

— 亚当
source

3

Perl，15个字节

包括+2 -lp

在STDIN上输入输入字符串：

depal.pl <<< "HelleH"

depal.pl：

#!/usr/bin/perl -lp
s/../chop/reg

-l如果您不输入最后的换行符而输入回文式，则不是真正需要的，但是我将其包括在内对其他使用它的perl解决方案来说是公平的。

— 吨·霍斯佩尔
source

3

Java 7，57字节

String c(String s){return s.substring(0,s.length()/2+1);}

— 数字结
source

您缺少结束语}（因此为57个字节）。

— 凯文·克鲁伊森

1

@KevinCruijssen已修复。

— Numberknot

2

TI-Basic，14个字节

标准功能。返回从索引1到索引的字符串（长度/ 2 + 1/2）。

sub(Ans,1,.5+.5length(Ans

— 添泰
source

2

GameMaker语言，59个字节

a=argument0 return string_copy(a,1,ceil(string_length(a)/2)

— 添泰
source

2

PHP，40个字节

<?=substr($a=$argv[1],0,1+strlen($a)/2);

strlen($a)/2被强制转换为int，并且输入始终具有奇数长度，+1足以将其舍入。

任何长度的42个字节：

<?=substr($a=$argv[1],0,(1+strlen($a))/2);

对于未知长度，(1+strlen)/2将其强制转换为int并四舍五入strlen/2。

— 提图斯
source

由于将输入定义为来自此（codegolf.stackexchange.com/questions/98325/…）质询，因此长度总是奇数，因此您可以选择较短的长度。

— user59178 '16

2

Dip，8个字节

H{C'0ÏEI

说明：

           # Implicit input
 H         # Push length of input
  {        # Add 1
   C       # Divide by 2
    '      # Convert to int
     0Ï    # Get string back
       E   # Push prefixes of string
        I  # Push prefixes[a]
           # Implicit print

这可能会大大改善。

— 倪
source

2

Perl，23 + 2（`-pl`标志）= 28 25字节

perl -ple '$_=substr$_,0,1+y///c/2'

取消高尔夫：

while (<>) {             # -p flag
    chomp($_)            # -l flag
    $_ = substr($_, 0, 1 + length($_) / 2);
    print($_, "\n")      # -pl flag
}

感谢@ardnew。

— 丹尼斯·伊巴耶夫（Denis Ibaev）
source

1

您可以通过替换length()为y|||c

— ardnew

2

Befunge，24 22字节

~:0`!#v_\1+
0:-2,\_@#`

在线尝试！

Befunge没有字符串或数组类型，因此所有操作一次只在堆栈上完成一个字符。第一个循环（在第一行）计算读取的字符数（交换堆栈中少于2个元素将产生一个初始0）。第二个（在中间一行）打印字符，同时倒数的速度是原来的两倍。结果，仅打印输入的最后一半，但是打印了LIFO，因此输入顺序正确。

感谢Brian Gradin为第一个循环提供了更好的版本。

— 莱纳斯
source

1

您可以通过一个半小时和7个字节打我:) befunge.tryitonline.net/...

— 布赖恩·格拉丁

@BrianGradin，很好。现在我已经击败了您9个字节；）

— Linus

喔好吧。我明白你的所作所为。我没有想到要倒数两个而不是计算要打印的实际字符数。做得很好。

— Brian Gradin '16

2

Perl，14 + 3（`-lF`标志）= 19 17个字节

对于5.20.0+：

perl -lF -E 'say@F[0..@F/2]'

对于5.10.0+（19字节）：

perl -nlaF -E 'say@F[0..@F/2]'

取消高尔夫：

while (<>) {             # -n flag (implicitly sets by -F in 5.20.0+)
    chomp($_)            # -l flag
    @F = split('', $_);  # -aF flag (implicitly sets by -F in 5.20.0+)
    say(@F[0 .. (scalar(@F) / 2)]);
}

感谢@simbabque。

— 丹尼斯·伊巴耶夫（Denis Ibaev）
source

2

您可以保存两个字节，不需要设置-n，-a因为-F这样做是隐式的。

— simbabque

@simbabque是的。但仅适用于5.20.0+。

— Denis Ibaev

2

Brainfuck，20个字节

,
[
  [>,]
  <[<]
  >.,>[>]
  <<
]

在线尝试。

与在启动主循环之前使用输入的更直接方法相比，这节省了一个字节：

,[>,]
<
[
  [<]
  >.,>[>]
  <,<
]

— 米奇·施瓦兹（Mitch Schwartz）
source

2

Pyth，8 7字节

<zh/lz2

感谢@Steven H，节省了1

不是最短的Pyth答案（一半），但是我正在努力学习该语言，这是我第一次使用它。尽可能多地发表评论和反馈。这也是我真正开始工作的第一个Pyth程序:)

现在我只需要计算@Maltysen的4字节答案是如何工作的:-)

— 埃尔佩德罗
source

1

如果您仍然想知道Maltysen的答案是如何工作的，它会将c输入Q分成2几部分，并使用来提取第一部分h（由于使用了chop的实现，它也将获取中心字母）。至于您的代码，您可以将替换+1为h，用于数字递增的内置函数。

— 史蒂文H.

感谢您的解释和h@Steven H 的提示。有太多内置函数，我想找到它们都需要一些时间:)

— ElPedro

1

没问题！如果您需要任何帮助，请尝试在第19个字节中对我执行ping操作。

— 史蒂文H.

2

实际上，5个字节

l½KßH

在线尝试！

-1字节感谢Sherlock9

说明：

l½K@H
l½K    ceil(len(input)/2)
   ßH  first (len(input)//2 + 1) characters of input

— Mego
source

6个字节：: ;l½K@HD

— Sherlock9

2

C，31 30字节

由于Cyoce，节省了1个字节。

f(char*c){c[-~strlen(c)/2]=0;}

用法：

main(){
 char a[]="hellolleh";
 f(a);
 printf("%s\n",a);
}

— 卡尔·纳普夫
source

@KevinCruijssen已修复

— Karl Napf '16

嗨，抱歉，我删除了我的评论。我说这对回文症不起作用是正确的。但是，由于这是其他挑战的反面，因此即使是回文集也不会有任何测试用例。很抱歉，您可以撤消更改。向我+1。:)

— Kevin Cruijssen '16

2

好吧，它现在的长度是一样的，适用于奇偶且看起来像高尔夫球手。我对此很好。

— Karl Napf '16

可以说这是内存泄漏:-)

— ShreevatsaR

1

我认为您可以删除char* c

— Cyoce

1

Python 2，23个字节

lambda x:x[:len(x)/2+1]

— Rɪᴋᴇʀ
source

我认为这需要Python 2；您应该在回答中指出这一点

— Luis Mendo

@LuisMendo哦，谢谢！

— Rɪᴋᴇʀ

1

MATLAB /八度，20 19 18 16字节

从@Easterly Irk的答案中借用一个想法1.5可以节省1个字节（添加而不是）
感谢@StewieGriffin（不需要的括号）可以减少2个字节

@(x)x(1:end/2+1)

在Ideone尝试一下。

— 路易斯·门多
source

@StewieGriffin谢谢！我不知道自己在想什么...

— 路易斯·门多

我也不：P也不是您不知道的“把戏” ...我也有一些:)

— Stewie Griffin

去palindromize此字符串！

测试用例

朱莉娅21 15字节

05AB1E，3个字节

Python 2，23个字节

Fuzzy Octo鳄梨酱，4字节

05AB1E，5个字节

Cheddar，22个 18字节

Pyth-4个字节

JavaScript（ES6），32 26 25字节

WinDbg，87 71字节

Haskell，27个字节

MATL，7 6字节

说明

果冻，4字节

说明

V，12个字节

Brachylog，4个字节

说明

Dyalog APL，9 个字节

Perl，15个字节

Java 7，57字节

TI-Basic，14个字节

GameMaker语言，59个字节

PHP，40个字节

Dip，8个字节

Perl，23 + 2（-pl标志）= 28 25字节

Befunge，24 22字节

Perl，14 + 3（-lF标志）= 19 17个字节

Brainfuck，20个字节

Pyth，8 7字节

实际上，5个字节

C，31 30字节

Python 2，23个字节

MATLAB /八度，20 19 18 16字节

Perl，23 + 2（`-pl`标志）= 28 25字节

Perl，14 + 3（`-lF`标志）= 19 17个字节