Bir tamsayı dizisi ve giriş olarak iki sayı verildiğinde, sayılarla belirtilen ilk ve son öğelerin belirli bir miktarını kaldırın. Giriş istediğiniz sırada olabilir.

X'in ilk sayısal giriş olduğu ilk x öğesini silmeli ve y'nin ikinci sayısal giriş olduğu son y öğesini de kaldırmalısınız .

Elde edilen dizinin en az iki uzunluğa sahip olduğu garanti edilir.

Örnekler:

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

Laikoni sayesinde 16 bayt kaydedildi

Laikoni sayesinde 6 bayt daha kaydedildi

Laikoni sayesinde 4 bayt daha kaydedildi

Bunun geliştirilebileceğinden eminim, ama yeni başlayanlar için elimden gelenin en iyisini yaptım.

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

kullanım

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

Çevrimiçi deneyin!

Oktav, 20 bayt

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

Çevrimiçi deneyin!

Mathematica, 17 bayt

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

giriş

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

Python , 28 26 bayt

@Rod sayesinde -2 bayt

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

Çevrimiçi deneyin!

C # (.NET Core) , 55 54 bayt

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

Çevrimiçi deneyin!

Bir List<int>giriş olarak kullanır .

• TheLethalCoder sayesinde 1 byte kaydedildi!

Perl 5 , 21 bayt

19 bayt kod + -apbayrakları.

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

Çevrimiçi deneyin!

Kullanım -agiriş iç otomatik bölme için @F, daha sonra, sadece diğer girişlere göre bunun bir dilim tutmak: dizinden <>(ikinci giriş) indeksine $#F-<>(dizi eksi üçüncü girdi büyüklüğü). Ve $_örtülü sayesinde yazdırılır -pbayrağı.

Pas, 29 bayt

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

Aşağıdaki gibi arayın:

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

Borç kontrolcüsü ile savaşırken çok eğlendim. İade edilen bir dilimin ömrünü kısaltmak için en kısa yaklaşımın ne olduğunu buldum. Kapakların etrafındaki davranışları, yaşam sürelerini kısaltacağından biraz düzensizdir, ancak yalnızca parametreyi referans türü olarak tanımlamazsanız. Ne yazık ki bu, imzadaki argüman tipini tanımlamak için gerekli olanla n.len metod çağrısı üzerinde çalıştığı tipin bilinmesi gerektiğini gerektirir.

Bu soruna geçici bir çözüm bulmaya çalıştığım diğer yaklaşımlar:

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 bayt

𝕘₃𝕙

Burada dene

Beni bu konuda cesaretlendirdiğim için teşekkürler ... :)

C #, 62 bayt

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

Bir Alır List<int>giriş ve getiri bir şekilde IEnumerable<int>.

Bu ayrıca 64 bayt için çalışır:

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

TIS-100, 413 405 Bayt

472 döngü, 5 düğüm, 35 kod satırı

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

Üstte bulunan m4,6, kodun bir parçası değil, bellek modüllerinin yerleşimini gösterir.

Bunu oyuna yapıştırarak bu seviyeyi kendin oyna:

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

Sanırım bu da bir lua cevabı olarak sayılıyor ...

MATL , 6 bayt

QJi-h)

Çevrimiçi deneyin!

Giriş 1) baştan kesilecek eleman sayısı; 2) uçtan kesilecek elemanların sayısı; 3) dizi. açıklama

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 bayt

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

Çevrimiçi deneyin!

Dizileri gerçekten kısıtlarsak, 53 bayttır:

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

Çevrimiçi deneyin!

JavaScript (ES6), 27 bayt

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

sliceSonundan mitibaren dilimi durduran negatif bir ikinci parametre , ancak msıfır olduğunda , bir yer tutucuyu geçmemiz gerekir ( Infinityburada (a,n,m,o)=>a.slice(n,-m||o)da çalışır).

R , 32 31 , 30 bayt

Rift sayesinde -1 bayt

Jarko Dubbeldam sayesinde -1 bayt

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

Anonim bir işlev için değerlendirir:

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

1+lR'nin 1 tabanlı endekslemeye sahip olması nedeniyle gereklidir. sum(n|1)eşittir, length(n)ancak bir bayt daha kısadır.

Çevrimiçi deneyin!

MATL , 10 bayt

tniQwi-&:)

Çevrimiçi deneyin!

Açıklama:

Sadece 11 byte için biraz uzun, ama ben de kendim öğrenmek için onu ayrıntılı olarak yazıyorum.

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

Bir bayt tasarrufu için @Tas teşekkürler!

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

Çevrimiçi deneyin!

C ++ (MinGW), 91 bayt

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

⌽⎕↓⌽⎕↓⎕

Çevrimiçi deneyin!

Bu, diziyi ilk giriş olarak alır, ardından iki sayı ayrı ayrı alır.

açıklama

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

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

PHP Sandbox Çevrimiçi

Beyin Flak , 60 bayt

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

Çevrimiçi deneyin!

Giriş bu formatta:

x

a
r
r
a
y

y

Nerede xönden almaya sayıdır, yarkasından almaya sayıdır ve dizi size satırbaşıyla ayrılmış, istediğiniz gibi ancak birçok sayılardır. İşte ilk iki (daha uzun) denemelerim:

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

Ve işte bir açıklama:

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

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

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

>)[()]}{}

APL (Dyalog) , 5 bayt

(⌽↓)/

Çevrimiçi deneyin!

Giriş formatı y x A

açıklama

/ Argümanının her bir çift çifti arasında işlevi sola ekleyen Reduce (Düşür) işlevi

(⌽↓)bu , dizinin {⌽⍺↓⍵}ilk ⍺elemanlarını silen ⍵ve daha sonra diziyi tersine çeviren, eşdeğer bir fonksiyon trenidir . ( ⍺soldaki tartışma⍵ doğru argümandır)

Böylece, ihtiyaç duyulan (⌽↓)/y x Aşey eşdeğerdir ⌽y↓⌽x↓A.

Java 8, 82 bayt

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

Burada dene.

Bir döngü kullanarak aynı ( 82 ) byte-count ile alternatif :

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

Burada dene.

Açıklama:

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()Yöntem kopya hedef dizinin belirli bir konuma, belirtilen pozisyonda başlayan belirtilen kaynak diziden bir dizi. Dizi bileşenlerinin bir sırası, tarafından başvurulan srchedef diziye başvurulan kaynak diziden kopyalanır dest. Kopyalanan bileşenlerin sayısı,length argümana .

Pozisyonlarda bileşenler srcPosaracılığıyla srcPos + length - 1kaynak dizideki pozisyonlara kopyalanır destPosyoluyla destPos + length - 1hedef dizinin sırasıyla.

C ++, 50 48 46 bayt

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

Çevrimiçi deneyin!

Kotlin , 30 bayt

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

Çevrimiçi deneyin!

Alır List<Int>girdi olarak ve başlamak düşüşlerini ardından ucundan.

Brachylog , 11 10 bayt

kb₍B&t;Bk₍

Çevrimiçi deneyin!

Girdiyi [x, A, y] olarak alır, burada A kırpılacak dizidir.

(@Fatalize sayesinde -1 bayt.)

Dyalog APL, 16 bayt

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

Çevrimiçi deneyin!

Pyth, 5 bayt

>E<QE

Burada dene

Argümanları ters sırada alır. <ve >argüman sırasına göre Pyth trim. Örneğin <Q5, beşinci değerden sonra girişteki tüm değerleri keser.

tcl, 19

lrange $L $x end-$y

Ldizi nerede .

gösteri

CJam , 8 bayt

{_,@-<>}

Girdileri yığından x , y , array sırasına alan ve onları çıktı dizisi ile değiştiren adsız blok .

Çevrimiçi deneyin!

açıklama

Girişlerini düşünün 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 bayt

Çözüm:

{(0-z)_y _x}

Örnek:

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

Açıklama:

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

Raket, 33 bayt

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

Bu şekilde çağrılabilir:

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