รับอาร์เรย์จำนวนเต็มและตัวเลขสองตัวเป็นอินพุตลบจำนวนแรกขององค์ประกอบแรกและสุดท้ายตามที่ระบุโดยตัวเลข อินพุตสามารถอยู่ในลำดับใดก็ได้ที่คุณต้องการ

คุณควรลบองค์ประกอบxแรกโดยที่xคืออินพุตตัวเลขแรกและลบองค์ประกอบyสุดท้ายโดยที่yคืออินพุตตัวเลขตัวที่สอง

อาร์เรย์ที่ได้นั้นรับประกันว่าจะมีความยาวอย่างน้อยสองตัว

ตัวอย่าง:

[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 ไบต์

บันทึกแล้ว 16 ไบต์ขอบคุณ Laikoni

บันทึกอีก 6 ไบต์ขอบคุณ Laikoni

บันทึกอีก 4 ไบต์ขอบคุณ Laikoni

แน่ใจว่าสิ่งนี้จะดีขึ้น แต่ในฐานะผู้เริ่มต้นให้ภาพที่ดีที่สุดของฉัน

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

การใช้

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

ลองออนไลน์!

อ็อกเทฟ 20 ไบต์

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

ลองออนไลน์!

Mathematica ขนาด 17 ไบต์

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

อินพุต

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

งูหลาม , 28 26 ไบต์

-2 ไบต์ขอบคุณ @Rod

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

ลองออนไลน์!

C # (. NET Core) , 55 54 ไบต์

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

ลองออนไลน์!

ใช้List<int>เป็นอินพุต

• บันทึก 1 ไบต์ขอบคุณ TheLethalCoder!

Perl 5 , 21 ไบต์

19 ไบต์ของรหัส + -apธง

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

ลองออนไลน์!

ใช้-aเพื่ออินพุตอัตโนมัติภายใน@Fโดยอัตโนมัติจากนั้นเก็บส่วนแบ่งตามอินพุตอื่น ๆ : จากดัชนี<>(อินพุตที่สอง) ไปยังดัชนี$#F-<>(ขนาดของอาร์เรย์ลบอินพุตที่สาม) และ$_พิมพ์โดยปริยายต้องขอบคุณ-pธง

สนิม 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

Neim , 3 ไบต์

𝕘₃𝕙

ลองที่นี่

ขอบคุณ Okx ที่สนับสนุนให้ฉันทำเช่นนี้ ... :)

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

TIS-100, 413 405 ไบต์

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

ดังนั้นฉันคิดว่านี่จะนับเป็นคำตอบ lua ...

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.

Java (OpenJDK 8) , 32 ไบต์

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

ลองออนไลน์!

ถ้าเรา จำกัด อาร์เรย์จริงๆมันคือ 53 ไบต์:

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

ลองออนไลน์!

JavaScript (ES6), 27 ไบต์

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

พารามิเตอร์ตัวที่สองที่เป็นค่าลบเพื่อsliceหยุดการแบ่งส่วนmจากจุดสิ้นสุดอย่างไรก็ตามเมื่อmเป็นศูนย์เราต้องส่งตัวยึดตำแหน่ง ( Infinityที่นี่แม้ว่าจะใช้(a,n,m,o)=>a.slice(n,-m||o)งานได้)

R , 32 31 30 ไบต์

-1 ไบต์ขอบคุณ Rift

-1 ไบต์ขอบคุณ Jarko Dubbeldam

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

หาค่าเป็นฟังก์ชันที่ไม่ระบุชื่อ:

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

1+lมีความจำเป็นเนื่องจาก R มีการจัดทำดัชนีแบบ 1 sum(n|1)เทียบเท่าlength(n)แต่สั้นกว่าไบต์

ลองออนไลน์!

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

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

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

PHP> = 7.1, 59 ไบต์

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

PHP Sandbox ออนไลน์

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
    ([]){{}({}<>)<>([])}{}<>

>)[()]}{}

APL (Dyalog) 5 ไบต์

(⌽↓)/

ลองออนไลน์!

รูปแบบอินพุตคือ y x A

คำอธิบาย

/ คือลดซึ่งแทรกฟังก์ชั่นทางด้านซ้ายระหว่างองค์ประกอบของการโต้แย้งแต่ละคู่

(⌽↓)เป็นฟังก์ชั่นการฝึกอบรมเทียบเท่ากับ{⌽⍺↓⍵}ซึ่งจะลบ⍺องค์ประกอบแรกของอาร์เรย์⍵และจากนั้นกลับอาร์เรย์ ( ⍺เป็นอาร์กิวเมนต์ด้านซ้ายและ⍵เป็นอาร์กิวเมนต์ที่ถูกต้อง)

ดังนั้นจึง(⌽↓)/y x Aเทียบเท่ากับ⌽y↓⌽x↓Aซึ่งเป็นสิ่งที่จำเป็น

Java 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()วิธีสำเนาอาร์เรย์จาก array ต้นทางที่ระบุเริ่มต้นที่ตำแหน่งที่ระบุตำแหน่งที่ระบุไว้ของอาร์เรย์ปลายทาง subsequence ของส่วนประกอบอาร์เรย์จะถูกคัดลอกจากแถวแหล่งที่มาอ้างอิงโดยอาร์เรย์ปลายทางโดยอ้างอิงจากsrc destจำนวนขององค์ประกอบที่คัดลอกจะเท่ากับlengthอาร์กิวเมนต์

ส่วนประกอบที่ตำแหน่งsrcPosผ่านsrcPos + length - 1ในอาร์เรย์ต้นทางจะถูกคัดลอกไปยังตำแหน่งdestPosผ่านdestPos + length - 1ตามลำดับของอาร์เรย์ปลายทาง

C ++, 50 48 46 ไบต์

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

ลองออนไลน์!

Kotlinขนาด 30 ไบต์

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

ลองออนไลน์!

ใช้List<Int>เป็นอินพุตและดร็อปตั้งแต่เริ่มต้นและจากท้าย

Brachylogขนาด11 10 ไบต์

kb₍B&t;Bk₍

ลองออนไลน์!

รับอินพุตเป็น [x, A, y] โดยที่ A คืออาร์เรย์ที่จะตัดแต่ง

(-1 ไบต์ขอบคุณ @Faleize)

Dyalog APL ขนาด 16 ไบต์

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

ลองออนไลน์!

Pyth, 5 ไบต์

>E<QE

ลองที่นี่

รับอาร์กิวเมนต์ตามลำดับตรงกันข้าม <และ>ในการตัด Pyth ตามลำดับอาร์กิวเมนต์ ตัวอย่างเช่น<Q5จะตัดค่าทั้งหมดในอินพุตหลังจากค่าที่ห้า

tcl, 19

lrange $L $x end-$y

ที่Lเป็นอาร์เรย์

การสาธิต

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]

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)

แร็กเก็ต, 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)