Diberikan array integer dan dua angka sebagai input, hapus sejumlah elemen pertama dan terakhir, ditentukan oleh angka. Input dapat dalam urutan apa pun yang Anda inginkan.

Anda harus menghapus elemen x pertama , di mana x adalah input numerik pertama, dan juga menghapus elemen y terakhir , di mana y adalah input numerik kedua.

Array yang dihasilkan dijamin memiliki panjang setidaknya dua.

Contoh:

[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

Disimpan 16 byte berkat Laikoni

Disimpan 6 byte lebih banyak berkat Laikoni

Disimpan 4 byte lebih banyak berkat Laikoni

Saya yakin ini bisa ditingkatkan, tetapi sebagai pemula, berikan yang terbaik.

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

Pemakaian

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

Cobalah online!

Oktaf, 20 byte

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

Cobalah online!

Mathematica, 17 byte

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

memasukkan

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

Python , 28 26 byte

-2 byte terima kasih kepada @Rod

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

Cobalah online!

C # (.NET Core) , 55 54 byte

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

Cobalah online!

Menggunakan List<int>input sebagai.

• 1 byte disimpan berkat TheLethalCoder!

Perl 5 , 21 byte

19 byte kode + -apbendera.

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

Cobalah online!

Menggunakan -auntuk otomatis memasukkan input di dalam @F, maka hanya menyimpan sepotong sesuai dengan input lainnya: dari indeks <>(input kedua) ke indeks $#F-<>(ukuran array dikurangi input ketiga). Dan $_dicetak secara tersirat berkat -pbendera.

Karat, 29 byte

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

Sebut saja sebagai berikut:

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

Saya banyak bersenang-senang berkelahi dengan pemeriksa pinjaman mencari tahu apa pendekatan yang paling pendek untuk membuatnya menyimpulkan seumur hidup dari potongan yang dikembalikan. Perilakunya di sekitar penutupan agak tidak menentu, karena akan menyimpulkan masa hidup, tetapi hanya jika Anda tidak benar-benar mendeklarasikan parameter sebagai tipe referensi. Sayangnya konflik ini dengan yang diperlukan untuk mendefinisikan tipe argumen dalam tanda tangan sebagai pemanggilan metode n.len perlu mengetahui jenis itu beroperasi.

Pendekatan lain saya mencoba mengatasi masalah ini:

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

𝕘₃𝕙

Coba di sini

Terima kasih kepada Okx karena mendorong saya untuk melakukan ini ... :)

C #, 62 byte

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

Mengambil List<int>input as dan mengembalikan IEnumerable<int>.

Ini juga berfungsi untuk 64 byte:

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

TIS-100, 413 405 Bytes

472 siklus, 5 node, 35 baris kode

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 di bagian atas bukan bagian dari kode, tetapi menandakan penempatan modul memori.

Mainkan level ini sendiri dengan menempelkan ini ke dalam permainan:

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

Jadi saya kira ini juga dianggap sebagai jawaban lua ...

MATL , 6 byte

QJi-h)

Cobalah online!

Input diberikan sebagai 1) jumlah elemen yang harus dipotong dari awal; 2) jumlah elemen yang harus dipotong dari ujung; 3) array. Penjelasan

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)

Cobalah online!

Jika kita benar-benar membatasi ke array, maka itu 53 byte:

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

Cobalah online!

JavaScript (ES6), 27 byte

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

Parameter kedua negatif untuk sliceberhenti mengiris mdari ujung, namun ketika mnol kita harus melewati placeholder (di Infinitysini, meskipun (a,n,m,o)=>a.slice(n,-m||o)juga berfungsi).

R , 32 31 30 byte

-1 byte berkat Rift

-1 byte terima kasih kepada Jarko Dubbeldam

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

Mengevaluasi fungsi anonim:

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

1+ldiperlukan karena R memiliki pengindeksan berbasis 1. sum(n|1)setara dengan length(n)tetapi satu byte lebih pendek.

Cobalah online!

MATL , 10 byte

tniQwi-&:)

Cobalah online!

Penjelasan:

Agak panjang untuk hanya 11 byte, tapi saya menulisnya secara rinci, untuk mempelajarinya sendiri juga.

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

Terima kasih kepada @Tas karena telah menghemat satu byte!

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

Cobalah online!

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

⌽⎕↓⌽⎕↓⎕

Cobalah online!

Ini mengambil array sebagai input pertama, diikuti oleh dua angka secara terpisah.

Penjelasan

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

Brain-Flak , 60 byte

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

Cobalah online!

Input dalam format ini:

x

a
r
r
a
y

y

Di mana xnomor yang akan diambil dari depan, ynomor yang akan diambil dari belakang, dan susunannya hanyalah berapa banyak angka yang Anda inginkan, dipisahkan oleh baris baru. Inilah dua upaya pertama saya (lebih lama):

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

Dan inilah penjelasannya:

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

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

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

>)[()]}{}

APL (Dyalog) , 5 byte

(⌽↓)/

Cobalah online!

Format input adalah y x A

Penjelasan

/ adalah Reduce, yang menyisipkan fungsi ke kiri di antara setiap pasangan elemen argumen

(⌽↓)adalah fungsi yang setara dengan kereta {⌽⍺↓⍵}, yang menghilangkan ⍺elemen pertama dari array ⍵dan kemudian membalikkan array. ( ⍺adalah argumen kiri dan⍵ argumen kanan)

Jadi, (⌽↓)/y x Asama dengan ⌽y↓⌽x↓A, yang dibutuhkan.

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

Coba di sini.

Alternatif dengan penghitungan byte yang sama ( 82 ) menggunakan loop:

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

Coba di sini.

Penjelasan:

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

The java.lang.System.arraycopy()Metode salinan array dari sumber array yang ditentukan, dimulai pada posisi yang ditentukan, untuk posisi tertentu dari array tujuan. Selanjutnya komponen array disalin dari array sumber yang dirujuk oleh srcke array tujuan yang direferensikan oleh dest. Jumlah komponen yang disalin sama denganlength argumen.

Komponen pada posisi srcPosmelalui srcPos + length - 1dalam larik sumber disalin ke posisi destPosmelalui destPos + length - 1, masing-masing, dari larik tujuan.

C ++, 50 48 46 byte

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

Cobalah online!

Kotlin , 30 byte

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

Cobalah online!

Dibawa List<Int>sebagai input dan turun dari awal dan kemudian dari ujung.

Brachylog , 11 10 byte

kb₍B&t;Bk₍

Cobalah online!

Mengambil input sebagai [x, A, y] dengan A adalah larik yang akan dipotong.

(-1 byte berkat @Fatalize.)

Dyalog APL, 16 byte

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

Cobalah online!

Pyth, 5 byte

>E<QE

Coba di sini

Membawa argumen dalam urutan yang berlawanan. <dan >dalam Pyth trim berdasarkan urutan argumen. Misalnya, <Q5akan memangkas semua nilai dalam input setelah yang kelima.

tcl, 19

lrange $L $x end-$y

dimana L array.

demo

CJam , 8 byte

{_,@-<>}

Blok anonim yang mengambil input dari tumpukan dalam urutan x , y , larik, dan menggantinya dengan larik keluaran.

Cobalah online!

Penjelasan

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

Larutan:

{(0-z)_y _x}

Contoh:

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

Penjelasan:

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

Racket, 33 byte

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

Ini bisa disebut seperti ini:

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