Вступ

Давайте спостерігатимемо наступний рядок:

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

Сітківка , 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]

Я думаю, це працює?

Математика, 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 тепер входить у цю кімнату 3х2, яка насправді є двома щільно стисненими (перекриваються) 2х2 петлями за годинниковою стрілкою. Перший цикл зчитує та відкидає 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

Вводимо ще 2х2 петлю за годинниковою стрілкою. Це відкидає головні 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]

Спробуйте тут

Віци, 12 9 (код) + 1 (новий рядок для оголошення функції) = 10 байт

\ o /

Очікує введення в стеці як рядок з наступним числом.

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.

СпробуйтеItOnline!

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.

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

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

Безумовно

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

Безумовно?

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

Зразок запущений на ideone .

Іржа, 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 завжди повертає текст, починаючи з правого боку. Якщо вказана довжина від'ємне число, $ ліворуч і $ право повертають весь текст мінус кількість символів з відповідних сторін.

$mid(<string>,<start>,[length])використовується для отримання підрядок з середини рядка. Start - це початок підрядок зліва. Від’ємне значення вказує на початок справа. В обох випадках може бути вказана необов'язкова довжина. Негативна довжина може бути використана для видалення цих знаків з кінця. Тому я використовував його для отримання другого символу та другого останнього символу, використовуючи довжину вхідного рядка.

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

Станом на ще без назви мови (так нові неконкурентоспроможні), 9 байт

hD_RQ:Q|J

Ви можете знайти вихідний код тут , мова є абсолютно нестабільною (перший тестовий виклик для неї), тому не сподівайтеся, що вона буде працювати в майбутньому (виконувати 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, тому що двоцифрові числа - це біль у попці.

РЕДАКТУВАННЯ: Я висмоктав це і додав підтримку двоцифрових цифр. Прокладка з нулем для однозначних цифр.

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

Perl, 27 байт

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

Виконати як perl -p sdr.pl

Введення, задане на STDIN, перший рядок рядка, другий рядок count Припускає, що рядок містить лише символи "word"

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

неозорий

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