Biorąc pod uwagę tablicę liczb całkowitych i dwie liczby jako dane wejściowe, usuń pewną liczbę pierwszego i ostatniego elementu, określoną liczbami. Dane wejściowe mogą być w dowolnej kolejności.

Powinieneś usunąć pierwsze x elementów, gdzie x jest pierwszym wprowadzeniem numerycznym, a także usunąć ostatnie y elementów, gdzie y jest drugim wprowadzeniem numerycznym.

Wynikowa tablica ma długość co najmniej dwóch.

Przykłady:

[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 bajtów

Zaoszczędzono 16 bajtów dzięki Laikoni

Zaoszczędź jeszcze 6 bajtów dzięki Laikoni

Zaoszczędzono jeszcze 4 bajty dzięki Laikoni

Jestem pewien, że można to poprawić, ale jako początkujący dałem z siebie wszystko.

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

Stosowanie

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

Wypróbuj online!

Oktawa, 20 bajtów

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

Wypróbuj online!

Mathematica, 17 bajtów

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

wkład

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

Python , 28 26 bajtów

-2 bajty dzięki @Rod

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

Wypróbuj online!

C # (.NET Core) , 55 54 bajtów

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

Wypróbuj online!

Używa List<int>jako danych wejściowych.

• 1 bajt zapisany dzięki TheLethalCoder!

Perl 5 , 21 bajtów

19 bajtów kodu + -apflagi.

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

Wypróbuj online!

Używa automatycznego -apodziału wejścia wewnątrz @F, a następnie zachowuje tylko jego fragment zgodnie z innymi danymi wejściowymi: od indeksu <>(drugie wejście) do indeksu $#F-<>(rozmiar tablicy minus trzecie wejście). I $_jest domyślnie drukowane dzięki -pflagom.

Rdza, 29 bajtów

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

Nazwij to w następujący sposób:

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

Świetnie się bawiłem, walcząc z funkcją sprawdzania pożyczek, zastanawiając się, jakie było najkrótsze podejście, aby mieć wpływ na żywotność zwróconego wycinka. Jego zachowanie wokół zamknięć jest nieco nieobliczalne, ponieważ będzie wnioskować o żywotnościach, ale tylko wtedy, gdy w rzeczywistości nie zadeklarujesz parametru jako typu odniesienia. Niestety koliduje to z koniecznością zdefiniowania typu argumentu w podpisie, ponieważ wywołanie metody n.len musi znać typ, na którym działa.

Inne podejścia próbowałem obejść ten problem:

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 bajty

𝕘₃𝕙

Wypróbuj tutaj

Dzięki Okx za zachęcenie mnie do tego ... :)

C #, 62 bajty

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

Pobiera List<int>dane wejściowe i zwraca wartość an IEnumerable<int>.

Działa to również dla 64 bajtów:

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

TIS-100, 413 405 bajtów

472 cykli, 5 węzłów, 35 linii kodu

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

M4,6 na górze nie jest częścią kodu, ale sygnalizuje umieszczenie modułów pamięci.

Zagraj na tym poziomie, wklejając go do gry:

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

Więc przypuszczam, że to również liczy się jako odpowiedź lua ...

MATL , 6 bajtów

QJi-h)

Wypróbuj online!

Dane wejściowe podano jako 1) liczbę elementów do przycięcia od początku; 2) liczba elementów do przycięcia od końca; 3) tablica. Wyjaśnienie

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 bajty

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

Wypróbuj online!

Jeśli naprawdę ograniczamy się do tablic, to jest to 53 bajty:

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

Wypróbuj online!

JavaScript (ES6), 27 bajtów

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

Drugi ujemny parametr slicezatrzymujący krojenie mod końca, jednak gdy mwynosi zero, musimy przekazać symbol zastępczy ( Infinitytutaj, chociaż (a,n,m,o)=>a.slice(n,-m||o)również działa).

R , 32 31 30 bajtów

-1 bajt dzięki Rift

-1 bajt dzięki Jarko Dubbeldam

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

Ocenia anonimową funkcję:

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

1+ljest konieczne, ponieważ R ma indeksowanie 1. sum(n|1)jest równoważne, length(n)ale bajt jest krótszy.

Wypróbuj online!

MATL , 10 bajtów

tniQwi-&:)

Wypróbuj online!

Wyjaśnienie:

Trochę za długo zajmuje zaledwie 11 bajtów, ale piszę to szczegółowo, aby samemu się tego nauczyć.

---- 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 bajtów

Dzięki @Tas za uratowanie bajtu!

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

Wypróbuj online!

C ++ (MinGW), 91 bajtów

#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 bajtów

⌽⎕↓⌽⎕↓⎕

Wypróbuj online!

Pobiera tablicę jako pierwsze wejście, a następnie dwie liczby osobno.

Wyjaśnienie

⎕            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 bajtów

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

PHP Sandbox Online

Brain-Flak , 60 bajtów

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

Wypróbuj online!

Dane wejściowe są w tym formacie:

x

a
r
r
a
y

y

Gdzie xjest liczba do pobrania z przodu, yto liczba do pobrania z tyłu, a tablica zawiera tyle liczb, ile chcesz, oddzielonych znakami nowej linii. Oto moje pierwsze dwie (dłuższe) próby:

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

A oto wyjaśnienie:

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

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

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

>)[()]}{}

APL (Dyalog) , 5 bajtów

(⌽↓)/

Wypróbuj online!

Format wejściowy to y x A

Wyjaśnienie

/ to Reduce, która wstawia funkcję po lewej stronie między każdą parą elementów argumentu

(⌽↓)jest ciągiem funkcji równoważnym z {⌽⍺↓⍵}, który usuwa pierwsze ⍺elementy tablicy, ⍵a następnie odwraca tablicę. ( ⍺to lewy argument i ⍵prawy argument)

Jest więc (⌽↓)/y x Arównoważne z tym ⌽y↓⌽x↓A, co jest potrzebne.

Java 8, 82 bajty

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

Wypróbuj tutaj.

Alternatywnie z taką samą ( 82 ) liczbą bajtów za pomocą pętli:

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

Wypróbuj tutaj.

Wyjaśnienie:

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

Te java.lang.System.arraycopy()metoda kopiuje tablicę z określonej tablicy źródłowej, które rozpoczynają się w określonym miejscu, do określonego położenia tablicy docelowej. Podsekwencja komponentów tablicy jest kopiowana z tablicy źródłowej, do której odwołuje się, srcdo tablicy docelowej, do której odwołuje się dest. Liczba skopiowanych komponentów jest równa lengthargumentowi.

Składniki w pozycjach srcPospoprzez srcPos + length - 1w tablicy źródłowej są kopiowane do pozycji destPospoprzez destPos + length - 1, odpowiednio, z tablicy docelowej.

C ++, 50 48 46 bajtów

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

Wypróbuj online!

Kotlin , 30 bajtów

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

Wypróbuj online!

Bierze List<Int>jako dane wejściowe i spada od początku, a następnie od końca.

Brachylog , 11 10 bajtów

kb₍B&t;Bk₍

Wypróbuj online!

Pobiera dane wejściowe jako [x, A, y], gdzie A jest tablicą do przycięcia.

(-1 bajt dzięki @Fatalize.)

Dyalog APL, 16 bajtów

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

Wypróbuj online!

Pyth, 5 bajtów

>E<QE

Wypróbuj tutaj

Przyjmuje argumenty w odwrotnej kolejności. <oraz >w przycinaniu Pyth na podstawie kolejności argumentów. Na przykład <Q5odetnie wszystkie wartości na wejściu po piątej.

tcl, 19

lrange $L $x end-$y

gdzie Ljest tablica.

próbny

CJam , 8 bajtów

{_,@-<>}

Anonimowy blok, który pobiera dane wejściowe ze stosu w kolejności x , y , tablica i zastępuje je tablicą wyjściową.

Wypróbuj online!

Wyjaśnienie

Rozważmy wejść 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 bajtów

Rozwiązanie:

{(0-z)_y _x}

Przykład:

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

Wyjaśnienie:

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

Rakieta, 33 bajty

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

Można to tak nazwać:

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