การดำเนินงานกับรายการ


10

แรงบันดาลใจจากคำถามนี้

รับรายการที่มีตัวเลขพิมพ์:

  • ผลรวมและผลคูณของตัวเลขในรายการ
  • ค่าเฉลี่ยและค่ามัธยฐาน
  • ความแตกต่างระหว่างแต่ละคำในรายการ (เช่น[1,2,3] -> [1,1]: 1+1=2, 2+1=3)
  • รายการเรียงลำดับจากน้อยไปมาก
  • ขั้นต่ำและสูงสุดของรายการ
  • ค่าเบี่ยงเบนมาตรฐานของรายการ

สำหรับการอ้างอิง:

ค่าเบี่ยงเบนมาตรฐาน
ส่วนเบี่ยงเบนมาตรฐาน
โดยที่μคือค่าเฉลี่ยหมายถึงx iเป็นiคำที่อยู่ในรายการและNเป็นความยาวของรายการ

รหัสที่สั้นที่สุดชนะ โชคดี!


พวกเราต้องพิมพ์มันตามลำดับไหม?
ติตัส

คำตอบ:



5

J, 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

TI-BASIC, 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

Q (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

สำหรับฉัน "Vector (-56, -4, 28, -16, -14)" ผิด
RosLuP

@RosLuP: ทำไมมันผิด
ผู้ใช้ที่ไม่รู้จัก

ใช่คุณถูกต้องถ้าอินพุตคือ "เวกเตอร์ (64, 8, 4, 32, 16, 2)" (ฉันสับสนอินพุต)
RosLuP

2

Julia 0.6 , 66 bytes

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

ลองออนไลน์!

Julia 0.6 , 88 ไบต์ (std dev ที่ไม่ได้แก้ไขเช่นเดียวกับ op)

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

ลองออนไลน์!


สิ่งนี้ไม่ถูกต้องเนื่องจาก Julia ใช้ตัวอย่างการคำนวณค่าเบี่ยงเบนมาตรฐาน (หารด้วยn-1) แทนที่จะเป็นประชากร std (หารด้วยn) ตามที่ต้องการในปัญหา คูณด้วย(n-1)/nจะไม่สามารถแก้ไขได้อย่างใดอย่างหนึ่งเพราะเมื่อหารด้วยn-1, NaNมีการผลิต ฉันพบปัญหาเดียวกันเมื่อพยายามทำสิ่งนี้ใน R และไม่เคยคิดมาก่อน
Giuseppe

นั่นไม่ได้เกิดขึ้นกับฉัน ฉันเพิ่มโซลูชันสำรองด้วยค่าเบี่ยงเบนมาตรฐานที่ถูกต้อง
gggg

1

C ++ 14, 340 383 ไบต์

เป็นแลมบ์ดาที่ไม่มีชื่อทั่วไป พารามิเตอร์แรกLเป็นรายการเป็นของลอยชนิดจุดและพารามิเตอร์ที่สองคือกระแสออกที่ต้องการเช่นstd::liststd::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)));}
Zacharý

@ Zacharý ;ในตอนท้ายมีสิ่งที่ไม่จำเป็นจริงๆ สามารถลบออกได้ แต่คอมไพเลอร์ไม่ชอบ" "F: warning: invalid suffix on literal; C++11 requires a space between literal and string macroมันคอมไพล์ แต่ ...
46414

มันใช้งานได้!
Zacharý

@ Zacharýใช่มันทำงานได้
Karl Napf



0

Pyt , 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

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
        )

0

PHP, 213 ไบต์

function($a){echo$s=array_sum($a),_,array_product($a),_,$v=$s/$c=count($a);foreach($a as$i=>$x){$d+=($x-$v)**2;$i&&$f[]=$x-$a[$i-1];}sort($a);var_dump(($a[$c/2]+$a[$c/2+~$c%2])/2,$f,$a,$a[0],max($a),sqrt($d/$c));}

ลองมันออนไลน์

โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.