অ্যারে ছাঁটাই!

27

একটি পূর্ণসংখ্যা অ্যারে এবং ইনপুট হিসাবে দুটি সংখ্যা দেওয়া, সংখ্যা দ্বারা নির্দিষ্ট প্রথম এবং শেষ উপাদানগুলির একটি নির্দিষ্ট পরিমাণ সরিয়ে দিন। ইনপুটটি আপনার যে কোনও ক্রম হতে পারে।

আপনার প্রথম 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
ঠিক কী, এর অর্থ হ'ল কোন অ্যারে থেকে "মুছে ফেলা" - বিশেষত এগুলি শেষ থেকে সরিয়ে নেওয়া? সি এর মতো ভাষায়, যেখানে একটি অ্যারে প্রথম উপাদান এবং দৈর্ঘ্যের কেবলমাত্র পয়েন্টার হয়, আমরা কী অ্যারেটি কেটে দেওয়ার জন্য দৈর্ঘ্যটি পরিবর্তন করতে পারি? এটাই সাধারণত বাস্তব-বিশ্ব প্রোগ্রামিংয়ে করা হত তবে চ্যালেঞ্জটি আমার কাছে অস্পষ্ট।
— কোডি গ্রে
@ কোডি গ্রে অ্যারে থেকে মানগুলি সরিয়ে ফেলা হচ্ছে এটি দেখতে কেমন হওয়া উচিত , তবে পর্দার আড়ালে কী ঘটে তা অগত্যা নয়।
— Okx
4
"দেখতে" এর অর্থ কী? অ্যারেগুলির একটি চেহারা নেই - এটি সমস্ত পর্দার আড়ালে রয়েছে!
— কোডি গ্রে
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
বিশেষত পিপিসিজি এবং হাস্কেল গল্ফিংয়ে আপনাকে স্বাগতম! উদ্দেশ্যটি হ'ল যথাসম্ভব কয়েকটি বাইট ব্যবহার করা, যাতে আপনি উদাহরণস্বরূপ বেশিরভাগ স্থান সরিয়ে এবং সংক্ষিপ্ত করতে পারেন 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
@ লাইকনি পরিচয় করিয়ে দেওয়ার জন্য ধন্যবাদ, খুব সহায়ক। সবেমাত্র এই সাইটটি পাওয়া গেছে, তবে অবশ্যই এখানে আরও কিছু খেলার জন্য অপেক্ষা করুন!
— হেনরি
6

গণিত, 17 বাইট

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

ইনপুট

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

— J42161217
সূত্র
ভাল ব্যবহার ;;! আমি আপনাকে সাথে বেঁধে রাখতে পেরেছি Drop@##2~Drop~-#&(যদি আমরা কোনও অদ্ভুত ক্রমে ইনপুটটি নিই 1, {1,2,3,4,5,6}, 2) তবে এর চেয়ে ভাল আর কিছু নয়।
— গ্রেগ মার্টিন
6

পাইথন , 28 26 বাইট

-২ বাইট @ রডকে ধন্যবাদ

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

এটি অনলাইন চেষ্টা করুন!

— ovs
সূত্র
6 টি সংরক্ষণ করুন ...lambda a,n,m:a[n:~m]
— অ্যারন
অ্যারন এটি একটি আইটেমকে খুব বেশি সরিয়ে দেয়।
— ovs
আমার খারাপ .. এটি একটি সাধারণ কৌশল যা আমি মাঝে মাঝে ব্যবহার করি এবং চ্যালেঞ্জের প্রয়োজনীয়তার বিরুদ্ধে পুরোপুরি চেক করি না ..
— অ্যারন
অ্যারন স্লাইসটির তুলনায় উচ্চতর অপারেটর রয়েছে +এবং তাই এটি প্রয়োগ করা হয় [0]। আপনি বন্ধনী প্রয়োজন হবে: (a+[0])[n:~m]।
— ovs
হ্যাঁ, পরে বুঝতে পেরেছি .. আমি আমার ধারণাকে কাজ করার চেষ্টা করছি
— অ্যারন
6

সি # (.নেট কোর) , 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যা কেবল
— এইরকমভাবেই
আপনার using System.Linq;বাইট গণনায় যোগ করার দরকার নেই :)
— স্টেফান
@Stefan আমি প্রতি গোনার দরকার usingআমি আমার উত্তর যোগ করুন, এবং পদ্ধতি Skipএবং Takeপ্রয়োজন যে using।
— চার্লি
HM। ঠিক আছে. অন্য কয়েকটি চ্যালেঞ্জের সময় আমাকে বলা হয়েছিল যে যেখানে প্রয়োজনীয় ব্যবহারের প্রয়োজন নেই।
— স্টিফান
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)

ফেরত টুকরোটির জীবনকাল অনুধাবন করার জন্য সংক্ষিপ্ততম পদ্ধতির কী ছিল তা নির্ধারণ করার জন্য orrowণ চেকারের সাথে লড়াই করে আমি অনেক মজা পেয়েছিলাম। ক্লোজারগুলির চারপাশের এর আচরণটি কিছুটা খাঁটি, কারণ এটি জীবনকালকে অনুমান করবে, তবে কেবলমাত্র যদি আপনি প্যারামিটারটিকে কোনও রেফারেন্স টাইপ হিসাবে ঘোষণা করেন না। দুর্ভাগ্যক্রমে এই দ্বন্দ্বগুলি স্বাক্ষরে আর্গুমেন্টের ধরণটি সংজ্ঞায়িত করা প্রয়োজন কারণ এন.এলেন পদ্ধতি কলটিতে এটি যে ধরণের অপারেটিং চলছে তা জানতে হবে।

অন্যান্য পদ্ধতির ক্ষেত্রে আমি এই সমস্যাটি নিয়ে কাজ করার চেষ্টা করেছি:

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

সি #, 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

শীর্ষে থাকা এম 4,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

সুতরাং আমি মনে করি এটি একটি লুয়া উত্তর হিসাবে গণনা ...

— আজাইরা মেইল
সূত্র
আপনি এখন অনলাইনে চেষ্টা করে দেখতে পারেন ! দ্রষ্টব্য: আমাকে একটি চালাক করতে হয়েছিল, এবং কোড ফাইলের শীর্ষটি ইনপুটটির একটি উত্স হিসাবে ব্যবহার করতে হয়েছিল, যেহেতু টিআইও বর্তমানে কেবল একটি একক ইনপুট ফাইল সরবরাহ করে।
— ফিলারাক্স
4

এমএটিএল , 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

জাভাস্ক্রিপ্ট (ES6), 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)তবে এটি একটি বাইট ছোট।

এটি অনলাইন চেষ্টা করুন!

— : Giuseppe
সূত্র
1
1 বাইট সংরক্ষণpryr::f(n[(1+l):(length(n)-r)])
— রিফ্ট
1
যোগফল (এন | 1) দৈর্ঘ্যের চেয়ে কম (এন)
— জেএড
@ জারকো ডাবডেলডাম দুর্দান্ত, আপনাকে ধন্যবাদ
— জিউসেপ
3

এমএটিএল , 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
— স্টিও গ্রিফিন
সূত্র
— সূচীকরণ
(তবুও, একটি উত্সাহ দিন - আমি বিশ্বাস করি এটি ভালভাবে গল্ফড এবং আপনি যে পদ্ধতিটি ব্যবহার করেছেন তা বিবেচনা করে ব্যাখ্যা করেছেন)
— সানচিইস
না, আমি এটা ভুলে যাইনি! আমি চেষ্টা করেছি, তবে কীভাবে এটি কাজ করা যায় তা আমি বুঝতে পারি না, (এবং আমি সত্যই চেষ্টা করেছি)। আমি উপসংহারে পৌঁছেছি যে Jযখন এ জাতীয় ব্যবহার করা হয় তখন এগুলি থেকে কিছু বিয়োগ করা অসম্ভব । আমি সন্দেহ করেছিলাম যে আমি ভুল ছিলাম, আমি আমার জীবনের জন্য এটি নির্ধারণ করতে পারি না ... আপনার উত্তরের সাথে লিঙ্ক দেওয়ার জন্য ধন্যবাদ, আমি খুব এমএএটিএল শিক্ষানবিশ ...
— স্টিভি গ্রিফিন
চিন্তা করবেন না, আমি এখনও অনেক বেশি শিখছি - যেমন, ইনপুটগুলির ক্রম )এবং আরও কুখ্যাতভাবে ( কাঁপুনি ...
— সানচাইজস
@ সাঞ্চাইজস খুব দেরিতে মন্তব্য করেছেন, তবে আমি আনন্দিত যে এটি কেবল আমারই নয় যে (বিভ্রান্তির জন্য ইনপুট অর্ডারটি পেয়েছে । :) আমি প্রতিবার "ডিডিআই" (= "গন্তব্য, ডেটা, সূচকগুলি" ম্যানুয়াল থেকে) আবৃত্তি করেছিলাম এবং এখনও মাঝে মাঝে ভুল হয়ে যাই।
— সূন্দর - মনিকা
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বেশিরভাগ সংকলকগুলিতে কাজ করবে, আমি এটিকে সম্পাদনা করব Min MinGW এ, এমনকি ফাংশনটির ধরণের কাজটি সম্পূর্ণরূপে বাদ দিয়ে। এবং হ্যাঁ, #include<list>শিরোনাম অন্তর্ভুক্ত করার জন্য এটি একটি মান-মেনে চলার উপায় হবে তবে #import<list>কমপক্ষে জিসিসি, মিনজিডাব্লু এবং এমএসভিসিতে কাজ করা উচিত, তাই এটিও ঠিক করা উচিত।
— স্টেডিবক্স
2

এপিএল (ডায়ালগ) , 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

ব্রেন-ফ্লাক , 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
    ([]){{}({}<>)<>([])}{}<>

>)[()]}{}
— ডিজেএমসিএমহেম
সূত্র
1
প্রতিবার এবং পরে টিউরিং টারপিট সমাধানটি দেখে ভাল লাগছে।
— Okx
2

এপিএল (ডায়ালগ) , 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->। যদিও আপনি ঠিক বলেছেন আমি কার্লি করার পরিবর্তে কেবল একটি নিয়মিত কল ব্যবহার করতে পারতাম। আমি যখন দুটি (বা তার বেশি) পরামিতি রাখি তখন
— কার্ভিং ব্যবহার করার চেষ্টা করতাম
আহ্ আপনি ঠিক বলেছেন আমি বাইটগুলি মিসকাস্ট করেছি এবং আমি এটি করেছি যে ভালভাবে কারি করা অবশ্যই এখন যাওয়া উচিত!
— TheLethalCoder
টিআইও লিঙ্ক নেই? -
— সম্পূর্ণরূপে
2
দুঃখিত, পাস করতে পারবেন না। আমি আমার নিজের উত্তর পোস্ট করেছি কারণ ... একটি অন্তর্নির্মিত আছে (ঠিক আছে, ঠিক নয়, তবে প্রায়)! : ও
— অলিভিয়ের গ্রাগোয়ার
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>
— ওয়াইজিলেবেভ
বুঝেছি! খুশী হলাম। কোডগল্ফে এটি বৈধ কিনা আমি জানি না।
— mazzy
2

ব্র্যাচল্যাগ , 11 10 বাইট

kb₍B&t;Bk₍

এটি অনলাইন চেষ্টা করুন!

[X, A, y] হিসাবে ইনপুট নেয় যেখানে A ট্রিম করার অ্যারে।

(-1 বাইট ধন্যবাদ @ ফ্যাটালাইজকে।)

— সূন্দর - মনিকা পুনরায় স্থাপন করুন
সূত্র
আপনি যেমন 1 বাইট দ্বারা এটি কমান পারেন: kb₍B&t;Bk₍। ,এটি সংযোজন করে ( এই আংশিক প্রোগ্রামের ফলাফল দেখুন ), এটি পছন্দ করে না ∧। এছাড়াও পুরানো (২০১--এর প্রথম দিকে 2017) থেকে কপিরাইট করার চেষ্টা করবেন না ব্র্যাচেলগ উত্তরগুলি কারণ এটি ভাষার প্রথম সংস্করণ ছিল এবং প্রোগ্রামগুলি পুনঃসংযোগযোগ্য নয় (বিশেষত, ,∧
— ব্র্যাচল্যাগ
@ ফ্যাটালাইজ ধন্যবাদ, আপডেট হয়েছে। সুতরাং ,পূর্ববর্তী সংস্করণে যোগ করেনি, কিন্তু এটা শুধু না ব্যাপার এই ক্ষেত্রে কারণ সেখানে তা-ই করতেন tযেকোনোভাবে পর - ভাগ্যবান কাকতালীয়। এবং হ্যাঁ, আমি এটি পোস্ট করার পরে সংস্করণের পার্থক্যগুলি বুঝতে পেরেছিলাম, আমি এখনও এই পর্যায়ে জিনিসগুলি সন্ধান করছি এবং ভীষণ ভয় দেখছিলাম। :)
— সূন্দর - মনিকা
1

পাইথ, 5 বাইট

>E<QE

এখানে চেষ্টা করুন

বিপরীত ক্রমে আর্গুমেন্ট নেয়। <এবং >যুক্তির ক্রমের ভিত্তিতে পাইথ ট্রিমে। উদাহরণস্বরূপ, <Q5পঞ্চমটির পরে ইনপুটটিতে সমস্ত মান ছাঁটাই করবে।

— FryAmTheEggman
সূত্র
1

সিজেম , 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]
— লুইস মেন্ডো
সূত্র
1
গুড পয়েন্ট, তারপর শুধু মজার জন্য, এখানে একটি বিকল্প 8-বাইট সমাধান :) হয় tio.run/##S85KzP1vxGXIFW1ooGBkoGBsoGBioGBqoGBmEPu/Olg7ps7GrvZ/...
— মার্টিন Ender
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)
— চূড়ান্ত হক
সূত্র
আমি কি ভাষার ওয়েবসাইটটিতে একটি লিঙ্ক রাখতে পারি?
— Okx
— চূড়ান্ত হক
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.