सूचियों के साथ संचालन


10

इस सवाल से प्रेरित ।

संख्याओं वाली सूची को देखते हुए प्रिंट करें:

  • सूची में संख्याओं का योग और उत्पाद
  • औसत और औसत दर्जे का
  • सूची में प्रत्येक शब्द के बीच अंतर (पूर्व [1,2,3] -> [1,1]: 1+1=2, 2+1=3)
  • सूची, आरोही क्रमबद्ध
  • सूची की न्यूनतम और अधिकतम
  • सूची का मानक विचलन

सन्दर्भ के लिए:

मानक विचलन
मानक विचलन
कहाँ μ मतलब औसत है, 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 के रूप में अगले अंतर के रूप में होना ही है
RosLuP

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

क्यू (87 वर्ण)

(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]])

प्रश्न में निर्दिष्ट क्रम में, कंसोल के लिए सभी आवश्यक मानों को आउटपुट करता है।

IdeOne उदाहरण:


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)" गलत है
RosLuP

@RosLuP: यह गलत क्यों है?
यूजर अनजान

हाँ आप सही हैं यदि इनपुट "वेक्टर (64, 8, 4, 32, 16, 2)" (मैं इनपुट को भ्रमित करता
हूं

2

जूलिया 0.6 , 66 बाइट्स

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

इसे ऑनलाइन आज़माएं!

जूलिया 0.6 , 88 बाइट्स (अस्पष्ट एस डी डी देव, सेशन में)

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

इसे ऑनलाइन आज़माएं!


यह सही नहीं है, क्योंकि जूलिया समस्या में आवश्यकतानुसार n-1जनसंख्या मानक std (से विभाजित) के बजाय नमूना मानक विचलन गणना (द्वारा विभाजित ) का उपयोग कर रहा nहै। गुणा (n-1)/nकरने से इसे ठीक भी नहीं किया जा सकता, क्योंकि जब विभाजित किया जाता है n-1, तो NaNइसका उत्पादन किया जाता है। जब मैं आर में ऐसा करने की कोशिश कर रहा था, तब से मैं उन्हीं समस्याओं में भाग रहा था और तब से नहीं सोचा था।
ग्यूसेप

मेरे साथ भी ऐसा नहीं हुआ। मैंने सही एसटीडी विचलन के साथ एक वैकल्पिक समाधान जोड़ा।
०५:३५ पर ggg

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)))}

एक चेतावनी के साथ संकलित, C ++, "जैसे कि शाब्दिक के बाद सीधे अनुमति नहीं देता है F। कार्यक्रम अभी भी चल रहा है।

  • -1 & -2 बाइट्स Zacharý की बदौलत

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

@ Zacharý वास्तव ;में अंत में एक अनावश्यक काफी था। इसे हटाया जा सकता है, लेकिन संकलक को पसंद नहीं है " "F: warning: invalid suffix on literal; C++11 requires a space between literal and string macroयह हालांकि संकलित करता है ...
कार्ल नेफ

हालांकि यह काम करता है ?!
Zachary

@ Zacharý हाँ यह काम करता है।
कार्ल नैप



0

पाइट , 39 बाइट्स

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

यह आउटपुट, क्रम में, माध्यिका, उत्पाद, अंतर, सूची उलट, योग, अधिकतम और न्यूनतम, माध्य और मानक विचलन .q

इसे ऑनलाइन आज़माएं!

स्पष्टीकरण:

←ĐĐĐĐĐĐĐ                                              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

APL 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

Ocaml - 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
        )

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.