Trim the array!

Question

Given an integer array and two numbers as input, remove a certain amount of the first and last elements, specified by the numbers. The input can be in any order you want.

You should remove the first x elements, where x is the first numerical input, and also remove the last y elements, where y is the second numerical input.

The resulting array is guaranteed to have a length of at least two.

Examples:

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

Answer 1

Haskell, 55 39 33 29 bytes

Saved 16 bytes thanks to Laikoni

Saved 6 more bytes thanks to Laikoni

Saved 4 more bytes thanks to Laikoni

Am sure this could be improved, but as a beginner, gave it my best shot.

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

Usage

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

Try it online!

Answer 2

Mathematica, 17 bytes

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

input

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

Answer 3

Octave, 20 bytes

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

Try it online!

Answer 4

Python, 28 26 bytes

-2 bytes thanks to @Rod

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

Try it online!

Answer 5

C# (.NET Core), 55 54 bytes

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

Try it online!

Uses a List<int> as input.

• 1 byte saved thanks to TheLethalCoder!

Answer 6

Neim, 3 bytes

𝕘₃𝕙

Try it here

Thanks to Okx for encouraging me to do this...:)

Answer 7

TIS-100, 413 405 Bytes

472 cycles, 5 nodes, 35 lines of code

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

The m4,6 at the top is not part of the code, but signals the placement of the memory modules.

Play this level yourself by pasting this into the game:

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

So I suppose this also counts as a lua answer...

Answer 8

Java (OpenJDK 8), 32 bytes

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

Try it online!

If we really restrict to arrays, then it's 53 bytes:

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

Try it online!

Answer 9

Perl 5, 21 bytes

19 bytes of code + -ap flags.

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

Try it online!

Uses -a to autosplit the input inside @F, then only keep a slice of it according to the other inputs: from index <> (second input) to index $#F-<> (size of the array minus third input). And $_ is implicitly printed thanks to -p flag.

Answer 10

JavaScript (ES6), 27 bytes

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

A negative second parameter to slice stops slicing m from the end, however when m is zero we have to pass a placeholder (Infinity here, although (a,n,m,o)=>a.slice(n,-m||o) also works).

Answer 11

Rust, 29 bytes

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

Call it as follows:

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

I had a lot of fun fighting with the borrow checker figuring out what the shortest approach was in order to have it infer the lifetime of a returned slice. Its behavior around closures is somewhat erratic, as it will infer the lifetimes, but only if you do not actually declare the parameter as a reference type. Unfortunately this conflicts with being required to define the argument type in the signature as the n.len method call needs to know the type it's operating on.

Other approaches I tried working around this issue:

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

Answer 12

MATL, 6 bytes

QJi-h)

Try it online!

Input is given as 1) number of elements to trim from the start; 2) number of elements to trim from the end; 3) array. Explanation

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.

Answer 13

Husk, 3 bytes

↓↓_

Try it online!

Explanation

                                               |  1 [1,2,3,4,5,6] 2
  _  -- negate y                               | -1 [1,2,3,4,5,6] 2
 ↓   -- drop y from end (negative argument)    |  [1,2,3,4,5] 2
↓    -- drop x from beginning                  |  [3,4,5]

Answer 14

C#, 62 bytes

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

Takes a List<int> as input and returns an IEnumerable<int>.

---

This also works for 64 bytes:

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

Answer 15

MATL, 10 bytes

tniQwi-&:)

Try it online!

Explanation:

It's a bit long for just 11 bytes, but I'm writing it out in detail, to learn it myself too.

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

Answer 16

Jelly, 5 bytes

Ṗ¡Ḋ⁴¡

Try it online!

Answer 17

05AB1E, 6 bytes

F¦}sF¨

Try it online!

F }    # For 0 .. number of elements to remove from front
 ¦     #   Remove the first element
   s   # Get the next input
    F  # For 0 .. number of elements to remove from back
     ¨ #   Remove the last element

Answer 18

Dyalog APL, 16 bytes

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

Try it online!

Answer 19

APL (Dyalog), 8 7 bytes

⌽⎕↓⌽⎕↓⎕

Try it online!

This takes the array as the first input, followed by the two numbers separately.

Explanation

⎕            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

Answer 20

PHP>=7.1, 59 bytes

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

PHP Sandbox Online

Answer 21

Brain-Flak, 60 bytes

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

Try it online!

Input is in this format:

x

a
r
r
a
y

y

Where x is the number to take from the front, y is the number to take from the back, and the array is just however many numbers you want, separated by newlines. Here are my first two (longer) attempts:

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

And here is an explanation:

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

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

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

>)[()]}{}

Answer 22

R, 32 31 30 bytes

-1 byte thanks to Rift

-1 byte thanks to Jarko Dubbeldam

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

Evaluates to an anonymous function:

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

1+l is necessary since R has 1-based indexing. sum(n|1) is equivalent to length(n) but it's a byte shorter.

Try it online!

Answer 23

APL (Dyalog), 5 bytes

(⌽↓)/

Try it online!

---

Input format is y x A

Explanation

/ is Reduce, which inserts the function to the left between each pair of elements of the argument

(⌽↓) is a function train equivalent to {⌽⍺↓⍵}, which removes the first ⍺ elements of the array ⍵ and then reverses the array. (⍺ is the left argument and ⍵ is the right argument)

Thus, (⌽↓)/y x A is equivalent to ⌽y↓⌽x↓A, which is what is needed.

Answer 24

Ruby, 17 bytes

->a,b,c{a[b..~c]}

Try it online!

Answer 25

C++, 50 48 46 bytes

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

Try it online!

Answer 26

C++, 96 95 bytes

Thanks to @Tas for saving a byte!

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

Try it online!

C++ (MinGW), 91 bytes

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

Answer 27

Kotlin, 30 bytes

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

Try it online!

Takes List<Int> as input and drops from begin and then from end.

Answer 28

K (oK), 10 bytes

{(-z)_y_x}

Try it online!

Port of my q/kdb+ answer...

Answer 29

Brachylog, 11 10 bytes

kb₍B&t;Bk₍

Try it online!

Takes input as [x, A, y] where A is the array to trim.

(-1 byte thanks to @Fatalize.)

Answer 30

Japt, 6 bytes

oW UsV

Try it

sVWnUl

Try it

oW UsV     :Implicit input of array U and integers V=x & W=y
oW         :Remove the last W elements of U, mutating the original
   UsV     :Slice U from 0-based index V

sVWnUÊ     :Implicit input of array U and integers V=x & W=y
sV         :Slice U from 0-based index V to index
  Wn       :  Subtract W from
    UÊ     :  Length of U