पूर्णांक सरणी और इनपुट के रूप में दो संख्याओं को देखते हुए, संख्याओं द्वारा निर्दिष्ट पहले और अंतिम तत्वों की एक निश्चित राशि निकालें। इनपुट आपके इच्छित किसी भी क्रम में हो सकता है।

आपको पहले 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]

code-golf array-manipulation

— Okx
स्रोत

2

क्या, वास्तव में, यह एक सरणी से मूल्यों को "हटाने" का मतलब है - विशेष रूप से उन्हें अंत से हटाने के लिए? C जैसी भाषाओं में, जहाँ एक सरणी पहले तत्व और लंबाई के लिए सिर्फ एक संकेतक है, क्या हम सरणी को छोटा करने के लिए केवल लंबाई बदल सकते हैं? यह वही है जो सामान्य रूप से वास्तविक दुनिया की प्रोग्रामिंग में किया जाएगा, लेकिन चुनौती मेरे लिए स्पष्ट नहीं है।

— कोड़ी ग्रे

@CodyGray सरणी से मानों को हटाना वही है जो इसे देखना चाहिए , लेकिन जरूरी नहीं कि पर्दे के पीछे क्या हो।

— ओकेक्स

4

"जैसे दिखते हैं" से आपका क्या मतलब है? Arrays एक नज़र नहीं है - यह सब पर्दे के पीछे है!

— कोड़ी ग्रे

1

@ मिचथन पीपीसीजी उपयोगकर्ता नाम

— ओकेएक्स

2

@ ओके नोप, यह बहुत छोटी गाड़ी है, मैं एक लीडरबोर्ड जोड़ने की सलाह दूंगा।

— एरिक आउटगोल्फ

16

हास्केल, 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]

इसे ऑनलाइन आज़माएं!

— हेनरी
स्रोत

5

विशेष रूप से PPCG और हास्केल गोल्फ में आपका स्वागत है! इसका उद्देश्य जितना संभव हो उतने बाइट्स का उपयोग करना है, इसलिए आप उदाहरण के लिए अधिकांश रिक्त स्थान को हटा सकते हैं और छोटा कर सकते हैं xs।

— लकोनी

@ लायकोनी आह, धन्यवाद! संपादित, अपने आप को किसी अनाम फ़ंक्शन के बिना किसी भी छोटे जा रहा है और कार्यों के लिए आवेदन का उपयोग नहीं कर सकता है (यह सुनिश्चित नहीं है कि यह कैसे काम करता है)।

— हेनरी

अब अच्छी लग रही है! :) आप को बदलते हैं f x a bकरने के लिए f a b x, तो आप बस छोड़ सकते हैं x: f a b=reverse.drop b.reverse.drop a।

— लकोनी

1

@ लाईकोनी वाह, दिलचस्प इन्फिक्स ट्रिक। एक बार फिर धन्यवाद! मैं इसे 33 बाइट्स में छोटा करने में सक्षम था, लेकिन a#b=let r=reverse in r.drop b.r.drop a38 बाइट्स करने की कोशिश कर रहा था । या हमें इस एक के बाहर एक समारोह घोषित करने की अनुमति है?

— हेनरी

1

@ लैकोनी परिचय के लिए धन्यवाद, बहुत उपयोगी। बस आज यह साइट मिली है, लेकिन निश्चित रूप से यहाँ कुछ और खेलने के लिए तत्पर हैं!

— हेनरी

7

ऑक्टेव, 20 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— rahnema1
स्रोत

6

गणितज्ञ, १ Mat बाइट्स

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

इनपुट

[{१, २, ३, ४, ५, ६}, २, १]

— J42161217
स्रोत

का अच्छा उपयोग ;;! मैं आपके साथ टाई करने में कामयाब रहा Drop@##2~Drop~-#&(यदि हम इनपुट को अजीब क्रम में लेते हैं जैसे 1, {1,2,3,4,5,6}, 2), लेकिन बेहतर नहीं है।

— ग्रेग मार्टिन

6

पायथन , 28 26 बाइट्स

-2 बाइट्स @Rod का धन्यवाद

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

इसे ऑनलाइन आज़माएं!

— OVS
स्रोत

बचाओ 6 ...lambda a,n,m:a[n:~m]

— हारून

@ ऐरन यह एक आइटम को बहुत अधिक हटा देता है।

— ओवंस

मेरा बुरा .. यह एक सामान्य चाल है जिसका मैं कभी-कभी उपयोग करता हूं, और चुनौती की आवश्यकताओं के खिलाफ पूरी तरह से जांच नहीं की है ..

— हारून

@Aaron स्लाइस की तुलना में एक उच्च ऑपरेटर पूर्वता है +और इसलिए इसे लागू किया जाता है [0]। आपको कोष्ठक की आवश्यकता होगी (a+[0])[n:~m]:।

— अंडा

याह, एहसास हुआ कि बाद में .. मैं अपने विचार को बनाने की कोशिश कर रहा हूँ

— हारून

6

सी # (.NET कोर) , 55 54 बाइट्स

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

इसे ऑनलाइन आज़माएं!

एक List<int>इनपुट के रूप में उपयोग करता है ।

1 बाइट ने TheLethalCoder को धन्यवाद दिया!

— चार्ली
स्रोत

1

मैं इस +1 का उत्तर देने वाला था। हालाँकि, आप एक बाइट को एक Listइनपुट के रूप में सहेज सकते हैं ताकि आप Countइसके बजाय उपयोग कर सकें Length।

— TheLethalCoder

मैं इसका उपयोग करके एक समाधान के साथ आया था Whereजो केवल इस तरह से थोड़ा लंबा है कि मैं साथ ही बहुत खुश हूं :)

— TheLethalCoder

आपको using System.Linq;बाइट काउंट में जोड़ने की आवश्यकता नहीं है :)

— स्टीफन

@Stefan मुझे usingअपने उत्तर में, मेरे द्वारा जोड़े जाने वाले तरीकों Skipऔर ज़रूरतों के बारे में जानने की Takeज़रूरत है using।

— चार्ली

एचएम। ठीक है। किसी अन्य चुनौती पर मुझे बताया गया कि वे प्रयोग जहाँ आवश्यक नहीं हैं।

— स्टीफन

5

पर्ल 5 , 21 बाइट्स

कोड + -apझंडे के 19 बाइट्स ।

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

इसे ऑनलाइन आज़माएं!

-aइनपुट को अंदर करने के लिए उपयोग करता है @F, उसके बाद अन्य इनपुट के अनुसार केवल उसका एक टुकड़ा रखें: इंडेक्स <>(दूसरा इनपुट) से लेकर इंडेक्स $#F-<>(एरे माइनस थर्ड इनपुट का आकार)। और झंडे $_के लिए स्पष्ट रूप से मुद्रित है -p।

— बापू
स्रोत

5

जंग, 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

— CensoredUsername
स्रोत

4

नीम , 3 बाइट्स

𝕘₃𝕙

इसे यहाँ आज़माएँ

मुझे ऐसा करने के लिए प्रोत्साहित करने के लिए ओएक्सएक्स को धन्यवाद ... :)

— आउटग्रॉफर को एरिक करें
स्रोत

4

सी #, 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()

— TheLethalCoder
स्रोत

4

टीआईएस -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

तो मुझे लगता है यह भी एक लुआ जवाब के रूप में गिना जाता है ...

— जंक मेल
स्रोत

अब आप इसे ऑनलाइन आज़मा सकते हैं ! नोट: मुझे एक चतुर करना था, और इनपुट के एक स्रोत के रूप में कोड फ़ाइल के शीर्ष का उपयोग करना था, क्योंकि TIO वर्तमान में केवल एक इनपुट फ़ाइल प्रदान करता है।

— फेल्क्स

4

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.

— Sanchises
स्रोत

4

जावा (ओपनजेडके 8) , 32 बाइट्स

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

इसे ऑनलाइन आज़माएं!

यदि हम वास्तव में सरणियों के लिए प्रतिबंधित करते हैं, तो यह 53 बाइट्स है:

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

इसे ऑनलाइन आज़माएं!

— ओलिवियर ग्रेजायर
स्रोत

3

जावास्क्रिप्ट (ईएस 6), 27 बाइट्स

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

अंत से sliceस्लाइसिंग mको रोकने के लिए एक नकारात्मक दूसरा पैरामीटर , हालांकि जब mशून्य होता है तो हमें एक प्लेसहोल्डर ( Infinityयहां, हालांकि (a,n,m,o)=>a.slice(n,-m||o)काम भी करता है) पास करना होगा।

— नील
स्रोत

3

आर , 32 31 30 बाइट्स

-1 बाइट रिफ्ट की बदौलत

-1 बाइट थैंक्स टू जारको डबेलडैम

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

एक अनाम फ़ंक्शन का मूल्यांकन:

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

1+lआर के बाद से 1-आधारित अनुक्रमण आवश्यक है। sum(n|1)के बराबर है, length(n)लेकिन यह एक बाइट कम है।

इसे ऑनलाइन आज़माएं!

— ग्यूसेप
स्रोत

1

1 बाइट की बचतpryr::f(n[(1+l):(length(n)-r)])

— रिफ्ट

1

Sum (n | 1) लंबाई (n) से छोटा है

— JAD

@JarkoDubbeldam उत्कृष्ट, धन्यवाद।

— Giuseppe

3

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

— स्टीवी ग्रिफिन
स्रोत

आप एंड-बेस्ड इंडेक्सिंग के बारे में भूल गए ;)

— Sanchises

(फिर भी, एक उत्थान है - मेरा मानना है कि यह अच्छी तरह से गोल्फ है और आपके द्वारा उपयोग की जाने वाली विधि को देखते हुए समझाया गया है)

— Sanchises

नहीं, मैं इसे भूल नहीं था! मैंने कोशिश की, लेकिन मुझे यह पता नहीं चला कि इसे कैसे काम करना है, (और मैंने वास्तव में कोशिश की)। मैंने निष्कर्ष निकाला कि Jइस तरह से उपयोग किए जाने पर कुछ को घटाना असंभव था । मुझे संदेह था कि मैं गलत था, मैं इसे अपने जीवन के लिए समझ नहीं पाया ... आपके उत्तर से जुड़ने के लिए धन्यवाद, मैं बहुत MATL नौसिखिया हूं ...

— Stewie Griffin

चिंता न करें, मैं अभी भी बहुत कुछ सीख रहा हूं - उदाहरण के लिए, इनपुट के क्रम )और अधिक कुख्यात ( कंपकंपी के लिए ...

— Sanchises

@Sanchises बहुत देर से टिप्पणी, लेकिन मुझे खुशी है कि यह सिर्फ मुझे नहीं है जो (भ्रमित करने के लिए इनपुट आदेश पाता है। :) मैं हर बार "डीडी" (= "गंतव्य, डेटा, सूचकांक" मैनुअल से) ले रहा हूं, और अभी भी कभी-कभी गलत हो जाता हूं।

— सूंदर -

3

सी ++, 96 95 बाइट्स

एक बाइट को बचाने के लिए @ टास के लिए धन्यवाद!

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

इसे ऑनलाइन आज़माएं!

सी ++ (मिनगव), 91 बाइट्स

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

— Steadybox
स्रोत

क्या आपका मतलब था #include<list>? आप एक बाइट दाढ़ी कर सकते हैंint f । कंपाइलर एक फ़ंक्शन को वापस नहीं आने देंगे, लेकिन वे इसके खिलाफ चेतावनी देंगे

— त्स

हाँ, धन्यवाद, int fअधिकांश संकलक पर काम करेंगे, मैं उस पर संपादित करूँगा। MinGW पर, यहां तक कि फ़ंक्शन के प्रकार को पूरी तरह से छोड़ देना। और हां, #include<list>हेडर को शामिल करने के लिए एक मानक-अनुपालन तरीका होगा, लेकिन #import<list>कम से कम जीसीसी, मिनजीडब्ल्यू और एमएसवीसी पर काम करना चाहिए, इसलिए यह भी ठीक होना चाहिए।

— स्टेयडबॉक्स

2

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

— क्रिक्टी लिथोस
स्रोत

वैकल्पिक 7 बाइट समाधान:⎕↓⎕↓⍨-⎕

— Adám

2

PHP> = 7.1, 59 बाइट्स

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

PHP सैंडबॉक्स ऑनलाइन

— जार्ग हुल्सरमन
स्रोत

2

ब्रेन-फ्लैक , 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
    ([]){{}({}<>)<>([])}{}<>

>)[()]}{}

— DJMcMayhem
स्रोत

1

ट्यूरिंग टारपिट के घोल को हर हाल में देखकर अच्छा लगा।

— ओकेक्स

2

APL (Dyalog) , 5 बाइट्स

(⌽↓)/

इसे ऑनलाइन आज़माएं!

इनपुट प्रारूप है y x A

व्याख्या

/ कम है, जो तर्क के तत्वों के प्रत्येक जोड़े के बीच बाईं ओर फ़ंक्शन सम्मिलित करता है

(⌽↓)के बराबर एक फ़ंक्शन ट्रेन है {⌽⍺↓⍵}, जो ⍺सरणी के पहले तत्वों को हटाती है ⍵और फिर सरणी को उलट देती है। ( ⍺बाएं तर्क है और ⍵सही तर्क है)

इस प्रकार, (⌽↓)/y x Aके बराबर है ⌽y↓⌽x↓A, जो की जरूरत है।

— TwiNight
स्रोत

2

जावा 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, क्रमशः, गंतव्य सरणी के।

— केविन क्रूज़सेन
स्रोत

क्या आप करी का उपयोग न करके बाइट बचा सकते हैं?

— TheLethalCoder

@ TheLethalCoder नहीं, इस मामले में नहीं। (a,n,m)->के रूप में एक ही बाइट गिनती है a->n->m->। हालाँकि आप सही कह रहे हैं कि मैं सिर्फ करीने की बजाय एक नियमित कॉल का उपयोग कर सकता हूं। जब मैं दो (या अधिक) मापदंडों का उपयोग कर रहा हूँ, तो मैंने थोड़े से उपयोग किया है .. मैंने पहले से ही चार बार कुछ पैरामीटर होने पर करी का उपयोग करने की गलती की है ..

— केविन क्रूज़सेन

आह आप सही हैं मैं बाइट्स को गलत तरीके से देखता हूं और मैंने किया है कि साथ ही साथ करीना अब निश्चित रूप से जा रही है!

— द लीथेलकोडर

कोई TIO लिंक नहीं? -

— बिलकुल अमानवीय

2

क्षमा करें, वह पास नहीं होने दे सकता। मैंने अपना जवाब पोस्ट किया क्योंकि ... वहाँ एक बिल्ट-इन (ठीक है, बिल्कुल नहीं, लेकिन लगभग) है! : ओ

— ओलिवियर ग्रैगोइरे

2

सी ++, 50 48 46 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— rahnema1
स्रोत

2

कोटलिन , 30 बाइट्स

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

इसे ऑनलाइन आज़माएं!

List<Int>इनपुट के रूप में लेता है और शुरू से और फिर अंत से गिरता है।

— YGolybev
स्रोत

1

मेरी पहुंच नहीं है try it online। क्या आप एक कॉलर कोड जोड़ सकते हैं? कोटलिन में प्रकार परिभाषाओं के बिना लैम्ब्डा कैसे संकलित करें? धन्यवाद।

— माज़ी जूल

1

@ माज़ी शायद यह एक हैक हो सकता है, लेकिन आप चर प्रकार में परिभाषा को निर्दिष्ट कर सकते हैं जैसेval f: (List<Int>, Int, Int) -> List<Int>

— YGolybev

समझ गया! अच्छा लगा। मुझे नहीं पता कि यह कोडगोल्फ में मान्य है या नहीं।

— माज़ी जूल

2

ब्रेकीलॉग , 11 10 बाइट्स

kb₍B&t;Bk₍

इसे ऑनलाइन आज़माएं!

इनपुट को [x, A, y] के रूप में लेता है जहां A को ट्रिम करने के लिए सरणी है।

(-1 बाइट @ फेटलाइज़ करने के लिए धन्यवाद।)

— sundar - मोनिका को बहाल करना
स्रोत

आप इस तरह के रूप में 1 बाइट से इसे छोटा कर सकते हैं: kb₍B&t;Bk₍। ,एपेंड करता है ( इस आंशिक कार्यक्रम का परिणाम देखें ), यह पसंद नहीं करता है ∧। पुरानी (2016 की शुरुआत में) 2017 के ब्रैकलॉग उत्तरों से चीजों को कॉपी करने की कोशिश न करें क्योंकि यह भाषा का पहला संस्करण था, और प्रोग्राम अप्रचलित नहीं हैं (विशेष रूप से, ब्रेकीलॉग ,v1 में अब ∧

— ब्रेकिग्लॉग

@ नियमित रूप से धन्यवाद, अद्यतन। तो ,पिछले संस्करण में संलग्न किया था, लेकिन यह इस मामले में सिर्फ इसलिए मायने नहीं रखता था क्योंकि इसके tबाद भी - भाग्यशाली संयोग था। और हाँ, मुझे यह पोस्ट करने के बाद संस्करण के अंतर का एहसास हुआ, मैं अभी भी चीजों को समझ रहा था और इस स्तर पर चारों ओर टकरा रहा था। :)

— सूंदर -

1

दिल्लोग एपीएल, 16 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— Uriel
स्रोत

1

इसे क्यों अस्वीकृत किया गया?

— यूरिल

1

अजगर, 5 बाइट्स

>E<QE

इसे यहाँ आज़माएँ

विपरीत क्रम में तर्क देता है। <और >तर्क क्रम के आधार पर पाइथ ट्रिम में। उदाहरण के लिए, <Q5पांचवें के बाद इनपुट में सभी मूल्यों को ट्रिम कर देगा।

— FryAmTheEggman
स्रोत

1

tcl, १ ९

lrange $L $x end-$y

Lसरणी कहां है

डेमो

— sergiol
स्रोत

1

सीजेएम , 8 बाइट्स

{_,@-<>}

बेनामी ब्लॉक जो ऑर्डर एक्स , वाई , सरणी में स्टैक से इनपुट लेता है , और उन्हें आउटपुट सरणी द्वारा बदल देता है।

इसे ऑनलाइन आज़माएं!

व्याख्या

आदानों पर विचार करें 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]

— लुइस मेंडो
स्रोत

1

अच्छी बात है, तो बस मज़े के लिए, यहाँ एक वैकल्पिक 8-बाइट समाधान है :) tio.run/##S85KzP1vxGXIFW1ooGBkoGBGBGBGBGBGBGBGBGBOEPO/Oln7ps7GrvZ/-

— मार्टिन

1

क्यू / केडीबी, 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)

— streetster
स्रोत

1

रैकेट, 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)

— परम हॉक
स्रोत

क्या मुझे भाषा की वेबसाइट का लिंक मिल सकता है?

— ओकेक्स

@ ऑक्स

— परम हॉक

सरणी ट्रिम!

उदाहरण:

हास्केल, 55 39 33 29 बाइट्स

प्रयोग

ऑक्टेव, 20 बाइट्स

गणितज्ञ, १ Mat बाइट्स

पायथन , 28 26 बाइट्स

सी # (.NET कोर) , 55 54 बाइट्स

पर्ल 5 , 21 बाइट्स

जंग, 29 बाइट्स

नीम , 3 बाइट्स

सी #, 62 बाइट्स

टीआईएस -100, 413 405 बाइट्स

MATL , 6 बाइट्स

जावा (ओपनजेडके 8) , 32 बाइट्स

जावास्क्रिप्ट (ईएस 6), 27 बाइट्स

आर , 32 31 30 बाइट्स

MATL , 10 बाइट्स

स्पष्टीकरण:

सी ++, 96 95 बाइट्स

सी ++ (मिनगव), 91 बाइट्स

APL (Dyalog) , 8 7 बाइट्स

व्याख्या

PHP> = 7.1, 59 बाइट्स

ब्रेन-फ्लैक , 60 बाइट्स

APL (Dyalog) , 5 बाइट्स

जावा 8, 82 बाइट्स

सी ++, 50 48 46 बाइट्स

कोटलिन , 30 बाइट्स

ब्रेकीलॉग , 11 10 बाइट्स

दिल्लोग एपीएल, 16 बाइट्स

अजगर, 5 बाइट्स

tcl, १ ९

डेमो

सीजेएम , 8 बाइट्स

व्याख्या

क्यू / केडीबी, 12 बाइट्स

रैकेट, 33 बाइट्स