introduction

Observons la chaîne suivante:

ABCDEFGHIJKLMNOP

Si nous échangeons les extrémités de la chaîne , qui sont les suivantes:

ABCDEFGHIJKLMNOP
^^            ^^

On obtient le résultat suivant:

BACDEFGHIJKLMNPO

Après cela, nous supprimons les extrémités de la chaîne, qui dans ce cas sont Bet O. Le résultat est:

ACDEFGHIJKLMNP

Si nous répétons le processus, nous obtenons la liste suivante:

N     Result

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

Vous pouvez voir que pour N = 5 , le résultat est AGHIJP. À N = 7 , la longueur de la chaîne est inférieure à 3 , donc N> 7 est considéré invalide dans ce cas.

La tâche

Étant donné une chaîne S avec au moins une longueur 4 et le nombre de répétitions N > 0, sortez le résultat final. Vous pouvez supposer que N est toujours valide .

Cas de test

Input                               >  Output

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

C'est du code-golf , donc la soumission avec le moins d'octets gagne! Pour plus de simplicité, vous pouvez supposer que la chaîne ne contiendra que des caractères alphanumériques .

MATL , 8 9 12 13 octets

th"P[]2(

Les entrées sont: d'abord Nune chaîne unaire avec des guillemets (autorisée par le défi); secondeS sous forme de chaîne avec des guillemets (les guillemets dans les chaînes sont autorisés par défaut); séparés par un saut de ligne.

Cela fonctionne en retournant la chaîne, en supprimant son deuxième élément et en répétant un total de 2*Nfois.

Essayez-le en ligne!

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

Rétine , 44 20 octets

_{Barré 44 est toujours régulier 44 :(}

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

Suppose une entrée au format suivant (en caractère de comptage unaire:) ':
{number of repeats}{string}
Par exemple: '''''''ABCDEFGHIJKLMNOP
Il n'y a pas d'espace entre le nombre de répétitions et la chaîne.

Merci @ MartinBüttner pour avoir rasé 24 octets!

Essayez-le en ligne!

Python 2, 31 octets

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

Je pense que cela fonctionne?

Mathematica, 29 octets

Ma première réponse!

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

Le nœud de Mathematica sans support! Les entrées de fonction sont une liste (de caractères ou autre) et un nombre.

Labyrinthe , 40 octets

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

L'entrée est Nsuivie de la chaîne, séparée par tout caractère non numérique.

Essayez-le en ligne!

Cela a été écrit en collaboration avec Sp3000 (ce qui signifie que je ne pouvais pas être dérangé pour trouver un algorithme, alors il a commencé à travailler dessus, a trouvé une solution de 118 octets mais ne pouvait pas être dérangé par le golf, alors j'ai fait le golf. .. yay pour le travail d'équipe).

Explication

Primaire habituel de Sp (comme d'habitude légèrement modifié):

• Labyrinth est un langage 2D basé sur une pile avec deux piles, principale et auxiliaire. Presque tout se passe sur la pile principale, mais vous pouvez déplacer les valeurs sur l'autre, par exemple pour les inverser ou les enregistrer pour plus tard.
• Les piles sont sans fond et remplies de zéros, donc sauter d'une pile vide n'est pas une erreur.
• L'exécution commence à partir du premier caractère valide (ici en haut à gauche). À chaque jonction, où il y a deux ou plusieurs chemins possibles que le pointeur d'instruction (IP) doit prendre, le haut de la pile est vérifié pour déterminer où aller ensuite. Négatif est tourner à gauche, zéro est aller de l'avant et positif est tourner à droite. Bien que cela ait été conçu pour donner au code l'apparence de passages sinueux et sinueux, rien ne vous empêche de créer des "pièces" où ces conditions sont vérifiées dans chaque cellule. Ceux-ci peuvent produire un comportement assez imprévisible, mais sont parfaits pour le golf.
• Le code source (et donc la disposition du labyrinthe) peut être modifié lors de l'exécution à l'aide de <>^vce qui décale cycliquement une ligne ou une colonne ou la grille.
• " ne sont pas opérationnels.

Et c'est parti.

Le code commence le <, ce qui est une astuce de golf que j'ai utilisée à quelques reprises pour commencer avec un long morceau de code linéaire. Il décale la première ligne cycliquement vers la gauche, avec l'IP dessus , donc la source ressemble alors à ceci:

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

Mais maintenant, l'IP ne peut plus se déplacer, donc il exécute à <nouveau. Cela continue jusqu'à ce que nous atteignions cet état:

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

À ce stade, l'IP peut quitter la cellule et commencer à exécuter la deuxième ligne à partir de ?. Voici donc le code linéaire décomposé:

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

L'IP entre maintenant dans cette salle 3x2, qui est en fait deux boucles compressées étroitement (se chevauchant) 2x2 dans le sens des aiguilles d'une montre. La première boucle lit et supprime les N-1caractères 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.

Maintenant, nous entrons dans la deuxième boucle qui lit le reste de la chaîne d'entrée. Nous pouvons détecter EOF car ,reviendra -1dans ce cas, faisant tourner l'IP à gauche.

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

Ce décrément n'est pas vraiment utile, mais nous pouvons l'annuler plus tard gratuitement et ici il nous permet de chevaucher les deux boucles.

Si nous prenons l' 5 ABCDEFGHIJKLMNOPexemple en entrée, la pile ressemble à ceci:

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

Notez que ceux-ci correspondent en fait aux caractères d'entrée FGHIJKLMNOP(parce que nous les avons décrémentés), et que nous ne voulons pas réellement imprimer le premier de ceux-ci (nous avons seulement supprimé les N-1caractères, mais nous voulons les ignorerN ).

Maintenant, il y a un petit bit linéaire qui prépare la pile pour la prochaine boucle:

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

Les piles ressemblent maintenant à:

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

Nous entrons dans une autre boucle 2x2 dans le sens horaire. Cela supprime les premiers Npersonnages de la pile principale:

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

Lorsque nous quittons la boucle, cela =permute à nouveau 0le dernier caractère de la chaîne d'entrée. Maintenant, les piles ressemblent à ceci:

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

Nous voulons imprimer le contenu de la pile principale (sauf l'élément du bas et tous incrémentés de 1), à partir de la gauche . Cela signifie que nous devons le transférer vers la pile auxiliaire. C'est ce que fait la prochaine boucle 2x2 (dans le sens des aiguilles d'une montre):

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

Empile maintenant:

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

Nous replaçons le premier (celui avec lequel nous ne voulons pas imprimer) dans la pile principale {. Et maintenant, nous entrons dans la boucle finale 2x2 ( antihoraire ), qui imprime le reste:

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

Enfin, nous terminons le programme avec @.

JavaScript (ES6), 39 octets

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

Il s'avère que je viens de réinventer la réponse de @ Sp3000.

Gelée, 8 octets

Ḣ1¦UðḤ}¡

Essayez-le en ligne!

Comment ça marche

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

Gelée , 10 octets

Ḣ;ṪjḊṖ$Ɠ¡F

Entrez le nombre via STDIN et la chaîne via les arguments de la ligne de commande . Merci à @Dennis pour beaucoup de conseils / aide pour que cela fonctionne (Jelly m'échappe toujours).

Essayez-le en ligne!

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

++hz:zhQ_hQez

Explication:

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

Essayez-le ici

Vitsy, 12 9 (code) + 1 (nouvelle ligne pour la déclaration de fonction) = 10 octets

\ o /

Attend l'entrée sur la pile comme la chaîne suivie du nombre.

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.

Avec qui vous pouvez appeler:

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

Il s'agit d'une fonction qui laisse la chaîne résultante sur la pile. Je l'ai fourni en tant que programme dans le lien TryItOnline.

TryItOnline!

Python 2, 49 48 octets

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

Essayez-le ici avec des testcases!

Solution récursive simple. Supprime le deuxième et le dernier second élément de la chaîne d'entrée et s'appelle avec ceci et n-1jusqu'à n=0.

edit: Se sentir un peu stupide, en regardant l'autre solution python . Je suppose que j'aime trop la récursivité ...

C, 96 octets

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

Non 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 */
}

Rubis, 29 octets

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

Très simple.

~astuce volée à la réponse de Sp , qui économise un octet s[n+1..-2-n]. (Cela fonctionne parce qu'il ~nest -1-nen complément à deux, puis ...est une gamme exclusive.)

Perl, 36 32 + 1 = 33 octets

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

Nécessite un -pindicateur et prend une entrée sur deux lignes, avec un nombre d'itérations à la fin:

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

Non golfé?

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

CJam, 12 octets

q~{VW@)t(t}*

Essayez-le en ligne!

Comment ça marche

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.

Octave, 28 octets

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

Indexez la chaîne, en omettant S(2:N+1)et S(end-N:end-1).

Exemple de run sur ideone .

Rouille, 135 octets

Eh bien, c'est une longueur assez 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()}

Assez imprimé:

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

Vous pouvez le réduire à 104 octets si nous autorisons les octets au lieu des chaînes appropriées.

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}

Assez imprimé:

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
 }

Curieux de savoir si quelqu'un peut faire mieux.

mSL - 137 octets

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

Explication:

%l = $len($1) obtiendra la longueur de la chaîne d'entrée et l'enregistrera dans une variable appelée l

$right(<input>,<length>) et $left(<input>,<length> peut être utilisé pour renvoyer la partie gauche ou droite de la chaîne d'origine de manière respectable. $ left renvoie toujours le texte à partir du côté très gauche tandis que $ right renvoie toujours le texte à partir du côté droit. Si la longueur spécifiée est un nombre négatif, $ left et $ right renvoient le texte entier moins le nombre de caractères de leurs côtés respectifs.

$mid(<string>,<start>,[length])est utilisé pour obtenir une sous-chaîne au milieu de la chaîne. Début est le début de la sous-chaîne à gauche. Une valeur négative indique un départ par la droite. Dans les deux cas, une longueur facultative peut être spécifiée. Une longueur négative peut être utilisée pour supprimer autant de caractères de la fin. Je l'ai donc utilisé pour récupérer le deuxième caractère et l'avant-dernier caractère en utilisant la longueur de la chaîne d'entrée.

$calc(<input>) est utilisé pour effectuer des calculs mathématiques

Langue encore sans titre (donc nouvelle non compétitive), 9 octets

hD_RQ:Q|J

Vous pouvez trouver le code source ici , le langage est complètement instable (premier défi de test pour lui) alors ne vous attendez pas à ce qu'il fonctionne à l'avenir (commit 7)

Il s'agit d'un langage basé sur la pile avec des fonctions qui ajoutent et suppriment des objets de la pile. Il existe actuellement 2 commandes de manipulation de pile: D(dupliquer le haut de la pile N fois) et R(faire pivoter les N éléments supérieurs de la pile)

Explication:

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

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

Testez-le ici.

Explication

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 octets

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

L'entrée devrait être sous la forme STRING Nsur la première ligne sans aucun autre caractère.

Explication:

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

Ma première entrée PPCG!

Évidemment, je ne vais pas gagner, mais bon.

Prend une entrée comme: 4ABCDEFGHIJKL, le premier caractère étant N.

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

Testez-le sur ce merveilleux site.

Limité à N inférieur ou égal à 9, car les nombres à deux chiffres sont une douleur dans le cul.

EDIT: je l'ai aspiré et ajouté la prise en charge des nombres à deux chiffres. Pad avec un zéro pour les chiffres simples.

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

Perl, 27 octets

Inclure +1 pour -p

Courir comme perl -p sdr.pl

Entrée donnée sur STDIN, première ligne de la chaîne, deuxième ligne le nombre Suppose que la chaîne ne contient que des caractères "word"

sdr.pl:

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

PHP, 60 octets

Cette solution définit de manière itérative les caractères de la chaîne d'entrée en une chaîne vide par index. Je manipule directement la chaîne d'entrée pour éviter une longue return.

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

Fondamentalement, en mémoire $wressemble à ceci une fois terminé:

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

Courez comme ceci:

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

Pylônes , 16 octets.

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

Comment ça marche:

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 octets

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

Je suis sûr qu'il est possible de jouer au golf plus loin ...

Jolf, 13 octets

ΆFi liγhj_γgi

Une traduction de la réponse JavaScript.

Explication:

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

Essayez-le ici!

Une version post-question plus intéressante:

 ΆFi]ihjYgi

Sérieusement, 17 octets

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

Prend l'entrée comme s \n n.

Essayez-le en ligne!

Explication:

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

Puisque nous sautons essentiellement 1 et supprimons N et le scénario inversé

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

non 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 octets

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