Entfernen Sie bei einem Ganzzahl-Array und zwei Zahlen als Eingabe eine bestimmte Menge des ersten und des letzten Elements, die durch die Zahlen angegeben werden. Die Eingabe kann in beliebiger Reihenfolge erfolgen.

Sie sollten die ersten x- Elemente entfernen , wobei x die erste numerische Eingabe ist, und auch das letzte y entfernen Elemente, wobei y die zweite numerische Eingabe ist.

Das resultierende Array hat garantiert eine Länge von mindestens zwei.

Beispiele:

[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

16 Bytes dank Laikoni gespart

6 weitere Bytes dank Laikoni gespart

4 weitere Bytes dank Laikoni gespeichert

Ich bin mir sicher, dass dies verbessert werden könnte, aber als Anfänger habe ich mein Bestes gegeben.

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

Verwendung

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

Probieren Sie es online!

Oktave, 20 Bytes

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

Probieren Sie es online!

Mathematica, 17 Bytes

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

Eingang

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

Python , 28 26 Bytes

-2 Bytes dank @Rod

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

Probieren Sie es online!

C # (.NET Core) , 55 54 Bytes

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

Probieren Sie es online!

Verwendet a List<int>als Eingabe.

• Dank TheLethalCoder 1 Byte gespart!

Perl 5 , 21 Bytes

19 Byte Code + -apFlags.

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

Probieren Sie es online!

Verwendet -a, um die Eingabe automatisch zu teilen @F, und behält dann nur einen Teil davon entsprechend den anderen Eingaben bei: vom Index <>(zweite Eingabe) bis zum Index $#F-<>(Größe des Arrays abzüglich der dritten Eingabe). Und $_wird dank -pFlagge implizit gedruckt .

Rust, 29 Bytes

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

Nennen Sie es wie folgt:

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

Ich hatte viel Spaß beim Kämpfen mit dem Leihscheck, um herauszufinden, was der kürzeste Weg war, um daraus die Lebensdauer eines zurückgegebenen Slices abzuleiten. Das Verhalten bei Schließungen ist etwas unregelmäßig, da dies auf die Lebensdauer schließen lässt, jedoch nur, wenn Sie den Parameter nicht als Referenztyp deklarieren. Leider steht dies im Widerspruch zu der Anforderung, den Argumenttyp in der Signatur zu definieren, da der Methodenaufruf n.len den Typ kennen muss, auf dem er ausgeführt wird.

Andere Ansätze, mit denen ich dieses Problem umgehen wollte:

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

𝕘₃𝕙

Probieren Sie es hier aus

Vielen Dank an Okx , der mich dazu ermutigt hat ... :)

C #, 62 Bytes

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

Nimmt ein List<int>als Eingabe und gibt ein zurück IEnumerable<int>.

Dies funktioniert auch für 64 Bytes:

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

TIS-100, 413 405 Bytes

472 Zyklen, 5 Knoten, 35 Codezeilen

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

Das m4,6 oben ist nicht Teil des Codes, signalisiert aber die Platzierung der Speichermodule.

Spielen Sie dieses Level selbst, indem Sie es in das Spiel einfügen:

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

Also ich nehme an, das zählt auch als lua Antwort ...

MATL , 6 Bytes

QJi-h)

Probieren Sie es online!

Die Eingabe erfolgt als 1) Anzahl der zu trimmenden Elemente von Anfang an; 2) Anzahl der Elemente, die vom Ende abgeschnitten werden sollen; 3) Array. Erläuterung

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)

Probieren Sie es online!

Wenn wir uns wirklich auf Arrays beschränken, dann sind es 53 Bytes:

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

Probieren Sie es online!

JavaScript (ES6), 27 Byte

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

Ein negativer zweiter Parameter slicestoppt das Slicing mam Ende, wenn mjedoch Null ist, müssen wir einen Platzhalter übergeben ( Infinityhier (a,n,m,o)=>a.slice(n,-m||o)funktioniert es zwar auch).

R , 32 31 30 Byte

-1 Byte dank Rift

-1 Byte danke an Jarko Dubbeldam

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

Wertet zu einer anonymen Funktion aus:

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

1+list notwendig, da R 1-basierte Indizierung hat. sum(n|1)entspricht length(n)aber es ist ein Byte kürzer.

Probieren Sie es online!

MATL , 10 Bytes

tniQwi-&:)

Probieren Sie es online!

Erläuterung:

Es ist ein bisschen lang für nur 11 Bytes, aber ich schreibe es ausführlich auf, um es selbst zu lernen.

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

Vielen Dank an @Tas für das Speichern eines Bytes!

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

Probieren Sie es 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

⌽⎕↓⌽⎕↓⎕

Probieren Sie es online!

Dies nimmt das Array als erste Eingabe, gefolgt von den beiden Zahlen getrennt.

Erläuterung

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

Brain-Flak , 60 Bytes

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

Probieren Sie es online!

Die Eingabe erfolgt in folgendem Format:

x

a
r
r
a
y

y

Wo xist die Nummer von vorne zu nehmen, yist die Nummer von hinten zu nehmen, und das Array ist nur so viele Zahlen, wie Sie möchten, durch Zeilenumbrüche getrennt. Hier sind meine ersten beiden (längeren) Versuche:

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

Und hier ist eine Erklärung:

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

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

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

>)[()]}{}

APL (Dyalog) , 5 Bytes

(⌽↓)/

Probieren Sie es online!

Eingabeformat ist y x A

Erläuterung

/ is Reduce fügt die Funktion links zwischen jedes Elementpaar des Arguments ein

(⌽↓)ist ein äquivalenter Funktionszug {⌽⍺↓⍵}, der die ersten ⍺Elemente des Arrays entfernt ⍵und das Array dann umkehrt. ( ⍺ist das linke Argument und⍵ ist das rechte Argument)

Also (⌽↓)/y x Aist gleichbedeutend damit ⌽y↓⌽x↓A, was gebraucht wird.

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

Probieren Sie es hier aus.

Alternative mit derselben ( 82 ) Byte-Anzahl unter Verwendung einer Schleife:

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

Probieren Sie es hier aus.

Erläuterung:

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

Die java.lang.System.arraycopy()Methode kopiert ein Array vom angegebenen Quellarray, beginnend an der angegebenen Position, an die angegebene Position des Zielarrays. Eine Untersequenz von Array-Komponenten wird vom Quell-Array, auf das von verwiesen wird src, zum Ziel-Array kopiert, auf das von verwiesen wird dest. Die Anzahl der kopierten Komponenten entspricht dem lengthArgument.

Die Komponenten an den Positionen srcPosbis srcPos + length - 1im Quellarray werden jeweils in die Positionen destPosbis zum Zielarray kopiert destPos + length - 1.

C ++, 50 48 46 Bytes

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

Probieren Sie es online!

Kotlin , 30 Bytes

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

Probieren Sie es online!

Nimmt List<Int>als Eingabe und fällt vom Anfang und dann vom Ende.

Brachylog , 11 10 Bytes

kb₍B&t;Bk₍

Probieren Sie es online!

Übernimmt die Eingabe als [x, A, y], wobei A das zu trimmende Array ist.

(-1 Byte dank @Fatalize.)

Dyalog APL, 16 Bytes

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

Probieren Sie es online!

Pyth, 5 Bytes

>E<QE

Probieren Sie es hier aus

Fasst die Argumente in umgekehrter Reihenfolge zusammen. <und >in Pyth schneiden basierend auf der Argumentreihenfolge. Zum Beispiel <Q5werden alle Werte in der Eingabe nach dem fünften abgeschnitten.

tcl, 19

lrange $L $x end-$y

woher L ist das Array?

Demo

CJam , 8 Bytes

{_,@-<>}

Anonymer Block, der die Eingaben vom Stapel in der Reihenfolge x , y , array nimmt und durch das Ausgabearray ersetzt.

Probieren Sie es online!

Erläuterung

Betrachten Sie Eingänge 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

Lösung:

{(0-z)_y _x}

Beispiel:

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

Erläuterung:

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

Schläger, 33 Bytes

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

Man kann es so nennen:

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