Dada una matriz entera y dos números como entrada, elimine una cierta cantidad del primer y último elemento, especificado por los números. La entrada puede estar en el orden que desee.

Debe eliminar los primeros elementos x , donde x es la primera entrada numérica, y también eliminar los últimos elementos y , donde y es la segunda entrada numérica.

Se garantiza que la matriz resultante tendrá una longitud de al menos dos.

Ejemplos:

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

Guardado 16 bytes gracias a Laikoni

Ahorré 6 bytes más gracias a Laikoni

Ahorré 4 bytes más gracias a Laikoni

Estoy seguro de que esto podría mejorarse, pero como principiante, di mi mejor oportunidad.

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

Uso

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

Pruébalo en línea!

Octava, 20 bytes

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

Pruébalo en línea!

Mathematica, 17 bytes

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

entrada

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

Python , 28 26 bytes

-2 bytes gracias a @Rod

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

Pruébalo en línea!

C # (.NET Core) , 55 54 bytes

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

Pruébalo en línea!

Utiliza a List<int>como entrada.

• ¡1 byte guardado gracias a TheLethalCoder!

Perl 5 , 21 bytes

19 bytes de código + -apbanderas.

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

Pruébalo en línea!

Se utiliza -apara dividir automáticamente la entrada en el interior @F, luego solo se mantiene una porción de ella de acuerdo con las otras entradas: desde el índice <>(segunda entrada) hasta el índice $#F-<>(tamaño de la matriz menos la tercera entrada). Y $_se imprime implícitamente gracias a la -pbandera.

Óxido, 29 bytes

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

Llámalo como sigue:

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

Me divertí mucho peleando con el verificador de préstamos descubriendo cuál era el enfoque más corto para que infiriera la vida útil de una porción devuelta. Su comportamiento en torno a los cierres es algo errático, ya que inferirá las vidas, pero solo si no declara realmente el parámetro como un tipo de referencia. Desafortunadamente, esto entra en conflicto con la obligación de definir el tipo de argumento en la firma ya que la llamada al método n.len necesita saber el tipo en el que está operando.

Otros enfoques que probé para solucionar este problema:

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 bytes

𝕘₃𝕙

Pruébalo aquí

Gracias a Okx para animarme a hacer esto ... :)

C #, 62 bytes

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

Toma un List<int>como entrada y devuelve un IEnumerable<int>.

Esto también funciona para 64 bytes:

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

TIS-100, 413405 bytes

472 ciclos, 5 nodos, 35 líneas de código

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

El m4,6 en la parte superior no es parte del código, pero indica la ubicación de los módulos de memoria.

Juega este nivel tú mismo pegando esto en el juego:

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

Así que supongo que esto también cuenta como una respuesta lua ...

MATL , 6 bytes

QJi-h)

Pruébalo en línea!

La entrada se da como 1) número de elementos para recortar desde el principio; 2) número de elementos para recortar desde el final; 3) matriz. Explicación

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 bytes

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

Pruébalo en línea!

Si realmente restringimos a las matrices, entonces son 53 bytes:

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

Pruébalo en línea!

JavaScript (ES6), 27 bytes

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

Un segundo parámetro negativo para slicedetener el corte mdesde el final, sin embargo, cuando mes cero, tenemos que pasar un marcador de posición ( Infinityaquí, aunque (a,n,m,o)=>a.slice(n,-m||o)también funciona).

R , 32 31 30 bytes

-1 byte gracias a Rift

-1 byte gracias a Jarko Dubbeldam

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

Evalúa a una función anónima:

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

1+les necesario ya que R tiene indexación basada en 1. sum(n|1)es equivalente a length(n)pero es un byte más corto.

Pruébalo en línea!

MATL , 10 bytes

tniQwi-&:)

Pruébalo en línea!

Explicación:

Es un poco largo para solo 11 bytes, pero lo estoy escribiendo en detalle, para aprenderlo yo mismo también.

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

¡Gracias a @Tas por guardar un byte!

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

Pruébalo en línea!

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

APL (Dyalog) , 8 7 bytes

⌽⎕↓⌽⎕↓⎕

Pruébalo en línea!

Esto toma la matriz como la primera entrada, seguida de los dos números por separado.

Explicación

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

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

PHP Sandbox en línea

Brain-Flak , 60 bytes

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

Pruébalo en línea!

La entrada está en este formato:

x

a
r
r
a
y

y

¿Dónde xestá el número para tomar desde el frente, yes el número para tomar desde la parte posterior, y la matriz tiene todos los números que desee, separados por nuevas líneas. Aquí están mis primeros dos intentos (más largos):

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

Y aquí hay una explicación:

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

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

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

>)[()]}{}

APL (Dyalog) , 5 bytes

(⌽↓)/

Pruébalo en línea!

El formato de entrada es y x A

Explicación

/ es Reducir, que inserta la función a la izquierda entre cada par de elementos del argumento

(⌽↓)es un tren de funciones equivalente a {⌽⍺↓⍵}, que elimina los primeros ⍺elementos de la matriz ⍵y luego invierte la matriz. (⍺ es el argumento izquierdo y⍵ es el argumento correcto)

Por lo tanto, (⌽↓)/y x Aes equivalente a ⌽y↓⌽x↓A, que es lo que se necesita.

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

Pruébalo aquí

Alternativa con el mismo ( 82 ) conteo de bytes usando un bucle:

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

Pruébalo aquí

Explicación:

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

El java.lang.System.arraycopy()método copia una matriz de la matriz de origen especificada, comenzando en la posición especificada, a la posición especificada de la matriz de destino. Una subsecuencia de componentes de la matriz se copia de la matriz de origen srca la que hace referencia la matriz de destino a la que hace referencia dest. El número de componentes copiados es igual al lengthargumento.

Los componentes en las posiciones a srcPostravés srcPos + length - 1de la matriz de origen se copian en posiciones a destPostravés destPos + length - 1, respectivamente, de la matriz de destino.

C ++, 50 48 46 bytes

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

Pruébalo en línea!

Kotlin , 30 bytes

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

Pruébalo en línea!

Toma List<Int>como entrada y cae desde el principio y luego desde el final.

Brachylog , 11 10 bytes

kb₍B&t;Bk₍

Pruébalo en línea!

Toma la entrada como [x, A, y] donde A es la matriz a recortar.

(-1 byte gracias a @Fatalize.)

Dyalog APL, 16 bytes

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

Pruébalo en línea!

Pyth, 5 bytes

>E<QE

Pruébalo aquí

Toma los argumentos en el orden opuesto. <y >en Pyth trim basado en el orden de los argumentos. Por ejemplo, <Q5recortará todos los valores en la entrada después del quinto.

tcl, 19

lrange $L $x end-$y

¿Dónde Lestá la matriz?

manifestación

CJam , 8 bytes

{_,@-<>}

Bloque anónimo que toma las entradas de la pila en el orden x , y , matriz y las reemplaza por la matriz de salida.

Pruébalo en línea!

Explicación

Considere insumos 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 bytes

Solución:

{(0-z)_y _x}

Ejemplo:

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

Explicación:

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

Raqueta, 33 bytes

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

Se le puede llamar así:

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