Geben Sie bei einer eingegebenen Ganzzahl n >= 10den Durchschnitt aller deduplizierten Umdrehungen der Ganzzahl aus.

Für die Eingabe 123sind die Umdrehungen beispielsweise 123(keine Umdrehung), 231(eine Umdrehung) und 312(zwei Umdrehungen). Der Durchschnitt von diesen ist (123 + 231 + 312) / 3oder 222.

Als weiteres Beispiel nehmen Sie 4928. Die Drehungen sind 4928, 9284, 2849, und 8492. Der Durchschnitt dieser vier Zahlen ist gleich 6388.25.

Für ein anderes Beispiel für die Eingabe 445445sind die deduplizierter Drehungen 445445, 454454und 544544so ist der Ausgang 481481.

Für die Eingabe 777gibt es nur eine deduplizierte Drehung, die Ausgabe ist also 777.

Regeln

• Gegebenenfalls können Sie davon ausgehen, dass die Eingabe / Ausgabe in den systemeigenen Integer-Typ Ihrer Sprache passt.
• Die Eingabe und Ausgabe kann durch jede bequeme Methode erfolgen .
• Es ist entweder ein vollständiges Programm oder eine Funktion zulässig. Bei einer Funktion können Sie die Ausgabe zurückgeben, anstatt sie zu drucken.
• Standardlücken sind verboten.
• Dies ist Codegolf, daher gelten alle üblichen Golfregeln, und der kürzeste Code (in Byte) gewinnt.

Python 3 , 38 36 Bytes

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

Nimmt die Ziffern als separate Argumente. Vielen Dank an @Rod, der Python 3 vorgeschlagen und 2 Bytes gespart hat.

Probieren Sie es online!

APL (Dyalog) , 9 Bytes

10⊥≢⍴+/÷≢

Eine monadische Funktion, die einen Vektor von Ziffern als Argument verwendet.

Probieren Sie es online!

Ich nehme den Durchschnitt der Ziffern +/÷≢, wiederhole ihn dann um die Länge der Eingabe ≢⍴und konvertiere schließlich von der Basis 10.

Konzeptionell nehme ich die Summe der Umdrehungen (ohne zu tragen):

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

Dies wird nur 4+2+9+8viermal wiederholt. Dann konvertieren von der Basis 10(die das Tragen für mich erledigt) und durch die Länge teilen. Obwohl ich früher durch die Länge dividiere, weil es gleichwertig ist und Bytes spart.

Java 10, 163 137 76 72 71 Bytes

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

-36 Bytes dank @Nevay .
-61 Bytes dank @ OlivierGrégoire durch Erstellen eines Ports für @Dennis 'Python 3-Antwort .
-1 Bytes, indem die Eingabe als Ziffernliste anstelle von String verwendet wird.

Erläuterung:

Probieren Sie es online aus.

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

Schale , 5 Bytes

d´MKA

Probieren Sie es online!

Erläuterung

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

Schale , 7 Bytes

A§modṙŀ

Probieren Sie es online!

Erläuterung

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 Bytes

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

Probieren Sie es online!

Eingabe als Ziffernliste.

Vielen Dank an MickyT für das Abschneiden von 11 Bytes! 8 Bytes durch Dennis 'Beweis, dass eine Deduplizierung nicht erforderlich ist.

05AB1E , 9 Bytes

vÀD}\OIg/

Probieren Sie es online!

Stax , 6 Bytes

ñJä⌠╤►

Führen Sie es aus und debuggen Sie es

Dieses Programm verwendet eine durch Anführungszeichen getrennte Zeichenfolge als Eingabe und drückt den Durchschnitt als reduzierten Bruch aus. zB 777/1 Es ist nicht notwendig, die Rotationen zu duplizieren. Es ändert nie das Ergebnis.

Ausgepackt, ungolfed und kommentiert sieht es so aus.

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

Führen Sie dieses aus

Perl 6 , 15 Bytes

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

Probieren Sie es online!

Der Durchschnitt ist der auf jede Dezimalstelle angewendete Zahlenmittelwert, sodass die Zahlenmittelwerte mal 111 ... 1 x $_eine Zeichenfolge von 1s erzeugen, die durch die Multiplikation zu Zeichenfolgen gezwungen wird.

Nimmt eine Ziffernliste als Eingabe. Eine Sequenz würde einen .cache vor der Summe erfordern, und eine Zahlen- oder Zeichenketteneingabe würde ein .comb erfordern.

Wolfram Language (Mathematica) , 22 Byte

FromDigits[0#+Mean@#]&

Probieren Sie es online!

JavaScript (Node.js) , 43 Byte

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

Probieren Sie es online!

Können wir Eingaben als Ziffernliste nehmen? - Dennis ♦ vor 7 Minuten

@ Tennis Sicher, das ist in Ordnung. Sparen Sie ein paar Bytes. : p - AdmBorkBork vor 3 Minuten

Gelee , 6 5 Bytes

ṙJḌÆm

Probieren Sie es online!

Wie es funktioniert

ṙ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.

Japt , 8 Bytes

Nimmt die Eingabe als Array von Zeichenfolgen mit einer Ziffer an.

xpUÊ)÷UÊ

Versuch es

Erläuterung

             :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 Byte ^SBCS

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

Probieren Sie es online!

Tacit-Präfix-Funktion. Übernimmt die Eingabe als Zeichenfolge.

Vielen Dank an Adám für eine aufschlussreiche 7-Byte-Speicherung .

Wie?

+/≢÷⍨⍳∘≢(⍎⌽)¨⊂ ⍝ 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 Bytes

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

EDIT: -6 Bytes dank @ovs

Holzkohle , 11 Bytes

Ｉ∕×ΣθＩ⭆θ1Ｌθ

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Erläuterung:

    θ  θ  θ 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 Bytes

10#.#$+/%#

Dies ist eine Portierung der großartigen APL-Lösung von H.PWiz für J.

Nimmt eine Liste von Ziffern als Argument.

Erläuterung:

+/%#der Durchschnitt der Ziffern (Teilen Sie %die Summe der Ziffern +/durch ihre Anzahl #)

#$Erstellt eine Liste mit Kopien des Durchschnittswerts entsprechend der Anzahl der Stellen

10#. Formularbasis konvertieren 10

Probieren Sie es online!

Perl 5 -lpF , 24 22 Bytes

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

Probieren Sie es online!

Das Auflisten von Ziffern ist nur 1 Byte kürzer und fühlt sich an wie Schummeln:

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

Probieren Sie es online!

Ruby , 60 Bytes

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

Probieren Sie es online!

Pari / GP , 34 Bytes

Übernimmt die Eingabe als Ziffernliste.

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

Probieren Sie es online!

Ruby , 33 Bytes

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

Probieren Sie es online!

Ein Port von Dennis 'Python 3-Antwort

Hier ist mein lahmer Versuch (74 Bytes)

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

Probieren Sie es online!

C ++ 218 208 Bytes

-10 Bytes dank 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();}

Und zum Testen:

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

Pyth, 12 Bytes

csms.<zdlzlz

Wahrscheinlich verbesserungsfähig.

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

Probieren Sie es hier aus!

J, 23 Bytes

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

Übernimmt die Eingabe als Zeichenfolge

Erläuterung

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

Matlab, 65 Bytes

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

Ich werde daran arbeiten, ziemlich sicher, dass es besser geht.

Clojure, 139 Bytes

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

Recht suboptimale Sprachfunktionen zum Konvertieren von Zeichenfolgen in Ganzzahlen.

Gleichstrom, 37 Bytes

Dies ist ein vollständiges Programm, das die Eingabe liest und die Ausgabe druckt:

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

Es trennt die Zahl in ihre Ziffern und multipliziert den Mittelwert der Ziffern mit der entsprechenden Längenangabe (die im weiteren Verlauf aufgebaut wird 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