Wprowadzenie

Zobaczmy następujący ciąg:

ABCDEFGHIJKLMNOP

Jeśli zamienimy końce łańcucha , które są następujące:

ABCDEFGHIJKLMNOP
^^            ^^

Otrzymujemy następujący wynik:

BACDEFGHIJKLMNPO

Następnie usuwamy końce łańcucha, którymi w tym przypadku są Bi O. Wynik to:

ACDEFGHIJKLMNP

Jeśli powtórzymy ten proces, otrzymamy następującą listę:

N     Result

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

Widać, że dla N = 5 wynik jest następujący AGHIJP. Przy N = 7 długość łańcucha jest mniejsza niż 3 , więc N> 7 jest w tym przypadku uważane za nieprawidłowe .

Zadanie

Biorąc pod uwagę ciąg S o długości co najmniej 4 i liczbie powtórzeń N > 0, wypisz wynik końcowy. Możesz założyć, że N jest zawsze ważne .

Przypadki testowe

Input                               >  Output

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

To jest golf golfowy , więc wygrywanie z najmniejszą ilością bajtów wygrywa! Dla uproszczenia można założyć, że ciąg będzie zawierał tylko znaki alfanumeryczne .

MATL , 8 9 12 13 bajtów

th"P[]2(

Dane wejściowe to: najpierw Njako ciąg jednoargumentowy z cudzysłowami (dozwolone przez wyzwanie); drugi Sjako ciąg znaków z cudzysłowami (domyślnie dozwolone są cudzysłowy w ciągach znaków); oddzielone podziałem wiersza.

Działa to poprzez odwrócenie łańcucha, usunięcie drugiego elementu i powtórzenie łącznie 2*N.

Wypróbuj 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

Siatkówka , 44 20 bajtów

_{Przekreślone 44 jest nadal regularne 44 :(}

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

Przyjmuje dane wejściowe w następującym formacie (jednokrotnie liczący:) ':
{number of repeats}{string}
Na przykład:'''''''ABCDEFGHIJKLMNOP
Nie ma spacji między liczbą powtórzeń a łańcuchem.

Dzięki @ MartinBüttner za zgolenie 24 bajtów!

Wypróbuj online!

Python 2, 31 bajtów

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

Myślę, że to działa?

Mathematica, 29 bajtów

Moja pierwsza odpowiedź!

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

Sedno bezobsługowej matematyki! Wprowadzane funkcje to lista (znaków lub cokolwiek) i liczba.

Labirynt , 40 bajtów

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

Po wprowadzeniu Nnastępuje ciąg oddzielony dowolnym znakiem nienumerycznym.

Wypróbuj online!

Zostało to napisane we współpracy ze Sp3000 (co oznacza, że ​​nie mogłem sobie pozwolić na wymyślenie algorytmu, więc zaczął nad nim pracować, wymyślił rozwiązanie 118-bajtowe, ale nie przeszkadzało mu to w golfa, więc grałem w golfa. .. tak dla pracy zespołowej).

Wyjaśnienie

Zwykły podkład SP (jak zwykle nieznacznie zmodyfikowany):

• Labirynt to oparty na stosie język 2D z dwoma stosami, głównym i pomocniczym. Prawie wszystko dzieje się na głównym stosie, ale możesz przenieść wartości na inny, np. Aby je odwrócić lub zachować na później.
• Stosy są bez dna i wypełnione zerami, więc wyskakiwanie z pustego stosu nie jest błędem.
• Wykonanie rozpoczyna się od pierwszego ważnego znaku (tutaj w lewym górnym rogu). Na każdym skrzyżowaniu, gdzie istnieją dwie lub więcej możliwych ścieżek, które ma wziąć wskaźnik instrukcji (IP), sprawdzana jest góra stosu, aby określić, gdzie iść dalej. Negatyw to skręt w lewo, zero to przejście do przodu, a dodatnie to skręt w prawo. Chociaż miało to na celu to sprawić, że kod będzie wyglądał jak kręte, kręte przejścia, nic nie stoi na przeszkodzie, aby tworzyć „pokoje”, w których warunki sprawdzane są w każdej komórce. Mogą one dać dość nieprzewidziane zachowanie, ale świetnie nadają się do gry w golfa.
• Kod źródłowy (a zatem i układ labiryntu) można modyfikować w czasie wykonywania, za pomocą <>^vktórego cyklicznie przesuwa się wiersz lub kolumna lub siatka.
• " nie ma operacji.

No to ruszamy.

Kod zaczyna się od <, czyli sztuczki golfowej, której użyłem kilka razy, kiedy zaczynałem od długiego kawałka kodu liniowego. Przesuwa cyklicznie pierwszy rząd w lewo, podając adres IP , więc źródło wygląda następująco:

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

Ale teraz IP nie może się nigdzie przenieść, więc wykonuje to <ponownie. Trwa to do momentu osiągnięcia tego stanu:

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

W tym momencie adres IP może opuścić komórkę i rozpocząć wykonywanie drugiej linii, zaczynając od ?. Oto poniższy kod liniowy:

?   # 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 wchodzi teraz do tego pokoju 3x2, który jest właściwie dwiema ściśle ściśniętymi (nakładającymi się) 2x2 pętlami zgodnie z ruchem wskazówek zegara. Pierwsza pętla odczytuje i odrzuca N-1znaki ze 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.

Teraz wchodzimy do drugiej pętli, która odczytuje resztę ciągu wejściowego. Możemy wykryć EOF, ponieważ w takim przypadku ,powróci -1, skręcając adres IP w lewo.

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

Ta redukcja nie jest w rzeczywistości przydatna, ale możemy ją później cofnąć za darmo, a tutaj pozwala nam nakładać się na dwie pętle.

Jeśli weźmiemy dane 5 ABCDEFGHIJKLMNOPwejściowe jako przykład, stos wygląda następująco:

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

Zauważ, że faktycznie odpowiadają one wejściowym znakom FGHIJKLMNOP(ponieważ je zmniejszyliśmy) i że tak naprawdę nie chcemy wydrukować pierwszego z nich (tylko odrzuciliśmy N-1znaki, ale chcemy pominąćN ).

Teraz jest krótki bit liniowy, który przygotowuje stos do następnej pętli:

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

Stosy wyglądają teraz następująco:

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

Wchodzimy w kolejną pętlę 2x2 zgodnie z ruchem wskazówek zegara. To odrzuca najlepsze Npostacie z głównego stosu:

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

Kiedy wychodzimy z pętli, =zamieniamy ją ponownie 0i ostatni znak ciągu wejściowego. Teraz stosy wyglądają tak:

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

Chcemy wydrukować zawartość głównego stosu (oprócz dolnego elementu i wszystkich z przyrostem o 1), od lewej . Oznacza to, że musimy przenieść go na stos pomocniczy. Tak właśnie robi następna pętla 2x2 (zgodnie z ruchem wskazówek zegara):

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

Stosy teraz:

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

Pierwszy z nich (ten, którego nie chcemy drukować) przenosimy z powrotem do głównego stosu {. A teraz wchodzimy w końcową pętlę 2x2 ( przeciwnie do ruchu wskazówek zegara ), która wypisuje resztę:

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

Na koniec kończymy program za pomocą @.

JavaScript (ES6), 39 bajtów

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

Okazuje się, że właśnie wymyśliłem odpowiedź @ Sp3000.

Galaretka, 8 bajtów

Ḣ1¦UðḤ}¡

Wypróbuj online!

Jak to działa

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

Galaretka , 10 bajtów

Ḣ;ṪjḊṖ$Ɠ¡F

Wprowadź liczbę za pomocą STDIN, a ciąg znaków za pomocą argumentów wiersza poleceń . Dzięki @Dennis za wiele wskazówek / pomoc w uruchomieniu tego (Jelly wciąż mi umyka).

Wypróbuj 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 bajtów

++hz:zhQ_hQez

Wyjaśnienie:

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

Wypróbuj tutaj

Vitsy, 12 lat 9 (kod) + 1 (nowy wiersz dla deklaracji funkcji) = 10 bajtów

\ o /

Oczekuje danych wejściowych na stosie jako ciągu, po którym następuje liczba.

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.

Możesz zadzwonić za pomocą:

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

Jest to funkcja, która pozostawia wynikowy ciąg znaków na stosie. Podałem go jako program w łączu TryItOnline.

TryItOnline!

Python 2, 49 48 bajtów

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

Wypróbuj tutaj z walizkami testowymi!

Proste rozwiązanie rekurencyjne. Usuwa drugi i ostatni drugi element z ciągu wejściowego i wywołuje się z tym i n-1do n=0.

edit: Czuję się trochę głupio, patrząc na inne rozwiązanie python . Chyba za bardzo lubię rekurencję ...

C, 96 bajtów

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

Bez golfa

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 bajtów

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

Bardzo proste.

~trick skradziony z odpowiedzi Sp , co oszczędza bajt s[n+1..-2-n]. (Działa, ponieważ ~njest -1-nw uzupełnieniu do dwóch, a następnie ...jest wyłącznym zakresem).

Perl, 36 32 + 1 = 33 bajty

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

Wymaga -p flagi i pobiera dane wejściowe w dwóch wierszach z liczbą iteracji na końcu:

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

Nie golfowany?

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

CJam, 12 bajtów

q~{VW@)t(t}*

Wypróbuj online!

Jak to działa

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.

Oktawa, 28 bajtów

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

Indeksuj ciąg, pomijając S(2:N+1) iS(end-N:end-1) .

Próbka uruchomiona na ideone .

Rdza, 135 bajtów

Cóż, to dość okropna długość.

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

Dość wydrukowane:

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

Możesz sprowadzić go do 104 bajtów, jeśli zezwolimy na bajtowanie zamiast odpowiednich ciągów.

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}

Dość wydrukowane:

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
 }

Ciekawe, czy ktoś może zrobić lepiej.

mSL - 137 bajtów

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

Wyjaśnienie:

%l = $len($1) otrzyma długość ciągu wejściowego i zapisze go w zmiennej o nazwie l

$right(<input>,<length>)i $left(<input>,<length>może być użyty do zwrócenia odpowiednio lewej lub prawej części oryginalnej ciągu. $ left zawsze zwraca tekst zaczynający się od bardzo lewej strony, podczas gdy $ right zawsze zwraca tekst zaczynający się od prawej strony. Jeśli podana długość jest liczbą ujemną, $ left i $ right zwracają cały tekst minus tyle znaków z każdej strony.

$mid(<string>,<start>,[length])służy do uzyskania podciągu ze środka łańcucha. Start to początek podciągu od lewej. Wartość ujemna oznacza początek od prawej. W obu przypadkach można określić opcjonalną długość. Użycie ujemnej długości pozwala usunąć tyle znaków z końca. Użyłem go więc do odzyskania drugiego znaku i drugiego ostatniego znaku przy użyciu długości ciągu wejściowego.

$calc(<input>) służy do wykonywania obliczeń matematycznych

Jak dotąd język bez tytułu (tak nowy niekonkurencyjny), 9 bajtów

hD_RQ:Q|J

Możesz znaleźć kod źródłowy tutaj , język jest całkowicie niestabilny (pierwsze wyzwanie testowe), więc nie spodziewaj się, że będzie działał w przyszłości (zatwierdzenie 7)

Jest to język oparty na stosie z funkcjami, które dodają i usuwają obiekty ze stosu. Obecnie dostępne są 2 polecenia manipulacji na stosie: D(zduplikuj górę stosu N razy) i R(obróć górne N elementów na stosie)

Wyjaśnienie:

          - 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 bajtów

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

Sprawdź to tutaj.

Wyjaśnienie

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 bajtów

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

Dane wejściowe powinny mieć postać STRING Nw pierwszym wierszu bez innych znaków.

Wyjaśnienie:

#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 bajtów

Mój pierwszy wpis PPCG!

Oczywiście nie wygra, ale hej.

Pobiera dane wejściowe takie jak: 4ABCDEFGHIJKL, przy czym pierwszym znakiem jest N.

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

Przetestuj to na tym wspaniałej stronie.

Ograniczone do N mniejszej lub równej 9, ponieważ liczby dwucyfrowe stanowią ból w tyłku.

EDYCJA: Zassałem go i dodałem obsługę dwucyfrowych liczb. Pad z zerem dla pojedynczych cyfr.

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

Perl, 27 bajtów

Uwzględnij +1 dla -p

Uruchom jako perl -p sdr.pl

Dane wejściowe podane na STDIN, pierwszy wiersz ciągu, drugi wiersz liczenia Zakłada, że ​​ciąg zawiera tylko znaki „słowo”

sdr.pl:

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

PHP, 60 bajtów

To rozwiązanie iteracyjnie ustawia znaki z ciągu wejściowego na pusty ciąg według indeksu. Manipuluję bezpośrednio łańcuchem wejściowym, aby zapobiec długiemu return.

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

Zasadniczo w pamięci $wwygląda to tak po zakończeniu:

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

Uruchom tak:

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

Pylony , 16 bajtów.

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

Jak to działa:

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 bajtów

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

Jestem pewien, że można dalej grać w golfa ...

Jolf, 13 bajtów

ΆFi liγhj_γgi

Tłumaczenie odpowiedzi JavaScript.

Wyjaśnienie:

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

Wypróbuj tutaj!

Bardziej interesująca wersja po pytaniu:

 ΆFi]ihjYgi

Poważnie, 17 bajtów

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

Pobiera dane wejściowe jako s \n n .

Wypróbuj online!

Wyjaśnienie:

,#,`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 bajtów

Ponieważ w zasadzie pomijamy 1 i usuwamy N i odwrócony scenariusz

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

bez golfa

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 bajty

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