Introdução

Vamos observar a seguinte string:

ABCDEFGHIJKLMNOP

Se trocarmos as extremidades da string , quais são:

ABCDEFGHIJKLMNOP
^^            ^^

Temos o seguinte resultado:

BACDEFGHIJKLMNPO

Depois disso, excluímos as extremidades da string, que neste caso são Be O. O resultado é:

ACDEFGHIJKLMNP

Se repetirmos o processo, obteremos a seguinte lista:

N     Result

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

Você pode ver que para N = 5 , o resultado é AGHIJP. Em N = 7 , o comprimento da string é menor que 3 , portanto, N> 7 é considerado inválido nesse caso.

A tarefa

Dada uma sequência S com pelo menos o comprimento 4 e o número de repetições N > 0, produz o resultado final. Você pode assumir que N é sempre válido .

Casos de teste

Input                               >  Output

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

Isso é código-golfe , então a submissão com a menor quantidade de bytes ganha! Para simplificar, você pode assumir que a sequência conterá apenas caracteres alfanuméricos .

MATL , 8 9 12 13 bytes

th"P[]2(

As entradas são: primeiro Ncomo uma string unária com aspas (permitida pelo desafio); segundo Scomo uma string com aspas (aspas em strings são permitidas por padrão); separados por uma quebra de linha.

Isso funciona invertendo a string, removendo seu segundo elemento e repetindo-o por um total de 2*Nvezes.

Experimente online!

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

Retina , 44 20 bytes

_{Riscado 44 ainda é regular 44 :(}

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

Assume a entrada no seguinte formato (em caracteres de contagem unária:) ':
{number of repeats}{string}
Por exemplo: '''''''ABCDEFGHIJKLMNOP
Não há espaço entre o número de repetições e a sequência.

Obrigado @ MartinBüttner por remover 24 bytes!

Experimente online!

Python 2, 31 bytes

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

Eu acho que isso funciona?

Mathematica, 29 bytes

Minha primeira resposta!

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

O ponto crucial do Mathematica sem suporte! As entradas de função são uma lista (de caracteres ou qualquer outra coisa) e um número.

Labirinto , 40 bytes

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

A entrada é Nseguida pela sequência, separada por qualquer caractere não numérico.

Experimente online!

Isso foi escrito em colaboração com o Sp3000 (o que significa que eu não me incomodei em descobrir um algoritmo, então ele começou a trabalhar nele, veio com uma solução de 118 bytes, mas não se incomodou em jogar golfe, então fiz o golfe. .. sim pelo trabalho em equipe).

Explicação

Primário usual de Sp (como de costume ligeiramente modificado):

• Labyrinth é uma linguagem 2D baseada em pilha com duas pilhas, principal e auxiliar. Praticamente tudo acontece na pilha principal, mas você pode mudar os valores para a outra, por exemplo, para revertê-los ou salvá-los para mais tarde.
• As pilhas não têm fundo e são preenchidas com zeros, portanto, saltar de uma pilha vazia não é um erro.
• A execução começa a partir do primeiro caractere válido (aqui, no canto superior esquerdo). Em cada junção, onde há dois ou mais caminhos possíveis para o ponteiro de instrução (IP) seguir, a parte superior da pilha é verificada para determinar para onde seguir. Negativo é virar à esquerda, zero é avançar e positivo é virar à direita. Embora isso tenha o objetivo de fazer o código parecer passagens sinuosas e sinuosas, não há nada que o impeça de criar "salas" onde essas condições são verificadas em todas as células. Aqueles podem produzir um comportamento bastante imprevisível, mas são ótimos para jogar golfe.
• O código fonte (e, portanto, o layout do labirinto) pode ser modificado em tempo de execução usando o <>^vque alterna ciclicamente uma linha ou coluna ou a grade.
• " são no-ops.

Aqui vamos nós.

O código começa no <, que é um truque de golfe que eu usei algumas vezes ao começar com um longo pedaço de código linear. Ele desloca a primeira linha ciclicamente para a esquerda, com o IP , para que a fonte fique assim:

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

Mas agora o IP não pode ser movido para lugar algum, portanto, ele executa <novamente. Isso continua até chegarmos a este estado:

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

Nesse ponto, o IP pode deixar a célula e começar a executar a segunda linha começando no ?. Então aqui está o código linear dividido:

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

O IP agora entra nesta sala 3x2, que na verdade é dois loops 2x2 no sentido horário compactados (sobrepostos). O primeiro loop lê e descarta N-1caracteres de 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.

Agora entramos no segundo loop que lê o restante da string de entrada. Podemos detectar o EOF porque ,retornará -1nesse caso, fazendo com que o IP vire à esquerda.

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

Esse decremento não é realmente útil, mas podemos desfazê-lo mais tarde de graça e aqui nos permite sobrepor os dois loops.

Se tomarmos a 5 ABCDEFGHIJKLMNOPentrada como exemplo, a pilha será assim:

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

Observe que eles realmente correspondem aos caracteres de entrada FGHIJKLMNOP(porque os diminuímos) e que na verdade não queremos imprimir o primeiro deles (apenas descartamos os N-1caracteres, mas queremos pular N).

Agora há um pequeno bit linear que prepara a pilha para o próximo loop:

;   # 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.

As pilhas agora se parecem com:

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

Entramos em outro loop 2x2 no sentido horário. Isso descarta os principais Ncaracteres da pilha principal:

;   # 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.

Quando saímos do loop, =trocamos esse 0e o último caractere da string de entrada novamente. Agora as pilhas ficam assim:

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

Queremos imprimir o conteúdo da pilha principal (exceto o elemento inferior e todos incrementados em 1), a partir da esquerda . Isso significa que precisamos transferi-lo para a pilha auxiliar. É isso que o próximo loop 2x2 (no sentido horário) faz:

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

Pilhas agora:

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

Movemos o primeiro desses (aquele que não queremos imprimir) de volta para a pilha principal {. E agora entramos no loop final 2x2 ( sentido anti-horário ), que imprime o restante:

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

Finalmente encerramos o programa com @.

JavaScript (ES6), 39 bytes

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

Acontece que eu apenas reinventei a resposta do @ Sp3000.

Gelatina, 8 bytes

Ḣ1¦UðḤ}¡

Experimente online!

Como funciona

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

Gelatina , 10 bytes

Ḣ;ṪjḊṖ$Ɠ¡F

Insira o número via STDIN e a string via linha de comando args . Obrigado ao @Dennis por muitas dicas / ajuda para que isso funcione (a Jelly ainda me escapa).

Experimente online!

Ḣ;Ṫ               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

Pitão, 13 bytes

++hz:zhQ_hQez

Explicação:

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

Experimente aqui

Vitsy, 12 9 (código) + 1 (nova linha para declaração de função) = 10 bytes

\ o /

Espera a entrada na pilha como a sequência seguida pelo número.

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.

Com o qual você pode ligar:

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

Essa é uma função que deixa a sequência resultante na pilha. Eu o forneci como um programa no link TryItOnline.

TryItOnline!

Python 2, 49 48 bytes

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

Experimente aqui com casos de teste!

Solução recursiva simples. Remove o segundo e o último segundo elemento da string de entrada e se chama com isso e n-1até n=0.

edit: Sentindo-se meio idiota, olhando para a outra solução python . Acho que gosto muito de recursão ...

C, 96 bytes

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);}

Ungolfed

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 bytes

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

Muito simples.

~truque roubado da resposta de Sp , que economiza um byte s[n+1..-2-n]. (Funciona porque ~né -1-num complemento de dois e, em seguida, ...é um intervalo exclusivo.)

Perl, 36 32 + 1 = 33 bytes

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

Requer -psinalizador e recebe entrada em duas linhas, com número de iterações no final:

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

Ungolfed?

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

CJam, 12 bytes

q~{VW@)t(t}*

Experimente online!

Como funciona

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.

Oitava, 28 bytes

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

Índice a cadeia, omitindo S(2:N+1)e S(end-N:end-1).

Amostra executada em ideone .

Ferrugem, 135 bytes

Bem, essa é uma duração bastante terrível.

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()}

Pretty-impresso:

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()
}

Você pode reduzi-lo a 104 bytes se permitirmos bytestrings em vez de strings apropriadas.

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}

Pretty-impresso:

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
 }

Curioso se alguém puder fazer melhor.

mSL - 137 bytes

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))
}

Explicação:

%l = $len($1) obterá o comprimento da string de entrada e a salvará na variável chamada l

$right(<input>,<length>)e $left(<input>,<length>pode ser usado para retornar a maior parte esquerda ou direita da string original de forma respeitável. $ left sempre retorna texto começando do lado esquerdo, enquanto $ right sempre retorna texto começando do lado direito. Se o comprimento especificado for um número negativo, $ left e $ right retornam o texto inteiro menos o número de caracteres de seus respectivos lados.

$mid(<string>,<start>,[length])é usado para obter uma substring no meio da string. Iniciar é o início da substring a partir da esquerda. Um valor negativo indica um início da direita. Nos dois casos, um comprimento opcional pode ser especificado. Um comprimento negativo pode ser usado para remover tantos caracteres do final. Então, usei-o para recuperar o segundo caractere e o segundo último caractere usando o comprimento da string de entrada.

$calc(<input>) é usado para executar cálculos matemáticos

No idioma ainda sem título (tão novo e não competitivo), 9 bytes

hD_RQ:Q|J

Você pode encontrar o código fonte aqui , a linguagem é completamente instável (primeiro desafio de teste), portanto, não espere que ela funcione no futuro (commit 7)

Este é um idioma baseado em pilha com funções que adicionam e removem objetos da pilha. Atualmente, existem 2 comandos de manipulação de pilha: D(duplique a parte superior da pilha N vezes) e R(gire os N itens principais na pilha)

Explicação:

          - 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 bytes

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

Teste aqui.

Explicaçã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 bytes

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

A entrada deve estar no formulário STRING Nna primeira linha sem outros caracteres.

Explicação:

#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 bytes

Minha primeira entrada no PPCG!

Obviamente não vai ganhar, mas ei.

Recebe entradas como: 4ABCDEFGHIJKL, com o primeiro caractere sendo N.

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

Teste neste site maravilhoso.

Limitado a N menor ou igual a 9, porque números de dois dígitos são um problema.

EDIT: Eu peguei e adicionei suporte para números de dois dígitos. Almofada com zero para dígitos únicos.

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

Perl, 27 bytes

Incluir +1 para -p

Correr como perl -p sdr.pl

Entrada fornecida em STDIN, primeira linha da string, segunda linha da contagem Assume que a string contém apenas caracteres "word"

sdr.pl:

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

PHP, 60 bytes

Esta solução define iterativamente os caracteres da sequência de entrada como uma sequência vazia pelo índice. Estou manipulando a string de entrada diretamente para evitar um longo return.

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

Basicamente, a memória $wfica assim quando concluída:

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

Execute assim:

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

Pilões , 16 bytes.

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

Como funciona:

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 bytes

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

Tenho certeza de que é possível jogar golfe ainda mais ...

Jolf, 13 bytes

ΆFi liγhj_γgi

Uma tradução da resposta JavaScript.

Explicação:

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

Experimente aqui!

Uma versão pós-pergunta mais interessante:

 ΆFi]ihjYgi

Sério, 17 bytes

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

Toma entrada como s \n n.

Experimente online!

Explicação:

,#,`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 bytes

Como basicamente pulamos 1 e removemos N e o cenário reverso

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());}

destroçado

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 bytes

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());}