소개

다음 문자열을 관찰하십시오.

ABCDEFGHIJKLMNOP

문자열 의 끝을 바꾸면 다음과 같습니다.

ABCDEFGHIJKLMNOP
^^            ^^

우리는 다음과 같은 결과를 얻습니다.

BACDEFGHIJKLMNPO

그런 다음 문자열의 끝을 삭제합니다 . 이 경우에는 Band O입니다. 결과는 다음과 같습니다.

ACDEFGHIJKLMNP

프로세스를 반복하면 다음 목록이 나타납니다.

N     Result

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

당신에 대한 것을 볼 수 N = 5 , 결과가 AGHIJP. 에서, N = 7 , 문자열의 길이보다 작은 3 N 있도록> 7이 고려되어, 잘못 이 경우.

작업

길이가 4 이상 이고 반복 횟수가 N > 0 인 문자열 S 가 주어지면 최종 결과가 출력됩니다. N이 항상 유효 하다고 가정 할 수 있습니다 .

테스트 사례

Input                               >  Output

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

이것은 code-golf 이므로 바이트 수가 가장 적은 제출이 승리합니다! 간단히하기 위해 문자열에 영숫자 만 포함한다고 가정 할 수 있습니다 .

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
반복 횟수와 문자열 사이에 공백이 없습니다.

24 바이트를 줄인 @ MartinBüttner 에게 감사 합니다!

온라인으로 사용해보십시오!

파이썬 2, 31 바이트

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

나는 이것이 효과가 있다고 생각합니까?

매스 매 티카, 29 바이트

내 첫 대답!

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

브라켓리스 Mathematica의 핵심! 함수 입력은 목록 (문자 등)과 숫자입니다.

미로 , 40 바이트

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

입력 N뒤에 숫자가 아닌 문자로 구분 된 문자열이옵니다.

온라인으로 사용해보십시오!

이것은 Sp3000과 공동으로 작성되었습니다. (알고리즘을 알아 내기 위해 귀찮게 할 수 없었기 때문에 알고리즘을 개발하기 시작했으며 118 바이트 솔루션을 제안했지만 골프를 타지 못했습니다. 그래서 골프를 쳤습니다. .. 팀워크를위한 예).

설명

Sp의 일반적인 프라이머 (보통 약간 수정 된대로) :

• Labyrinth는 기본 및 보조의 두 스택이있는 스택 기반 2D 언어입니다. 거의 모든 것이 기본 스택에서 발생하지만 값을 다른 값으로 이동하여 값을 바꾸거나 나중에 저장할 수 있습니다.
• 스택은 밑이없고 0으로 채워 지므로 빈 스택에서 터지는 것은 오류가 아닙니다.
• 첫 번째 유효한 문자 (여기서는 왼쪽 위)부터 실행이 시작됩니다. 명령어 포인터 (IP)가 취할 수있는 두 개 이상의 가능한 경로가있는 각 접점에서 스택의 맨 위를 확인하여 다음에 갈 곳을 결정합니다. 음수는 왼쪽이고, 0은 앞으로 가고 양수는 오른쪽입니다. 이는 동안 의미 , 구불 구불 한 구절 권선과 같은 코드를 보이게하기 위해, 이러한 조건은 모든 세포에 체크 "방"을 만들기에서 당신을 중지 아무것도 없다. 그것들은 예측할 수없는 행동을 낳을 수 있지만 골프에는 좋습니다.
• 소스 코드 (따라서 미로의 레이아웃)는 <>^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 공간으로 들어갑니다. 실제로 2 개의 압축 압축 된 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.

마지막으로로 프로그램을 종료합니다 @.

자바 스크립트 (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을 통해 숫자를 입력 하고 명령 행 args를 통해 문자열을 입력 하십시오 . @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!

파이썬 2, 49 48 바이트

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

테스트 케이스와 함께 여기에서 사용해보십시오!

간단한 재귀 솔루션. 입력 문자열에서 두 번째 및 마지막 두 번째 요소를 제거하고 this 및 n-1until로 자신을 호출합니다 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보수에하고 ...독점적 인 범위입니다.)

펄, 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는 항상 오른쪽부터 텍스트를 반환합니다. 지정된 길이가 음수이면 $ left 및 $ right는 각면에서 해당 문자의 수를 뺀 전체 텍스트를 반환합니다.

$mid(<string>,<start>,[length])문자열 중간에서 하위 문자열을 가져 오는 데 사용됩니다. 시작은 왼쪽에서 부분 문자열의 시작입니다. 음수 값은 오른쪽에서 시작을 나타냅니다. 두 경우 모두 선택적 길이를 지정할 수 있습니다. 음수 길이를 사용하여 끝에서 많은 문자를 제거 할 수 있습니다. 그래서 입력 문자열의 길이를 사용하여 두 번째 문자와 두 번째 마지막 문자를 검색하는 데 사용했습니다.

$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입니다.

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

이 멋진 사이트 에서 테스트 하십시오.

두 자리 숫자는 엉덩이에 통증이 있기 때문에 9 이하의 N으로 제한됩니다.

편집 : 나는 그것을 빨아 두 자리 숫자에 대한 지원을 추가했습니다. 한 자릿수는 0으로 채 웁니다.

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

펄, 27 바이트

에 +1 포함 -p

다음으로 실행 perl -p sdr.pl

STDIN에 제공된 입력, 첫 번째 줄, 두 번째 줄 개수 문자열에 "단어"문자 만 포함되어 있다고 가정

sdr.pl:

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

PHP, 60 바이트

이 솔루션은 입력 문자열의 문자를 색인별로 빈 문자열로 반복해서 설정합니다. long을 방지하기 위해 입력 문자열을 직접 조작하고 있습니다 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());
}

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