Введение

Давайте посмотрим на следующую строку:

ABCDEFGHIJKLMNOP

Если мы поменяем местами концы строки , это:

ABCDEFGHIJKLMNOP
^^            ^^

Мы получаем следующий результат:

BACDEFGHIJKLMNPO

После этого мы удаляем концы строки, которые в этом случае являются Bи O. Результат:

ACDEFGHIJKLMNP

Если мы повторим процесс, мы получим следующий список:

N     Result

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

Вы можете видеть, что для N = 5 результат равен AGHIJP. При N = 7 длина строки меньше 3 , поэтому в этом случае N> 7 считается недействительным .

Задание

Если задана строка S с длиной не менее 4 и числом повторений N > 0, выведите окончательный результат. Вы можете предположить, что N всегда верно .

Контрольные примеры

Input                               >  Output

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

Это код-гольф , поэтому выигрывает представление с наименьшим количеством байтов! Для простоты можно предположить, что строка будет содержать только буквенно-цифровые символы.

MATL , 8 9 12 13 байт

th"P[]2(

Входные данные: сначала Nв виде унарной строки с кавычками (разрешено заданием); второй Sкак строка с кавычками (кавычки в строках разрешены по умолчанию); разделены переносом строки.

Это работает путем переворачивания строки, удаления ее второго элемента и повторения в общей сложности несколько 2*Nраз.

Попробуйте онлайн!

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 байт

_{Вычеркнул 44, все еще регулярно 44 :(}

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

Предполагается ввод в следующем формате (с одинарным счетом:) ':
{number of repeats}{string}
Например: '''''''ABCDEFGHIJKLMNOP
между числом повторов и строкой нет пробела.

Спасибо @ MartinBüttner за то, что он сбрил 24 байта!

Попробуйте онлайн!

Python 2, 31 байт

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

Я думаю, что это работает?

Mathematica, 29 байт

Мой первый ответ!

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

Суть бескаркасного Mathematica! Функциональные входы - это список (символов или чего-либо еще) и число.

Лабиринт , 40 байт

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

За вводом Nследует строка, отделенная любым нечисловым символом.

Попробуйте онлайн!

Это было написано в сотрудничестве с Sp3000 (что означает, что я не мог разобраться с алгоритмом, поэтому он начал работать над ним, придумал 118-байтовое решение, но не мог быть обеспокоен игрой в гольф, поэтому я занялся гольфом. .. ура для совместной работы).

объяснение

Обычный праймер Sp (как обычно, немного модифицированный):

• Лабиринт - это двумерный язык на основе стека с двумя стеками: основным и вспомогательным. Практически все происходит в основном стеке, но вы можете перенести значения в другое, например, чтобы изменить их или сохранить на потом.
• Стеки бездонные и заполнены нулями, поэтому выталкивание из пустого стека не является ошибкой.
• Выполнение начинается с первого действительного символа (здесь вверху слева). В каждом соединении, где есть два или более возможных путей для указателя инструкций (IP), вершина стека проверяется, чтобы определить, куда идти дальше. Отрицательным является поворот влево, нулевым - движение вперед, а положительным - поворот направо. Хотя это должно было сделать код похожим на извилистые, извилистые переходы, ничто не мешает вам создавать «комнаты», в которых эти условия проверяются в каждой ячейке. Они могут привести к совершенно непредсказуемому поведению, но отлично подходят для игры в гольф.
• Исходный код (и, следовательно, макет лабиринта) может быть изменен во время выполнения, используя <>^vкоторый циклически сдвигает строку или столбец или сетку.
• " нет опс.

Вот так.

Код начинается <с трюка, который я использовал несколько раз, когда начинал с длинного куска линейного кода. Он смещает первый ряд циклически влево с IP-адресом , поэтому источник выглядит следующим образом:

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

Но теперь IP не может никуда двигаться, поэтому он выполняет <снова. Это продолжается, пока мы не достигнем этого состояния:

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

В этот момент IP может покинуть ячейку и начать выполнение второй строки, начиная с ?. Итак, вот линейный код с разбивкой:

?   # 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 входит в эту комнату 3x2, которая на самом деле представляет собой две сильно сжатые (перекрывающиеся) петли 2x2 по часовой стрелке. Первый цикл читает и отбрасывает N-1символы из 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.

Теперь мы вводим второй цикл, который читает остаток входной строки. Мы можем обнаружить EOF, потому ,что -1в этом случае вернемся , и IP повернет налево.

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

Это уменьшение на самом деле не полезно, но мы можем отменить его позже бесплатно, и здесь оно позволяет нам перекрывать два цикла.

Если мы возьмем 5 ABCDEFGHIJKLMNOPвходные данные в качестве примера, стек выглядит так:

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

Обратите внимание, что они на самом деле соответствуют входным символам FGHIJKLMNOP(потому что мы их уменьшили), и что мы на самом деле не хотим печатать первые из них (мы только отбросили N-1символы, но хотим пропустить N).

Теперь есть короткий линейный бит, который подготавливает стек к следующему циклу:

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

Стеки теперь выглядят так:

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

Мы входим в другой цикл 2x2 по часовой стрелке. Это отбрасывает верхние Nсимволы из основного стека:

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

Когда мы выходим из цикла =, 0снова меняем местами последний и последний символ входной строки. Теперь стеки выглядят так:

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

Мы хотим напечатать содержимое основного стека (кроме нижнего элемента и всего с шагом 1) слева . Это означает, что нам нужно передать его во вспомогательный стек. Вот что делает следующий цикл 2x2 (по часовой стрелке):

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

Стеки сейчас:

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

Мы перемещаем первый из них (тот, который мы не хотим печатать) обратно в основной стек {. И теперь мы входим в последний цикл 2x2 ( против часовой стрелки ), который печатает остаток:

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

Наконец мы завершаем программу с @.

JavaScript (ES6), 39 байт

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

Оказывается, я просто заново изобрел ответ @ Sp3000.

Желе, 8 байт

Ḣ1¦UðḤ}¡

Попробуйте онлайн!

Как это работает

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

Желе , 10 байт

Ḣ;ṪjḊṖ$Ɠ¡F

Введите число через STDIN, а строку через аргументы командной строки . Спасибо @Dennis за много подсказок / помощь, чтобы заставить это работать (Jelly все еще ускользает от меня).

Попробуйте онлайн!

Ḣ;Ṫ               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 байт

++hz:zhQ_hQez

Объяснение:

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

Попробуй здесь

Vitsy, 12 9 (код) + 1 (перевод строки для объявления функции) = 10 байт

\ О /

Ожидается ввод в стек в виде строки, за которой следует число.

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.

Который вы можете позвонить с:

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

Это функция, которая оставляет результирующую строку в стеке. Я предоставил это как программу в ссылке TryItOnline.

TryItOnline!

Python 2, 49 48 байтов

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

Попробуйте здесь с тестовыми примерами!

Простое рекурсивное решение. Удаляет второй и последний второй элемент из входной строки и вызывает себя с этим и n-1до n=0.

редактировать: чувствую себя немного глупо, глядя на другое решение Python . Думаю, я просто слишком люблю рекурсию ...

C 96 байтов

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

Рубин, 29 байт

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

Очень просто.

~трюк, украденный из ответа Sp , который сохраняет байт s[n+1..-2-n]. (Это работает, потому что ~nнаходится -1-nв двух дополнениях, а затем ...является эксклюзивным диапазоном.)

Perl, 36 32 + 1 = 33 байта

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

Требует -pфлаг и принимает данные в две строки с числом итераций в конце:

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

Ungolfed?

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

CJam, 12 байт

q~{VW@)t(t}*

Попробуйте онлайн!

Как это работает

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.

Октава, 28 байт

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

Индексируйте строку, опуская S(2:N+1)и S(end-N:end-1).

Пробный прогон на идеоне .

Ржавчина, 135 байт

Ну, это довольно ужасная длина.

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

Довольно отпечатанный:

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

Вы можете уменьшить его до 104 байт, если мы допустим строки байтов вместо правильных строк.

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}

Довольно отпечатанный:

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
 }

Любопытно, если кто-нибудь может сделать лучше.

mSL - 137 байт

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

Объяснение:

%l = $len($1) получит длину входной строки и сохранит ее в переменной с именем l

$right(<input>,<length>)и $left(<input>,<length>может использоваться для возврата левой или правой части оригинальной строки соответственно. $ left всегда возвращает текст, начинающийся с самой левой стороны, а $ right всегда возвращает текст, начинающийся с правой стороны. Если указанная длина является отрицательным числом, $ left и $ right возвращают весь текст минус столько символов с соответствующих сторон.

$mid(<string>,<start>,[length])используется для получения подстроки из середины строки. Начало - это начало подстроки слева. Отрицательное значение указывает начало справа. В обоих случаях указывается необязательная длина. Отрицательная длина может быть использована для удаления такого количества символов с конца. Поэтому я использовал его для извлечения второго символа и второго последнего символа, используя длину входной строки.

$calc(<input>) используется для выполнения математических расчетов

На языке без названия (новый неконкурентоспособный) 9 байт

hD_RQ:Q|J

Вы можете найти исходный код здесь , язык совершенно нестабилен (первое испытание для него), поэтому не ожидайте, что он будет работать в будущем (commit 7)

Это основанный на стеке язык с функциями, которые добавляют и удаляют объекты из стека. В настоящее время есть 2 команды манипуляции со стеком: D(дублируйте вершину стека N раз) и R(вращайте верхние 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 байтов

l(o)\l~_W*@<>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 байт

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

Ожидается, что вход будет в форме STRING 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 байт

Моя первая запись PPCG!

Очевидно, не выиграю, но эй.

Принимает следующие данные: 4ABCDEFGHIJKL, первый символ - N.

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

Проверьте это на этом замечательном сайте.

Ограничено N меньше или равно 9, потому что двузначные числа являются болью в заднице.

РЕДАКТИРОВАТЬ: Я смирился с этим и добавил поддержку двузначных чисел. Pad с нуля для однозначных.

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

Perl, 27 байт

Включить +1 для -p

Беги как perl -p sdr.pl

Ввод данных в STDIN, первая строка - строка, вторая строка - число Предполагается, что строка содержит только символы «слова»

sdr.pl:

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

PHP, 60 байт

Это решение итеративно устанавливает символы из входной строки в пустую строку по индексу. Я манипулирую входной строкой напрямую, чтобы предотвратить длинные return.

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

В основном в памяти $wвыглядит так, когда сделано:

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

Запустите так:

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

Пилоны , 16 байтов.

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

Как это работает:

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 байтов

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

Я уверен, что это возможно в гольф дальше ...

Джольф, 13 байт

ΆFi liγhj_γgi

Ответ на JavaScript.

Объяснение:

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

Попробуй это здесь!

Более интересная пост-вопросная версия:

 ΆFi]ihjYgi

Серьезно, 17 байтов

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

Принимает вход как s \n 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 байт

Так как мы в основном пропускаем 1 и удаляем N и обратный сценарий

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 байта

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