介绍

让我们观察以下字符串：

ABCDEFGHIJKLMNOP

如果我们交换字符串的结尾，这些结尾是：

ABCDEFGHIJKLMNOP
^^            ^^

我们得到以下结果：

BACDEFGHIJKLMNPO

之后，我们删除字符串的结尾，在这种情况下为B和O。结果是：

ACDEFGHIJKLMNP

如果重复此过程，则会得到以下列表：

N     Result

2     ADEFGHIJKLMP
3     AEFGHIJKLP
4     AFGHIJKP
5     AGHIJP
6     AHIP
7     AP

您可以看到，对于N = 5，结果为AGHIJP。在N = 7时，字符串的长度小于3，因此在这种情况下N> 7被认为是无效的。

任务

给定的字符串小号与至少长度为4和重复数Ñ > 0，输出最终结果。您可以假设N始终有效。

测试用例

Input                               >  Output

N = 3, S = ABCDEFGHIJKLMNOP         >  AEFGHIJKLP
N = 1, S = Hello                    >  Hlo
N = 2, S = 123321                   >  11

这是代码高尔夫球，因此以最少的字节提交为准！为简单起见，您可以假定该字符串仅包含字母数字字符。

MATL，8 9 12 13字节

th"P[]2(

输入为：首先N是带引号的一元字符串（挑战允许）；第二个S是带引号的字符串（默认情况下允许使用字符串中的引号）；由换行符分隔。

这可以通过翻转字符串，删除其第二个元素并重复一遍来完成2*N。

在线尝试！

th       % implicitly take first input (N) as a unary string. Concatenate horizontally
         % with itself: gives a string of 2*N ones
"        % for each (i.e., repeat 2*N times)
  P      %   flip string. Take S implicitly as input the first time
  []     %   empty array (used as new contents)
  2      %   2 (used as index)
  (      %   assign [] to position 2 of string; that is, remove second element
         % implicitly end for each
         % implicitly display

视网膜，44 20字节

_{划掉44仍然是常规44 :(}

+`'(\w).(.*).\B
$1$2

假定以以下格式输入（一元-计数字符：）'：
{number of repeats}{string}
例如：'''''''ABCDEFGHIJKLMNOP
重复次数和字符串之间没有空格。

感谢@MartinBüttner删除了24个字节！

在线尝试！

Python 2，31个字节

lambda s,n:s[0]+s[n+1:~n]+s[-1]

我认为这可行吗？

Mathematica，29个字节

我的第一个答案！

#~Delete~{{2},{-2}}&~Nest~##&

无括号Mathematica的症结！函数输入是一个列表（字符列表或其他内容）和一个数字。

迷宫，40字节

<
,,}:?
.
;("   {(={}{".
,",;=};} }) "{@

输入N后跟字符串，用任何非数字字符分隔。

在线尝试！

这是与Sp3000协作编写的（这意味着我不必费心找出一个算法，因此他开始研究它，提出了118字节的解决方案，但是不费力打高尔夫球，所以我就打了高尔夫球。 ..对团队合作而言。

说明

Sp的常用底漆（通常稍加修改）：

• 迷宫是一种基于堆栈的2D语言，具有两个堆栈，主堆栈和辅助堆栈。几乎所有事情都发生在主堆栈上，但是您可以将值转移到另一个堆栈上，例如反转它们或将它们保存以备后用。
• 堆栈是无底的，并填充有零，因此从空堆栈弹出不会出错。
• 从第一个有效字符（此处为左上角）开始执行。在每个结点，有两条或更多条可能的指令指针（IP）可以采用的路径，将检查堆栈的顶部以确定下一步要走的地方。负向左转，零向前进，正向右转。虽然这样做的目的是使代码看起来像蜿蜒曲折的段落，但没有什么能阻止您创建“房间”，在每个房间检查这些条件。这些可能会产生不可预测的行为，但非常适合打高尔夫球。
• 可以在运行时修改源代码（以及迷宫的布局），使用<>^v该代码周期性地移动行或列或网格。
• " 没有人。

开始了。

该代码以开头<，这是我从一长串线性代码开始使用几次的高尔夫技巧。它将第一行循环左移，并带有IP，因此源看起来像这样：

              <
,,}:?
.
;("   {(={}{".
,",;=};} }) "{@

但是现在IP无法移动到任何地方，因此它将<再次执行。这一直持续到我们达到以下状态：

    <
,,}:?
.
;("   {(={}{".
,",;=};} }) "{@

此时，IP可以离开单元并开始执行从开始的第二行?。所以这是分解的线性代码：

?   # Read the first integer on STDIN, i.e. N.
:}  # Duplicate it and move one copy over to the auxiliary stack.
,   # Read the separator character.
,.  # Read the first character of the input string and directly print it.

IP现在进入3x2机房，实际上是两个紧密压缩（重叠）的2x2顺时针循环。第一个循环N-1从STDIN 读取并丢弃字符。

;   # Discard the top of the stack. On the first iteration, this is the
    # separator we've already read. On subsequent iterations this will be
    # one of the N-1 characters from the input string.
(   # Decrement N. If this hits zero, we leave the loop, otherwise we continue.
,   # Read the next character from STDIN to be discarded.

现在我们进入第二个循环，该循环读取输入字符串的其余部分。我们可以检测到EOF，因为在这种情况下,它将返回-1，从而使IP左转。

,   # Read a character. Exit the loop if EOF.
(   # Decrement it.

这个减量实际上并没有用，但是我们以后可以免费撤销它，这里它允许我们将两个循环重叠。

如果以5 ABCDEFGHIJKLMNOP输入为例，则堆栈如下所示：

Main [ ... 'E' 'F' 'G' 'H' 'I' 'J' 'K' 'L' 'M' 'N' 'O' -1  |  5 ... ] Auxiliary

请注意，这些实际上对应于输入字符FGHIJKLMNOP（因为我们将它们减少了），并且实际上我们不想打印其中的第一个N-1字符（我们只丢弃了字符，但想跳过N）。

现在有一个简短的线性位，可以为下一个循环准备堆栈：

;   # Discard the -1.
=   # Swap the tops of the stacks, i.e. N with the last character. 
    # By putting the last character on the auxiliary stack, we ensure that
    # it doesn't get discarded in the next loop.
}   # Move N over to the auxiliary stack as well.

堆栈现在看起来像：

Main [ ... 'E' 'F' 'G' 'H' 'I' 'J' 'K' 'L' 'M' 'N'  |  5 'O' ... ] Auxiliary

我们进入另一个2x2顺时针循环。这会丢弃N主堆栈中的前几个字符：

;   # Discard the top of the main stack.
{   # Pull N over from the auxiliary stack.
(   # Decrement it. It it's 0 we leave the loop.
}   # Push N back to the auxiliary stack.

当我们退出循环时=，它会0再次与输入字符串的最后一个字符交换。现在堆栈看起来像这样：

Main [ ... 'E' 'F' 'G' 'H' 'I' 'O'  |  ... ] Auxiliary

我们要从左侧开始打印主堆栈的内容（底部元素除外，所有元素都加1）。这意味着我们需要将其移至辅助堆栈。这就是下一个2x2（顺时针）循环的作用：

{   # Pull an element over from the auxiliary stack. This is necessary so we
    # have a 0 on top of the stack when entering the loop, to prevent the IP
    # from turning right immediately.
}   # Move the top of the main stack back to the auxiliary stack. If this was the
    # bottom of the stack, exit the loop.
)   # Increment the current character.
}   # Move it over to the auxiliary stack.

现在堆叠：

Main [ ...  |  'F' 'G' 'H' 'I' 'J' 'P] ... ] Auxiliary

我们使用将第一个（我们不想打印的）移回主堆栈{。现在，我们进入最后的2x2（逆时针）循环，该循环将打印其余部分：

{   # Pull another character over from the auxiliary stack. Exit the loop
    # if that's the zero at the bottom of the stack.
.   # Print the character.

最后，我们使用终止程序@。

JavaScript（ES6），39个字节

(s,n)=>s[0]+s.slice(++n,-n)+s.slice(-1)

原来我只是重塑了@ Sp3000的答案。

果冻，8个字节

Ḣ1¦UðḤ}¡

在线尝试！

怎么运行的

Ḣ1¦UðḤ}¡  Main link. Left input: S (string). Right input: N (deletions)

Ḣ         Pop the first element of S.
          This return the element and modifies S.
 1¦       Apply the result to the first index.
          This replaces the first character of the popped S with the popped char.
   U      Upend/reverse the resulting string.
    ð     Convert the preceding chain into a (dyadic) link.
     Ḥ}   Apply double to the right input.
          This yields 2N.
       ¡  Repeat the link 2N times.

果冻，10 字节

Ḣ;ṪjḊṖ$Ɠ¡F

通过STDIN输入数字，并通过命令行args输入字符串。感谢@Dennis提供了很多提示/帮助，使其可以正常工作（Jelly仍然使我难以理解）。

在线尝试！

Ḣ;Ṫ               Pop first and last chars of string and concatenate
   j              Join by...
       Ɠ¡           Execute n times...
    ḊṖ$               Drop first, drop last of string ($ combines the two monadically)
         F        Flatten to filter out empty lists, since Jelly's j is weird

Pyth，13个字节

++hz:zhQ_hQez

说明：

              - autoassign z = input()
              - autoassign Q = eval(input())
    :zhQ_hQ   -  z[Q+1:-(Q+1)]
++hz       ez - z[0]+^+z[-1]

在这里尝试

Vitsy，12 9（代码）+1（函数声明的换行符）= 10字节

\ o /

期望在堆栈上输入为字符串，后跟数字。

2*\[vXvr]
2*         Multiply by 2.
  \[    ]  Do the stuff in the brackets that many times. (input num * 2)
    v      Take the top item off the stack and save it as a local variable.
     X     Remove the top item of the stack.
      v    Push the temporary variable back onto the stack.
       r   Reverse the stack.

您可以通过以下方式致电：

'String' r <number> 1m Z
2*\[vXvr]

此函数将结果字符串保留在堆栈中。我在TryItOnline链接中将其作为程序提供。

TryItOnline！

Python 2，49 48字节

g=lambda s,n:n and g(s[0]+s[2:-2]+s[-1],n-1)or s

在这里用测试用例！

简单的递归解决方案。从输入字符串中删除第二个和最后一个第二个元素，并使用this和n-1直到它本身进行调用n=0。

编辑：觉得有点愚蠢，看着另一个python解决方案。猜猜我太喜欢递归了...

C，96字节

i;main(c,v,p)char**v,*p;{i=atoi(v[2])+1;c=strlen(p=v[1]);printf("%c%.*s%s",*p,c-2*i,p+i,p+c-1);}

不打高尔夫球

i; /* Param 2, the number of chars to remove */

main(c,v,p)char**v,*p;
{
    i=atoi(v[2])+1; /* convert param 2 to integer */
    c=strlen(p=v[1]); /* Length of the input */
    printf("%c%.*s%s",*p, /* Print the first char... */
        c-2*i, /* a number of characters equal to the length minus twice the input... */
        p+i, /* skip the "removed" chars... */
        p+c-1); /* Print the last character of the string */
}

Ruby，29个字节

->s,n{s[0]+s[n+1...~n]+s[-1]}

非常简单。

~从Sp的答案中偷走的花样，节省了一个字节s[n+1..-2-n]。（它之所以起作用是因为它~n是-1-n二进制补码，然后...是一个互斥范围。）

Perl，36 32 +1 = 33字节

for$i(1..<>){s;\B.(.+).(.);$1$2;}

需要-pflag并接受两行输入，最后有迭代次数：

$ perl -pe'for$i(1..<>){s;\B.(.+).(.);$1$2;}' <<< $'ABCDEFGHIJKLMNOP\n4'
AFGHIJKP

不打高尔夫球？

for $i ( 1..<> ) {
  s;
  \B.(.+).(.);$1$2;x
}

CJam，12个字节

q~{VW@)t(t}*

在线尝试！

怎么运行的

q~            Read and evaluate all input. This pushes S (string) and N (integer).
  {       }*  Do the following N times:
   VW           Push 0 and -1.
     @          Rotate S on top of them.
      )         Pop the last character of S.
       t        Set the item at index -1 to that character.
        (       Pop the first character of S.
         t      Set the item at index 0 to that character.

八度，28字节

@(S,N)S([1,N+2:end-N-1,end])

索引字符串，省略S(2:N+1)和S(end-N:end-1)。

样品在亚乙基酮上运行。

锈，135字节

好吧，那真是太可怕了。

fn f(s:&str,n:usize)->String{let s=s.as_bytes();s[..1].iter().chain(&s[n+1..s.len()-n-1]).chain(s.last()).map(|d|*d as char).collect()}

精美印刷：

fn f(s: &str, n: usize) -> String {
    let s = s.as_bytes();
    s[..1].iter()
          .chain(&s[n+1..s.len()-n-1])
          .chain(s.last())
          .map(|d| *d as char)
          .collect()
}

如果我们允许使用字节串而不是适当的字符串，则可以将其减少到104个字节。

fn f(s:&[u8],n:usize)->Vec<u8>{let mut r=vec![s[0]];r.extend(&s[n+1..s.len()-n-1]);r.extend(s.last());r}

精美印刷：

fn f(s: &[u8], n: usize) -> Vec<u8> {
    let mut r = vec![s[0]];
    r.extend(&s[n+1..s.len()-n-1]);
    r.extend(s.last());
    r
 }

好奇是否有人可以做得更好。

mSL-137字节

c {
%l = $len($1)
return $mid($+($mid($1,2,1),$left($1,1),$right($left($1,-2),-2),$right($1,1),$mid($1,$calc(%l -1),1)),2,$calc(%l -2))
}

说明：

%l = $len($1) 将获取输入字符串的长度并将其保存在名为l的变量中

$right(<input>,<length>)并且$left(<input>,<length>可用于分别返回原始字符串的最左或最右部分。$ left总是从最左边开始返回文本，而$ right总是从右边开始返回文本。如果指定的长度为负数，则$ left和$ right会返回整个文本减去相应侧面的许多字符。

$mid(<string>,<start>,[length])用于从字符串中间获取子字符串。Start是从左侧开始的子字符串的开始。负值表示从右开始。在这两种情况下，都可以指定一个可选的长度。负长度可用于从末尾删除那么多字符。因此，我使用它通过使用输入字符串的长度来检索第二个字符和倒数第二个字符。

$calc(<input>) 用于执行数学计算

截至尚未命名的语言（如此新的非竞争性语言）开始，为9个字节

hD_RQ:Q|J

你可以找到源代码 此处，语言是完全不稳定的（这是它的第一个测试挑战），所以不要指望它将来会起作用（commit 7）

这是一种基于堆栈的语言，具有可在堆栈中添加和删除对象的功能。当前有2个堆栈操作命令：D将堆栈顶部重复N次）和R（旋转堆栈上顶部N个项目）

说明：

          - autoassign Q = eval_or_not(input()) (string)
h         - imp_eval_input()+1
 D        - duplicate(^)
  _       - neg(^)
   R      - rotate(^)
    Q:    - Q[^:^]
      Q|  - Q[0], Q[-1]
        J - "".join(all)

CJam，14个字节

l(o)\l~_W*@<>o

在这里测试。

说明

l   e# Read the input string.
(o  e# Pull off the first character and print it.
)\  e# Pull off the last character and swap with the rest of the string.
l~  e# Read the second line of the input and evaluate it (N).
_   e# Duplicate.
W*  e# Multiply by -1 to get -N.
@   e# Pull up the string.
<   e# Discard the last N characters.
>   e# Discard the first N characters.
o   e# Output what's left. The last character of the input is now still on the
    e# stack and is automatically printed at the end of the program.

Vim，27个字节

o0lxehx <ESC>"ay0ddA@a<ESC>B"bdWx@b

输入应采用以下形式 STRING N采用第一行，且没有其他字符。

说明：

#Write a macro to do one round of the swap and delete and save to register a
o0lxehx <ESC>"ay0dd

#Append register a to N and save in register B so it will run @a N times.
A@a<ESC>B"bdWx

# Actually run the macro
@b

Brainfuck，130个字节

我的第一个PPCG参赛作品！

显然不会赢，但是嘿。

输入类似：4ABCDEFGHIJKL的输入，第一个字符为N。

,>+++++++[<------->-]<+>>+[>,]<[<]>-<<[>>>[<+>-]>[<+>-]<<[>>+<<-]>[>]<[>+<-]<[>+<-]>>[<<+>>-]<[-]<[<]>[-]>[[<+>-]>]<<[<]<<-]>>>[.>]

在这个很棒的网站上进行测试。

限制为N小于或等于9，因为两位数是一个麻烦。

编辑：我吸了它，并增加了对两位数的支持。用零填充以表示单个数字。

,>+++++++[<------->-]<+ [>++++++++++<-]>[<+>-],>+++++++[<------->-]<+ [<+>-]>+[>,]<[<]>-<<[>>>[<+>-]>[<+>-]<<[>>+<<-]>[>]<[>+<-]<[>+<-]>>[<<+>>-]<[-]<[<]>[-]>[[<+>-]>]<<[<]<<-]>>>[.>]

Perl，27个字节

包括+1 -p

运行为 perl -p sdr.pl

输入在STDIN上给出，第一行是字符串，第二行是计数假定字符串仅包含“单词”字符

sdr.pl：

eval's%\B.(.*).\B%$1%;'x<>

PHP，60字节

此解决方案通过索引将字符从输入字符串迭代设置为空字符串。我直接操纵输入字符串以防止long return。

function(&$w,$i){for(;$i;)$w[$i--]=$w[strlen($w)-$i-2]="";};

完成后，基本上在内存中$w看起来像这样：

Addr 0 1 2 3 4
     H   l   o
     ^   ^   ^
>Result: Hlo

像这样运行：

php -r '$f = function(&$w,$i){for(;$i;)$w[$i--]=$w[strlen($w)-$i-2]="";}; $f($argv[1],$argv[2]);echo"$argv[1]\n";' Hello 1

定向塔，16字节。

i:At,{\,v\,v,A}c

怎么运行的：

i    # Get command line input.
:At  # Set A equal to the top of the stack.
,    # Pop the stack.
{    # Start a for loop.
 \   # Swap the top two elements of the stack.
  ,  # Pop the stack.
   v # Reverse the stack.
 \   # Swap the top two elements of the stack.
  ,  # Pop the stack.
   v # Reverse the stack.
 ,   # Switch to loop iterations.
 A   # Iterate A times.
}    # End the for loop.
c    # Print the stack as a string

CJam，15个字节

r(\)\{(;);}ri*\

我确信有可能进一步打高尔夫球...

Jolf，13个字节

ΆFi liγhj_γgi

JavaScript答案的翻版。

说明：

ΆFi liγhj_γgi
Ά             ternary add
 Fi            i[0],
   `li         i sliced
      γhj       γ = j + 1
         _γ     to -γ
           gi  and the last of i

在这里尝试！

问题后更有趣的版本：

 ΆFi]ihjYgi

认真地，17个字节

,#,`p@pXod@dXq`nΣ

将输入作为s \n n。

在线尝试！

说明：

,#,`p@pXod@dXq`nΣ
,#                 push a list of characters in s
  ,`          `n   do the following n times:
    p@pXo          pop 2 characters off the front, discard the second, put the first back
         d@dXq     pop 2 characters off the back, discard the second, put the first back
                Σ  join

C＃，129个字节

因为我们基本上跳过1并删除N和相反的情况

string o(string i,int n){var s=i.ToList();int x=0;while(x<2){s.RemoveRange(1,n);s.Reverse();x++;}return new string(s.ToArray());}

不打高尔夫球

string o(string i, int n)
{
    var s = i.ToList();
    int x = 0;
    while (x < 2) //Repeat the following twice
    {
        s.RemoveRange(1, n); //remove n at index 1
        s.Reverse(); //Reverse the list
        x++;
    }
    return new string(s.ToArray());
}

Java，144个字节

static String y(int i,String s){return i==0?s:y(i-1,new StringBuffer(s).replace(1,2,"").replace(s.length()-3,s.length()-2,"").toString());}