รับค่าอินพุตจำนวนเต็มn >= 10ส่งออกค่าเฉลี่ยของการหมุนที่ซ้ำซ้อนทั้งหมดของจำนวนเต็ม

ตัวอย่างเช่นสำหรับอินพุต123การหมุนคือ123(ไม่มีการหมุน), 231(หนึ่งการหมุน) และ312(การหมุนสองครั้ง) ค่าเฉลี่ยของผู้ที่เป็นหรือ(123 + 231 + 312) / 3222

เป็นอีกตัวอย่าง4928หนึ่ง หมุนเป็น4928, 9284, และ2849 การเฉลี่ยของผู้ที่ตัวเลขสี่เท่ากับ84926388.25

สำหรับอีกตัวอย่างหนึ่งสำหรับการป้อนข้อมูล445445ที่ผลัดซ้ำมี445445, 454454และเพื่อส่งออกเป็น544544481481

สำหรับการป้อนข้อมูลมีเพียงหนึ่งหมุนซ้ำเพื่อให้ออกเป็น777777

กฎระเบียบ

• หากเป็นไปได้คุณสามารถสันนิษฐานได้ว่าอินพุต / เอาท์พุตจะพอดีกับภาษาของคุณ Integer
• อินพุตและเอาต์พุตจะได้รับโดยวิธีการที่สะดวกใด ๆ
• ยอมรับได้ทั้งโปรแกรมหรือฟังก์ชั่น หากฟังก์ชั่นคุณสามารถส่งคืนผลลัพธ์มากกว่าการพิมพ์
• ช่องโหว่มาตรฐานเป็นสิ่งต้องห้าม
• นี่คือรหัส - กอล์ฟเพื่อให้ใช้กฎการเล่นกอล์ฟตามปกติทั้งหมดและรหัสที่สั้นที่สุด (เป็นไบต์) ชนะ

Python 3 , 38 36 ไบต์

lambda*n:10**len(n)//9*sum(n)/len(n)

นำตัวเลขเป็นอาร์กิวเมนต์แยกกัน ขอบคุณ @Rod ที่แนะนำ Python 3 ประหยัด 2 ไบต์

ลองออนไลน์!

APL (Dyalog)ขนาด 9 ไบต์

10⊥≢⍴+/÷≢

ฟังก์ชัน monadic ที่ใช้เวกเตอร์ของตัวเลขเป็นอาร์กิวเมนต์

ลองออนไลน์!

ฉันหาค่าเฉลี่ยของตัวเลข+/÷≢จากนั้นทำซ้ำตามความยาวของอินพุต≢⍴และในที่สุดก็แปลงจากฐาน 10

ตามแนวคิดฉันกำลังหาผลรวมของการหมุน (โดยไม่ต้องถือ):

 4  2  9  8
 2  9  8  4
 9  8  4  2
+8  4  2  9
 -----------
 23 23 23 23

นี่เป็นเพียงแค่4+2+9+8ทำซ้ำ 4 ครั้ง จากนั้นแปลงจากฐาน10(ซึ่งแบกสำหรับฉัน) และหารด้วยความยาว แม้ว่าฉันจะหารด้วยความยาวก่อนหน้านี้เพราะมันมีความเท่าเทียมและประหยัดไบต์

Java 10, 163 137 76 72 71 ไบต์

n->(Math.pow(10,n.size())-1)/9*n.stream().mapToInt(i->i).sum()/n.size()

-36 ไบต์ขอบคุณที่@Nevay
-61 ไบต์ขอบคุณที่@ OlivierGrégoireโดยการสร้างพอร์ตของ@Dennis 'งูใหญ่ 3 คำตอบ
-1 ไบต์โดยการป้อนข้อมูลเป็นรายการหลักแทนที่จะเป็นสตริง

คำอธิบาย:

ลองออนไลน์

n->                                 // Method with String parameter and double return-type
  (Math.pow(10,n.size())-1)/9       //  Repunits the same length as the input-size
  *n.stream().mapToInt(i->i).sum()  //  multiplied by the sum of digits
  /n.size()                         //  divided by the input-size

Husk , 5 ไบต์

d´MKA

ลองออนไลน์!

คำอธิบาย

d´MKA
    A  Take the average of the digits
 ´MK   Replace each element of the original list with the average
d      Join the list to get a number

Husk , 7 ไบต์

A§modṙŀ

ลองออนไลน์!

คำอธิบาย

A§modṙŀ
      ŀ  Take the range [1..length(input)]
 §m  ṙ   Rotate the input by each element of the range
   od    Convert each list of digits to a number
A        Take the average of the list

R , 84 73 64 ไบต์

function(D,K=sum(D|1))mean(array(D,K+1:0)[1:K,1:K]%*%10^(K:1-1))

ลองออนไลน์!

ป้อนเป็นรายการตัวเลข

ขอบคุณ MickyT สำหรับการโกนขนาด 11 ไบต์! 8 ไบต์ถูกลบล้างโดยหลักฐานของ Dennis ที่ไม่จำเป็นต้องใช้คำซ้ำซ้อน

05AB1E , 9 ไบต์

vÀD}\OIg/

ลองออนไลน์!

Stax , 6 ไบต์

ñJä⌠╤►

เรียกใช้และแก้ไขข้อบกพร่อง

โปรแกรมนี้ใช้สตริงที่คั่นด้วยเครื่องหมายคำพูดเป็นอินพุตและแสดงค่าเฉลี่ยเป็นเศษส่วนที่ลดลง เช่น777/1 ไม่จำเป็นต้องยกเลิกการหมุนซ้ำ ไม่เคยเปลี่ยนผลลัพธ์

คลายกล่อง ungolfed และแสดงความคิดเห็นมันมีลักษณะเช่นนี้

:)  get all character rotations
{em convert strings back to integers
:V  mean - integer inputs means result will be rational

เรียกใช้อันนี้

Perl 6 , 15 ไบต์

{.sum/$_*1 x$_}

ลองออนไลน์!

ค่าเฉลี่ยคือค่าเฉลี่ยตัวเลขที่ใช้กับตำแหน่งทศนิยมแต่ละตำแหน่งดังนั้นค่าเฉลี่ย1 x $_ตัวเลขคูณ111 ... จะสร้างสตริง 1s ซึ่งได้รับการรวมกับสตริงด้วยจำนวนทวีคูณ

ใช้รายการของตัวเลขเป็นอินพุต ลำดับจะต้องมี. cache ก่อนการรวมและการป้อนตัวเลขหรือสตริงจะต้องมี. com

ภาษา Wolfram (Mathematica)ขนาด 22 ไบต์

FromDigits[0#+Mean@#]&

ลองออนไลน์!

JavaScript (Node.js) , 43 ไบต์

x=>eval(x.join`+`)*'1'.repeat(n=x.length)/n

ลองออนไลน์!

เราสามารถรับข้อมูลเป็นรายการตัวเลขได้หรือไม่? - เดนนิส♦ 7 นาทีที่แล้ว

@Dennis แน่นอนนั่นเป็นเรื่องปกติ ไปบันทึกไบต์ : p - AdmBorkBork 3 นาทีที่แล้ว

เยลลี่ , 6 5 ไบต์

ṙJḌÆm

ลองออนไลน์!

มันทำงานอย่างไร

ṙJḌÆm  Main link. Argument: A (digit array)

 J     Yield the indices of A, i.e., [1, ..., len(A)].
ṙ      Rotate A 1, ..., and len(A) units to the left, yielding a 2D array.
  Ḍ    Convert each rotation from decimal to integer.
   Æm  Take the arithmetic mean.

Japtet , 8 ไบต์

รับอินพุตเป็นอาร์เรย์ของสตริงหลักเดียว

xpUÊ)÷UÊ

ลองมัน

คำอธิบาย

             :Implicit input of array U
 pUÊ         :Repeat each string length of U times
x   )        :Reduce by addition
     ÷UÊ     :Divide by the length of U

APL (Dyalog Unicode) , 21 14 ไบต์^SBCS

+/≢÷⍨⍳∘≢(⍎⌽)¨⊂

ลองออนไลน์!

ฟังก์ชั่นนำหน้า Tacit รับอินพุตเป็นสตริง

ขอขอบคุณที่อดัมenlightening 7 ไบต์ประหยัด

อย่างไร?

+/≢÷⍨⍳∘≢(⍎⌽)¨⊂ ⍝ Main fn, example argument '123'
              ⊂ ⍝ Enclose the argument (turns it into a scalar)
             ¨  ⍝ Use each of the left arguments to
         ( ⌽)   ⍝ Rotate, then
          ⍎     ⍝ Convert strings into numbers
      ⍳∘≢       ⍝ Tally (≢) the argument, then index (⍳) from 1. 
                ⍝ Returns 1 2 3 for a 3 digit argument, and rotates the argument 1, 2, then 3 times.
     ⍨          ⍝ Use the result as left argument for
    ÷           ⍝ Divide
   ≢            ⍝ By the number of rotations
+/              ⍝ And sum the results

Python 2, 83 77 ไบต์

def f(a):b={int(`a`[i:]+`a`[:i])for i in range(len(`a`))};print sum(b)/len(b)

แก้ไข: -6 ไบต์ขอบคุณ @ovs

ถ่าน 11 ไบต์

Ｉ∕×ΣθＩ⭆θ1Ｌθ

ลองออนไลน์! การเชื่อมโยงคือการใช้รหัสเวอร์ชันอย่างละเอียด คำอธิบาย:

    θ  θ  θ Input as a string
   Σ        Sum of digits
      ⭆ 1   Replace each character with the literal `1`
     Ｉ      Cast to integer
  ×         Multiply
         Ｌ  Length
 ∕          Divide
Ｉ           Cast to string
            Implicitly print

J , 10 ไบต์

10#.#$+/%#

นี่เป็นพอร์ตของโซลูชั่น APL ที่ยอดเยี่ยมของ H.PWiz สำหรับ J

ใช้รายการของตัวเลขเป็นอาร์กิวเมนต์

คำอธิบาย:

+/%#ค่าเฉลี่ยของตัวเลข (หาร%ผลรวมของตัวเลข+/ด้วยหมายเลข#)

#$สร้างรายการสำเนาของค่าเฉลี่ยตามจำนวนหลัก

10#. แปลงฐานแบบฟอร์ม 10

ลองออนไลน์!

Perl 5 -lpF , 24 22 ไบต์

#!/usr/bin/perl -lpF
$_=1x@F/s/./+$&/g*eval

ลองออนไลน์!

การทำมันเป็นรายการของตัวเลขนั้นสั้นลงเพียง 1 ไบต์และรู้สึกว่าโกง:

#!/usr/bin/perl -p
$;+=$_}{$_=1x$./$.*$

ลองออนไลน์!

Ruby , 60 ไบต์

->n{a=b=c=0.0;a,b,c,n=a+n%10,b*10+1,c+1,n/10while n>0;a*b/c}

ลองออนไลน์!

Pari / GP , 34 ไบต์

รับอินพุตเป็นรายการของตัวเลข

n->fromdigits([vecsum(n)|x<-n])/#n

ลองออนไลน์!

Ruby , 33 ไบต์

->n{10**(k=n.size)/9*n.sum*1.0/k}

ลองออนไลน์!

พอร์ตของเดนนิส Python 3 คำตอบ

นี่คือความพยายามง่อยของฉัน (74 ไบต์)

->s{a=(1..s.size).map{|i|s.chars.rotate(i).join.to_i}|[];a.sum*1.0/a.size}

ลองออนไลน์!

C ++, 218 208 ไบต์

-10 ไบต์ขอบคุณZacharý

#include<set>
#include<cmath>
float a(int m){std::set<int>a;int n=m,t,c=0;for(;n>0;n/=10)++c;for(;n<c;++n){a.insert(m);t=m%10;m=m/10+std::pow(10.f,c-1)*t;}int s=0;for(int v:a){s+=v;}return float(s)/a.size();}

และเพื่อทดสอบ:

int main() {
    printf("%f\n%f\n%f\n%f\n",a(123),a(4928),a(445445),a(777));
}

Pyth, 12 ไบต์

csms.<zdlzlz

น่าจะเป็นไปไม่ได้

c         lz     Divide by the length of the input:
 s               Reduce by +
  m     lz       Map over d = [0 ... the length of the input]:
   s.<zd         Shift the input d characters to the left and cast to int

ลองที่นี่!

J, 23 ไบต์

(+/%#)".~.(|."0 1~i.@#)

รับอินพุตเป็นสตริง

คำอธิบาย

          (|."0 1~i.@#)  | All rotations
        ~.               | Deduplicate
      ".                 | Convert each to int
(+/%#)                   | Average

Matlab, 65 ไบต์

c=num2str(n);l=nnz(c);mean(str2num(c(mod((1:l)+(0:l-1)'-1,l)+1)))

จะทำงานในเรื่องนี้ค่อนข้างแน่ใจว่าสามารถทำได้ดีกว่า

Clojure, 139 ไบต์

#(let[n(count %)G(set(apply map list(for[i(range n)](take n(drop i(cycle %))))))](/(apply +(for[g G](read-string(apply str g))))(count G)))

มีคุณสมบัติภาษาที่เหมาะสมที่สุดสำหรับการแปลงลำดับอักขระเป็นจำนวนเต็ม

dc, 37 ไบต์

นี่เป็นโปรแกรมแบบเต็มอ่านอินพุตและพิมพ์เอาต์พุต:

?1sd[O~rzsadO<x+ldO*1+sd]dsxxOkld*la/p

มันทำงานโดยการแยกตัวเลขลงในตัวเลขของตนและการคูณค่าเฉลี่ยของตัวเลขโดย repdigit ความยาวที่เหมาะสม (ซึ่งถูกสร้างขึ้นในdขณะที่เราไป)

?                               # read input
 1sd                            # initialize d=1
    [                   ]dsxx   # define and execute recursive macro x:
     O~r                        #   remainder and quotient of /10
        zsa                     #   a = number of digits
           dO<x                 #   recurse if needed
               +ldO*1+sd        #   increment repdigit d
                             Ok         # after executing x, set precision 
                               ld*la/   # multiply by repdigit; divide by a
                                     p  # print the result