Dato un array intero e due numeri come input, rimuovere una certa quantità del primo e dell'ultimo elemento, specificati dai numeri. L'input può essere nell'ordine desiderato.

Dovresti rimuovere i primi x elementi, dove x è il primo input numerico e rimuovere anche gli ultimi y elementi, dove y è il secondo input numerico.

L'array risultante è garantito per avere una lunghezza di almeno due.

Esempi:

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

Risparmiato 16 byte grazie a Laikoni

Risparmiato altri 6 byte grazie a Laikoni

Salvati altri 4 byte grazie a Laikoni

Sono sicuro che questo potrebbe essere migliorato, ma come un principiante, ho dato il mio colpo migliore.

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

uso

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

Provalo online!

Ottava, 20 byte

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

Provalo online!

Mathematica, 17 byte

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

ingresso

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

Python , 28 26 byte

-2 byte grazie a @Rod

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

Provalo online!

C # (.NET Core) , 55 54 byte

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

Provalo online!

Utilizza a List<int> input.

• 1 byte salvato grazie a TheLethalCoder!

Perl 5 , 21 byte

19 byte di codice + -apflag.

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

Provalo online!

Usa -aper inserire automaticamente l'ingresso all'interno @F, quindi mantenerne solo una porzione in base agli altri input: dall'indice <>(secondo input) all'indice $#F-<>(dimensione dell'array meno il terzo input). Ed $_è implicitamente stampato grazie alla -pbandiera.

Ruggine, 29 byte

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

Chiamalo come segue:

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

Mi sono divertito molto a combattere con il controllore del prestito per capire quale fosse l'approccio più breve per fargli dedurre la durata di una fetta restituita. Il suo comportamento attorno alle chiusure è alquanto irregolare, in quanto inferirà la durata della vita, ma solo se non si dichiara effettivamente il parametro come tipo di riferimento. Sfortunatamente questo è in conflitto con la necessità di definire il tipo di argomento nella firma poiché la chiamata al metodo n.len deve conoscere il tipo su cui sta operando.

Altri approcci che ho provato a risolvere questo 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 byte

𝕘₃𝕙

Provalo qui

Grazie a Okx per avermi incoraggiato a fare questo ... :)

C #, 62 byte

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

Prende un List<int>input e restituisce un IEnumerable<int>.

Questo funziona anche per 64 byte:

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

TIS-100, 413 405 byte

472 cicli, 5 nodi, 35 righe di codice

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

L'm4,6 nella parte superiore non fa parte del codice, ma segnala il posizionamento dei moduli di memoria.

Gioca tu stesso questo livello incollandolo nel gioco:

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

Quindi suppongo che questo valga anche come una risposta lua ...

MATL , 6 byte

QJi-h)

Provalo online!

L'input è dato come 1) numero di elementi da tagliare dall'inizio; 2) numero di elementi da tagliare dall'estremità; 3) matrice. Spiegazione

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 byte

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

Provalo online!

Se ci limitiamo davvero alle matrici, allora sono 53 byte:

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

Provalo online!

JavaScript (ES6), 27 byte

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

Un secondo parametro negativo per sliceinterrompere il taglio mdalla fine, tuttavia quando mè zero dobbiamo passare un segnaposto ( Infinityqui, (a,n,m,o)=>a.slice(n,-m||o)anche se funziona anche).

R , 32 31 30 byte

-1 byte grazie a Rift

-1 byte grazie a Jarko Dubbeldam

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

Valuta una funzione anonima:

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

1+lè necessario poiché R ha l'indicizzazione basata su 1. sum(n|1)è equivalente a length(n)ma è un byte più breve.

Provalo online!

MATL , 10 byte

tniQwi-&:)

Provalo online!

Spiegazione:

È un po 'lungo per soli 11 byte, ma lo scrivo in dettaglio, per impararlo anche io.

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

Grazie a @Tas per aver salvato un byte!

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

Provalo online!

C ++ (MinGW), 91 byte

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

⌽⎕↓⌽⎕↓⎕

Provalo online!

Questo prende l'array come primo input, seguito dai due numeri separatamente.

Spiegazione

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

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

PHP Sandbox online

Brain-Flak , 60 byte

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

Provalo online!

L'input è in questo formato:

x

a
r
r
a
y

y

Dov'è xil numero da prendere dalla parte anteriore, yè il numero da prendere dalla parte posteriore e l'array è proprio come molti numeri vuoi, separati da nuove righe. Ecco i miei primi due (più lunghi) tentativi:

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

Ed ecco una spiegazione:

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

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

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

>)[()]}{}

APL (Dyalog) , 5 byte

(⌽↓)/

Provalo online!

Il formato di input è y x A

Spiegazione

/ è Riduci, che inserisce la funzione a sinistra tra ogni coppia di elementi dell'argomento

(⌽↓)è un treno di funzioni equivalente a {⌽⍺↓⍵}, che rimuove i primi ⍺elementi dell'array ⍵e quindi inverte l'array. ( ⍺è l'argomento sinistro e⍵ è l'argomento giusto)

Pertanto, (⌽↓)/y x Aè equivalente a ⌽y↓⌽x↓A, che è ciò che è necessario.

Java 8, 82 byte

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

Provalo qui.

Alternativa con lo stesso ( 82 ) byte-count usando un 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;}

Provalo qui.

Spiegazione:

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

Il java.lang.System.arraycopy()metodo copia un array dall'array di origine specificato, iniziando dalla posizione specificata, nella posizione specificata dell'array di destinazione. Una sottosequenza dei componenti dell'array viene copiata dall'array di origine a cui fa riferimento srcl'array di destinazione a cui fa riferimento dest. Il numero di componenti copiati è uguale alength all'argomento.

I componenti nelle posizioni srcPosattraverso srcPos + length - 1l'array di origine vengono copiati in posizioni destPosattraverso destPos + length - 1, rispettivamente, l'array di destinazione.

C ++, 50 48 46 byte

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

Provalo online!

Kotlin , 30 byte

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

Provalo online!

Accetta List<Int>come input e scende dall'inizio e poi dalla fine.

Brachylog , 11 10 byte

kb₍B&t;Bk₍

Provalo online!

Prende l'input come [x, A, y] dove A è l'array da tagliare.

(-1 byte grazie a @Fatalize.)

Dyalog APL, 16 byte

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

Provalo online!

Pyth, 5 byte

>E<QE

Provalo qui

Accetta gli argomenti nell'ordine opposto. <e >in Pyth trim basato sull'ordine degli argomenti. Ad esempio, <Q5eliminerà tutti i valori nell'input dopo il quinto.

tcl, 19

lrange $L $x end-$y

dov'è Ll'array.

dimostrazione

CJam , 8 byte

{_,@-<>}

Blocco anonimo che accetta gli input dallo stack nell'ordine x , y , array e li sostituisce con l'array di output.

Provalo online!

Spiegazione

Considerate ingressi 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 byte

Soluzione:

{(0-z)_y _x}

Esempio:

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

Spiegazione:

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

Racchetta, 33 byte

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

Può essere chiamato così:

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