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

Вы должны удалить первые элементы 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 байтов благодаря Laikoni

Сохранено еще 6 байтов благодаря Laikoni

Сохранено еще 4 байта благодаря Laikoni

Уверен, что это можно улучшить, но, как новичок, сделал все возможное.

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)

Попробуйте онлайн!

Mathematica, 17 байт

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

вход

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

Python , 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)

Попробуйте онлайн!

Использует 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)и работает).

Р , 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 Sandbox Online

Brain-Flak , 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

объяснение

/ является Reduce, который вставляет функцию слева между каждой парой элементов аргумента

(⌽↓)является эквивалентом последовательности функций {⌽⍺↓⍵}, который удаляет первые ⍺элементы массива, ⍵а затем переворачивает массив. ( ⍺это левый аргумент и⍵ правый аргумент)

Таким образом, (⌽↓)/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.)

Дьялог АПЛ, 16 байт

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

Попробуйте онлайн!

Pyth, 5 байт

>E<QE

Попробуй здесь

Принимает аргументы в обратном порядке. <и >в Pyth Trim на основе порядка аргументов. Например, <Q5обрезает все значения на входе после пятого.

ткл, 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)