Introducción

Observemos la siguiente cadena:

ABCDEFGHIJKLMNOP

Si intercambiamos los extremos de la cadena , que son estos:

ABCDEFGHIJKLMNOP
^^            ^^

Obtenemos el siguiente resultado:

BACDEFGHIJKLMNPO

Después de eso, eliminamos los extremos de la cadena, que en este caso son By O. El resultado es:

ACDEFGHIJKLMNP

Si repetimos el proceso, obtenemos la siguiente lista:

N     Result

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

Puedes ver que para N = 5 , el resultado es AGHIJP. En N = 7 , la longitud de la cadena es menor que 3 , por lo que N> 7 se considera inválido en este caso.

La tarea

Dada una cadena S con al menos longitud 4 y el número de repeticiones N > 0, se obtiene el resultado final. Puede suponer que N siempre es válido .

Casos de prueba

Input                               >  Output

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

Este es el código de golf , por lo que gana el envío con la menor cantidad de bytes. Por simplicidad, puede suponer que la cadena solo contendrá caracteres alfanuméricos .

MATL , 8 9 12 13 bytes

th"P[]2(

Las entradas son: primero Ncomo una cadena unaria con comillas (permitidas por el desafío); segundo Scomo una cadena con comillas (las comillas en cadenas están permitidas por defecto); separados por un salto de línea.

Esto funciona volteando la cadena, eliminando su segundo elemento y repitiendo un total de 2*Nveces.

Pruébalo en línea!

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

_{Tachado 44 sigue siendo regular 44 :(}

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

Asume la entrada en el siguiente formato (en carácter de conteo unario:) ':
{number of repeats}{string}
Por ejemplo: '''''''ABCDEFGHIJKLMNOP
no hay espacio entre el número de repeticiones y la cadena.

¡Gracias @ MartinBüttner por eliminar 24 bytes!

Pruébalo en línea!

Python 2, 31 bytes

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

Creo que esto funciona?

Mathematica, 29 bytes

Mi primera respuesta!

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

¡El quid de Mathematica sin soporte! Las entradas de funciones son una lista (de caracteres, o lo que sea) y un número.

Laberinto , 40 bytes

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

La entrada es Nseguida por la cadena, separada por cualquier carácter no numérico.

Pruébalo en línea!

Esto fue escrito en colaboración con Sp3000 (lo que significa que no me molesté en descifrar un algoritmo, por lo que comenzó a trabajar en él, ideó una solución de 118 bytes pero no me molestó jugar al golf, así que hice el golf. .. yay para el trabajo en equipo).

Explicación

Imprimación habitual de Sp (como siempre ligeramente modificada):

• Labyrinth es un lenguaje 2D basado en pila con dos pilas, principal y auxiliar. Casi todo sucede en la pila principal, pero puede cambiar los valores a la otra, por ejemplo, para revertirlos o guardarlos para más adelante.
• Las pilas no tienen fondo y están llenas de ceros, por lo que saltar de una pila vacía no es un error.
• La ejecución comienza desde el primer carácter válido (aquí arriba a la izquierda). En cada cruce, donde hay dos o más rutas posibles para que el puntero de instrucción (IP) tome, la parte superior de la pila se verifica para determinar a dónde ir después. Negativo es girar a la izquierda, cero es avanzar y positivo es girar a la derecha. Si bien esto estaba destinado a hacer que el código pareciera pasajes sinuosos y sinuosos, no hay nada que le impida hacer "habitaciones" donde se verifican estas condiciones en cada celda. Esos pueden producir un comportamiento bastante impredecible, pero son excelentes para jugar al golf.
• El código fuente (y, por lo tanto, el diseño del laberinto) se puede modificar en tiempo de ejecución mediante el <>^vcual se desplaza cíclicamente una fila o columna o la cuadrícula.
• " son no-ops.

Aquí vamos.

El código comienza en el <, que es un truco de golf que he usado varias veces al comenzar con un código lineal largo. Desplaza la primera fila cíclicamente a la izquierda, con la IP en ella , por lo que la fuente se ve así:

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

Pero ahora la IP no puede moverse a ninguna parte, por lo que se ejecuta <nuevamente. Esto continúa hasta que alcancemos este estado:

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

En este punto, la IP puede abandonar la celda y comenzar a ejecutar la segunda línea a partir de ?. Así que aquí está el código lineal desglosado:

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

El IP ahora ingresa a esta sala de 3x2, que en realidad son dos bucles 2x2 apretados (superpuestos) en sentido horario. El primer ciclo lee y 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.

Ahora ingresamos al segundo ciclo que lee el resto de la cadena de entrada. Podemos detectar EOF porque ,volverá -1en ese caso, haciendo que la IP gire a la izquierda.

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

Esa disminución no es realmente útil, pero podemos deshacerla más tarde de forma gratuita y aquí nos permite superponer los dos bucles.

Si tomamos la 5 ABCDEFGHIJKLMNOPentrada como un ejemplo, la pila se ve así:

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

Tenga en cuenta que estos realmente corresponden a los caracteres de entrada FGHIJKLMNOP(porque los disminuimos), y que en realidad no queremos imprimir el primero de ellos (solo hemos descartado los N-1caracteres, pero queremos omitirlos N).

Ahora hay un bit lineal corto que prepara la pila para el siguiente ciclo:

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

Las pilas ahora se ven así:

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

Entramos en otro ciclo de 2x2 en sentido horario. Esto descarta los Ncaracteres superiores de la pila 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.

Cuando salimos del bucle, =intercambiamos eso 0y el último carácter de la cadena de entrada nuevamente. Ahora las pilas se ven así:

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

Queremos imprimir el contenido de la pila principal (excepto el elemento inferior y todo incrementado en 1), desde la izquierda . Eso significa que necesitamos llevarlo a la pila auxiliar. Eso es lo que hace el siguiente ciclo 2x2 (en sentido horario):

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

Pilas ahora:

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

Volvemos al primero de ellos (el que no queremos imprimir) de nuevo a la pila principal {. Y ahora entramos en el ciclo final 2x2 (en sentido antihorario ), que imprime el resto:

{   # 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 terminamos el programa con @.

JavaScript (ES6), 39 bytes

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

Resulta que acabo de reinventar la respuesta de @ Sp3000.

Jalea, 8 bytes

Ḣ1¦UðḤ}¡

Pruébalo en línea!

Cómo 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.

Jalea , 10 bytes

Ḣ;ṪjḊṖ$Ɠ¡F

Ingrese el número a través de STDIN y la cadena a través de la línea de comando args . Gracias a @Dennis por muchas sugerencias / ayuda para que esto funcione (Jelly aún me elude).

Pruébalo en línea!

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

++hz:zhQ_hQez

Explicación:

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

Pruébalo aquí

Vitsy, 12 9 (código) + 1 (nueva línea para declaración de función) = 10 bytes

\ o /

Espera la entrada en la pila como la cadena seguida del 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.

Con el que puedes llamar:

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

Esta es una función que deja la cadena resultante en la pila. Lo he proporcionado como un programa en el enlace 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

¡Pruébalo aquí con cajas de prueba!

Solución recursiva simple. Elimina el segundo y el último segundo elemento de la cadena de entrada y se llama a sí mismo con esto y n-1hasta n=0.

editar: Sentirse un poco estúpido, mirando la otra solución de Python . Supongo que me gusta demasiado la recursividad ...

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

Sin golf

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

Muy sencillo

~truco robado de la respuesta de Sp , que ahorra un byte s[n+1..-2-n]. (Funciona porque ~nestá -1-nen el complemento de dos, y luego ...es un rango exclusivo).

Perl, 36 32 + 1 = 33 bytes

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

Requiere -pbandera y toma entrada en dos líneas, con números de iteraciones al 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}*

Pruébalo en línea!

Cómo 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.

Octava, 28 bytes

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

Indice la cadena, omitiendo S(2:N+1)y S(end-N:end-1).

Ejecución de muestra en ideone .

Óxido, 135 bytes

Bueno, esa es una longitud bastante terrible.

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

Bonito estampado:

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

Puede reducirlo a 104 bytes si permitimos cadenas de bytes en lugar de las cadenas adecuadas.

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}

Bonito estampado:

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 si alguien puede hacerlo mejor.

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

Explicación:

%l = $len($1) obtendrá la longitud de la cadena de entrada y la guardará en una variable llamada l

$right(<input>,<length>)y $left(<input>,<length>se puede usar para devolver la parte izquierda o derecha de la cadena original respetablemente. $ left siempre devuelve el texto desde el lado izquierdo, mientras que $ right siempre devuelve el texto desde el lado derecho. Si la longitud especificada es un número negativo, $ left y $ right devuelven todo el texto menos esa cantidad de caracteres de sus respectivos lados.

$mid(<string>,<start>,[length])se usa para obtener una subcadena desde el medio de la cadena. Inicio es el inicio de la subcadena desde la izquierda. Un valor negativo indica un comienzo desde la derecha. En ambos casos, se puede especificar una longitud opcional. Se puede usar una longitud negativa para eliminar tantos caracteres del final. Entonces lo usé para recuperar el segundo carácter y el segundo último carácter usando la longitud de la cadena de entrada.

$calc(<input>) se usa para realizar cálculos matemáticos

A partir del lenguaje aún sin título (tan nuevo no competitivo), 9 bytes

hD_RQ:Q|J

Puede encontrar el código fuente aquí , el idioma es completamente inestable (primer desafío de prueba para él), así que no espere que funcione en el futuro (commit 7)

Este es un lenguaje basado en la pila con funciones que agregan y eliminan objetos de la pila. Actualmente hay 2 comandos de manipulación de pila: D(duplicar la parte superior de la pila N veces) y R(rotar los N elementos superiores en la pila)

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

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

Pruébalo aquí.

Explicación

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

Se espera que la entrada tenga el formato STRING Nen la primera línea sin otros caracteres.

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

Mi primera entrada PPCG!

Obviamente no voy a ganar pero oye.

Toma datos como: 4ABCDEFGHIJKL, siendo el primer carácter N.

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

Pruébelo en este maravilloso sitio.

Limitado a N menor o igual a 9, porque los números de dos dígitos son una molestia en el trasero.

EDITAR: Lo absorbí y agregué soporte para números de dos dígitos. Almohadilla con un cero para un solo dígito.

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

Perl, 27 bytes

Incluye +1 para -p

Correr como perl -p sdr.pl

Entrada dada en STDIN, primera línea de la cadena, segunda línea del recuento Asume que la cadena contiene solo caracteres de "palabras"

sdr.pl:

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

PHP, 60 bytes

Esta solución establece iterativamente los caracteres de la cadena de entrada a una cadena vacía por índice. Estoy manipulando la cadena de entrada directamente para evitar un largo return.

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

Básicamente en la memoria se $wve así cuando se hace:

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

Corre así:

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

Pilones , 16 Bytes.

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

Cómo 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*\

Estoy seguro de que es posible jugar golf más allá ...

Jolf, 13 bytes

ΆFi liγhj_γgi

Una tranpilación de la respuesta de JavaScript.

Explicación:

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

Pruébalo aquí!

Una versión posterior a la pregunta más interesante:

 ΆFi]ihjYgi

En serio, 17 bytes

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

Toma entrada como s \n n.

Pruébalo en línea!

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

Dado que básicamente omitimos 1 y eliminamos N y el escenario invertido

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

sin golf

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