সর্বনিম্ন চলমান

40

স্ট্যাক ওভারফ্লোতে একটি প্রশ্ন দ্বারা অনুপ্রাণিত এখানে শিরোনাম পুরোপুরি আমার দোষ।

চ্যালেঞ্জ

কমপক্ষে দুটি এন্ট্রি সমন্বিত ধনাত্মক পূর্ণসংখ্যার একটি তালিকা দেওয়া হয়েছে, প্রতিটি সংখ্যা নিজেকে বাদ দিয়ে সমস্ত এন্ট্রিগুলির সর্বনিম্ন দ্বারা প্রতিস্থাপন করুন।

পরীক্ষার মামলা

[4 3 2 5]    ->  [2 2 3 2]
[4 2 2 5]    ->  [2 2 2 2]
[6 3 5 5 8]  ->  [3 5 3 3 3]
[7 1]        ->  [1 7]
[9 9]        ->  [9 9]
[9 8 9]      ->  [8 9 8]

বিধি

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

কোনও প্রোগ্রামিং ভাষায় প্রোগ্রাম বা ফাংশন অনুমোদিত । স্ট্যান্ডার্ড লুফোলগুলি নিষিদ্ধ।

ইনপুট যে কোনও যুক্তিসঙ্গত উপায়ে নেওয়া যেতে পারে ; এবং যে কোনও বিন্যাস সহ। আউটপুট জন্য একই। ইনপুট এবং আউটপুট ফর্ম্যাটগুলি আলাদা হতে পারে।

বাইটস মধ্যে সংক্ষিপ্ত কোড।

code-golf  math  arithmetic  integer 
— লুইস মেন্ডো
সূত্র
[4 3 2 2 5]আউটপুট কি করা উচিত ?
— কৃতিমিক লিথোস
@ ক্রিতিক্সিলিথোস দ্বিতীয় পরীক্ষার কেসটি কি এটি কভার করেনি?
— লিকি নুন
@ ক্রিটিক্সিলিথোস ইনপুট [4 3 2 2 5]জন্য আউটপুট হবে [2 2 2 2 2](এটি দ্বিতীয় পরীক্ষার ক্ষেত্রে অনুরূপ)
— লুইস মেন্ডো
ওহ, আমি দ্বিতীয় পরীক্ষার কেস মিস করেছি। তবে এখন আমি বুঝতে পারি যে এটি কীভাবে কাজ করে
— ক্রিটসি লিথোস
@ লুইস মেন্ডো আপনি "পূর্ণসংখ্যা" কে "কোনও ইনপুট আকার এবং মান" তে পরিবর্তন করেছেন। এর অর্থ কি আমাদের সমস্ত আসল সংখ্যার জন্য অ্যাকাউন্টিং করা দরকার?
— লিকি নুন

উত্তর:

19

জেলি , 9 6 5 বাইট

JḟÐ € `ị⁸Ṃ € 
ṙJṖ € Ṃ €
ṙJṖ «/ যুক্তি: 1 ডি অ্যারে (z)

 জে [1,2,3, ..., লেন (জেড)]
z উপরের প্রতিটি পরিমাণে জেড ঘোরান (বর্তমান অ্যারে 2D হয়)
  The শেষ অ্যারে সরান
   Imp / সর্বনিম্ন [কার্যকরভাবে ভেক্টরাইজড] দ্বারা হ্রাস করুন

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

তাদের একবারে যাচাই করুন! (সামান্য সংশোধিত)

আমি খুব নিশ্চিত যে ডেনিস এটিকে গল্ফ করতে পারে।

কিভাবে এটা কাজ করে

অ্যালগরিদম বরং সংশ্লেষিত হয়। আসুন এটি পর্যালোচনা করুন [4,2,2,5]।

প্রথমত, আমরা Jপ্রাপ্ত করতে ব্যবহার করি [1,2,3,4]। নোট করুন যে জেলি 1-ইনডেক্সিং ব্যবহার করে।

তারপরে, আমরা দেখি ṙ। এটি দুটি আর্গুমেন্ট লাগে: একটি অ্যারে এবং একটি পূর্ণসংখ্যা। এটি পূর্ণসংখ্যা দ্বারা নির্দিষ্ট পরিমাণে অ্যারেকে বামে ঘোরে। এখানে, তার বাম দিকে এবং তার ডানদিকে ṙদেখতে পাবেন ( টিউটোরিয়ালে কীভাবে এই কাজগুলি পাওয়া যাবে সে সম্পর্কে আরও জানুন )। জেলিতে, আদেশগুলি সুস্পষ্টভাবে ভেক্টরাইজ করে। সুতরাং, এই কমান্ডটি প্রতিটি স্বতন্ত্র উপাদানটির ডানদিকে সঞ্চালিত হবে, এজন্য আমরা একটি 2D অ্যারে তৈরি করব:[4,2,2,5][1,2,3,4]

অতএব, [4,2,2,5]ṙ[1,2,3,4]হয়ে যায় [[4,2,2,5]ṙ1,[4,2,2,5]ṙ2,[4,2,2,5]ṙ3,[4,2,2,5]ṙ4], যা হয়ে:

[[2,2,5,4],
 [2,5,4,2],
 [5,4,2,2],
 [4,2,2,5]]

লক্ষ্য করুন যে মূল উপাদানগুলি শেষ সারিতে রয়েছে, যেহেতু সেই সারিতে আমরা অ্যারের দৈর্ঘ্যের সমান পরিমাণে বাম দিকে ঘোরালাম, সেই কারণেই আমরা Ṗসেই সারিটি সরিয়ে দেওয়ার জন্য পরবর্তীটি ব্যবহার করি , যাতে কলামগুলি সংগ্রহগুলি হয় অ্যারের উপাদানগুলি যা বর্তমান সূচীতে নেই:

[[2,2,5,4],
 [2,5,4,2],
 [5,4,2,2]]

নিম্নলিখিত ক্রিয়াকলাপ, «/এছাড়াও বেশ বিশৃঙ্খল। প্রথমত, «তার বাম এবং ডান দিকে যে দুটি সংখ্যক এটি দেখাবে তার সর্বনিম্ন ফিরিয়ে দেয়। উদাহরণস্বরূপ, 5«3ফেরৎ 3। এখন, যদি দুটি টি আর্গুমেন্ট অ্যারে হয়, তবে এটি আমি উপরে যেমন বলেছি তেমন ভেক্টরাইজ হবে। এটি এর অর্থ কী যা [1,5,2,3]«[4,1,5,2]হয়ে উঠবে । এখন, হয় যে আমরা শেষ পর্যন্ত প্রতিটি সারির উপর অপারেশন না, যার মানে। উদাহরণস্বরূপ, হয়ে যাবে , যা অ্যারের যোগফল ।[1«4,5«1,2«5,3«2][1,1,2,2]/reduce[1,2,3,4]+/((1+2)+3)+4[1,2,3,4]

সুতরাং, আমরা যদি «/সবে পেয়েছি 2D অ্যারে প্রয়োগ করি তবে আমরা পেয়ে যাব:

([2,2,5,4]«[2,5,4,2])«[5,4,2,2]

যা ভেক্টরাইজেশনের কারণে সমান হবে:

[2«2«5,2«5«4,5«4«2,4«2«2]

যা সূচকে উপাদান ছাড়াই প্রতিটি অ্যারের সর্বনিম্ন গণনা করে।

— ফুটো নুন
সূত্র
1
ওহ, আপনার সম্পাদনা ... আপনি সেখানে প্রথম পেয়েছেন।
— জোনাথন অ্যালান
1
@ জোনাথান অ্যালান
— লিকি নুন
40

পাইথন 2 , 41 বাইট

lambda l:[sorted(l)[x==min(l)]for x in l]

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

প্রতিটি উপাদান জন্য xআমরা পরীক্ষা কিনা x==min(l)। যদি তা না হয় তবে এটি Falseসেই হিসাবে বিবেচনা করা হবে 0যখন sorted(l)ক্ষুদ্রতম উপাদান সরবরাহ করে তালিকার সূচক হিসাবে ব্যবহার করা হয় । অন্যথায়, এটি Trueওরফ 1, দ্বিতীয়-ক্ষুদ্রতম উপাদান দেয় কারণ যে উপাদানটি নিজেই সবচেয়ে ছোট এবং এড়ানো উচিত and

— xnor
সূত্র
2
আমি বিশ্বাস করি যে এটি কাজ করে hard
— লিকি নুন
2
দুর্দান্ত পন্থা!
— লুইস মেন্ডো
আপনি একটি ব্যাখ্যা যোগ করতে পারেন? এটা খুবই জটিল হবে না, কিন্তু এর কৌতুক "প্রত্যেক সংখ্যা সর্বনিম্ন হবে, এক যে ছাড়া হয় সর্বনিম্ন, যা দ্বিতীয় ক্ষুদ্রতম হতে হবে" এবং এটা সত্য যে Falseরূপান্তরিত পরার 0এবং Trueরূপান্তরিত পরার 1সত্যিই শীতল এবং bra ডাব্লু x ওয়েক্সপ্লাইনেড সম্পর্কে নিকৃষ্ট করা উচিত
— নিক হার্টলি
18

জেলি , 5 বাইট

=Ṃ‘ịṢ

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

কিভাবে?

=Ṃ‘ịṢ - Main link: list a     e.g.  [4,3,2,5]
 Ṃ    - minimum of a                2
=     - equals? (vectorises)        [0,0,1,0]
  ‘   - increment                   [1,1,2,1]
    Ṣ - sort a                      [2,3,4,5]
   ị  - index into                  [2,2,3,2]
— জোনাথন অ্যালান
সূত্র
4
@ লেকিউন এটি কোনও বন্দর নয়, এটি ঠিক একই পদ্ধতি, আমি এখনও খুব কম খুঁজছি ... আমিও এখন এই উত্তরটি উন্নত করেছি :)
— জোনাথন অ্যালান
5
@ লিক্যনুন আমি এখানে নতুন, কিন্তু আপনি কি সর্বদা এই শত্রু? এটির কাছে আসার মতো প্রচুর অনন্য উপায় রয়েছে বলে মনে হয় না। এমনকি যদি তিনি এটি বন্দর করেন তবে তার উত্তর এখনও ছোট।
— গ্রেসন কেন্ট
3
@ গ্রেইসক্যান্ট আমি আমার অনুভূত শত্রুতার জন্য ক্ষমা চাইছি
— লিকি নুন
1
@ গ্রেসনকেন্ট পিপিসিজিতে আপনাকে স্বাগতম!
— লুইস মেন্ডো
1
@ লেকিউন এটি সহজ চ্যালেঞ্জের ক্ষেত্রে অনেক কিছু ঘটে, আপনি সত্যই বলতে পারবেন না প্রতিটি উত্তর একে অপরের একটি বন্দর
— ASCII- কেবল
12

হাস্কেল , 42 41 39 বাইট

সম্পাদনা করুন:

  • -২ বাইট ধন্যবাদ নিমিকে!
  • -২ বাইট। Xnor একটি ধন্যবাদ! এবং নিজেই একজন।

fপূর্ণসংখ্যার (বা যে কোনও Ordধরণের) একটি তালিকা নেয় এবং একটি তালিকা ফেরত দেয়।

f(x:y)=minimum y:(fst<$>zip(f$y++[x])y)

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

fতালিকাটি ঘোরানোর সময় পুনরাবৃত্তি হয়। xপ্রথম তালিকার উপাদান এবং yবাকীটি। পুনরাবৃত্তি যেহেতু অসীম তাই ফলাফলের তালিকাটি কেটে ফেলা দরকার: fst<$>zip...yবলার একটি ছোট উপায় take(length y)...।

— আরজান জোহানসেন
সূত্র
1
আপনি মাধ্যমে পুরো ইনপুট তালিকা নামকরণের পর এক বাইট সংরক্ষণ করতে পারবেন @এবং তালিকা টুসকি জিপ করা হতে: f l@(x:y)=fst<$>zip(minimum...)l।
— নিমি
1
f(h:t)=minimum t:(fst<$>zip(f(t++[h]))t)
— xnor
9

অক্টাভা, 26 বাইট

@(x)sort(x)((x==min(x))+1)

অনুরূপ একটি অভিমুখ হিসাবে ব্যবহৃত এই উত্তর , যা হিসাবে একই হতে হবে এই ।

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

ব্যাখ্যা:

জনাথন অ্যালান ইতিমধ্যে জেলি-কোডের জন্য একটি ভাল ব্যাখ্যা সরবরাহ করেছে, সুতরাং এটি অক্টাভা-বিটটি জুড়ে এবং এটি কেন কাজ করে (এবং ম্যাটল্যাবে কাজ করবে না)।

@(x)                       % An unnamed anonymous function taking a vector x as input
    sort(x)                % Gives a sorted version of x
            (x==min(x))    % Checks if each element is equal to the minimum value
           ((x==min(x))+1) % Adds 1 to the boolean vector, to use as indices
@(x)sort(x)((x==min(x))+1) % Complete function

এটি এমএটিএলবিতে কাজ করে না, যেহেতু ইনলাইন অ্যাসাইনমেন্ট এবং সরাসরি সূচক কাজ করে না। sort(x)(1)বাছাই করা ভেক্টরের প্রথম উপাদান নয়, ম্যাটল্যাবে একটি ত্রুটি দেয়।

— স্টিও গ্রিফিন
সূত্র
8

হাস্কেল, 41 বাইট

a#(b:c)=minimum(a++c):(b:a)#c
a#b=b 
([]#)

ব্যবহারের উদাহরণ: ([]#) [4,3,2,5]-> [2,2,3,2]। এটি অনলাইন চেষ্টা করুন!

খালি সঞ্চয়কারী দিয়ে শুরু aকরুন এবং ইনপুট তালিকাটি চালান। আউটপুট তালিকার পরবর্তী উপাদানটি হ'ল সংযোজকের সর্বনিম্ন aএবং ইনপুট তালিকার প্রথম উপাদান ছাড়া সমস্ত (-> c) তারপরে প্রথম উপাদানটির সাথে একটি পুনরাবৃত্ত কল আসে যা সংযোজকের সাথে bযুক্ত হয় এবং c। আপনি যখন ইনপুট তালিকার শেষে পৌঁছবেন তখন থামুন।

— nimi
সূত্র
7

জাভাস্ক্রিপ্ট (ES6), 50 46 বাইট

a=>a.map((_,i)=>Math.min(...a.filter(_=>i--)))

সম্পাদনা করুন: @ আরনল্ডকে ধন্যবাদ 4 টি বাইট সংরক্ষণ করা হয়েছে

— নিল
সূত্র
a=>a.map(x=>Math.min(...a.filter(y=>x!=y)))43 বাইট জন্য।
— শেগি
@ শেগি আমি মনে করি না যে কোনও ইনপুট যেমন কাজ করে3,3,3,3
— আরনাউল্ড ২
ডি আহা! না, ন্যূনতম মানের 2 বা ততোধিক ঘটনা উপস্থিত থাকলে এটি কাজ করবে না।
— শেগি
1
যাইহোক, আপনি কি করতে পারেন a=>a.map((_,i)=>Math.min(...a.filter(_=>i--)))46. জন্য
— Arnauld
@ আরনাউল্ড খুব চালাক, ধন্যবাদ!
— নীল
7

ব্র্যাচল্যাগ , 13 12 বাইট

l+₁:?⊇ᶠ⁽⌋ᵐb↔

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

@ আইস ৫৩৩ এর জন্য একটি বাইট সংরক্ষণ করা হয়েছে।

ব্যাখ্যা

l+₁:?            The list [length(Input) + 1, Input]
     ⊇ᶠ⁽         Find the length(Input) + 1 first subsets of the Input
        ⌋ᵐ       Get the min of each subset 
           b↔    Remove the first element and reverse

আমরা ⊇ইউনিটকে বৃহত্তর থেকে ক্ষুদ্রতম পর্যন্ত উপস্থাপিত করে এটিকে কাজে লাগাই। জন্য উদাহরণস্বরূপ [1,2,3], সাব-সেট নির্বাচন আমরা পেতে এই আদেশ আছে: [1,2,3], [1,2], [1,3], [2,3], [1], [2], [3], []।

আমরা দেখতে পাচ্ছি যে সাবসেটগুলি হ'ল [1,2], [1,3], [2,3]আমরা সর্বনিম্ন চাই, তবে ইনপুট তালিকার তুলনায় বিপরীত ক্রমে (তাই ↔)। আমরা কেবলমাত্র প্রথম length(Input) + 1সাবসেটগুলি সন্ধান করেই সেই সাবসেটগুলি নির্বাচন করতে পারি , এতে প্রথমে সমস্ত তালিকা থাকবে। আমরা সেই সম্পূর্ণ তালিকাটি বাতিল করে দিয়েছি b।

— Fatalize
সূত্র
1
আপনি আপনার "ফান্ডাল সাবসেট + ন্যূনতম" "ফাইন্ডল সাবসেট" এবং "মানচিত্র সর্বনিম্ন" এ বিভক্ত করে একটি বাইট সংরক্ষণ করতে পারেন। (ব্র্যাচল্যাগ টিপস থ্রেডে আমার এটি যোগ করা দরকার, এখন আপনি এটির কথা আমাকে মনে করিয়ে দিয়েছেন))
1
@ ais523 ধন্যবাদ, আমি সর্বদা সেই কৌশলটি ভুলে যাই ...
— ফ্যাটালাইজ করুন
6

আসলে , 13 বাইট

;;S╝m╗⌠╜=╛E⌡M

এক্সএনওর একই কৌশল ব্যবহার করে ।

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

ব্যাখ্যা:

;;S╝m╗⌠╜=╛E⌡M
;;             make two extra copies of input list
  S╝           sort one and save it in register 1
    m╗         save the minimum of the other in register 0
      ⌠╜=╛E⌡M  for each value in list:
       ╜=╛E      return the minimum element of the input list if the value is not equal to the minimum, else return the second-smallest element
— ঐ মেগো
সূত্র
1
আপনি এখনও আমাদের অস্থায়ী স্ট্যাকের অভ্যন্তরে গ্লোবাল স্ট্যাকটি দেখার অনুমতি দেননি?
— লিকি নুন
1
পছন্দ করেছেন দোভাষীর কোড যে বর্তমান অবস্থায় রয়েছে, তা খুব কঠিন হবে। আমি যে বড় রিফ্যাক্টরিংয়ের উপর কাজ করছি তা শেষ করার পরে, আমি সেই কার্যকারিতাটি যুক্ত করার বিষয়ে দেখতে পাব।
— ঐ মেগো
1
আপনি কখন বড় রিফ্যাক্টরিং শুরু করলেন?
— লিকি নুন
6

আর, 46 31 বাইট

l=scan();sort(l)[(min(l)==l)+1]

স্টে গ্রিফিনের সমাধানটি আরে প্রয়োগ করে , হায়, আমার আসল ধারণাটি 50% দীর্ঘ! এখনও স্টিডিন থেকে তালিকাটি পড়ে, তবে এখন আরও পাঠযোগ্য পাঠ্যসংখ্যক ভেক্টরটি প্রদান করে।

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

পুরানো বাস্তবায়ন:

l=scan();Map(function(x)min(l[-x]),match(l,l))

স্টিডিন থেকে তালিকায় পড়ে। একটি নেতিবাচক সূচক l[-x]তালিকা থেকে উপাদান বাদ দেয় এবং তালিকার match(l,l)প্রতিটি উপাদানের প্রথম উপস্থিতির সূচকটি প্রদান করে। একটি তালিকা ফেরত দেয়।

— : Giuseppe
সূত্র
4

সি, 85 বাইট

i,j,m;f(d,o,n)int*d,*o;{for(i=n;i--;)for(m=d[!i],j=n;j;o[i]=m=--j^i&&d[j]<m?d[j]:m);}

প্রথম যুক্তি হ'ল ইনপুট পূর্ণসংখ্যার অ্যারে। দ্বিতীয় যুক্তি হ'ল আউটপুট পূর্ণসংখ্যা অ্যারে। তৃতীয় যুক্তি হ'ল উভয় অ্যারের জন্য উপাদান গণনা।

এটি অনলাইনে কাজ দেখুন ।

— 2501
সূত্র
3

পার্ল 6 ,  26 24  19 বাইট

26

{.map: (.Bag∖*).min.key}

দ্রষ্টব্য যে ∖U + 2216 \U + 5C নয়

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

{.map: (.Bag⊖*).min.key}

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

24

{(.min X%$_)X||.sort[1]}

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

19

{.sort[.min X==$_]}

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

26

{           # bare block lambda with implicit parameter ｢$_｣

  .map:     # for each of the values in the input (implicit method call on ｢$_｣)
  (
    .Bag    # turn the block's input into a Bag
    ∖       # set-difference           ｢∖｣ U+2216 aka ｢(-)｣
    # ⊖     # symmetric-set-difference ｢⊖｣ U+2296 aka ｢(^)｣
    *       # turn expression into a WhateverCode lambda (this is the parameter)
  ).min.key # get the minimum pair from the Bag, and return its key
}

আমি "ফ্যানসি" ইউনিকোড অপারেটরগুলি ascii সমতুল্যের চেয়ে বেশি ব্যবহার করেছি কারণ তাদের সামনে একটি জায়গার প্রয়োজন হত যাতে তারা .Bagপদ্ধতি কলের অংশ হিসাবে পার্স না হয় ।

24

{
  (.min X% $_) # the minimum cross modulus-ed with the input
  X||          # cross or-ed 
  .sort[1]     # with the second minimum
}

19

{
  .sort\        # sort the values
  [             # index into that
    .min X== $_ # the minimum cross compared with the input
  ]
}

(24 এবং 19 বাইট গল্ফগুলি জেলি বাস্তবায়নে অনুপ্রাণিত হয়েছিল )

— ব্র্যাড গিলবার্ট বি 2 গিলস
সূত্র
3

ক্লোজার, 36 81 62 71 বাইট

নতুন (তাড়াতাড়ি সত্যিই এগুলি জমা দেওয়া উচিত নয়):

#(for[c[(zipmap(range)%)]i(sort(keys c))](apply min(vals(dissoc c i))))

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

Aaaand এই একটির বাগ (62 বাইট) রয়েছে, জিপম্যাপ একটি আনর্ডারড মানচিত্র তৈরি করে যাতে এটি বড় ইনপুটগুলিতে সঠিক ক্রম উত্পাদন করে না।

#(for[c[(zipmap(range)%)][i v]c](apply min(vals(dissoc c i))))

vআসলে কোনও কিছুর জন্য ব্যবহৃত হয় না তবে এটি তার চেয়ে কম i (keys c)।

আগের ৮১ বাইটে:

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

#(let[r(range(count %))](for[i r](apply min(for[j r :when(not= i j)](nth % j)))))

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

ওহ, আসল (36 বাইট) অভিহিত করা যখন ন্যূনতম সংখ্যাটি পুনরাবৃত্তি হয় তখন কাজ করে না, [4 2 2 5]ফলস্বরূপ [2 4 4 2]উভয় 2গুলি সরানো হয় :(

#(for[i %](apply min(remove #{i}%)))

#{i}সেটটি কেবলমাত্র iএটিই থাকে , এটি অন্যের জন্য সত্যবাদী iএবং মিথ্যা দেয়, যার অর্থ ইনপুট তালিকার মধ্যে অন্য সমস্ত সংখ্যা থেকে সর্বনিম্ন গণনা করা হয়।

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

— NikoNyrh
সূত্র
2

স্কালা, 37 বাইট

l.indices map(i=>l diff Seq(l(i))min)

l ইন্টের কোনও সংগ্রহ।

পরীক্ষার কেস:

scala> val l = List(4,3,2,5)
l: List[Int] = List(4, 3, 2, 5)

scala> l.indices map(i=>l diff Seq(l(i))min)
res0: scala.collection.immutable.IndexedSeq[Int] = Vector(2, 2, 3, 2)

scala> val l = List(4,2,2,5)
l: List[Int] = List(4, 2, 2, 5)

scala> l.indices map(i=>l diff Seq(l(i))min)
res1: scala.collection.immutable.IndexedSeq[Int] = Vector(2, 2, 2, 2)

scala> val l = List(6,3,5,5,8)
l: List[Int] = List(6, 3, 5, 5, 8)

scala> l.indices map(i=>l diff Seq(l(i))min)
res2: scala.collection.immutable.IndexedSeq[Int] = Vector(3, 5, 3, 3, 3)

scala> val l = List(7,1)
l: List[Int] = List(7, 1)

scala> l.indices map(i=>l diff Seq(l(i))min)
res3: scala.collection.immutable.IndexedSeq[Int] = Vector(1, 7)

scala> val l = List(9,9)
l: List[Int] = List(9, 9)

scala> l.indices map(i=>l diff Seq(l(i))min)
res4: scala.collection.immutable.IndexedSeq[Int] = Vector(9, 9)

scala> val l = List(9,8,9)
l: List[Int] = List(9, 8, 9)

scala> l.indices map(i=>l diff Seq(l(i))min)
res5: scala.collection.immutable.IndexedSeq[Int] = Vector(8, 9, 8)

এটি সম্ভবত এখনও গল্ফ করা যেতে পারে, আমি কোনও তালিকা থেকে কোনও উপাদান সরানোর জন্য আরও ছোট উপায় খুঁজে পাই না l diff Seq(l(i))

— therealfarfetchd
সূত্র
2

সি #, 36 বাইট

i.Select((x,a)=>i.Where((y,b)=>b!=a).Min())

উপাদানগুলি নিয়ে যায় (i) এবং সর্বনিম্ন মানের জন্য আইটেমটি ছাড়াই উপাদানগুলিতে সন্ধান করে।

এটি দুঃখের বিষয়, আমরা আদিম ধরণের সাথে কাজ করি বলে অন্য কিছু প্রচেষ্টা কাজ করে না, এবং সুতরাং আইটেমগুলির সাথে তুলনা করার জন্য রেফারেন্স সহ তালিকা নেই।

— MetaColon
সূত্র
2

পাওয়ারশেল , 49 38 বাইট

-11 বাইট মজির ধন্যবাদ 

($a=$args)|%{($c=$a|sort)[$_-eq$c[0]]}

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

সিনুসয়েডের সুন্দর উত্তরটির উন্নতি । অ্যারে তৈরির পরিবর্তে সুস্পষ্ট আউটপুট ব্যবহার করে 10 বাইট সঞ্চয় করে। শর্তাধীন যদি সত্য হয় তবে স্পট 0 (অর্থাত্ সর্বনিম্ন মান) বা স্পট 1 এ বাছাই করা অ্যারেতে সূচকগুলি।

— Veskah
সূত্র
1
এটি স্মার্ট। আরও সংরক্ষণ করুন :) এটি অনলাইন চেষ্টা করুন!
— mazzy
1
@ মমজি ভাল হয়েছে এটি এখন সুস্পষ্ট যে আমি এটি দেখছি কিন্তু আমি কখনই এটি একসাথে রাখি না।
— ভেস্কাহ
1
চমৎকার কাজ! ইতি আরো সুন্দর :)
— Sinusoid
1

পার্ল 5, 43 বাইট

sub{@x=sort{$a<=>$b}@_;map$x[$_==$x[0]],@_}

পাইথন সমাধানের সমতুল্য। পার্ল এর sortদুর্ভাগ্যবশত সংখ্যার জন্য ভুল ডিফল্ট (একটি সুনির্দিষ্ট comparator প্রয়োজন) আছে, এবং minবিল্ট-ইন করা হয় না, কিন্তু এটা প্রায় দ্বারা এটি জন্য তোলে আপ subচেয়ে খাটো হচ্ছে lambda, map$_,চেয়ে খাটো হচ্ছে x for x in, এবং বিনিময়ে এবং args তালিকার implicitness।

— হবস
সূত্র
1

রুবি, 30 বাইট

প্রতিটি উপাদানের জন্য অ্যারেটিকে বাছাই করুন, বর্তমান উপাদানটি সরিয়ে ফেলুন এবং অবশিষ্ট অ্যারের প্রথম উপাদানটি ধরুন।

->a{a.map{|e|(a.sort-[e])[0]}}

এটি একটি বেনাম ফাংশন যা এইরকম ব্যবহার করা যেতে পারে:

f = ->a{a.map{|e|(a.sort-[e])[0]}}
p f[[6, 3, 5, 5, 8]] # => [3, 5, 3, 3, 3]
— daniero
সূত্র
1

সিজেম, 15 বাইট

{:S{S:e<=S$=}%}

মূলত সিএনজেমে এক্সনোরের অ্যালগরিদমের অনুবাদ।

এটি একটি নামবিহীন ব্লক যা স্ট্যাক থেকে একটি অ্যারে নেয় এবং ফলাফলটি স্ট্যাকের উপরে ফেলে।

ব্যাখ্যা:

{
  :S     e# Save in S
  {      e# For X in S:
    S:e< e#   Push Min(S)
    =    e#   X == Min(S)
    S$=  e#   Sorted(S)[top of stack]
  }%     e# End
}
— ফল ফল
সূত্র
1
@ লুইসমেডো উফস - আমি আসলে অ্যারে বাছাই করতে ভুলে গেছি। এটি এখন কাজ করা উচিত।
— 23.38
1

05 এ বি 1 ই , 5 বাইট

{sWQè

@ এক্সনোরের পাইথন 2 উত্তরটির বন্দর ।

এটি অনলাইনে চেষ্টা করুন বা সমস্ত পরীক্ষার কেস যাচাই করুন ।

ব্যাখ্যা:

{        # Sort the (implicit) input-list
         #  i.e. [4,1,3,6] → [1,3,4,6]
 s       # Swap, so the (implicit) input-list is at the top of the stack again
  W      # Get the minimum without popping from the list
         #  i.e. [4,1,3,6] → 1
   Q     # Check for each element if they are equal to this value (1/0 as truthy/falsey)
         #  i.e. [4,1,3,6] and 1 → [0,1,0,0]
    è    # Use these 0s and 1s to index in the sorted list
         #  i.e. [1,3,4,6] and [0,1,0,0] → [1,3,1,1]
— কেভিন ক্রুইজসেন
সূত্র
1

জাভা 8, 119 বাইট

a->{int t[]=a.clone(),m=a[0],i=a.length;for(int x:a)m=x<m?x:m;for(java.util.Arrays.sort(t);i-->0;)a[i]=t[a[i]==m?1:0];}

@ এক্সনোরের পাইথন 2 উত্তরটির বন্দর ।

বাইটগুলি সংরক্ষণ করতে কোনও নতুন ফেরতের পরিবর্তে ইনপুট-অ্যারে পরিবর্তন করে।

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

ব্যাখ্যা:

a->{                  // Method with integer-array parameter and no return-type
  int t[]=a.clone(),  //  Make a copy of the input-array
      m=a[0],         //  Minimum `m`, starting at the first value of the input-array
      i=a.length;     //  Index-integer, starting at the length of the input-array
  for(int x:a)        //  Loop over the input-array
    m=x<m?            //   If the current item is smaller than the current `m`
       x              //    Replace `m` with this value
      :               //   Else:
       m;             //    Leave `m` the same
  for(java.util.Arrays.sort(t);
                      //  Sort the copy we've made of the input-array
      i-->0;)         //  Loop `i` in the range (length, 0]
    a[i]=             //   Modify the item at index `i` of the input-array to:
      t[              //    The item in the sorted array at index:
        a[i]==m?      //     If the current item and the minimum are equal:
         1            //      Use index 1 in the sorted array
        :             //     Else:
         0];}         //      Use index 0 in the sorted array
— কেভিন ক্রুইজসেন
সূত্র
1

এপিএল (ডায়ালগ প্রসারিত) , 7 বাইট

Xnor এর পাইথন 2 উত্তর বন্দর। প্রয়োজনীয় ⎕IO←0: 

∧⊇⍨⊢=⌊/

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

ব্যাখ্যা:

∧⊇⍨⊢=⌊/  ⍝ Monadic function train
      ⌊/  ⍝ The minimum element of the input
    ⊢=    ⍝ Element-wise compare the input to the above
          ⍝ Results in a boolean vector, let's call it "X"
∧         ⍝ Sort the input
 ⊇⍨      ⍝ Index into sorted input by X
— voidhawk
সূত্র
1

হাস্কেল , 76 বাইট

এটি পূর্বের হাস্কেল এন্ট্রিগুলির তুলনায় যথেষ্ট দীর্ঘ, তবে এটিই প্রথম যা কেবল একটি রৈখিক সংখ্যার তুলনা করে এবং রৈখিক পরিমাণে অতিরিক্ত কাজ করে।

f(x:y)|(z,w)<-x!y=z:w
a![x]=(x,[a])
a!(x:y)|(p,q)<-a#x!y=(x#p,a#p:q)
(#)=min

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

ব্যাখ্যা

!দুটি আর্গুমেন্ট নেয়: একটি চলমান ন্যূনতম এবং একটি অমানবিক তালিকা। এটি তালিকার সর্বনিম্ন মান এবং চলমান সর্বনিম্ন ব্যবহার করে প্রদত্ত তালিকার প্রক্রিয়াকরণের ফলাফল প্রদান করে।

— dfeuer
সূত্র
1

ম্যাথগল্ফ , 9 7 বাইট

s_╓?m=§

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

ব্যাখ্যা

মূলত কেভিন ক্রুইজসেনের 05AB1E উত্তরটির একটি বন্দর, তবে আমি স্পষ্টভাবে জিনিসগুলি করার জন্য 2 বাইট হারিয়েছি।

s         sort(array)
 _        duplicate TOS
  ╓       minimum of two elements, min of list, minimum by filter
   ?      rot3 pops input on top of stack again
    m=    explicit map to check equality
      §   get from sorted array for each
— maxb
সূত্র
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.