Cho một mảng số nguyên và hai số làm đầu vào, loại bỏ một lượng nhất định của các phần tử đầu tiên và cuối cùng, được chỉ định bởi các số. Đầu vào có thể theo bất kỳ thứ tự nào bạn muốn.

Bạn nên loại bỏ các phần tử x đầu tiên , trong đó x là đầu vào số đầu tiên và cũng loại bỏ các phần tử y cuối cùng , trong đó y là đầu vào số thứ hai.

Mảng kết quả được đảm bảo có độ dài ít nhất hai.

Ví dụ:

[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]

Haskell, 55 39 33 29 byte

Đã lưu 16 byte nhờ Laikoni

Đã lưu thêm 6 byte nhờ Laikoni

Đã lưu thêm 4 byte nhờ Laikoni

Chắc chắn điều này có thể được cải thiện, nhưng là người mới bắt đầu, đã cho nó bức ảnh đẹp nhất của tôi.

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

Sử dụng

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

Hãy thử trực tuyến!

Octave, 20 byte

@(a,x,y)a(x+1:end-y)

Hãy thử trực tuyến!

Toán học, 17 byte

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

đầu vào

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

Python , 28 26 byte

-2 byte nhờ @Rod

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

Hãy thử trực tuyến!

C # (.NET Core) , 55 54 byte

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

Hãy thử trực tuyến!

Sử dụng List<int>như là một đầu vào.

• Lưu 1 byte nhờ TheLethalCoder!

Perl 5 , 21 byte

19 byte mã + -apcờ.

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

Hãy thử trực tuyến!

Sử dụng -ađể tự động đặt đầu vào bên trong @F, sau đó chỉ giữ một lát của nó theo các đầu vào khác: từ chỉ mục <>(đầu vào thứ hai) đến chỉ mục $#F-<>(kích thước của mảng trừ đầu vào thứ ba). Và $_được in ngầm nhờ -pcờ.

Rust, 29 byte

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

Gọi nó như sau:

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

Tôi đã có rất nhiều niềm vui khi chiến đấu với người kiểm tra mượn để tìm ra cách tiếp cận ngắn nhất là gì để nó có thể suy ra thời gian của một lát cắt được trả lại. Hành vi của nó xung quanh việc đóng cửa có phần thất thường, vì nó sẽ suy ra thời gian sống, nhưng chỉ khi bạn không thực sự khai báo tham số là một kiểu tham chiếu. Thật không may, điều này mâu thuẫn với việc được yêu cầu xác định loại đối số trong chữ ký là lệnh gọi phương thức n.len cần biết loại nó đang hoạt động.

Các cách tiếp cận khác tôi đã cố gắng giải quyết vấn đề này:

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

Neim , 3 byte

𝕘₃𝕙

Hãy thử nó ở đây

Cảm ơn Okx đã khuyến khích tôi làm điều này ... :)

C #, 62 byte

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

Lấy một List<int>làm đầu vào và trả về một IEnumerable<int>.

Điều này cũng hoạt động cho 64 byte:

using System.Linq;(l,x,y)=>l.Skip(x).Reverse().Skip(y).Reverse()

TIS-100, 413 405 byte

472 chu kỳ, 5 nút, 35 dòng mã

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 ở trên cùng không phải là một phần của mã, nhưng báo hiệu vị trí của các mô-đun bộ nhớ.

Chơi cấp độ này bằng cách dán này vào trò chơi:

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

Vì vậy, tôi cho rằng điều này cũng được tính là một câu trả lời lua ...

MATL , 6 byte

QJi-h)

Hãy thử trực tuyến!

Đầu vào được cho là 1) số phần tử cần cắt từ đầu; 2) số phần tử cần cắt từ cuối; 3) mảng. Giải trình

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.

Java (OpenJDK 8) , 32 byte

(l,i,j)->l.subList(i,l.size()-j)

Hãy thử trực tuyến!

Nếu chúng ta thực sự hạn chế các mảng, thì đó là 53 byte:

(a,i,j)->java.util.Arrays.copyOfRange(a,i,a.length-j)

Hãy thử trực tuyến!

JavaScript (ES6), 27 byte

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

Một tham số thứ hai âm để slicedừng cắt mtừ cuối, tuy nhiên khi mbằng 0, chúng ta phải vượt qua một trình giữ chỗ ( Infinityở đây, mặc dù (a,n,m,o)=>a.slice(n,-m||o)cũng hoạt động).

R , 32 31 30 byte

-1 byte nhờ Rift

-1 byte nhờ Jarko Dubbeldam

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

Đánh giá một chức năng ẩn danh:

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

1+llà cần thiết vì R có lập chỉ mục dựa trên 1. sum(n|1)tương đương với length(n)nhưng nó ngắn hơn một byte.

Hãy thử trực tuyến!

MATL , 10 byte

tniQwi-&:)

Hãy thử trực tuyến!

Giải trình:

Nó hơi dài chỉ 11 byte, nhưng tôi cũng đang viết nó một cách chi tiết, để tự học nó.

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

C ++, 96 95 byte

Cảm ơn @Tas vì đã tiết kiệm một byte!

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

Hãy thử trực tuyến!

C ++ (MinGW), 91 byte

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

APL (Dyalog) , 8 7 byte

⌽⎕↓⌽⎕↓⎕

Hãy thử trực tuyến!

Điều này lấy mảng làm đầu vào đầu tiên, theo sau là hai số riêng biệt.

Giải trình

⎕            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

PHP> = 7.1, 59 byte

<?[$a,$b,$e]=$_GET;print_r(array_slice($a,$b,$e?-$e:NULL));

PHP Sandbox trực tuyến

Brain-Flak , 60 byte

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

Hãy thử trực tuyến!

Đầu vào ở định dạng này:

x

a
r
r
a
y

y

Trong trường hợp xlà số lấy từ phía trước, ylà số lấy từ phía sau, và mảng chỉ là tuy nhiên nhiều số điện thoại bạn muốn, ngăn cách bởi dòng mới. Đây là hai lần thử đầu tiên (dài hơn) của tôi:

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

Và đây là một lời giải thích:

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

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

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

>)[()]}{}

APL (Dyalog) , 5 byte

(⌽↓)/

Hãy thử trực tuyến!

Định dạng đầu vào là y x A

Giải trình

/ là Giảm, sẽ chèn hàm sang trái giữa mỗi cặp phần tử của đối số

(⌽↓)là một hàm chức năng tương đương {⌽⍺↓⍵}, loại bỏ các ⍺phần tử đầu tiên của mảng ⍵và sau đó đảo ngược mảng. ( ⍺là đối số bên trái và ⍵là đối số bên phải)

Như vậy, (⌽↓)/y x Atương đương với ⌽y↓⌽x↓A, đó là những gì cần thiết.

Java 8, 82 byte

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

Hãy thử nó ở đây.

Thay thế bằng số byte tương tự ( 82 ) bằng cách sử dụng vòng lặp:

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

Hãy thử nó ở đây.

Giải trình:

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

Các java.lang.System.arraycopy()phương pháp bản sao một mảng từ mảng nguồn quy định, bắt đầu ở vị trí quy định, đến vị trí cụ thể của mảng đích. Một chuỗi các thành phần mảng được sao chép từ mảng nguồn được tham chiếu srcđến mảng đích được tham chiếu bởi dest. Số lượng thành phần được sao chép bằnglength đối số.

Các thành phần tại các vị trí srcPosthông qua srcPos + length - 1trong mảng nguồn được sao chép vào các vị trí destPosthông qua destPos + length - 1, tương ứng, của mảng đích.

C ++, 50 48 46 byte

#define f(a,x,y)decltype(a)(&a[x],&*a.end()-y)

Hãy thử trực tuyến!

Kotlin , 30 byte

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

Hãy thử trực tuyến!

Lấy List<Int>làm đầu vào và giảm từ đầu và sau đó từ cuối.

Brachylog , 11 10 byte

kb₍B&t;Bk₍

Hãy thử trực tuyến!

Lấy đầu vào là [x, A, y] trong đó A là mảng cần cắt.

(-1 byte nhờ vào @Firthize.)

APL Dyalog, 16 byte

{(⍵↓⍨⊃⍺)↓⍨-⍺[2]}

Hãy thử trực tuyến!

Bình thường, 5 byte

>E<QE

Hãy thử nó ở đây

Đưa các đối số theo thứ tự ngược lại. <và >trong Pyth trim dựa trên thứ tự đối số. Ví dụ: <Q5sẽ cắt bỏ tất cả các giá trị trong đầu vào sau giá trị thứ năm.

tcl, 19

lrange $L $x end-$y

nơi Llà mảng.

bản giới thiệu

CJam , 8 byte

{_,@-<>}

Khối ẩn danh nhận các đầu vào từ ngăn xếp theo thứ tự x , y , mảng và thay thế chúng bằng mảng đầu ra.

Hãy thử trực tuyến!

Giải trình

Xem xét đầu vào 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]

q / kdb, 12 byte

Dung dịch:

{(0-z)_y _x}

Thí dụ:

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

Giải trình:

{          } / lambda function
          x  / input array
       y _   / drop y elements from .. (takes from start)
 (0-z)       / negative z ()
      _      / drop -z elements from ... (takes from end)

Vợt, 33 byte

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

Nó có thể được gọi như vậy:

((λ(a i j)(drop-right(drop a i)j)) '(1 2 3 4 5 6) 2 1)