Étant donné un entier en entrée n >= 10, affichez la moyenne de toutes les rotations dédupliquées de l'entier.

Par exemple, pour la saisie 123, les rotations sont 123(aucune rotation), 231(une rotation) et 312(deux rotations). La moyenne de ceux-ci est (123 + 231 + 312) / 3ou222 .

Comme autre exemple, prenez 4928. Les rotations sont 4928, 9284, 2849et 8492. Prendre la moyenne de ces quatre nombres est égal 6388.25.

Pour un autre exemple, pour les entrées 445445, les rotations sont dédupliquées 445445, 454454et 544544, de sorte que la sortie est 481481.

Pour l'entrée 777, il n'y a qu'une seule rotation dédupliquée, donc la sortie l'est 777.

Règles

• Le cas échéant, vous pouvez supposer que l'entrée / sortie s'adaptera au type Integer natif de votre langue.
• L'entrée et la sortie peuvent être fournies par n'importe quelle méthode pratique .
• Un programme complet ou une fonction sont acceptables. S'il s'agit d'une fonction, vous pouvez renvoyer la sortie plutôt que de l'imprimer.
• Les failles standard sont interdites.
• Il s'agit de code-golf, donc toutes les règles de golf habituelles s'appliquent et le code le plus court (en octets) l'emporte.

Python 3 , 38 36 octets

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

Prend les chiffres comme arguments séparés. Merci à @Rod d'avoir suggéré Python 3, économisant 2 octets.

Essayez-le en ligne!

APL (Dyalog) , 9 octets

10⊥≢⍴+/÷≢

Une fonction monadique prenant comme argument un vecteur de chiffres.

Essayez-le en ligne!

Je prends la moyenne des chiffres +/÷≢, puis je la répète par la longueur de l'entrée ≢⍴, et enfin convertis à partir de la base 10.

Conceptuellement, je prends la somme des rotations (sans porter):

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

Ceci est simplement 4+2+9+8répété 4 fois. Puis conversion de la base 10(qui fait le transport pour moi) et division par la longueur. Bien que je divise par la longueur plus tôt, car elle est équivalente et économise des octets.

Java 10, 163 137 76 72 71 71 octets

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

-36 octets grâce à @Nevay .
-61 octets grâce à @ OlivierGrégoire en créant un portage de réponse @Dennis 'Python 3 .
-1 octets en prenant l'entrée comme une liste de chiffres au lieu d'une chaîne.

Explication:

Essayez-le en ligne.

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 octets

d´MKA

Essayez-le en ligne!

Explication

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 octets

A§modṙŀ

Essayez-le en ligne!

Explication

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 octets

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

Essayez-le en ligne!

Saisie sous forme de liste de chiffres.

Merci à MickyT pour avoir rasé 11 octets! 8 octets rasés par la preuve de Dennis que la déduplication n'est pas nécessaire.

05AB1E , 9 octets

vÀD}\OIg/

Essayez-le en ligne!

Stax , 6 octets

ñJä⌠╤►

Exécuter et déboguer

Ce programme prend en entrée une chaîne délimitée par des guillemets et exprime la moyenne sous forme de fraction réduite. par exemple777/1 il n'est pas nécessaire de dédoublonner les rotations. Cela ne change jamais le résultat.

Déballé, non golfé et commenté, il ressemble à ceci.

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

Exécutez celui-ci

Perl 6 , 15 octets

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

Essayez-le en ligne!

La moyenne est la moyenne des chiffres appliquée à chaque position décimale, donc la moyenne des chiffres multipliée par 111 ... 1 x $_ produit une chaîne de 1 qui est forcée aux chaînes par la multiplication.

Prend une liste de chiffres en entrée. Une séquence nécessiterait un .cache avant la somme, et une entrée de nombre ou de chaîne aurait besoin d'un .comb.

Wolfram Language (Mathematica) , 22 octets

FromDigits[0#+Mean@#]&

Essayez-le en ligne!

JavaScript (Node.js) , 43 octets

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

Essayez-le en ligne!

Pouvons-nous prendre la saisie comme une liste de chiffres? - Dennis ♦ il y a 7 minutes

@ Dennis Bien sûr, ça va. Allez enregistrer quelques octets. : p - AdmBorkBork Il y a 3 minutes

Gelée , 6 5 octets

ṙJḌÆm

Essayez-le en ligne!

Comment ça fonctionne

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

Prend l'entrée comme un tableau de chaînes à un chiffre.

xpUÊ)÷UÊ

Essayez-le

Explication

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

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

Essayez-le en ligne!

Fonction de préfixe tacite. Prend l'entrée sous forme de chaîne.

Merci à Adám pour une sauvegarde éclairante de 7 octets .

Comment?

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

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

EDIT: -6 octets grâce à @ovs

Fusain , 11 octets

Ｉ∕×ΣθＩ⭆θ1Ｌθ

Essayez-le en ligne! Le lien est vers la version détaillée du code. Explication:

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

10#.#$+/%#

Ceci est un portage de la grande solution APL de H.PWiz à J.

Prend une liste de chiffres comme argument.

Explication:

+/%#la moyenne des chiffres (divisez %la somme des chiffres +/par leur nombre #)

#$crée une liste de copies de la moyenne en fonction du nombre de chiffres

10#. convertir la base de formulaire 10

Essayez-le en ligne!

Perl 5 -lpF , 24 22 octets

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

Essayez-le en ligne!

Le faire sous forme de liste de chiffres n'est que d'un octet plus court et ressemble à de la triche:

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

Essayez-le en ligne!

Rubis , 60 octets

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

Essayez-le en ligne!

Pari / GP , 34 octets

Prend la saisie sous forme de liste de chiffres.

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

Essayez-le en ligne!

Rubis , 33 octets

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

Essayez-le en ligne!

Un port de la réponse Python 3 de Dennis

Voici ma tentative boiteuse (74 octets)

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

Essayez-le en ligne!

C ++, 218 208 octets

-10 octets grâce à 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();}

Et, pour tester:

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

Pyth, 12 octets

csms.<zdlzlz

Probablement améliorable.

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

Essayez-le ici!

J, 23 octets

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

Prend l'entrée sous forme de chaîne

Explication

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

Matlab, 65 octets

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

Je vais y travailler, je suis sûr que cela peut être mieux fait.

Clojure, 139 octets

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

Fonctionnalités de langage assez peu optimales pour convertir des séquences de caractères en nombres entiers.

dc, 37 octets

Il s'agit d'un programme complet, lisant l'entrée et imprimant la sortie:

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

Il fonctionne en séparant le nombre en ses chiffres et en multipliant la moyenne des chiffres par le chiffre de longueur approprié (qui est construit au dfur et à mesure).

?                               # 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