Einführung

Beobachten wir die folgende Zeichenfolge:

ABCDEFGHIJKLMNOP

Wenn wir die Enden der Zeichenkette vertauschen , sind dies:

ABCDEFGHIJKLMNOP
^^            ^^

Wir erhalten folgendes Ergebnis:

BACDEFGHIJKLMNPO

Danach löschen wir die Enden der Zeichenkette, die in diesem Fall Bund sind O. Das Ergebnis ist:

ACDEFGHIJKLMNP

Wenn wir den Vorgang wiederholen, erhalten wir die folgende Liste:

N     Result

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

Sie können sehen, dass für N = 5 das Ergebnis ist AGHIJP. Bei N = 7 ist die Länge der Zeichenfolge kleiner als 3 , daher wird N> 7 in diesem Fall als ungültig betrachtet .

Die Aufgabe

Geben Sie bei einer Zeichenfolge S mit mindestens der Länge 4 und der Anzahl der Wiederholungen N > 0 das Endergebnis aus. Sie können davon ausgehen, dass N immer gültig ist .

Testfälle

Input                               >  Output

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

Das ist Code-Golf , also gewinnt die Einsendung mit der geringsten Anzahl von Bytes! Der Einfachheit halber können Sie davon ausgehen, dass die Zeichenfolge nur alphanumerische Zeichen enthält.

MATL , 8 9 12 13 Bytes

th"P[]2(

Eingaben sind: erstens Nals unäre Zeichenfolge mit Anführungszeichen (durch die Abfrage zulässig); Sekunde Sals Zeichenfolge mit Anführungszeichen (Anführungszeichen in Zeichenfolgen sind standardmäßig zulässig); durch einen Zeilenumbruch getrennt.

Dies funktioniert, indem die Zeichenfolge gespiegelt, das zweite Element entfernt und insgesamt 2*Nmehrmals wiederholt wird .

Probieren Sie es 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

_{Durchgestrichen 44 ist immer noch regulär 44 :(}

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

Geht davon Eingang in folgendem Format (in unäre - Zählen Charakter: '):
{number of repeats}{string}
Zum Beispiel: '''''''ABCDEFGHIJKLMNOP
Es gibt keinen Raum zwischen der Anzahl der Wiederholungen und der Zeichenkette.

Danke @ MartinBüttner für das Abschneiden von 24 Bytes!

Probieren Sie es online!

Python 2, 31 Bytes

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

Ich denke das funktioniert?

Mathematica, 29 Bytes

Meine erste Antwort!

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

Das A und O von Mathematica ohne Klammern! Funktionseingaben sind eine Liste (von Zeichen oder was auch immer) und eine Zahl.

Labyrinth , 40 Bytes

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

Auf die Eingabe Nfolgt die Zeichenfolge, die durch ein beliebiges nicht numerisches Zeichen getrennt wird.

Probieren Sie es online!

Dies wurde in Zusammenarbeit mit Sp3000 geschrieben (was bedeutet, dass ich nicht die Mühe hatte, einen Algorithmus zu finden, und er begann, daran zu arbeiten. Er kam auf eine 118-Byte-Lösung, konnte sich aber nicht die Mühe machen, sie zu spielen, also spielte ich Golf. .. yay für Teamarbeit).

Erläuterung

Sp's üblicher Primer (wie üblich leicht modifiziert):

• Labyrinth ist eine stapelbasierte 2D-Sprache mit zwei Stapeln, Main und Auxiliary. Auf dem Hauptstapel passiert so ziemlich alles, aber Sie können Werte auf den anderen Stapel verschieben, z. B. um sie umzukehren oder für später zu speichern.
• Die Stapel sind bodenlos und mit Nullen gefüllt, sodass das Herausspringen aus einem leeren Stapel kein Fehler ist.
• Die Ausführung beginnt mit dem ersten gültigen Zeichen (hier oben links). An jeder Kreuzung, an der zwei oder mehr mögliche Pfade für den Anweisungszeiger (IP) zur Verfügung stehen, wird die Oberseite des Stapels überprüft, um zu bestimmen, wohin er als Nächstes gehen soll. Negativ ist links abbiegen, Null ist vorwärts und positiv ist rechts abbiegen. Während dies bedeutete den Code aussehen wie Wickeln, kurvigen Passagen zu machen, gibt es nichts , was man aus machen „Räumen“ zu stoppen , wo diese Bedingungen in jeder Zelle überprüft werden. Diese können zu unvorhersehbarem Verhalten führen, eignen sich aber hervorragend zum Golfen.
• Der Quellcode (und damit das Layout des Labyrinths) kann zur Laufzeit geändert werden, indem <>^vzyklisch eine Zeile oder Spalte oder das Raster verschoben wird.
• " sind No-Ops.

Auf geht's.

Der Code beginnt mit dem <Golf-Trick, den ich einige Male verwendet habe, als ich mit einem langen Stück linearen Codes angefangen habe. Die erste Zeile wird zyklisch mit der IP- Adresse nach links verschoben , sodass die Quelle dann wie folgt aussieht:

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

Aber jetzt kann sich die IP nirgendwo bewegen, also führt sie die <nochmal aus. Dies geht so lange weiter, bis wir diesen Zustand erreichen:

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

An diesem Punkt kann die IP die Zelle verlassen und mit der Ausführung der zweiten Zeile beginnen, beginnend mit ?. Hier ist der lineare Code:

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

Die IP betritt nun diesen 3x2-Raum, der eigentlich zwei fest komprimierte (überlappende) 2 x 2-Schleifen im Uhrzeigersinn ist. Die erste Schleife liest und N-1löscht Zeichen aus 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.

Nun betreten wir die zweite Schleife, die den Rest der Eingabezeichenfolge liest. Wir können erkennen , da EOF ,zurückkehren wird -1in diesem Fall, so dass die IP links abbiegen.

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

Diese Dekrementierung ist eigentlich nicht sinnvoll, aber wir können sie später kostenlos rückgängig machen und hier können wir die beiden Schleifen überlappen.

Wenn wir die 5 ABCDEFGHIJKLMNOPEingabe als Beispiel nehmen, sieht der Stapel folgendermaßen aus:

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

Beachten Sie, dass diese tatsächlich den eingegebenen Zeichen entsprechen FGHIJKLMNOP(weil wir sie dekrementiert haben) und dass wir die ersten N-1Zeichen nicht drucken möchten (wir haben nur Zeichen verworfen , möchten sie aber überspringen N).

Jetzt gibt es ein kurzes lineares Bit, das den Stack für die nächste Schleife vorbereitet:

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

Die Stapel sehen nun so aus:

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

Wir betreten eine weitere 2 × 2-Schleife im Uhrzeigersinn. Dies verwirft die obersten NZeichen vom Hauptstapel:

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

Beim Verlassen der Schleife werden =dieses 0und das letzte Zeichen der Eingabezeichenfolge erneut ausgetauscht. Nun sehen die Stapel so aus:

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

Wir möchten den Inhalt des Hauptstapels (mit Ausnahme des unteren Elements und alle um 1 erhöht) von links drucken . Das heißt, wir müssen es zum Hilfsstapel bringen. Das macht die nächste 2x2-Schleife (im Uhrzeigersinn):

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

Stacks jetzt:

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

Wir verschieben die erste davon (die, die wir nicht drucken möchten) zurück in den Hauptstapel mit {. Und jetzt geben wir die letzte 2x2- Schleife ( gegen den Uhrzeigersinn ) ein, die den Rest ausgibt:

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

Zum Schluss beenden wir das Programm mit @.

JavaScript (ES6), 39 Byte

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

Es stellte sich heraus, dass ich die Antwort von @ Sp3000 neu erfunden habe.

Gelee, 8 Bytes

Ḣ1¦UðḤ}¡

Probieren Sie es online!

Wie es funktioniert

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

Gelee , 10 Bytes

Ḣ;ṪjḊṖ$Ɠ¡F

Eingang die Nummer über STDIN, und die Zeichenfolge über die Befehlszeile args . Vielen Dank an @Dennis für viele Hinweise / Hilfe, damit das funktioniert (Jelly entzieht sich mir immer noch).

Probieren Sie es 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

Pyth, 13 Bytes

++hz:zhQ_hQez

Erläuterung:

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

Probieren Sie es hier aus

Vitsy, 12 9 (Code) + 1 (Newline für Funktionsdeklaration) = 10 Bytes

\O/

Erwartet die Eingabe auf dem Stapel als Zeichenfolge, gefolgt von der Zahl.

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.

Mit welchen Sie anrufen können:

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

Dies ist eine Funktion, die die resultierende Zeichenfolge auf dem Stapel belässt. Ich habe es als Programm im TryItOnline-Link bereitgestellt.

TryItOnline!

Python 2, 49 48 Bytes

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

Probieren Sie es hier mit Testfällen!

Einfache rekursive Lösung. Entfernt das zweite und letzte zweite Element aus der Eingabezeichenfolge und ruft sich mit diesem und n-1bis auf n=0.

edit: Ich fühle mich irgendwie dumm, wenn ich mir die andere Python-Lösung ansehe . Ich denke, ich mag Rekursion einfach zu sehr ...

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

Sehr einfach.

~Ein Trick, der aus der Antwort von Sp gestohlen wurde und der ein Byte überflüssig macht s[n+1..-2-n]. (Es funktioniert, weil ~nes sich um -1-nein Zweier-Komplement handelt und es sich dann ...um ein exklusives Sortiment handelt.)

Perl, 36 32 + 1 = 33 Bytes

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

Benötigt -pFlag und nimmt Eingaben in zwei Zeilen vor, mit der Anzahl der Iterationen am Ende:

$ 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}*

Probieren Sie es online!

Wie es funktioniert

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.

Oktave, 28 Bytes

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

Indizieren Sie die Zeichenfolge, lassen Sie S(2:N+1)und weg S(end-N:end-1).

Probelauf auf ideone .

Rust, 135 Bytes

Nun, das ist eine ziemlich schreckliche Länge.

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

Hübsch gedruckt:

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

Sie können es auf 104 Bytes reduzieren, wenn wir Bytestrings anstelle von richtigen Strings zulassen.

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}

Hübsch gedruckt:

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
 }

Neugierig, wenn es jemand besser machen kann.

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

Erläuterung:

%l = $len($1) Ruft die Länge der Eingabezeichenfolge ab und speichert sie in der Variablen l

$right(<input>,<length>)und $left(<input>,<length>kann verwendet werden, um den linken oder rechten Teil der ursprünglichen Zeichenfolge respektabel zurückzugeben. $ left gibt den Text immer von der linken Seite aus zurück, während $ right den Text immer von der rechten Seite aus zurückgibt. Wenn die angegebene Länge eine negative Zahl ist, geben $ left und $ right den gesamten Text abzüglich der Anzahl der Zeichen von ihren jeweiligen Seiten zurück.

$mid(<string>,<start>,[length])wird verwendet, um eine Teilzeichenfolge aus der Mitte der Zeichenfolge abzurufen. Start ist der Anfang des Teilstrings von links. Ein negativer Wert zeigt einen Start von rechts an. In beiden Fällen kann eine optionale Länge angegeben werden. Eine negative Länge kann verwendet werden, um so viele Zeichen am Ende zu entfernen. Ich habe es also verwendet, um das zweite und das vorletzte Zeichen mithilfe der Länge der Eingabezeichenfolge abzurufen.

$calc(<input>) wird verwendet, um mathematische Berechnungen durchzuführen

Ab noch unbenannter Sprache (also neu, nicht konkurrenzfähig) 9 Bytes

hD_RQ:Q|J

Den Quellcode finden Sie hier . Die Sprache ist vollständig instabil (erste Testanforderung). Erwarten Sie also nicht, dass sie in Zukunft funktioniert (Commit 7).

Dies ist eine stapelbasierte Sprache mit Funktionen, die Objekte zum Stapel hinzufügen und daraus entfernen. Derzeit gibt es 2 Stapelmanipulationsbefehle: D(Duplizieren Sie den oberen Teil des Stapels N-mal) und R(Drehen Sie die oberen N-Elemente auf dem Stapel.)

Erläuterung:

          - 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 es hier.

Erläuterung

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

Es wird erwartet, dass die Eingabe im Formular erfolgt STRING N in der ersten Zeile ohne andere Zeichen erfolgt.

Erläuterung:

#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

Mein erster PPCG-Eintrag!

Offensichtlich nicht gewinnen, aber hey.

Nimmt Eingaben wie folgt entgegen: 4ABCDEFGHIJKL, wobei das erste Zeichen N ist.

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

Testen Sie es auf dieser wundervollen Seite.

Beschränkt auf N kleiner oder gleich 9, da zweistellige Zahlen nerven.

EDIT: Ich habe es aufgesaugt und Unterstützung für zweistellige Zahlen hinzugefügt. Mit einer Null für einzelne Ziffern auffüllen.

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

Perl, 27 Bytes

Fügen Sie +1 für -p

Rennen wie perl -p sdr.pl

Eingabe über STDIN, erste Zeile die Zeichenfolge, zweite Zeile die Anzahl Angenommen, die Zeichenfolge enthält nur "Wort" -Zeichen

sdr.pl:

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

PHP, 60 Bytes

Diese Lösung setzt iterativ Zeichen aus der Eingabezeichenfolge nach Index in eine leere Zeichenfolge. Ich manipuliere die Eingabezeichenfolge direkt, um eine lange zu verhindern return.

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

Grundsätzlich $wsieht das im Speicher so aus:

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

Laufen Sie wie folgt:

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

Pylone , 16 Bytes.

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

Wie es funktioniert:

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*\

Ich bin sicher, es ist möglich, dies weiter zu golfen ...

Jolf, 13 Bytes

ΆFi liγhj_γgi

Eine Übersetzung der JavaScript-Antwort.

Erläuterung:

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

Probieren Sie es hier aus!

Eine interessantere Version nach der Frage:

 ΆFi]ihjYgi

Im Ernst, 17 Bytes

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

Übernimmt die Eingabe als s \n n.

Probieren Sie es online!

Erläuterung:

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

129 Bytes

Da wir im Grunde 1 überspringen und entfernen N und das umgekehrte Szenario

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

ungolfed

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