배열을 정리하십시오!

27

정수 배열과 두 개의 숫자를 입력으로 받으면 숫자로 지정된 특정 양의 첫 번째 요소와 마지막 요소를 제거하십시오. 원하는 순서대로 입력 할 수 있습니다.

첫 번째 x 요소 (여기서 x 는 첫 번째 숫자 입력)를 제거하고 마지막 y 요소 (여기서 y 는 두 번째 숫자 입력) 도 제거해야 합니다.

결과 배열의 길이는 2 이상이어야합니다.

예 :

[1 2 3 4 5 6] 2 1 -> [3 4 5]
[6 2 4 3 5 1 3] 5 0 -> [1 3]
[1 2] 0 0 -> [1 2]
code-golf  array-manipulation 
— 옥스
소스
2
정확히 배열에서 값을 "제거"한다는 것은 무엇을 의미합니까? 특히 값을 제거하는 것은 무엇입니까? 배열이 첫 번째 요소와 길이에 대한 포인터 인 C와 같은 언어에서 길이를 변경하여 배열을자를 수 있습니까? 그것이 실제 프로그래밍에서 일반적 으로 수행되는 것입니다. 그러나 도전은 분명하지 않습니다.
— 코디 그레이
@CodyGray 배열에서 값을 제거하는 것이 모양 과 동일하지만 반드시 배후에서 진행되는 것은 아닙니다.
— Okx
4
"모양"이란 무슨 뜻입니까? 배열은없는 모양을 - 그것이 모든 배후를!
— 코디 그레이
1
— Okx
2
@Okx Nope, 매우 버그가 많으므로 리더 보드를 추가하는 것이 좋습니다.
— Outgolfer Erik

답변:

16

하스켈, 55 39 33 29 바이트

Laikoni 덕분에 16 바이트 절약

Laikoni 덕분에 6 바이트 더 절약

Laikoni 덕분에 4 바이트 더 절약

이것이 향상 될 수 있다고 확신하지만 초보자는 최선을 다했습니다.

r=(reverse.).drop
a#b=r b.r a

용법

(5#0) [6,5,4,3,2,1,3]

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

— 헨리
소스
5
특히 PPCG와 Haskell 골프에 오신 것을 환영합니다! 목표는 가능한 적은 바이트를 사용하는 것이므로 예를 들어 대부분의 공백을 제거하고 단축 할 수 xs있습니다.
— Laikoni
@ Laikoni 아, 감사합니다! 편집 된 익명 함수없이 함수가 짧아지는 것을 볼 수 없습니다.
— Henry
지금 좋아 보인다! 당신이 변경하는 경우 : f x a b에 f a b x, 당신은 간단하게 삭제할 수 있습니다 x: f a b=reverse.drop b.reverse.drop a.
— Laikoni
1
@ Laikoni 와우, 재미있는 삽입 트릭. 다시 감사합니다! 나는 그것을 33 바이트로 줄일 수 있었지만 시도 a#b=let r=reverse in r.drop b.r.drop a는 38 바이트입니다. 아니면이 함수 외부에서 선언 된 함수를 사용할 수 있습니까?
— Henry
1
@Laikoni 소개해 주셔서 감사합니다. 매우 도움이되었습니다. 오늘이 사이트를 찾았지만 여기에서 더 많은 것을 기대하십시오!
— Henry
6

매스 매 티카, 17 바이트

#[[#2+1;;-#3-1]]&

입력

[{1, 2, 3, 4, 5, 6}, 2, 1]

— J42161217
소스
의 좋은 사용 ;;! 나는 Drop@##2~Drop~-#&( 당신 이 입력을 이상한 순서로 가져 가면) 당신과 연결 1, {1,2,3,4,5,6}, 2했지만 더 나아지지 않았습니다.
— Greg Martin
6

파이썬 , 28 26 바이트

@Rod 덕분에 -2 바이트

lambda a,n,m:a[n:len(a)-m]

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

— ovs
소스
6 저장 ...lambda a,n,m:a[n:~m]
— Aaron
@Aaron 이것은 하나의 항목을 너무 많이 제거합니다.
— ovs
나의 나쁜 .. 그것은 때때로 사용하는 일반적인 속임수이며, 도전의 요구 사항을 완전히 확인하지 못했습니다 ..
— Aaron
@Aaron 슬라이스는 연산자보다 우선 순위가 높 +으므로에 적용됩니다 [0]. 괄호가 필요합니다 : (a+[0])[n:~m].
— ovs
아아, 나중에 깨달았 어. 나는 아이디어를 작동 시키려고 노력하고있다
— Aaron
6

C # (. NET 코어) , 55 54 바이트

using System.Linq;(a,x,y)=>a.Skip(x).Take(a.Count-x-y)

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

List<int>입력을 사용합니다 .

  • TheLethalCoder 덕분에 1 바이트가 절약되었습니다!
— 야경
소스
1
나는이 +1에 대답하려고했습니다. 그러나 대신 List입력 을 사용하여 바이트를 저장하여 Count대신 사용할 수 있습니다 Length.
— TheLethalCoder
나는 그것을 사용하여 솔루션을 생각해 냈습니다. Where이 방법보다 약간 길어서도 꽤 행복합니다 :)
— TheLethalCoder
using System.Linq;바이트 수 에 추가 할 필요가 없습니다. :)
— Stefan
@ 스테판 나는 using내 답변에 추가하는 모든 것을 계산해야 하며 방법 Skip과 Take필요합니다 using.
— Charlie
흠. 괜찮아. 다른 도전에서 나는 필요하지 않은 곳에서 사용한다고 들었습니다.
— Stefan
5

펄 5 , 21 바이트

19 바이트의 코드 + -ap플래그.

$_="@F[<>..$#F-<>]"

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

용도 -a입력 내부 자동 구분하기는 @F다음 만 다른 입력에 따라 슬라이스 유지 : 인덱스에서 <>(제 2 입력) 색인 $#F-<>(배열 마이너스 번째 입력의 크기). 그리고 플래그 $_덕분에 암시 적으로 인쇄됩니다 -p.

— 다다이즘
소스
5

녹, 29 바이트

|n,i,j|&n[i..<[_]>::len(n)-j]

다음과 같이 호출하십시오.

let a = &[1, 2, 3, 4, 5, 6];
let f = |n,i,j|&n[i..<[_]>::len(n)-j];
f(a, 2, 1)

나는 가장 짧은 접근법이 반환 된 슬라이스의 수명을 추론하기 위해 무엇인지 알아내는 빌리 체커와 많은 싸움을 벌였습니다. 클로저에 대한 동작은 수명을 유추하기 때문에 다소 불규칙하지만 실제로 매개 변수를 참조 유형으로 선언하지 않은 경우에만 가능합니다. 불행히도 이것은 n.len 메소드 호출이 작동하는 유형을 알아야하므로 서명에서 인수 유형을 정의 해야하는 것과 충돌합니다.

이 문제를 해결하기 위해 시도한 다른 접근법 :

fn f<T>(n:&[T],i:usize,j:usize)->&[T]{&n[i..n.len()-j]}     // full function, elided lifetimes
let f:for<'a>fn(&'a[_],_,_)->&'a[_]=|n,i,j|&n[i..n.len()-j] // type annotation only for lifetimes. Currently in beta.
|n:&[_],i,j|n[i..n.len()-j].to_vec()                        // returns an owned value
|n,i,j|&(n as&[_])[i..(n as&[_]).len()-j]                   // casts to determine the type
|n,i,j|&(n:&[_])[i..n.len()-j]                              // type ascription (unstable feature)
|n,i,j|{let b:&[_]=n;&b[i..b.len()-j]}                      // re-assignment to declare the type
— 검열 된 사용자 이름
소스
4

C #, 62 바이트

using System.Linq;(l,x,y)=>l.Where((n,i)=>i>=x&i<=l.Count-y-1)

List<int>를 입력으로 취하고를 반환합니다 IEnumerable<int>.

이것은 64 바이트에서도 작동합니다.

using System.Linq;(l,x,y)=>l.Skip(x).Reverse().Skip(y).Reverse()
— TheLethalCoder
소스
4

TIS-100, 413405 바이트

472 사이클, 5 노드, 35 라인 코드

m4,6
@0
MOV 0 ANY
S:MOV UP ACC
JEZ A
MOV ACC ANY
JMP S
A:MOV RIGHT ACC
L:JEZ B
MOV DOWN NIL
SUB 1
JMP L
B:MOV 0 RIGHT
MOV RIGHT NIL
@1
MOV RIGHT LEFT
MOV LEFT DOWN
MOV RIGHT DOWN
MOV DOWN LEFT
@2
MOV UP ACC
MOV UP LEFT
MOV ACC LEFT
@4
MOV 0 RIGHT
MOV UP NIL
S:MOV LEFT ACC
JEZ A
MOV ACC RIGHT
JMP S
A:MOV UP ACC
L:JEZ B
MOV RIGHT NIL
SUB 1
JMP L
B:MOV 0 UP
K:MOV RIGHT ACC
MOV ACC DOWN
JNZ K
@7
MOV UP ANY

상단의 m4,6은 코드의 일부가 아니지만 메모리 모듈의 배치를 나타냅니다.

여기에 이미지 설명을 입력하십시오

이것을 게임에 붙여 넣어이 레벨을 직접 플레이하십시오 :


function get_name()
    return "ARRAY TRIMMER"
end
function get_description()
    return { "RECIEVE AN ARRAY FROM IN.A", "RECIEVE TWO VALUES A THEN B FROM IN.T", "REMOVE THE FIRST A TERMS AND LAST B TERMS FROM IN.A", "ARRAYS ARE 0 TERMINATED" }
end

function get_streams()
    input = {}
    trim = {}
    output = {}

  arrayLengths = {}

    a = math.random(1,5) - 3

    b = math.random(1,7) - 4

    arrayLengths[1] = 9+a
    arrayLengths[2] = 9+b
    arrayLengths[3] = 8-a
    arrayLengths[4] = 9-b

    s = 0

    trimIndex = 1

  for i = 1,4 do
      for k = 1,arrayLengths[i] do
          x = math.random(1,999)
      input[k+s] = x
            output[k+s] = x
        end

        input[s + arrayLengths[i] + 1]= 0
        output[s + arrayLengths[i] + 1]= 0

        a = math.random(0,3)
        b = math.random(0,arrayLengths[i]-a)

        trim[trimIndex] = a
        trim[trimIndex+1] = b

        trimIndex = trimIndex + 2

    s = s + arrayLengths[i] + 1
    end

    s = 1
    trimIndex = 1

    for i = 1,4 do

      for i = s,s+trim[trimIndex]-1 do
          output[i]=-99
        end

        for i = s + arrayLengths[i] - trim[trimIndex+1], s + arrayLengths[i]-1 do
      output[i]=-99
        end

  trimIndex = trimIndex +2
  s = s + arrayLengths[i] + 1
    end

    trimmedOut = {}
    for i = 1,39 do
            if(output[i] ~= -99) then
                    table.insert(trimmedOut, output[i])
            end
    end

    return {
        { STREAM_INPUT, "IN.A", 0, input },
        { STREAM_INPUT, "IN.T", 2, trim },
        { STREAM_OUTPUT, "OUT.A", 1, trimmedOut },
    }
end
function get_layout()
    return {
        TILE_COMPUTE,   TILE_COMPUTE,   TILE_COMPUTE,   TILE_COMPUTE,
        TILE_MEMORY,    TILE_COMPUTE,    TILE_MEMORY,   TILE_COMPUTE,
        TILE_COMPUTE,   TILE_COMPUTE,   TILE_COMPUTE,   TILE_COMPUTE,
    }
end

그래서 이것이 루아 답변으로 계산된다고 생각합니다 ...

— 스팸 메일
소스
이제 온라인으로 사용해 볼 수 있습니다! 참고 : TIO는 현재 단일 입력 파일 만 제공하기 때문에 영리한 작업을 수행하고 코드 파일의 상단을 하나의 입력 소스로 사용했습니다.
— Phlarx
4

MATL , 6 바이트

QJi-h)

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

입력은 1) 시작부터 트리밍 할 요소 수로 제공됩니다. 2) 끝에서 다듬을 요소의 수; 3) 배열. 설명

Q   % Implicit input (1). Increment by 1, since MATL indexing is 1-based.
Ji- % Complex 1i minus real input (2). In MATL, the end of the array is given by `1i`.
h   % Concatenate indices to get range-based indexing 1+(1):end-(2).
)   % Index into (implicitly taken) input array. Implicit display.
— 상치
소스
3

자바 스크립트 (ES6), 27 바이트

(a,n,m)=>a.slice(n,-m||1/m)

끝에서 slice슬라이싱 을 중지 하는 음의 두 번째 매개 변수 m이지만 m0이 되면 자리 표시자를 전달해야합니다 ( Infinity여기 (a,n,m,o)=>a.slice(n,-m||o)에서도 작동).

— 닐
소스
3

R , 32 31 30 바이트

리프트 덕분에 -1 바이트

Jarko Dubbeldam 덕분에 -1 바이트

pryr::f(n[(1+l):(sum(n|1)-r)])

익명 함수로 평가합니다.

function (l, n, r) 
    n[(1 + l):(sum(n|1) - r)]

1+lR에는 1 기반 색인이 있으므로 필요합니다. sum(n|1)동일 length(n)하지만 바이트가 더 짧습니다.

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

— 주세페
소스
1
1 바이트 절약pryr::f(n[(1+l):(length(n)-r)])
— Rift
1
Sum (n | 1)이 length (n)보다 짧습니다.
— JAD
@JarkoDubbeldam 훌륭합니다, 감사합니다.
— 주세페
3

MATL , 10 바이트

tniQwi-&:)

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

설명:

11 바이트에 대해서는 조금 길지만 직접 배우기 위해 자세히 작성하고 있습니다.

---- Input ----
[1 2 3 4 5 6]
2
1
----- Code ----
           % Implicit first input
t          % Duplicate input.
           % Stack: [1 2 3 4 5 6], [1 2 3 4 5 6]
 n         % Number of elements
           % Stack: [1 2 3 4 5 6], 6
  i        % Second input
           % Stack: [1 2 3 4 5 6], 6, 2
   Q       % Increment: [1 2 3 4 5 6], 6, 3
    w      % Swap last two elements
           % Stack: [1 2 3 4 5 6], 3, 6
     i     % Third input
           % Stack: [1 2 3 4 5 6], 3, 6, 1
      -    % Subtract
           % Stack: [1 2 3 4 5 6], 3, 5
       &:  % Range with two input arguments, [3 4 5]
           % Stack: [1 2 3 4 5 6], [3 4 5]
         ) % Use as index
           % Stack: [3 4 5]
           % Implicit display
— 스튜이 그리핀
소스
최종 기반 인덱싱을 잊어 버렸습니다 ;)
— Sanchises
(여전히 upvote에이 -이 잘 golfed 있다고 생각하고 사용하는 방법을 고려 설명)
— Sanchises
아니, 나는 그것을 잊지 않았다! 나는 시도했지만 작동시키는 방법을 알지 못했습니다 (실제로 시도했습니다). 나는 J이와 같이 사용될 때에서 무언가를 빼는 것이 불가능하다는 결론을 내렸다 . 나는 당신의 대답에 연결하기위한, 난 그냥 내 인생을 알아낼 수 ... 감사 잘못 의심, 나는 ... 아주 많이 MATL 초보자를 해요
— 스튜이 그리핀
예를 들어, 입력 순서에 -하지 마십시오 걱정, 난 아주 많이 여전히 학습도있어 )더 악명 ( 전율 ...
— Sanchises
@ Sanchises 매우 늦은 의견이지만 (혼란 스러울 수 있는 입력 순서를 찾는 것이 나에게만 기쁘지 않습니다 . :) 매번 "ddi"(= "매뉴얼에서"목적지, 데이터, 색인 ")를 낭송했지만 여전히 잘못되었습니다.
— sundar-복원 모니카
3

C ++, 96 95 바이트

바이트를 저장해 준 @Tas에게 감사합니다!

#import<list>
int f(std::list<int>&l,int x,int y){for(l.resize(l.size()-y);x--;)l.pop_front();}

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

C ++ (MinGW), 91 바이트

#import<list>
f(std::list<int>&l,int x,int y){for(l.resize(l.size()-y);x--;)l.pop_front();}
— 스테디 박스
소스
당신은 의미 했습니까 #include<list>? 를 사용 하여 바이트를 면도 할 수int f 있습니다. 컴파일러는 함수가 리턴하지 않도록 허용하지만 경고하지 않습니다.
— Tas
그래, 고마워, int f대부분의 컴파일러에서 작동 할 것입니다. 나는 그것을 편집 할 것입니다. MinGW에서는 함수의 유형을 완전히 생략해도 작동합니다. 예, #include<list>헤더를 포함하는 표준 호환 방법이지만 #import<list>적어도 GCC, MinGW 및 MSVC에서 작동해야하므로 괜찮습니다.
— Steadybox
2

APL (Dyalog) , 8 7 바이트

⌽⎕↓⌽⎕↓⎕

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

이것은 배열을 첫 번째 입력으로 취한 다음 두 숫자를 개별적으로 취합니다.

설명

⎕            from the input array
⎕↓           drop the first input elements
⌽            reverse the array
⎕↓           drop first input elements
⌽            reverse again to go back to the original array
— 크리 티시 리 토스
소스
대체 7 바이트 솔루션 :⎕↓⎕↓⍨-⎕
— Adám
2

Brain-Flak , 60 바이트

(()()){({}<{({}<{}>[()])}{}([]){{}({}<>)<>([])}{}<>>[()])}{}

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

입력 형식은 다음과 같습니다.

x

a
r
r
a
y

y

x앞면에서 가져 오는 숫자는 어디 y에서, 뒷면에서 가져 오는 숫자는 어디에서나 배열은 개행으로 구분 된 원하는 숫자입니다. 다음은 처음 두 번의 더 긴 시도입니다.

({}<>)<>{({}<{}>[()])}([])<>({}<><{{}({}<>)<>([])}{}><>){({}<{}>[()])}{}([]){{}({}<>)<>([])}<>{}
{({}<{}>[()])}{}([]){{}({}<>)<>([])}{}<>{({}<{}>[()])}{}([]){{}({}<>)<>([])}<>

그리고 여기에 설명이 있습니다 :

#Two times:
(()()){({}<

    #Remove *n* numbers from the top of the stack
    {({}<{}>[()])}{}

    #Reverse the whole stack
    ([]){{}({}<>)<>([])}{}<>

>)[()]}{}
— DJMcMayhem
소스
1
가끔씩 타르타르 솔루션을 만나서 반가워요.
— Okx
2

APL (Dyalog) , 5 바이트

(⌽↓)/

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

입력 형식은 y x A

설명

/ Reduce는 인수의 각 요소 쌍 사이에서 왼쪽에 함수를 삽입합니다.

(⌽↓)는 함수와 동일하며 {⌽⍺↓⍵}, ⍺배열 의 첫 번째 요소 를 제거한 ⍵다음 배열 을 반대로합니다. ( ⍺왼쪽 인수이고 ⍵오른쪽 인수입니다)

따라서 필요한 (⌽↓)/y x A것과 동일한 ⌽y↓⌽x↓A입니다.

— TwiNight
소스
2

자바 8, 82 바이트

a->n->m->{int l=a.length-m-n,r[]=new int[l];System.arraycopy(a,n,r,0,l);return r;}

여기에서 시도하십시오.

루프를 사용하여 동일한 ( 82 ) 바이트 수를 가진 대안 :

(a,n,m)->{int l=a.length-m,r[]=new int[l-n],i=0;for(;n<l;r[i++]=a[n++]);return r;}

여기에서 시도하십시오.

설명:

a->n->m->{                      // Method with integer-array and two integer parameters and integer-array return-type
  int l=a.length-m-n,           //  Length of the array minus the two integers
      r[]=new int[l];           //  Result integer-array
  System.arraycopy(a,n,r,0,l);  //  Java built-in to copy part of an array to another array
  return r;                     //  Return result-String
}                               // End of method

System.arraycopy:

arraycopy(Object src, int srcPos, Object dest, int destPos, int length):

이 java.lang.System.arraycopy()메소드는 지정된 위치에서 시작하여 지정된 소스 배열에서 대상 배열의 지정된 위치로 배열을 복사합니다. 배열 구성 요소의 하위 시퀀스는에서 참조하는 소스 배열에서 참조 src하는 대상 배열 로 복사 됩니다 dest. 복사 된 구성 요소의 수는 length인수와 같습니다.

위치의 요소 srcPos를 통해 srcPos + length - 1소스 어레이는 위치로 복사 destPos를 통해 destPos + length - 1목적지 어레이의 각각.

— 케빈 크루이 센
소스
카레를 사용하지 않고 바이트를 절약 할 수 있습니까?
— TheLethalCoder 2016 년
이 경우에는 @TheLethalCoder 아니요. (a,n,m)->와 동일한 바이트 수를 갖습니다 a->n->m->. 당신이 옳았지만 카레 대신 정기적 인 전화를 사용했을 수 있습니다. 나는 두 개 이상의 매개 변수가있을 때 카레를 사용하는 데 익숙합니다 .. 네 개의 매개 변수가 몇 번있을 때 카레를 사용하는 실수를 이미했습니다.
— Kevin Cruijssen
Ahh 당신은 맞습니다. 나는 바이트를 잘못 세었고 카레는 확실히 지금 가야한다는 것을했습니다!
— TheLethalCoder
TIO 링크가 없습니까? -
— totallyhuman
2
죄송합니다. 통과 할 수 없습니다. 내 자신의 답변을 게시 했기 때문에 ... 내장되어 있습니다 (정확하지는 않지만 거의)! : o
— Olivier Grégoire
2

코 틀린 , 30 바이트

{a,s,e->a.drop(s).dropLast(e)}

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

취하고 List<Int>입력으로 시작하고부터 삭제 후 단부로부터.

— 이골 리 베프
소스
1
에 액세스 할 수 없습니다 try it online. 발신자 코드를 추가 할 수 있습니까? Kotlin에서 유형 정의없이 람다를 어떻게 컴파일합니까? 감사.
— mazzy
1
@mazzy 아마도 해킹 일 수 있지만 변수 유형 정의에서 유형을 다음과 같이 지정할 수 있습니다.val f: (List<Int>, Int, Int) -> List<Int>
— YGolybev
알았다! 좋은. 이것이 CodeGolf에서 유효한지 모르겠습니다.
— mazzy
2

Brachylog , 11 10 바이트

kb₍B&t;Bk₍

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

입력을 [x, A, y]로 가져옵니다. 여기서 A는 트리밍 할 배열입니다.

(@Fatalize 덕분에 1 바이트)

— sundar-복원 모니카
소스
다음과 같이 1 바이트 씩 줄일 수 있습니다 kb₍B&t;Bk₍. ,추가 ( 이 부분 프로그램 의 결과 참조 )는 작동하지 않습니다 ∧. 또한 Brachylog는 언어의 첫 번째 버전이었으며 이전 버전 (2016-2017 년 초)의 답변을 복사하지 마십시오. 프로그램은 역 호환되지 않습니다 (특히 ,Brachylog v1은 현재 ∧Brachylog v2에 있음)
— Fatalize
@Fatalize 감사합니다. 그래서 ,이전 버전에 추가 않았다,하지만이 때문에 그것은 단지이 경우에는 중요하지 않았다 t어쨌든 후 - 운이 우연의 일치. 그리고 그래, 나는 이것을 게시 한 후에 버전 차이를 깨달았다. 나는 여전히이 단계에서 물건을 알아 내고 울퉁불퉁했다. :)
— sundar-복원 모니카
1

Pyth, 5 바이트

>E<QE

여기 사용해보십시오

인수를 반대 순서로 취합니다. <그리고 >인수 순서에 따라 Pyth 트림에서. 예를 들어, <Q5다섯 번째 값 다음에 입력의 모든 값을 제거합니다.

— FryAmTheEggman
소스
1

CJam , 8 바이트

{_,@-<>}

스택에서 x , y , 배열 순서로 입력을 가져 와서 출력 배열로 대체하는 익명 블록 .

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

설명

입력을 고려 2, 1, [10 20 30 40 50 60].

{      }    e# Block
            e# STACK: 2, 1, [10 20 30 40 50 60]
 _          e# Duplicate
            e# STACK: 2, 1, [10 20 30 40 50 60], [10 20 30 40 50 60]
  ,         e# Length
            e# STACK: 2, 1, [10 20 30 40 50 60], 6
   @        e# Rotate
            e# STACK: 2, [10 20 30 40 50 60], 6, 1
    -       e# Subtract
            e# STACK: 2, [10 20 30 40 50 60], 5
     <      e# Slice before
            e# STACK: 2, [10 20 30 40 50]
      >     e# Slice after
            e# STACK: [30 40 50]
— 루이스 멘도
소스
1
좋은 점은, 다음 그냥 재미, 여기에 다른 8 바이트 솔루션입니다 :) tio.run/##S85KzP1vxGXIFW1ooGBkoGBsoGBioGBqoGBmEPu/Olg7ps7GrvZ/...
— 마틴 청산
1

q / kdb, 12 바이트

해결책:

{(0-z)_y _x}

예:

q){(0-z)_y _x}[1 2 3 4 5 6;2;1]
3 4 5
q){(0-z)_y _x}[6 2 4 3 5 1 3;5;0]
1 3
q){(0-z)_y _x}[1 2;0;0]
1 2

설명:

{          } / lambda function
          x  / input array
       y _   / drop y elements from .. (takes from start)
 (0-z)       / negative z ()
      _      / drop -z elements from ... (takes from end)
— 스트리트 스터
소스
1

라켓, 33 바이트

(λ(a i j)(drop-right(drop a i)j))

다음과 같이 호출 할 수 있습니다.

((λ(a i j)(drop-right(drop a i)j)) '(1 2 3 4 5 6) 2 1)
— 궁극의 매
소스
해당 언어의 웹 사이트로 연결되는 링크가 있습니까?
— Okx
— Ultimate Hawk
당사 사이트를 사용함과 동시에 당사의 쿠키 정책과 개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.