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.
[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]
>E<QE
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.
{_,@-<>}
Anonymous block that takes the inputs from the stack in the order x, y, array, and replaces them by the output array.
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]
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)
(λ(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)
a->n->m->{int l=a.length-m-n,r[]=new int[l];System.arraycopy(a,n,r,0,l);return r;}
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;}
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
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 bysrcto the destination array referenced bydest. The number of components copied is equal to thelengthargument.The components at positions
srcPosthroughsrcPos + length - 1in the source array are copied into positionsdestPosthroughdestPos + length - 1, respectively, of the destination array.
(a,n,m)-> has the same byte-count as a->n->m->. Although you're right I could have just used a regular call instead of currying. I'm kinda used of using currying when I have two (or more) parameters.. I've already made the mistake of using currying when I have four parameters a few times..
\$\endgroup\$
{x _(-y)_ z}
Usage:
{x _(-y)_ z}[2;1;"hello world"]
"llo worl"
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.
‘ṫṚ¥ƒ
Takes [x, y] on the left and the list on the right. Ties the existing Jelly answer, but I'm posting it anyways because:
‘ Increment x and y.
ƒ With the list as the initial value of the accumulator, reduce [x, y] by:
ṫ remove the first (right - 1) elements from the accumulator,
Ṛ¥ then reverse it.
p
vvj
-0
j
0
j
0
Takes input as
y
array
x
via STDIN.
This program translates to:
p (v (j (0),v (- (0,j (0)),j (0)))
print(drop(eval_input(0),drop(minus(0,eval_input(0)),eval_input(0)))
=OFFSET(A1,B1,,COUNT(A:A)-B1-C1)
The array is entered in column A starting at A1.
ZxsZy
Takes x then the array then y
Zx # Remove the first x elements from the array
s # Swap so y is now on the top of the stack
Zy # Remove the last y elements from the array
# Implicit output
#(subvec % %2(-(count %)%3))
Well there is the built-in.
ᵢqᵢpᵢ
The symmetry is an amazing coincidence
ᵢ 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.
[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].
#(drop %2(drop-last %3 %))
ñ.
\$\endgroup\$
Àd.
\$\endgroup\$
d by itself doesn't work. You'd need dd and 2) That doesn't work if the first input is 0.
\$\endgroup\$
{@^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).
#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.
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>
(-@{:@[}.{.@[}.])
Usage:
2 1 (-@{:@[}.{.@[}.]) 11 12 13 14 15 16
13 14 15