Dada uma matriz inteira e dois números como entrada, remova uma certa quantidade do primeiro e do último elementos, especificados pelos números. A entrada pode estar na ordem que você desejar.

Você deve remover os primeiros x elementos, em que x é a primeira entrada numérica e também remover os últimos y elementos, em que y é a segunda entrada numérica.

A matriz resultante é garantida para ter um comprimento de pelo menos dois.

Exemplos:

[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 graças a Laikoni

Economizou mais 6 bytes graças a Laikoni

Economizou mais 4 bytes graças a Laikoni

Estou certo de que isso poderia ser melhorado, mas como iniciante, dei o meu melhor.

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

Uso

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

Experimente online!

Oitava, 20 bytes

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

Experimente online!

Mathematica, 17 bytes

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

entrada

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

Python , 28 26 bytes

-2 bytes graças a @Rod

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

Experimente online!

C # (.NET Core) , 55 54 bytes

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

Experimente online!

Usa a List<int>como entrada.

• 1 byte economizado graças ao TheLethalCoder!

Perl 5 , 21 bytes

19 bytes de código + -apsinalizadores.

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

Experimente online!

Usos -apara autosplit o interior de entrada @F, então só manter uma fatia de la de acordo com as outras entradas: índice de <>(segunda entrada) para índice $#F-<>(tamanho da matriz menos terceira entrada). E $_é implicitamente impresso graças à -pbandeira.

Ferrugem, 29 bytes

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

Chame da seguinte maneira:

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

Eu me diverti muito lutando com o verificador de empréstimos descobrindo qual era a abordagem mais curta para inferir a vida útil de uma fatia retornada. Seu comportamento em relação aos fechamentos é um tanto irregular, pois inferirá a vida útil, mas apenas se você não declarar o parâmetro como um tipo de referência. Infelizmente, isso entra em conflito com a necessidade de definir o tipo de argumento na assinatura, pois a chamada do método n.len precisa saber o tipo em que está operando.

Outras abordagens que tentei solucionar esse 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

𝕘₃𝕙

Experimente aqui

Agradeço à Okx por me incentivar a fazer isso ... :)

C #, 62 bytes

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

Toma um List<int>como entrada e retorna um IEnumerable<int>.

Isso também funciona para 64 bytes:

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

TIS-100, 413 405 bytes

472 ciclos, 5 nós, 35 linhas 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

O m4,6 na parte superior não faz parte do código, mas sinaliza o posicionamento dos módulos de memória.

Jogue esse nível você mesmo colando isso no jogo:

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

Então, suponho que isso também conte como uma resposta da lua ...

MATL , 6 bytes

QJi-h)

Experimente online!

A entrada é fornecida como 1) número de elementos para aparar desde o início; 2) número de elementos para cortar a partir do final; 3) matriz. Explicação

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)

Experimente online!

Se realmente restringirmos a matrizes, serão 53 bytes:

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

Experimente online!

JavaScript (ES6), 27 bytes

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

Um segundo parâmetro negativo para sliceparar de fatiar a mpartir do final, no entanto, quando mé zero, temos que passar um espaço reservado ( Infinityaqui, embora (a,n,m,o)=>a.slice(n,-m||o)também funcione).

R , 32 31 30 bytes

-1 byte graças ao Rift

-1 byte graças a Jarko Dubbeldam

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

Avalia para uma função anônima:

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

1+lé necessário, pois R possui indexação baseada em 1. sum(n|1)é equivalente a, length(n)mas é um byte mais curto.

Experimente online!

MATL , 10 bytes

tniQwi-&:)

Experimente online!

Explicação:

É um pouco longo para apenas 11 bytes, mas estou escrevendo em detalhes, para aprender também.

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

Agradecemos a @Tas por salvar um byte!

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

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

APL (Dyalog) , 8 7 bytes

⌽⎕↓⌽⎕↓⎕

Experimente online!

Isso leva a matriz como a primeira entrada, seguida pelos dois números separadamente.

Explicação

⎕            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));

Sandbox do PHP Online

Flacidez cerebral , 60 bytes

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

Experimente online!

A entrada está neste formato:

x

a
r
r
a
y

y

Onde xestá o número a ser retirado da frente, yé o número a ser retirado da parte de trás, e a matriz é apenas quantos números você deseja, separados por novas linhas. Aqui estão minhas duas primeiras tentativas (mais longas):

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

E aqui está uma explicação:

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

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

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

>)[()]}{}

APL (Dyalog) , 5 bytes

(⌽↓)/

Experimente online!

O formato de entrada é y x A

Explicação

/ é Reduce, que insere a função à esquerda entre cada par de elementos do argumento

(⌽↓)é um trem de funções equivalente a {⌽⍺↓⍵}, que remove os primeiros ⍺elementos da matriz ⍵e depois reverte a matriz. ( ⍺é o argumento da esquerda e ⍵é o argumento da direita)

Assim, (⌽↓)/y x Aé equivalente a ⌽y↓⌽x↓A, que é o que é necessário.

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

Experimente aqui.

Alternativa com a mesma contagem de bytes ( 82 ) usando um 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;}

Experimente aqui.

Explicação:

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

O java.lang.System.arraycopy()método copia uma matriz da matriz de origem especificada, começando na posição especificada, para a posição especificada da matriz de destino. Uma subsequência dos componentes da matriz é copiada da matriz de origem referenciada srcpara a matriz de destino referenciada por dest. O número de componentes copiados é igual ao lengthargumento.

Os componentes em posições srcPosatravés srcPos + length - 1da matriz de origem são copiados para posições destPosatravés destPos + length - 1, respectivamente, da matriz de destino.

C ++, 50 48 46 bytes

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

Experimente online!

Kotlin , 30 bytes

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

Experimente online!

Toma List<Int>como entrada e cai do começo e depois do fim.

Braquilog , 11 10 bytes

kb₍B&t;Bk₍

Experimente online!

Recebe a entrada como [x, A, y] onde A é a matriz a ser cortada.

(-1 byte graças a @Fatalize.)

Dyalog APL, 16 bytes

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

Experimente online!

Pitão, 5 bytes

>E<QE

Experimente aqui

Aceita os argumentos na ordem oposta. <e >em Pyth trim com base na ordem dos argumentos. Por exemplo, <Q5cortará todos os valores na entrada após a quinta.

tcl, 19

lrange $L $x end-$y

onde Lestá a matriz.

demonstração

CJam , 8 bytes

{_,@-<>}

Bloco anônimo que pega as entradas da pilha na ordem x , y , matriz e as substitui pela matriz de saída.

Experimente online!

Explicação

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

Solução:

{(0-z)_y _x}

Exemplo:

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

Explicação:

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

Raquete, 33 bytes

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

Pode ser chamado assim:

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