Враховуючи цілий масив та два числа як вхідні дані, видаліть певну кількість першого та останнього елементів, визначених числами. Вхід може бути в будь-якому бажаному порядку.

Вам слід видалити перші x елементи, де x - перший числовий вхід, а також видалити останні y елементи, де y - другий числовий вхід.

Отриманий масив гарантовано матиме довжину щонайменше двох.

Приклади:

[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 байт

Збережено 16 байт завдяки Лайконі

Збережено ще 6 байт завдяки Лайконі

Збережено ще 4 байти завдяки Лайконі

Впевнений, що це можна було б покращити, але, як початківець, я зробив це найкращим чином.

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

Використання

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

Спробуйте в Інтернеті!

Октава, 20 байт

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

Спробуйте в Інтернеті!

Математика, 17 байт

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

вхід

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

Пітон , 28 26 байт

-2 байти завдяки @Rod

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

Спробуйте в Інтернеті!

C # (.NET Core) , 55 54 байти

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

Спробуйте в Інтернеті!

Використовує a List<int>як вхід.

• 1 байт збережено завдяки TheLethalCoder!

Perl 5 , 21 байт

19 байт коду + -apпрапори.

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

Спробуйте в Інтернеті!

Використовується -aдля автоматичного розщеплення вводу всередині @F, а тоді зберігайте лише його фрагмент відповідно до інших входів: від індексу <>(другий вхід) до індексу $#F-<>(розмір масиву мінус третій вхід). І $_друкується неявно завдяки -pпрапору.

Іржа, 29 байт

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

Назвіть це так:

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

Мені було весело, бореться з контролером позики, з'ясовуючи, який найкоротший підхід для того, щоб він міг визначити час повернутого фрагмента. Його поведінка навколо закриття дещо помилкова, оскільки це може призвести до тривалості життя, але тільки якщо ви фактично не оголосите параметр як еталонний тип. На жаль, це суперечить тому, що потрібно визначити тип аргументу в підписі, оскільки виклик методу n.len повинен знати тип, над яким він працює.

Інші підходи, з якими я намагався працювати над цією проблемою:

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

Нейм , 3 байти

𝕘₃𝕙

Спробуйте тут

Дякую Okx за те, що закликав мене до цього ... :)

C #, 62 байти

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

Приймає List<int>як вхід і повертає IEnumerable<int>.

Це також працює на 64 байти:

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

TIS-100, 413 405 байт

472 цикли, 5 вузлів, 35 рядків коду

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 вгорі не є частиною коду, але сигналізує про розміщення модулів пам'яті.

Грайте на цьому рівні самостійно, вставляючи це в гру:

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

Тож я вважаю, що це також вважається відповіддю на луа ...

MATL , 6 байт

QJi-h)

Спробуйте в Інтернеті!

Вхід подається як 1) кількість елементів, які слід обрізати з самого початку; 2) кількість елементів, які слід обрізати з кінця; 3) масив. Пояснення

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 байти

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

Спробуйте в Інтернеті!

Якщо ми дійсно обмежимось масивами, то це 53 байти:

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

Спробуйте в Інтернеті!

JavaScript (ES6), 27 байт

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

Негативний другий параметр sliceзупиняє зрізання mз кінця, однак, коли mдорівнює нулю, ми повинні передати заповнювач ( Infinityтут, хоча це (a,n,m,o)=>a.slice(n,-m||o)також працює).

R , 32 31 30 байт

-1 байт завдяки Rift

-1 байт завдяки Ярко Дуббелдам

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

Оцінює анонімну функцію:

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

1+lнеобхідно, оскільки R має індексацію на основі 1. sum(n|1)еквівалентно, length(n)але це байт коротший.

Спробуйте в Інтернеті!

MATL , 10 байт

tniQwi-&:)

Спробуйте в Інтернеті!

Пояснення:

Це трохи довге всього 11 байт, але я детально його виписую, щоб і сам це вивчити.

---- 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 байт

Дякуємо @Tas за збереження байта!

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

Спробуйте в Інтернеті!

C ++ (MinGW), 91 байт

#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 байт

⌽⎕↓⌽⎕↓⎕

Спробуйте в Інтернеті!

Це приймає масив як перший вхід, після чого два числа окремо.

Пояснення

⎕            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 байт

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

PHP Пісочниця Інтернет

Мозок-Флак , 60 байт

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

Спробуйте в Інтернеті!

Введення в такому форматі:

x

a
r
r
a
y

y

Де xчисло, яке потрібно взяти спереду, yце число, яке потрібно взяти ззаду, а масив - це скільки завгодно потрібних чисел, розділених новими рядками. Ось мої перші дві (довші) спроби:

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

І ось пояснення:

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

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

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

>)[()]}{}

APL (Dyalog) , 5 байт

(⌽↓)/

Спробуйте в Інтернеті!

Формат вводу є y x A

Пояснення

/ є Зменшити, яка вставляє функцію зліва між кожною парою елементів аргументу

(⌽↓)це функція, еквівалентна поїзду {⌽⍺↓⍵}, яка видаляє перші ⍺елементи масиву, ⍵а потім реверсує масив. ( ⍺це лівий аргумент і ⍵правий аргумент)

Таким чином, (⌽↓)/y x Aеквівалентно тому ⌽y↓⌽x↓A, що саме потрібно.

Java 8, 82 байти

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

Спробуйте тут.

Альтернатива з тим же ( 82 ) підрахунком байтів за допомогою циклу:

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

Спробуйте тут.

Пояснення:

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

У java.lang.System.arraycopy()методі копіює масив із зазначеного вихідного масиву, починаючи із зазначеною позицією, в зазначену позицію в масиві призначення. Послідовність компонентів масиву копіюється з вихідного масиву, на який посилається srcмасив призначення, на який посилається dest. Кількість скопійованих компонентів дорівнює lengthаргументу.

Компоненти в позиціях srcPosнаскрізь srcPos + length - 1у вихідному масиві копіюються в положення destPosчерез destPos + length - 1масив призначення.

C ++, 50 48 46 байт

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

Спробуйте в Інтернеті!

Котлін , 30 байт

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

Спробуйте в Інтернеті!

Приймає List<Int>як вхід і падає від початку, а потім від кінця.

Брахілог , 11 10 байт

kb₍B&t;Bk₍

Спробуйте в Інтернеті!

Приймає введення як [x, A, y], де A - масив для обрізки.

(-1 байт завдяки @Fatalize.)

Діалог APL, 16 байт

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

Спробуйте в Інтернеті!

Pyth, 5 байт

>E<QE

Спробуйте тут

Приймає аргументи у зворотному порядку. <і >в обробці Pyth на основі порядку аргументів. Наприклад, <Q5обріже всі значення вхідних даних після п'ятого.

tcl, 19

lrange $L $x end-$y

де Lмасив.

демонстрація

CJam , 8 байт

{_,@-<>}

Анонімний блок, який приймає входи зі стека в порядку x , y , масив і замінює їх вихідним масивом.

Спробуйте в Інтернеті!

Пояснення

Розглянемо входи 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 байт

Рішення:

{(0-z)_y _x}

Приклад:

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

Пояснення:

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

Ракетка, 33 байти

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

Це можна назвати так:

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