তালিকা সহ অপারেশন


10

এই প্রশ্নের দ্বারা অনুপ্রাণিত ।

নম্বরযুক্ত একটি তালিকা দেওয়া হয়েছে, মুদ্রণ:

  • তালিকায় থাকা সংখ্যার যোগফল এবং গুণফল
  • গড় এবং মধ্যম
  • তালিকার প্রতিটি শর্তের মধ্যে পার্থক্য (প্রাক্তন [1,2,3] -> [1,1]: 1+1=2, 2+1=3)
  • তালিকা, আরোহণ অনুসারে বাছাই করা
  • সর্বনিম্ন এবং সর্বোচ্চ তালিকা
  • তালিকার মানক বিচ্যুতি

রেফারেন্সের জন্য:

স্ট্যান্ডার্ড বিচ্যুতি
আদর্শ চ্যুতি
যেখানে average গড় গড়, সেখানে x আমি তালিকার iদশম পদ, এবং তালিকার Nদৈর্ঘ্য।

সংক্ষিপ্ততম কোড জিতেছে। শুভকামনা!


আমাদের কি সেগুলি মুদ্রণ করতে হবে?
— টাইটাস

উত্তর:



5

জে, 73 70 টি অক্ষর

((+/;*/;a;(<.@-:@#{/:~);2&-~/\;/:~;<./;>./;%:@:(a@:*:@:(-a)))[a=.+/%#)

ব্যবহার:

   ((+/;*/;a;(<.@-:@#{/:~);2&-~/\;/:~;<./;>./;%:@:(a@:*:@:(-a)))[a=.+/%#)1 2 3 4
+--+--+---+-+-------+-------+-+-+-------+
|10|24|2.5|3|1 1 1 1|1 2 3 4|1|4|1.11803|
+--+--+---+-+-------+-------+-+-+-------+

এর পরের পার্থক্য হিসাবে এটি 1 1 1 নয় 1 1 1 1 হতে হবে
— রোজলুপি

5

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

1-Var Statsহয় এক বাইট , এবং Σx, x̄ইত্যাদি দুই প্রতিটি বাইট হয়।

Ans→L₁
1-Var Stats
SortA(L₁
Disp Σx,prod(Ans),x̄,Med,ΔList(Ans),L₁,minX,maxX,σx

যদি আউটপুট ক্রম পরিবর্তন করার অনুমতি দেওয়া হয় তবে স্কোরটি 40 বাইটে এনে একটি নিকট-পেরেন সংরক্ষণ করা যায়।


4

প্রশ্ন (৮rs টি চর)

(sum;prd;avg;{.5*(sum/)x[((<)x)(neg(_)t;(_)neg t:.5*1-(#)x)]};(-':);asc;min;max;dev)@\:

যেমন।

q) (sum;prd;avg;{.5*(sum/)x[((<)x)(neg(_)t;(_)neg t:.5*1-(#)x)]};(-':);asc;min;max;dev)@\: 10 9 8 7 6 5 4 3 2 1
55
3628800
5.5
5.5
10 -1 -1 -1 -1 -1 -1 -1 -1 -1
`s#1 2 3 4 5 6 7 8 9 10
1
10
2.872281

4

রুবি 187

O=->l{g=l.size
r=l.sort
s=l.inject(:+)+0.0
m=s/g
p s,l.inject(:*),m,g%2>0?r[g/2]:(r[g/2]+r[g/2-1])/2.0,l.each_cons(2).map{|l|l[1]-l[0]},r,r[0],r[-1],(l.inject(0){|e,i|e+(i-m)**2}/g)**0.5}

ব্যবহারের বাক্য গঠন: O[<array>] (উদাহরণস্বরূপ O[[1,2,3]])

কনসোলে সমস্ত প্রয়োজনীয় মানগুলি আউটপুট করে থাকে, প্রশ্নের মধ্যে নির্দিষ্ট ক্রমে।

আইডিয়ো উদাহরণ:


2

স্কালা 208 202 188:

val w=l.size
val a=l.sum/w
val s=l.sortWith(_<_)
Seq(l.sum,l.product,a,s((w+1)/2),(0 to w-2).map(i=>l(i+1)-l(i)),s,l.min,l.max,(math.sqrt((l.map(x=>(a-x)*(a-x))).sum*1.0/w))).map(println)

টেস্ট:

scala> val l = util.Random.shuffle((1 to 6).map(p=>math.pow(2, p).toInt))
l: scala.collection.immutable.IndexedSeq[Int] = Vector(64, 8, 4, 32, 16, 2)

scala> val a=l.sum/l.size
a: Int = 21

scala> val s=l.sortWith(_<_)
s: scala.collection.immutable.IndexedSeq[Int] = Vector(2, 4, 8, 16, 32, 64)

scala> Seq(l.sum,l.product,a,s((s.size+1)/2),(0 to l.size-2).map(i=>l(i+1)-l(i)),l.sortWith(_<_),l.min,l.max,(math.sqrt((l.map(x=>(a-x)*(a-x))).sum*1.0/l.size))).map(println)
126
2097152
21
16
Vector(-56, -4, 28, -16, -14)
Vector(2, 4, 8, 16, 32, 64)
2
64
21.656407827707714

আমার জন্য "ভেক্টর (-56, -4, 28, -16, -14)" ভুল
— রোসএলপি

@ রোসলুপি: কেন এটা ভুল?
— ব্যবহারকারী অজানা

হ্যাঁ আপনি ঠিক বলেছেন ইনপুটটি "ভেক্টর (, 64, ৮, ৪, ৩২, ১,, ২)" (আমি ইনপুটটি বিভ্রান্ত করি)
— রোজলুপি

2

জুলিয়া 0.6 , 66 বাইট

x->map(f->f(x),[sum,prod,mean,median,diff,sort,extrema,std])|>show

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

জুলিয়া ০..6 , ৮৮ বাইট (অপারেটিংয়ের মতো অসাধু স্ট্যান্ড ডেভ)

x->map(f->f(x),[sum,prod,mean,median,diff,sort,extrema,x->std(x,corrected=false)])|>show

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


এটি সঠিক নয়, কারণ জুলিয়া সমস্যা হিসাবে প্রয়োজনীয় হিসাবে n-1জনসংখ্যার (বিভাজক) পরিবর্তে নমুনা স্ট্যান্ডার্ড বিচ্যুতি গণনা (ভাগ করে ) ব্যবহার করছে n। দ্বারা গুণ (n-1)/nকরলে তাও ঠিক হয় না, কারণ যখন ভাগ করে n-1, NaNউত্পাদিত হয়। আর-তে এটি করার চেষ্টা করার সময় আমি একই সমস্যার মধ্যে পড়েছিলাম এবং তখন থেকে এটি ভেবে দেখিনি।
— জিউসেপ

তা আমার কাছে ঘটেনি। আমি সঠিক এসডিডি বিচ্যুতি সহ একটি বিকল্প সমাধান যুক্ত করেছি।
— gggg

1

সি ++ 14, 340 383 বাইট

জেনেরিক নামহীন লাম্বদা হিসাবে। প্রথম প্যারামিটারটি Lহল std::listভাসমান পয়েন্টের ধরণের তালিকা এবং দ্বিতীয় প্যারামিটারটি পছন্দসই আউটপুট স্ট্রিমের মতো std::cout।

#import<cmath>
#define F(x);O<<x<<'\n';
#define Y l=k;++l!=L.end();
#define A auto
[](A L,A&O){A S=L;A l=L.begin(),k=l;A n=L.size();A s=*l,p=s,d=s*s,h=n/2.;for(S.sort(),Y s+=*l,p*=*l,d+=*l**l);for(l=S.begin();--h>0;++l)F(s)F(p)F(s/n)F(*l)for(Y)O<<*l-*k++<<","F(' ')for(A x:S)O<<x<<","F(' ')F(S.front())F(S.back())F(sqrt((d-s*s/n)/(n-1)))}

একটি সতর্কতা সহ সংকলন, সি ++ "সরাসরি আক্ষরিক পছন্দ অনুসারে অনুমতি দেয় না F। প্রোগ্রাম এখনও চলছে।

  • -1 এবং -2 বাইট জ্যাচারিকে ধন্যবাদ ý

Ungolfed:

#include<iostream>
#include<list>

#import<cmath>
#define F(x);O<<x<<'\n';
#define Y l=k;++l!=L.end();
#define A auto

auto f=
[](A L, A&O){
  A S=L;                  //copy the list for later sorting
  A l=L.begin(),          //main iterator
    k=l;                  //sidekick iterator
  A n=L.size();
  A s=*l,                 //sum, init with head of list
    p=s,                  //product, same
    d=s*s,                //standard deviation, formula see https://en.wikipedia.org/wiki/Algebraic_formula_for_the_variance
    h=n/2.;               //for the median later   
  for(
    S.sort(),             //now min/med/max is at known positions in S
    Y //l=k;++l!=L.end(); //skip the headitem-loop
    s += *l,              //l points the next element which is fine
    p *= *l,              //since the head given at definiten
    d += *l * *l          //needs the sum of the squares
  );
  for(
    l=S.begin();          //std::list has no random access
    --h>0;                //that's why single increment loop
    ++l                   //until median is crossed
  )
  F(s)  //;O<<s<<'\n';    //sum
  F(p)                    //product
  F(s/n)                  //average
  F(*l)                   //median (in S)
  for(Y) //l=k;++l!=L.end(); //set l back to L
    O<<*l-*k++<<","       //calc difference on the fly
  F(' ')
  for(A x:S)              //output sorted list
    O<<x<<"," 
  F(' ')
  F(S.front())            //minimum
  F(S.back())             //maximum
  F(sqrt((d-s*s/n)/(n-1))) //standard deviation
}

;


using namespace std;

int main() {
 list<double> l = {10,3,1,2,4};
 f(l, cout);
}

আমার মনে হয় আপনি পরিবর্তন করে কয়েক বাইট সংরক্ষণ করতে পারবেন Fকরার ;F(x)O<<x<<'\n';ও শেষ লাইন:[](A L,A&O){A S=L;A l=L.begin(),k=l;A n=L.size();A s=*l,p=s,d=s*s,h=n/2.;for(S.sort(),Y s+=*l,p*=*l,d+=*l**l);for(l=S.begin();--h>0;++l)F(s)F(p)F(s/n)F(*l)for(Y)O<<*l-*k++<<","F(' ')for(A x:S)O<<x<<","F(' ')F(S.front())F(S.back())F(sqrt((d-s*s/n)/(n-1)));}
— Zachary

@ জ্যাচারý শেষ অবধি সত্যিই একটা অপ্রয়োজনীয় ছিল ;। এটি সরানো যেতে পারে, তবে " "Fwarning: invalid suffix on literal; C++11 requires a space between literal and string macro
— সংকলকটি

যদিও এটি কাজ করে ?!
— জ্যাচার

@ জ্যাচারý হ্যাঁ এটি কাজ করে।
— কার্ল ন্যাপ্ফ



0

পাইট , 39 বাইট

←ĐĐĐĐĐĐĐŞ⇹Ʃ3ȘΠ4Șµ5Ș₋⇹6Ș↕⇹7ȘṀ↔Đе-²Ʃ⇹Ł/√

এই ফলাফলগুলি, ক্রম অনুসারে, মিডিয়ান, পণ্য, পার্থক্য, তালিকাটি বিপরীত, যোগফল, সর্বাধিক এবং সর্বনিম্ন, গড় এবং মানক বিচ্যুতি

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

ব্যাখ্যা:

←ĐĐĐĐĐĐĐ                                              Push the array onto the stack 8 times
        ş                                             Sort in ascending order
         ⇹                                            Stack management
          Ʃ                                           Sum
           3Ș                                         Stack management
             Π                                        Product
              4Ș                                      Stack management
                µ                                     Mean (as a float)
                 5Ș                                   Stack management
                   ₋                                  Differences
                    ⇹6Ș                               Stack management
                       ↕                              Minimum and maximum
                        ⇹7Ș                           Stack management
                           Ṁ                          Median
                            ↔                         Stack management
                             Đе-²Ʃ⇹Ł/√               Standard Deviation

0

এপিএল NARS, 119 চর, 182 বাইট

{m←(s←+/w)÷n←⍴w←,⍵⋄s,(×/w),m,(n{j←⌊⍺÷2⋄2|⍺:⍵[1+j]⋄2÷⍨⍵[j]+⍵[j+1]}t),(⊂¯1↓(1⌽w)-w),(⊂t←w[⍋w]),(⌊/w),(⌈/w),√n÷⍨+/(w-m)*2}

পরীক্ষা

  h←{m←(s←+/w)÷n←⍴w←,⍵⋄s,(×/w),m,(n{j←⌊⍺÷2⋄2|⍺:⍵[1+j]⋄2÷⍨⍵[j]+⍵[j+1]}t),(⊂¯1↓(1⌽w)-w),(⊂t←w[⍋w]),(⌊/w),(⌈/w),√n÷⍨+/(w-m)*2}
  ⎕fmt h 0 
┌9──────────────────────┐
│        ┌0─┐ ┌1─┐      │
│0 0 0 0 │ 0│ │ 0│ 0 0 0│
│~ ~ ~ ~ └~─┘ └~─┘ ~ ~ ~2
└∊──────────────────────┘
  ⎕fmt h 3
┌9──────────────────────┐
│        ┌0─┐ ┌1─┐      │
│3 3 3 3 │ 0│ │ 3│ 3 3 0│
│~ ~ ~ ~ └~─┘ └~─┘ ~ ~ ~2
└∊──────────────────────┘
  ⎕fmt h 1 2 3
┌9───────────────────────────────────────┐
│        ┌2───┐ ┌3─────┐                 │
│6 6 2 2 │ 1 1│ │ 1 2 3│ 1 3 0.8164965809│
│~ ~ ~ ~ └~───┘ └~─────┘ ~ ~ ~~~~~~~~~~~~2
└∊───────────────────────────────────────┘
  ⎕fmt h 1 2 3 4
┌9────────────────────────────────────────────────┐
│              ┌3─────┐ ┌4───────┐                │
│10 24 2.5 2.5 │ 1 1 1│ │ 1 2 3 4│ 1 4 1.118033989│
│~~ ~~ ~~~ ~~~ └~─────┘ └~───────┘ ~ ~ ~~~~~~~~~~~2
└∊────────────────────────────────────────────────┘
  ⎕fmt h 1 2 7 3 4 5 
┌9──────────────────────────────────────────────────────────────────┐
│                       ┌5──────────┐ ┌6───────────┐                │
│22 840 3.666666667 3.5 │ 1 5 ¯4 1 1│ │ 1 2 3 4 5 7│ 1 7 1.972026594│
│~~ ~~~ ~~~~~~~~~~~ ~~~ └~──────────┘ └~───────────┘ ~ ~ ~~~~~~~~~~~2
└∊──────────────────────────────────────────────────────────────────┘

0

ওকামল - 288 বাইট

প্রদত্ত তালিকাটি ধরে নেওয়া হ'ল ভাসমান (রূপান্তর এড়ানোর জন্য) একটি খালি খালি তালিকা এবং ফিরে আসা মিডিয়ানটি মধ্যকের দুর্বল সংজ্ঞা:

median l = nযেমন অর্ধেক উপাদান lছোট বা সমান nএবং অর্ধের উপাদানগুলি lবৃহত্তর বা সমানn

open List
let f=fold_left
let z=length
let s l=f(+.)0. l
let a l=(s l)/.(float_of_int(z l))let rec i=function|a::[]->[]|a::b->(hd b -. a)::(i b)let r l=let t=sort compare l in(s,f( *.)1. l,a t,nth t((z t)/2+(z t)mod 2-1),t,i l,nth t 0,nth t((z t)-1),sqrt(a(map(fun n->(n-.(a l))**2.)l)))

পঠনযোগ্য সংস্করণটি

open List

let sum l = fold_left (+.) 0. l
let prod l = fold_left ( *. ) 1. l
let avg l = (sum l) /. (float_of_int (length l))
let med l =
        let center = (length l) / 2 + (length l) mod 2 -1 in
        nth l center
let max l = nth l 0
let min l = nth l ((length l) - 1)
let dev l =
let mean = avg l in
        sqrt (avg (map (fun n -> (n -. mean)**2.) l))

let rec dif =
        function
        | a::[] -> []
        | a::b -> ((hd b) - a) :: (dif b)

let result l =
        let sorted = sort compare l in
        (
                sum sorted,
                prod sorted,
                avg sorted,
                med sorted,
                sorted,
                dif l,
                max sorted,
                min sorted,
                dev sorted
        )

আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.