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

Octave, 20 bytes

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

Try it online!

Answer 3

Mathematica, 17 bytes

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

input

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

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

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 7

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 8

Neim, 3 bytes

₃

Try it here

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

Answer 9

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 10

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 11

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 12

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 13

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 14

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 15

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 16

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 17

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 18

PHP>=7.1, 59 bytes

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

PHP Sandbox Online

Answer 19

Java 8, 82 bytes

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

Try it here.

Alternative with same (82) byte-count using a 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;}

Try it here.

Explanation:

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() method copies an array from the specified source array, beginning at the specified position, to the specified position of the destination array. A subsequence of array components are copied from the source array referenced by src to the destination array referenced by dest. The number of components copied is equal to the length argument.

The components at positions srcPos through srcPos + length - 1 in the source array are copied into positions destPos through destPos + length - 1, respectively, of the destination array.

Answer 20

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 21

C++, 50 48 46 bytes

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

Try it online!

Answer 22

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 23

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 24

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 25

Dyalog APL, 16 bytes

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

Try it online!

Answer 26

Pyth, 5 bytes

>E<QE

Try it here

Takes the arguments in the opposite order. < and > in Pyth trim based on argument order. For example, <Q5 will trim off all values in the input after the fifth one.

Answer 27

CJam, 8 bytes

{_,@-<>}

Anonymous block that takes the inputs from the stack in the order x, y, array, and replaces them by the output array.

Try it online!

Explanation

Consider inputs 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]

Answer 28

tcl, 19

lrange $L $x end-$y

where L is the array.

demo

Answer 29

q/kdb, 12 bytes

Solution:

{(0-z)_y _x}

Example:

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

Explanation:

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

Answer 30

Racket, 33 bytes

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

It can be called like so:

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

Answer 31

Pyth, 4 bytes

<E>E

Demonstration

Put the list last.

Answer 32

Ruby, 17 bytes

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

Try it online!

Answer 33

Kona/K4, 12 bytes

{x _(-y)_ z}

Usage:

   {x _(-y)_ z}[2;1;"hello world"]
"llo worl"

Answer 34

K (oK), 10 bytes

{(-z)_y_x}

Try it online!

Port of my q/kdb+ answer...

Answer 35

Japt, 8 7 bytes

sVUl -W

Try it online!

Saved a byte thanks to ETHproductions

Answer 36

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 37

Jelly, 5 bytes

Ṗ¡Ḋ⁴¡

Try it online!

Answer 38

V, 9 8 bytes

ÀñdñGÀñd

Try it online!

One byte saved thanks to Erik the golfer!

Answer 39

Clojure, 28 bytes

#(subvec % %2(-(count %)%3))

Well there is the built-in.

Answer 40

NewStack, 5 bytes

ᵢqᵢpᵢ

The symmetry is an amazing coincidence

The breakdown:

ᵢ      Append an input (the array).
 qᵢ    Pop off an input's amount off the bottom.
   pᵢ  Pop off an input's amount off the top.

Answer 41

F#, 39 bytes

let f(i:int[])s e=i.[s..(i.Length-1-e)]

Try it online!

Answer 42

Braingolf, 22 21 bytes

1-<1-[v$_R][v<$_R]v=;

Try it online!

Answer 43

LOGO, 33 bytes

[cascade ?2 "bf cascade ?3 "bl ?]

Try it on FMSLogo.

This is a template-list in LOGO, which is the equivalent of lambda (anonymous) function in many other languages.

Where:

• cascade outputs the result of applying a template repeatedly, in this case is ?2 times bf and ?3 times bl.
• bf and bl stands for ButFirst and ButLast respectively.
• ? is used to access parameters. So ?2 is the second parameter, ?3 is the third parameter, etc.

Test:

show apply [cascade ?2 "bf cascade ?3 "bl ?] [[1 2 3 4 5 6] 2 1]

print [3 4 5].

Answer 44

Clojure, 26 bytes

#(drop %2(drop-last %3 %))

Answer 45

Perl 6, 18 bytes

{@^a[$^x..^*-$^y]}

@^a is the input array (first parameter), $^x is the number of elements to remove from the front (second parameter), and $^y is the number of elements to remove from the end (third parameter).

$^x ..^ *-$^y is a slicing subscript that selects a range of elements from the one with index $^x until one prior to the one with index *-$^y (* meaning "the length of the array" in a subscript context).

Answer 46

C++, 81 bytes

#include<vector>
int f(std::vector<int>&v,int x,int y){v={v.begin()+x,v.end()-y};}

Not as short as this use of a macro.

std::vector provides random access, and we simply create a new vector from the start point v.begin() + x, to the new end point v.end() - y elements.

Uses the iterator overload v.begin() and v.end() since it's the same length as the pointer one &v[0] and &*(v.end()), but more readable.

Function doesn't return an int like it promises, which is only a compiler warning.

Answer 47

8th, 33 bytes

Code

This code leaves resulting array on TOS

( a:rev swap -1 a:slice ) 2 times

Usage

ok> 2 1 [1,2,3,4,5] ( a:rev swap -1 a:slice ) 2 times .
[3,4]
ok> 5 0 [6,2,4,3,5,1,3] ( a:rev swap -1 a:slice ) 2 times .
[1,3]
ok> 
ok> 0 0 [1,2] ( a:rev swap -1 a:slice ) 2 times .
[1,2]
ok>

Answer 48

Common Lisp, 41 bytes

(lambda(a x y)(subseq a x(-(length a)y)))

Try it online!

Answer 49

J, 17 bytes

(-@{:@[}.{.@[}.])

Usage:

   2 1 (-@{:@[}.{.@[}.]) 11 12 13 14 15 16
13 14 15

Answer 50

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 51

Japt, 6 bytes

oW UsV

Try it

sVWnUl

Try it

Answer 52

C++, 50 bytes

[](auto&v,int x,int y){v={v.begin()+x,v.end()-y};}

Just construct a new container from the existing one. This requires v to be of a type with random-access iterators and constructible from an iterator pair - std::vector is ideally suited.

Demo

auto const trim =
    [](auto&v,int x,int y){v={v.begin()+x,v.end()-y};}
    ;

#include<iostream>
#include<vector>
int main(int argc, char **argv)
{
    if (argc < 4) {
        std::cerr << "Usage: " << argv[0] << " X Y ELE...";
        return 1;
    }

    auto const x = std::atoi(argv[1]);
    auto const y = std::atoi(argv[2]);
    std::vector<int> v;
    v.reserve(argc - 3);
    for (int i = 3;  i < argc;  ++i)
        v.push_back(std::atoi(argv[i]));

    auto const print_vector = [](auto v){for(auto i:v)std::cout<<i<<" ";std::cout<<'\n';};

    print_vector(v);
    trim(v, x, y);
    print_vector(v);
}

Answer 53

Scala, 52 bytes

def f(a:Seq[Int],c:Int,d:Int)=a.dropRight(d).drop(c)

Try it online!

Answer 54

Lua, 94 bytes

n,s=loadstring('return{},'..p[1])()for x=1,#s do n[#n+1]=x>0+p[2]and#s>=x+p[3]and s[x]or _ end

Try it online!

If I used something that I couldn't please tell me.

Explanation

p = {...} -- (Header) It gets the 3 arguments (the list and the 2 numbers and stores in a table)


n,s=loadstring('return{},'..p[1])() -- is the same as (i) and (ii):
 (i) n = {} -- initializes an empty table
(ii) s = loadstring('return '..p[1])() -- makes the string '{1,2,3}' become a table with 3 elements (1, 2 and 3)

for x=1,#s do -- from 1 to the number of elements in s, repeat:
  n[#n+1] = x>0+p[2] and #s>=x+p[3] and s[x] or _
  n[#n+1]   -- append to n
              0+p[2]   -- convert "2" to the number 2
            x>0+p[2] and #s>=x+p[3]   -- if we're past the start limit and before the end limit
                                    and s[x]   -- then the element to be appended is the one with index x of the original list
                                             or _   -- else append nil (the same as doing nothing)
end


print(table.concat(n, ", ")) -- (Footer) print the elements of n separated by commas

I used _ as nil just to be a little bit more clear (although this is not the point of these answers hahah). I could've used any variable that wasn't previously declared. _ doesn't have anything special in Lua.
And the comparisons are really messy because I tried to organize the math in a way that special characters would help me to use less space. ... and a>#b uses 1 more byte than ... and#b>a.

If you have any questions ask and I'll try to answer them.

Answer 55

Recursiva, 7 bytes

Zba-Lac

Try it online!

Answer 56

C (gcc), 16 bytes

The compiler instruction:

-DX(a,x,y)=(a+x)

As most would know, an array in C is just a known length and a pointer to the beginning of an array. Thus, we get an array with x members removed from the left and y members removed from the right by just moving the pointer to the array by +x.

Try it online!