Étant donné un tableau entier et deux nombres en entrée, supprimez une certaine quantité des premier et dernier éléments, spécifiés par les nombres. L'entrée peut être dans n'importe quel ordre.

Vous devez supprimer les premiers éléments x , où x est la première entrée numérique, et également supprimer les derniers éléments y , où y est la deuxième entrée numérique.

Le tableau résultant est garanti d'avoir une longueur d'au moins deux.

Exemples:

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

16 octets enregistrés grâce à Laikoni

6 octets de plus enregistrés grâce à Laikoni

4 octets de plus enregistrés grâce à Laikoni

Je suis sûr que cela pourrait être amélioré, mais en tant que débutant, j'ai fait de mon mieux.

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

Usage

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

Essayez-le en ligne!

Octave, 20 octets

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

Essayez-le en ligne!

Mathematica, 17 octets

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

contribution

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

Python , 28 26 octets

-2 octets grâce à @Rod

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

Essayez-le en ligne!

C # (.NET Core) , 55 54 octets

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

Essayez-le en ligne!

Utilise une List<int>entrée.

• 1 octet économisé grâce à TheLethalCoder!

Perl 5 , 21 octets

19 octets de code + -apdrapeaux.

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

Essayez-le en ligne!

Utilise -apour diviser automatiquement l'entrée à l'intérieur @F, puis n'en conserver qu'une tranche en fonction des autres entrées: de l'index <>(deuxième entrée) à l'index $#F-<>(taille du tableau moins troisième entrée). Et $_est implicitement imprimé grâce au -pdrapeau.

Rouille, 29 octets

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

Appelez-le comme suit:

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

Je me suis beaucoup amusé à me battre avec le vérificateur d'emprunt pour déterminer l'approche la plus courte afin de déduire la durée de vie d'une tranche retournée. Son comportement autour des fermetures est quelque peu erratique, car il déduira les durées de vie, mais uniquement si vous ne déclarez pas réellement le paramètre comme type de référence. Malheureusement, cela entre en conflit avec la nécessité de définir le type d'argument dans la signature car l'appel de méthode n.len doit connaître le type sur lequel il fonctionne.

D'autres approches, j'ai essayé de contourner ce problème:

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 octets

𝕘₃𝕙

Essayez-le ici

Merci à Okx de m'avoir encouragé à le faire ... :)

C #, 62 octets

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

Prend une List<int>entrée et renvoie un IEnumerable<int>.

Cela fonctionne également pour 64 octets:

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

TIS-100, 413 405 octets

472 cycles, 5 nœuds, 35 lignes de code

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

Le m4,6 en haut ne fait pas partie du code, mais signale le placement des modules de mémoire.

Jouez ce niveau vous-même en le collant dans le jeu:

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

Donc je suppose que cela compte aussi comme une réponse lua ...

MATL , 6 octets

QJi-h)

Essayez-le en ligne!

L'entrée est donnée comme 1) nombre d'éléments à couper depuis le début; 2) nombre d'éléments à couper à partir de la fin; 3) tableau. Explication

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 octets

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

Essayez-le en ligne!

Si nous nous limitons vraiment aux tableaux, alors c'est 53 octets:

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

Essayez-le en ligne!

JavaScript (ES6), 27 octets

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

Un deuxième paramètre négatif pour slicearrêter le découpage à mpartir de la fin, mais quand il mest nul, nous devons passer un espace réservé ( Infinityici, bien que cela (a,n,m,o)=>a.slice(n,-m||o)fonctionne également).

R , 32 31 30 octets

-1 octet grâce à Rift

-1 octet grâce à Jarko Dubbeldam

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

Évalue à une fonction anonyme:

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

1+lest nécessaire car R a une indexation basée sur 1. sum(n|1)est équivalent à length(n)mais c'est un octet plus court.

Essayez-le en ligne!

MATL , 10 octets

tniQwi-&:)

Essayez-le en ligne!

Explication:

C'est un peu long pour seulement 11 octets, mais je l'écris en détail, pour l'apprendre moi aussi.

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

Merci à @Tas pour avoir sauvé un octet!

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

Essayez-le en ligne!

C ++ (MinGW), 91 octets

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

⌽⎕↓⌽⎕↓⎕

Essayez-le en ligne!

Cela prend le tableau comme première entrée, suivi des deux nombres séparément.

Explication

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

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

PHP Sandbox Online

Brain-Flak , 60 octets

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

Essayez-le en ligne!

L'entrée est dans ce format:

x

a
r
r
a
y

y

Où xest le numéro à prendre de l'avant, yest le numéro à prendre de l'arrière, et le tableau est juste autant de nombres que vous voulez, séparés par des retours à la ligne. Voici mes deux premières tentatives (plus longues):

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

Et voici une explication:

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

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

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

>)[()]}{}

APL (Dyalog) , 5 octets

(⌽↓)/

Essayez-le en ligne!

Le format d'entrée est y x A

Explication

/ est Reduce, qui insère la fonction à gauche entre chaque paire d'éléments de l'argument

(⌽↓)est un train de fonctions équivalent à {⌽⍺↓⍵}, qui supprime les premiers ⍺éléments du tableau ⍵puis inverse le tableau. ( ⍺est l'argument de gauche et⍵ l'argument de droite)

Ainsi, (⌽↓)/y x Aest équivalent à ⌽y↓⌽x↓A, ce qui est nécessaire.

Java 8, 82 octets

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

Essayez-le ici.

Alternative avec le même ( 82 ) nombre d'octets en utilisant une boucle:

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

Essayez-le ici.

Explication:

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

La java.lang.System.arraycopy()méthode copie un tableau du tableau source spécifié, en commençant à la position spécifiée, vers la position spécifiée du tableau de destination. Une sous-séquence de composants de tableau est copiée du tableau source référencé par srcvers le tableau de destination référencé par dest. Le nombre de composants copiés est égal à l' lengthargument.

Les composants aux positions à srcPostravers srcPos + length - 1dans le tableau source sont copiés dans les positions à destPostravers destPos + length - 1, respectivement, du tableau de destination.

C ++, 50 48 46 octets

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

Essayez-le en ligne!

Kotlin , 30 octets

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

Essayez-le en ligne!

Prend List<Int>en entrée et tombe du début puis de la fin.

Brachylog , 11 10 octets

kb₍B&t;Bk₍

Essayez-le en ligne!

Prend l'entrée comme [x, A, y] où A est le tableau à découper.

(-1 octet grâce à @Fatalize.)

Dyalog APL, 16 octets

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

Essayez-le en ligne!

Pyth, 5 octets

>E<QE

Essayez-le ici

Prend les arguments dans l'ordre inverse. <et >en Pyth Trim basé sur l'ordre des arguments. Par exemple, <Q5supprimera toutes les valeurs de l'entrée après la cinquième.

tcl, 19

lrange $L $x end-$y

où Lest le tableau.

démo

CJam , 8 octets

{_,@-<>}

Bloc anonyme qui prend les entrées de la pile dans l'ordre x , y , tableau et les remplace par le tableau de sortie.

Essayez-le en ligne!

Explication

Tenez compte des entrées 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 octets

Solution:

{(0-z)_y _x}

Exemple:

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

Explication:

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

Raquette, 33 octets

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

Il peut être appelé ainsi:

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