চ্যালেঞ্জ

আসল সংখ্যার একটি অসাধারণ তালিকা দেওয়া হয়েছে, এর মধ্যমা গণনা করুন।

সংজ্ঞা

মিডিয়ানটি নিম্নরূপে গণনা করা হয়: প্রথমে তালিকাটি সাজান,

যদি প্রবেশের সংখ্যাটি বিজোড় হয় , তবে মধ্যম হল সাজানো তালিকার কেন্দ্রে মান,
অন্যথায় মধ্যম হ'ল বাছাই করা তালিকার কেন্দ্রের নিকটতম দুটি মানগুলির পাটিগণিত গড়।

উদাহরণ

[1,2,3,4,5,6,7,8,9] -> 5
[1,4,3,2] -> 2.5
[1.5,1.5,1.5,1.5,1.5,1.5,1.5,1.5,1.5,-5,100000,1.3,1.4] -> 1.5
[1.5,1.5,1.5,1.5,1.5,1.5,1.5,1.5,1.5,1.5,-5,100000,1.3,1.4] -> 1.5

code-golf statistics

— flawr
সূত্র

আমরা কি 2 (যেমন 7/2বা 8/2) এর চেয়ে বেশি ভগ্নাংশ হিসাবে আউটপুট দিতে পারি

— গম উইজার্ড

এই ভগ্নাংশ অনুযায়ী ঠিক আছে।

— flawr

15

এটি কীভাবে ইতিমধ্যে চ্যালেঞ্জ নয়?

— orlp

1

@orlp এটি এই চ্যালেঞ্জের একটি উপসেট ।

— অ্যাডমবর্কবার্ক

3

কিছু আকর্ষণীয় লিনিয়ার সময় অ্যালগরিদম রয়েছে বলে এটি একটি দুর্দান্ত দ্রুততম কোড চ্যালেঞ্জও তৈরি করে।

18

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

একটি নামবিহীন ফাংশন যা ফলাফল দেয় returns -1 বাইট xnor ধন্যবাদ।

lambda l:l.sort()or(l[len(l)/2]+l[~len(l)/2])/2.

প্রথম পদক্ষেপটি অবশ্যই অ্যারে বাছাই করে ব্যবহার করে l.sort()। যাইহোক, আমরা কেবল একটি ল্যাম্বডায় একটি বিবৃতি রাখতে পারি, সুতরাং আমরা এই সত্যটি ব্যবহার করি যে সাজ্ট ফাংশনটি Noneযোগ করে or- Noneপাইথনের মিথ্যাচারী হিসাবে এটি এটি বিবৃতিটির পরবর্তী অংশটি মূল্যায়ন করতে এবং ফিরিয়ে দিতে বলে।

এখন আমাদের বাছাই করা তালিকা রয়েছে, আমাদের মাঝারি বা মাঝের দুটি, মানগুলি সন্ধান করতে হবে।

দৈর্ঘ্যের সমতা পরীক্ষা করার জন্য শর্তযুক্ত ব্যবহার করা খুব ভার্জোজ হবে, সুতরাং পরিবর্তে আমরা সূচকগুলি পাই len(l)/2এবং ~len(l)/2:

প্রথমটি হল মেঝে (দৈর্ঘ্য / 2) , যা দৈর্ঘ্যটি বিজোড় হলে মাঝারি উপাদান বা দৈর্ঘ্য সমান হলে কেন্দ্রীয় জোড়ের বাম আইটেমটি পায়।
দ্বিতীয়টি হল তালিকা দৈর্ঘ্যের বাইনারি বিপর্যয়, -1 - তল (দৈর্ঘ্য / 2) এর মূল্যায়ন । পাইথনের নেতিবাচক সূচকের কারণে এটি মূলত প্রথম সূচকের মতোই হয় তবে অ্যারের শেষ থেকে পিছনে থাকে।

যদি তালিকাটি বিজোড় দৈর্ঘ্যের হয় তবে এই সূচকগুলি একই মানকে নির্দেশ করবে। এটি যদি দৈর্ঘ্যের হয় তবে তারা কেন্দ্রীয় দুটি আইটেমগুলিতে নির্দেশ করবে।

এখন যেহেতু আমাদের এই দুটি সূচক রয়েছে, আমরা তালিকার এই মানগুলি খুঁজে পাই, তাদের যোগফলগুলি এবং ২ দিয়ে ভাগ করব The এর পিছনে দশমিক স্থান /2.নিশ্চিত করে যে এটি পূর্ণসংখ্যা বিভাগের পরিবর্তে ভাসমান বিভাগ।

ফলাফলটি স্পষ্টতই ফিরে আসে, কারণ এটি ল্যাম্বডা ফাংশন।

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

— FlipTack
সূত্র

দেখে মনে হচ্ছে পুনরাবৃত্তি সত্ত্বেও কোনও lambda l:l.sort()or(l[len(l)/2]+l[~len(l)/2])/2.

— ল্যাম্বদা

@ এক্সনোর ধন্যবাদ! আমি যখন এটি চেষ্টা করেছিলাম, আমি দুর্ঘটনাক্রমে f=এটিকে 1 বাইট দীর্ঘ বলে ভেবেছিলাম by

— ফ্লিপট্যাক

13

পাইথন 3 - 31 30 বাইট

@ ডেনিসকে একটি বাইট সংরক্ষণ করে!

আমি একটি অন্তর্নির্মিত উত্তর নিয়ে পরিকল্পনা করছিলাম না, তবে আমি এই মডিউলটি পেয়েছি এবং ভেবেছিলাম এটি সত্যিই শীতল ছিল কারণ এটি সম্পর্কে আমার কোনও ধারণা নেই।

from statistics import*;median

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

— Maltysen
সূত্র

6

from statistics import*;medianএকটি বাইট সংরক্ষণ করে।

— ডেনিস

@ ডেনিস ওহ দুর্দান্ত সবসময় কি খাটো?

— মালটিসেন

2

এটি সর্বদা ব্যবহার করে মারধর করে __import__তবে import math;math.logমারবে from math import*;log।

— ডেনিস

9

আসলে , 1 বাইট

║

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

— ডেনিস
সূত্র

কাজের জন্য সঠিক সরঞ্জাম।

— মেগো

9

জেলি , 9 বাইট

L‘HịṢµ÷LS

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

ব্যাখ্যা

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

L          Get the length of the input.
 ‘         Increment it.
  H        Halve it. This gives us the index of the median for an odd-length list
           (Jelly uses 1-based indexing), and a half-integer between the two indices
           we need to average for even-length lists.
   ịṢ      Use this as an index into the sorted input. As explained above this will
           either give us the median (in case of an odd-length list) or a pair of
           values we'll now need to average.
     µ     Starts a monadic chain which is then applied to this median or pair...
      ÷L     Divide by the length. L treats atomic values like singleton lists.
        S    Sum. This also treats atomic values like singleton lists. Hence this
             monadic chain leaves a single value unchanged but will return the
             mean of a pair.

— মার্টিন ইন্ডার
সূত্র

অবশ্যই, Æṁএখন কাজ করবে

— কায়ারড coinheringaahing

9

ব্রেন-ফ্লাক , 914 + 1 = 915 বাইট

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

-Aচালানোর জন্য পতাকা প্রয়োজন ।

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

ব্যাখ্যা

এই অ্যালগরিদমের পিছনের অংশটি একটি বুদ্বুদ সাজানো যা আমি কিছুক্ষণ আগে লিখেছিলাম।

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

আমি মনে করি না এটি কীভাবে কাজ করে তাই আমাকে জিজ্ঞাসা করবেন না। তবে আমি জানি এটি স্ট্যাকটি বাছাই করে এমনকি নেতিবাচকদের জন্যও কাজ করে

সবকিছু বাছাই করার পরে আমি নীচের অংশটির সাথে 2 বার মাঝারি খুঁজে পাই

([]<(()())>(<>))<>{(({})){({}[()])<>}{}}{}<>([{}()]{}<(())>)  #Stack height modulo 2
{((<{}{}          #If odd
 ([[]]())         #Push negative stack height +1
 {                #Until zero 
  ({}()()<{}>)    #add 2 to the stack height and pop one
 }{}              #Get rid of garbage
 (({}){}<         #Pickup and double the top value
 ([]){{}{}([])}{} #Remove everything on the stack
 >)               #Put it back down
>))}{}            #End if
{(<{}                     #If even
  ([[]]()())              #Push -sh + 2
  {({}()()<{}>)}{}        #Remove one value for every 2 in that value
  ({}{}<([]){{}{}([])}{}>)#Add the top two and remove everything under them
>)}{}                     #End if

এখন যা বাকি আছে তা হ'ল ASCII তে রূপান্তর করা

([(({}<((((((()()()){}){}){}()){})[()()()])>)<(())>)](<>)){({}())<>}{}<>{}{}<>(({})){{}{}<>(<(())>)}{}(({}<>)<
{(<{}([{}])>)}{}  #Absolute value (put "/2" beneath everything)

{                 #Until the residue is zero 
(({})<            #|Convert to base 10
((()()()()()){})  #|
>)                #|...
({}(<>))<>{(({})){({}[()])<>}{}}{}<>([{}()]{})
({}<({}<>)<>>((((()()()){}){}){}){})((()()()()()){})<>({}<>)
                  #|
(()()){({}[()]<([([({})](<()>))](<>())){({}())<>}{}<>{}{}<>(({})){{}{}<>(<(())>)}{}(({})<>)<>{(<{}([{}])>)}{}({}<>)<>({}<><({}<>)>)>)}{}({}(<>))<>([()]{()<(({})){({}[()])<>}{}>}{}<><{}{}>)<>(({}{}[(())])){{}{}(((<{}>)))}{}{}{(<{}<>([{}])><>)}{}<>
}{}               #|
>)
{(<{}(((((()()()()())){}{})){}{})>)}{}  #If it was negative put a minus sign

— গম উইজার্ড
সূত্র

7

আর, 6 বাইট

median

কোনও পরিসংখ্যান প্রোগ্রামিং ভাষা আর, এর অন্তর্নির্মিত রয়েছে তা অবাক করার মতো নয়।

— rturnbull
সূত্র

4

Rজেলিকে মারধর: ডি: ডি: ডি

— জেডি

5

এমএটিএল , 4 বাইট

.5Xq

এটি 0.5-কোয়ান্টাইলের সন্ধান করে যা মাঝারি।

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

— লুইস মেন্ডো
সূত্র

আমি ঠিক এটি বের করতে ছিল!

— flawr

আহ না, মানে আমি এমএটিএল = এটি কীভাবে করব তা নির্ধারণ করছিলাম () তবে আমার একটি 5 বাইট সমাধান ছিল, তাই হ্যাঁ ...)

— ফ্লাওয়ার

@ ফ্লোয়ার পোস্ট করুন! এটি অবশ্যই আমার চেয়ে আরও আকর্ষণীয় হবে

— লুইস মেন্ডো

নাহ, এটি ঠিক তোমার সামনের আই এর সাথে একই ছিল :)

— flawr

@ ফ্লোয়ার iআপনি একইভাবে অন্তর্ভুক্ত করার পরামর্শ দিয়েছেন? :

— লুইস মেন্ডো

5

পাইথ - 11 বাইট

উভয় পিছন এবং সামনের দিকে নেওয়া মাঝারি আইটেমের গড় সন্ধান করে।

.O@R/lQ2_BS

টেস্ট স্যুট ।

— Maltysen
সূত্র

5

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

@(x)mean(([1;1]*sort(x))(end/2+[0 1]))

এটি একটি বেনামী ফাংশন সংজ্ঞায়িত করে। ইনপুট একটি সারি ভেক্টর।

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

ব্যাখ্যা

            sort(x)                 % Sort input x, of length k
      [1;1]*                        % Matrix-multiply by column vector of two ones
                                    % This vertically concatenates the sort(x) with 
                                    % itself. In column-major order, this effectively 
                                    % repeats each entry of sort(x)
     (             )(end/2+[0 1])   % Select the entry at position end/2 and the next.
                                    % Entries are indexed in column-major order. Since
                                    % the array has 2*k elements, this picks the k-th 
                                    % and (k+1)-th. Because entries were repeated, for
                                    % odd k this takes the original (k+1)/2-th entry
                                    % (1-based indexing) twice. For even k this takes
                                    % the original (k/2)-th and (k/2+1)-th entries
mean(                            )  % Mean of the two selected entries

— লুইস মেন্ডো
সূত্র

1

উঘ ... " bsxfun" এবং mean:-) এর চতুর ব্যবহার

— স্টিভি গ্রিফিন

5

জাভাস্ক্রিপ্ট, 57 52 বাইট

v=>(v.sort((a,b)=>a-b)[(x=v.length)>>1]+v[--x>>1])/2

অ্যারে সংখ্যাগতভাবে বাছাই করুন। অ্যারেটি যদি সমান দৈর্ঘ্য হয় তবে 2 টি মাঝারি সংখ্যাগুলি সন্ধান করুন এবং সেগুলি গড় করুন। অ্যারেটি যদি অদ্ভুত হয় তবে মাঝের সংখ্যাটি দু'বার আবিষ্কার করুন এবং 2 দ্বারা ভাগ করুন।

— Grax32
সূত্র

1

আমি খুঁজে পেয়েছি যে Array.sort()দশমিকের সাথে সঠিকভাবে কাজ করে না

— ট্রোজানবাইসিসিডেন্ট

3

আপনি যেমন আমার মত একটি বাছাই ফাংশন পাস যদি এটি না। আপনি যদি কোনও প্যারামিটার ছাড়াই অ্যারে.সোর্ট () কল করেন তবে এটি বর্ণানুক্রমিক বাছাই করে।

— Grax32

মজাদার. এটি জানা ছিল না

— ট্রোজানবিসিসিডেন্ট

sort()প্রত্যক্ষের রিটার্ন মানটি ব্যবহার করে এবং tভেরিয়েবলটি থেকে মুক্তি পেয়ে আপনি কয়েকটি বাইট সংরক্ষণ করতে পারেন :v=>(v.sort((a,b)=>a-b)[(x=v.length)>>1]+v[--x>>1])/2

— আরনাউল্ড

1

এটির জন্য আপনার অগত্যা সংশোধন করা উচিত নয়, তবে যদি x>=2**31এটি ব্যর্থ হয়। >>একটি সাইন-প্রসেসিং ডান শিফট , যার অর্থ যখন সংখ্যাটি 32 বিট পূর্ণসংখ্যার হিসাবে ব্যাখ্যা করা হয়, যদি এমএসবি সেট করা থাকে, তবে এটি সেট থাকে এবং ফলাফলটিকে নেতিবাচক করে তোলে 2**32>x>=2**31। কারণ x>=2**32, এটি কেবল ফলন দেয় 0।

— প্যাট্রিক রবার্টস

5

মতলব / অষ্টাভ, 6 বাইট

একটি বিরক্তিকর অন্তর্নির্মিত:

median

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

— flawr
সূত্র

আমি ম্যাটল্যাব / অষ্টাভে অজ্ঞাতনামা ফাংশনের নিয়মগুলি ভুলে গেছি, এটি কি হওয়া উচিত @median?

— জিউসেপে

@ জিউজেপ্পে আমি জানি না বিল্ট-ইন ফাংশনগুলি করার জন্য বর্তমানে গৃহীত উপায় কী।

— flawr

4

গণিত, 6 বাইট

Median

যত তাড়াতাড়ি আমি Mthmtca বুঝতে , আমি এটি একটি সমাধান পোস্ট করছি।

— পাভেল
সূত্র

Mthmtca 0.1 / 10.1.0.0 এ কোডটিতে বাইট CBC8( ËÈ) থাকবে। তবে, আমি অন্য প্যাচ প্রয়োগ না করা পর্যন্ত, ফাংশন-কলিংয়ের ধারণা পিপিসিজির মান পূরণ করতে পারে না।

— LegionMammal978

4

পার্ল 6 , 31 বাইট

*.sort[{($/=$_/2),$/-.5}].sum/2

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

সম্প্রসারিত:

*\     # WhateverCode lambda ( this is the parameter )

.sort\ # sort it

[{     # index into the sorted list using a code ref to calculate the positions

  (
    $/ = $_ / 2 # the count of elements divided by 2 stored in ｢$/｣
  ),            # that was the first index

  $/ - .5       # subtract 1/2 to get the second index

                # indexing operations round down to nearest Int
                # so both are effectively the same index if given
                # an odd length array

}]\

.sum / 2        # get the average of the two values

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

1

24 বাইট

— জো কিং

4

এপিএল (ডায়ালগ ইউনিকোড) , 14 বাইট

≢⊃2+/2/⊂∘⍋⌷÷∘2

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

এটি একটি ট্রেন আসল dfn ছিল {(2+/2/⍵[⍋⍵])[≢⍵]÷2}।

ট্রেনটি নিম্নরূপে কাঠামোযুক্ত

┌─┼───┐
≢ ⊃ ┌─┼───┐
    2 / ┌─┼───┐
    ┌─┘ 2 / ┌─┼─┐
    +       ∘ ⌷ ∘
           ┌┴┐ ┌┴┐
           ⊂ ⍋ ÷ 2

⊢ সঠিক যুক্তি বোঝায়।

⌷ সূচক

⊂∘⍋সূচকগুলি অনুসারে বাছাইয়ের ⊢ফলাফলগুলিতে ⊢সূচকযুক্ত
÷∘2মধ্যে ⊢2 দ্বারা বিভক্ত

2/এটিকে দু'বার প্রতিলিপি করুন, তাই 1 5 7 8হয়ে যায়1 1 5 5 7 7 8 8

2+/ জোড় জোড় নিন, এটি হয়ে যায় (1+1)(1+5)(5+5)(5+7)(7+7)(7+8)(8+8)

⊃ এই বাছাই থেকে

≢ দৈর্ঘ্যের সমান সূচক সহ উপাদান ⊢

পূর্ববর্তী সমাধান

{.5×+/(⍵[⍋⍵])[(⌈,⌊).5×1+≢⍵]}
{+/(2/⍵[⍋⍵]÷2)[0 1+≢⍵]}
{+/¯2↑(1-≢⍵)↓2/⍵[⍋⍵]÷2}
{(2+/2/⍵[⍋⍵])[≢⍵]÷2}
{(≢⍵)⊃2+/2/⍵[⍋⍵]÷2}
≢⊃2+/2/2÷⍨⊂∘⍋⌷⊢
≢⊃2+/2/⊂∘⍋⌷÷∘2

— ক্রিটসি লিথোস
সূত্র

3

কমন লিস্প, 89

(lambda(s &aux(m(1-(length s)))(s(sort s'<)))(/(+(nth(floor m 2)s)(nth(ceiling m 2)s))2))

আমি অবস্থানে থাকা উপাদানগুলির গড়ের গণনা করি (floor middle)এবং (ceiling middle)যেখানে middleসাজানো তালিকার মধ্যবর্তী উপাদানটির জন্য শূন্য-ভিত্তিক সূচক। এটা তোলে জন্য সম্ভব middleমতো একটি পূর্ণ সংখ্যা হতে 1যেমন আকার 3 এর একটি ইনপুট তালিকার জন্য (10 20 30), অথবা উপাদান, মত একটি এমনকি সংখ্যার তালিকার জন্য ভগ্নাংশ 3/2জন্য (10 20 30 40)। উভয় ক্ষেত্রেই, আমরা প্রত্যাশিত মধ্যবর্তী মান গণনা করি।

(lambda (list &aux
             (m (1-(length list)))
             (list (sort list #'<)))
  (/ (+ (nth (floor m 2) list)
        (nth (ceiling m 2) list))
     2))

— coredump
সূত্র

3

ভিম, 62 বাইট

আমি প্রথমটি কেবল শেষ অবধি কেবলমাত্র টেক্সট ম্যানিপুলেশন ব্যবহার করে এটি করেছি, তবে [এক্স] এবং [এক্স, ওয়াই] হ্যান্ডলিং করে হতাশ হয়ে পড়েছি, সুতরাং এখানে সহজ সংস্করণটি রয়েছে। তারা প্রায় একই দৈর্ঘ্য।

c$:let m=sort(")[(len(")-1)/2:len(")/2]
=(m[0]+m[-1])/2.0

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

Unprintables:

c$^O:let m=sort(^R")[(len(^R")-1)/2:len(^R")/2]
^R=(m[0]+m[-1])/2.0

সম্মানজনক উল্লেখ:

^O আপনাকে একটি আদেশ (লেট কমান্ড) এর জন্য সন্নিবেশ মোড থেকে বাইরে নিয়ে যায়।
^R" ইয়াঙ্ক করা পাঠ্য সন্নিবেশ করান (এই ক্ষেত্রে তালিকাটি)

— nmjcman101
সূত্র

3

টিআই-বেসিক, 2 বাইট

median(Ans

খুব সোজা।

— Timtech
সূত্র

2

Ansনা একটি হল মঞ্জুরিপ্রাপ্ত ইনপুট / আউটপুট পদ্ধতি ।

— মেগো

1

আপনার লিঙ্ক এবং মন্তব্য বিভ্রান্ত আমাকে @Mego ... ভোট অনুযায়ী, এটি করা হয় মঞ্জুরিপ্রাপ্ত। আমি কিছু অনুপস্থিত করছি?

— প্যাট্রিক রবার্টস

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

— মেগো

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

— টিমটেক

@ মেগো +38 দ্বিগুণ -18

— টিমটেক

3

সি #, 126 বাইট

using System.Linq;float m(float[] a){var x=a.Length;return a.OrderBy(g=>g).Skip(x/2-(x%2==0?1:0)).Take(x%2==0?2:1).Average();}

খুব সোজা, এখানে লিনিক্যু সহ মানগুলি অর্ডার করার জন্য, অর্ধেক তালিকাটি এড়িয়ে চলুন, সম / বিজোড়ের উপর নির্ভর করে এক বা দুটি মান নিন এবং সেগুলি গড় করুন।

— জেনস
সূত্র

আপনাকে using System.Linq; আপনার বাইট গণনাতে অন্তর্ভুক্ত করতে হবে, তবে আপনি কিছু পরিবর্তন করে এটি বাতিল করতে পারেন। একটি কম্পাইল Func<float[], float>এবং 106 বাইট জন্য একটি পরিবর্তনশীল করতে মডিউল মান নির্ধারণ:using System.Linq;a=>{int x=a.Length,m=x%2<1?1:0;return a.OrderBy(g=>g).Skip(x/2-m).Take(++m).Average();};

— TheLethalCoder

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

— জেনস

চ্যালেঞ্জটি উল্লেখ করে না যে আপনার একটি সম্পূর্ণ প্রোগ্রামের প্রয়োজন তাই বেনামে পদ্ধতি ভাল। এর বাইরে আমি কেবল কয়েকটি সাধারণ গল্ফিং টিপস বলেছি যাতে আমার উত্তর যুক্ত করার দরকার নেই শুধু নিজের গল্ফ!

— TheLethalCoder

3

সি ++ 112 বাইট

আমাকে বাইটস সংরক্ষণে সহায়তা করার জন্য @ original.legin ধন্যবাদ to

#include<vector>
#include<algorithm>
float a(float*b,int s){std::sort(b,b+s);return(b[s/2-(s&1^1)]+b[s/2])/2;}

ব্যবহার:

    int main()
    {
        int n = 4;
        float e[4] = {1,4,3,2};
        std::cout<<a(e,n); /// Prints 2.5

        n = 9;
        float e1[9] = {1,2,3,4,5,6,7,8,9};
        std::cout<<a(e1,n); /// Prints 5

        n = 13;
        float e2[13] = {1.5,1.5,1.5,1.5,1.5,1.5,1.5,1.5,1.5,-5,100000,1.3,1.4};
        std::cout<<a(e2,n); /// Prints 1.5

        return 0;
    }

— ওয়েড টাইলার
সূত্র

1

আপনি দুটি বাইট সংরক্ষণ করার floatপরিবর্তে ব্যবহার করতে পারেন double। এছাড়াও, জিসিসিতে, আপনি এর পরিবর্তে #import<vector>এবং ব্যবহার করতে পারেন । (দ্রষ্টব্য যে আপনার বা এর পরে কোনও জায়গার দরকার নেই )#import<algorithm>#include#include#import

— স্টেডিবক্স

@ স্টেডিবক্স আমি দুটি স্কোরের মধ্যে নেই বলে গণনা করি নি। আমি কি? এছাড়াও, আমি মূলত কলং ব্যবহার করি যাতে আমি জিসিসি সম্পর্কে বেশি কিছু জানি না তবে ধন্যবাদ।

— ওয়েড টাইলার

হ্যাঁ, কোডগুলি সেগুলি ব্যতীত সংকলন না করে অন্তর্ভুক্তগুলি বাইট গণনায় অন্তর্ভুক্ত করা উচিত।

— স্টেডিবক্স

3

জে , ₁₆ 14 বাইট

2%~#{2#/:~+\:~

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

বিএমওর অ্যারের সদৃশ কৌশল ছাড়াও , আমি দেখতে পেলাম যে আমরা দুটি দিক বাছাই করা পুরো অ্যারে যুক্ত করতে পারি। তারপরে আমি বুঝতে পারি যে দুটি ধাপ বিপরীত হতে পারে, অর্থাৎ দুটি অ্যারে যুক্ত করুন, তারপরে সদৃশ করুন এবং nতম উপাদানটি গ্রহণ করুন ।

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

2%~#{2#/:~+\:~
                Input: array of length n
       /:~      Sort ascending
           \:~  Sort descending
          +     Add the two element-wise
     2#         Duplicate each element
   #{           Take n-th element
2%~             Halve

পূর্ববর্তী উত্তর

`stats`অ্যাডন সহ জে , 18 বাইট

load'stats'
median

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

লাইব্রেরি ফাংশন এফটিডব্লিউ।

medianএর বাস্তবায়ন এরকম দেখাচ্ছে:

জে , 31 বাইট

-:@(+/)@((<.,>.)@(-:@<:@#){/:~)

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

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

-:@(+/)@((<.,>.)@(-:@<:@#){/:~)
         (<.,>.)@(-:@<:@#)       Find center indices:
                  -:@<:@#          Compute half of given array's length - 1
          <.,>.                    Form 2-element array of its floor and ceiling
                          {/:~   Extract elements at those indices from sorted array
-:@(+/)                          Sum and half

কিছুটা গল্ফ এই দেয়:

জে , 28 বাইট

2%~[:+/(<.,>.)@(-:@<:@#){/:~

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

— Bubbler
সূত্র

1

খুব সুন্দরভাবে সম্পন্ন হয়ে গেলে, আমার এপিএলের উত্তরটির জে বন্দরটি #{0,2+/\2#-:/:]প্রায় 15 বাইটে হবে (লোকটি আমি মিস করছি ⎕io)।

— ক্রিটসি লিথোস

2

জে, 19 বাইট

<.@-:@#{(/:-:@+\:)~

ব্যাখ্যা:

        (        )~   apply monadic argument twice to dyadic function 
         /:           /:~ = sort the list upwards
               \:     \:~ = sort the list downwards
           -:@+       half of sum of both lists, element-wise
<.@-:@#               floor of half of length of list
       {              get that element from the list of sums

— সামুদ্রিক
সূত্র

আপনি প্রথম বন্ধনীগুলি মুছে ফেলে এবং ~প্রত্যেকে সরাসরি প্রয়োগ করে একটি বাইট সংরক্ষণ করতে পারেন<.@-:@#{/:~-:@+\:~

— মাইল

2

জাভাস্ক্রিপ্ট, 273 বাইট

function m(l){a=(function(){i=l;o=[];while(i.length){p1=i[0];p2=0;for(a=0;a<i.length;a++)if(i[a]<p1){p1=i[a];p2=a}o.push(p1);i[p2]=i[i.length-1];i.pop()}return o})();return a.length%2==1?l[Math.round(l.length/2)-1]:(l[Math.round(l.length/2)-1]+l[Math.round(l.length/2)])/2}

— TrojanByAccident
সূত্র

2

জাভা 7, 99 বাইট

Golfed:

float m(Float[]a){java.util.Arrays.sort(a);int l=a.length;return l%2>0?a[l/2]:(a[l/2-1]+a[l/2])/2;}

Ungolfed:

float m(Float[] a)
{
    java.util.Arrays.sort(a);
    int l = a.length;
    return l % 2 > 0 ? a[l / 2] : (a[l / 2 - 1] + a[l / 2]) / 2;
}

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

— peech
সূত্র

আমি একটু হতাশ এমনকি জাভা 7 অল্প যথেষ্ট হয়েছে আছি শ্রেণীবিভাজন সিনট্যাক্স যে en.wikipedia.org/wiki/... হয় দরুণ পর্যাপ্ত

— JollyJoker

আপনি কি জন্য আমদানি গণনা প্রয়োজন java.util.Arrays?

— ফ্লিপট্যাক

ওফ, আপনাকে জানানোর জন্য ধন্যবাদ :)

— পিচ

হ্যালো ভবিষ্যত থেকে! দৈর্ঘ্য সমতাটি পরিচালনা করতে আপনি ইন্টিজার ডিভিশন ট্রাঙ্কেশন ব্যবহার করে 14 বাইট সংরক্ষণ করতে পারেন। দেখুন আমার জাভা 8 উত্তর ।

— Jakob

2

পরী / জিপি - 37 39 বাইট

যাক একটি মান সম্বলিত একটি rowvector হও।

b=vecsort(a);n=#b+1;(b[n\2]+b[n-n\2])/2  \\ 39 byte              

n=1+#b=vecsort(a);(b[n\2]+b[n-n\2])/2    \\ obfuscated but only 37 byte

যেহেতু পারী / জিপি ইন্টারেক্টিভ, ফলাফলটি প্রদর্শনের জন্য কোনও অতিরিক্ত কমান্ডের প্রয়োজন নেই।

জন্য "চেষ্টা-এটা-অনলাইন" আগে একটি লাইন লিঙ্ক এবং পরে যোগ করা হয়। মুদ্রণ পেতে, মিডিয়ায়-ফলাফলটি পরিবর্তনশীল ডাব্লুতে সঞ্চিত থাকে

a=vector(8,r,random(999))           
n=1+#b=vecsort(a);w=(b[n\2]+b[n-n\2])/2      
print(a);print(b);print(w)

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

— গটফ্রিড হেলমস
সূত্র

2

জাপট, 20 বাইট

n gV=0|½*Ul)+Ug~V)/2

এটি অনলাইন পরীক্ষা!এই চ্যালেঞ্জটির সত্যই সংক্ষিপ্ত উত্তর তৈরি করতে জাপ্টের সত্যই কোনও বিল্ট-ইন প্রয়োজন নেই ...

ব্যাখ্যা

n gV=0|½*Ul)+Ug~V)/2  // Implicit: U = input list
n                     // Sort U.
   V=0|½*Ul)          // Set variable V to floor(U.length / 2).
  g                   // Get the item at index V in U.
            +Ug~V     // Add to that the item at index -V - 1 in U.
                 )/2  // Divide by 2 to give the median.
                      // Implicit: output result of last expression

— ETHproductions
সূত্র

2

জাভা 8, 71 বাইট

সমতা মজা! এখান থেকে একটি ল্যামডা এর double[]জন্য Double।

l->{java.util.Arrays.sort(l);int s=l.length;return(l[s/2]+l[--s/2])/2;}

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

দৈর্ঘ্য যদি সমান হয় তবে প্রথম সংখ্যাটি অ্যারের ঠিক মাঝখানে থেকে নেওয়া হবে এবং দ্বিতীয় সংখ্যাটি পূর্বে পূর্ণসংখ্যা বিভাগের দ্বারা অবস্থান থেকে নেওয়া হবে। এই সংখ্যাগুলির গড়টি হ'ল ইনপুটটির মধ্যম।
দৈর্ঘ্যটি বিজোড় হলে sএবং s-1উভয়ই মাঝারি উপাদানটির সূচকে বিভক্ত হয়। সংখ্যাটি নিজের সাথে যুক্ত হয় এবং ফলাফলটি দুটি দ্বারা বিভক্ত হয়, আসল মান দেয়।

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

— জ্যাকব
সূত্র

2

স্মাইলব্যাসিক, 45 বাইট

DEF M A
L=LEN(A)/2SORT A?(A[L-.5]+A[L])/2
END

মেঝেতে দৈর্ঘ্যের (দৈর্ঘ্য / 2) এবং মেঝেতে দৈর্ঘ্যের / দৈর্ঘ্য / 2-0.5 পরিমাণ পাওয়া যায় খুব সহজ, তবে আমি চারপাশে জিনিসগুলি সরিয়ে 1 বাইট সংরক্ষণ করতে সক্ষম হয়েছি:

DEF M A
SORT A    <- extra line break
L=LEN(A)/2?(A[L-.5]+A[L])/2
END

— 12Me21
সূত্র

2

হুশ , 10 বাইট

½ΣF~e→←½OD

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

ব্যাখ্যা

এই ফাংশনটি মাঝারিটি ব্যবহার করে $[a_1 \dots a_N]$ এর মধ্যম হিসাবে একই $[a_1 \; a_1 \dots a_N \; a_N]$ যা বিজোড় / এমনকি-দৈর্ঘ্যের তালিকার কুৎসিত পার্থক্য এড়িয়ে চলে।

½ΣF~e→←½OD  -- example input: [2,3,4,1]
         D  -- duplicate: [2,3,4,1,2,3,4,1]
        O   -- sort: [1,1,2,2,3,3,4,4]
       ½    -- halve: [[1,1,2,2],[3,3,4,4]]
  F         -- fold the following
   ~        -- | compose the arguments ..
     →      -- | | last element: 2
      ←     -- | | first element: 3
    e       -- | .. and create list: [2,3]
            -- : [2,3]
 Σ          -- sum: 5
½           -- halve: 5/2

_{দুর্ভাগ্যক্রমে ½তালিকাগুলির জন্য টাইপ রয়েছে [a] -> [[a]]এবং [a] -> ([a],[a])যা অনুমতি দেয় না F~+→←যেহেতু প্রথম যুক্তি হিসাবে foldl1ধরণের ফাংশন প্রয়োজন a -> a -> a, আমাকে জোর করে ব্যবহার করতে বাধ্য করে e।}

— ბიმო
সূত্র

2

আর অন্তর্নির্মিত ব্যবহার না করে `median`, 51 বাইট

function(x,n=sum(x|1)+1)mean(sort(x)[n/2+0:1*n%%2])

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

— J.Doe
সূত্র

2

function(x)mean(x,.5)

— এনজিএম

2

গল্ফস্ক্রিপ্ট , 27 25 20 17 বাইট

~..+$\,(>2<~+"/2"

স্টিডিনে পূর্ণসংখ্যার অ্যারের হিসাবে ইনপুট নেয়। অবিশ্বস্ত ভগ্নাংশ হিসাবে আউটপুট। এটি অনলাইন চেষ্টা করুন!

ব্যাখ্যা

অ্যারের মধ্যমা, যেমন BMO এর তুষ উত্তর ব্যাখ্যা, একটি বিন্যাস দুইবার হিসাবে দীর্ঘ যেখানে প্রতিটি উপাদান দুইবার পুনরাবৃত্তি করা হয় মধ্যমা সমান। সুতরাং আমরা অ্যারেটিকে নিজের সাথে সংযুক্ত করি, বাছাই করি এবং মাঝের দুটি উপাদানগুলির গড় গ্রহণ করি। মূল অ্যারের দৈর্ঘ্য যদি হয় $l$ দ্বিগুণ অ্যারের মাঝের দুটি উপাদান সূচকগুলিতে রয়েছে $l-1$ এবং $l$ ।

~                  Evaluate input (converting string -> array)
 ..                Duplicate twice
   +               Concatenate two of the copies
    $              Sort the doubled array
     \,            Swap with the non-doubled array and get its length: l
       (           Decrement: l-1
        >          Array slice: all elements at index (l-1) and greater
         2<        Array slice: first two elements (originally at indices l-1 and l)
           ~       Dump array elements to stack
            +      Add
             "/2"  Push that string
                   Output all items on stack without separator

আউটপুট কিছু হবে 10/2।

— DLosc
সূত্র

মিডিয়ান গণনা

চ্যালেঞ্জ

সংজ্ঞা

উদাহরণ

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

পাইথন 3 - 31 30 বাইট

আসলে , 1 বাইট

জেলি , 9 বাইট

ব্যাখ্যা

ব্রেন-ফ্লাক , 914 + 1 = 915 বাইট

ব্যাখ্যা

আর, 6 বাইট

এমএটিএল , 4 বাইট

পাইথ - 11 বাইট

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

ব্যাখ্যা

জাভাস্ক্রিপ্ট, 57 52 বাইট

মতলব / অষ্টাভ, 6 বাইট

গণিত, 6 বাইট

পার্ল 6 , 31 বাইট

সম্প্রসারিত:

এপিএল (ডায়ালগ ইউনিকোড) , 14 বাইট

কমন লিস্প, 89

ভিম, 62 বাইট

টিআই-বেসিক, 2 বাইট

সি #, 126 বাইট

সি ++ 112 বাইট

জে , 16 14 বাইট

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

পূর্ববর্তী উত্তর

statsঅ্যাডন সহ জে , 18 বাইট

জে , 31 বাইট

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

জে , 28 বাইট

জে, 19 বাইট

জাভাস্ক্রিপ্ট, 273 বাইট

জাভা 7, 99 বাইট

পরী / জিপি - 37 39 বাইট

জাপট, 20 বাইট

ব্যাখ্যা

জাভা 8, 71 বাইট

স্মাইলব্যাসিক, 45 বাইট

হুশ , 10 বাইট

ব্যাখ্যা

আর অন্তর্নির্মিত ব্যবহার না করে median, 51 বাইট

গল্ফস্ক্রিপ্ট , 27 25 20 17 বাইট

ব্যাখ্যা

জে , ₁₆ 14 বাইট

`stats`অ্যাডন সহ জে , 18 বাইট

আর অন্তর্নির্মিত ব্যবহার না করে `median`, 51 বাইট