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


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, ইত্যাদি দুই প্রতিটি বাইট হয়।

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.