Dado un entero de entrada n >= 10, genera el promedio de todas las rotaciones deduplicadas del entero.

Por ejemplo, para la entrada 123, las rotaciones son 123(sin rotación), 231(una rotación) y 312(dos rotaciones). El promedio de esos es (123 + 231 + 312) / 3o 222.

Como otro ejemplo, tómalo 4928. Las rotaciones son 4928, 9284, 2849, y 8492. Tomar el promedio de esos cuatro números es igual 6388.25.

Para otro ejemplo, para la entrada 445445, las rotaciones deduplicados son 445445, 454454, y 544544, por lo que la salida es 481481.

Para la entrada 777, solo hay una rotación deduplicada, por lo que la salida es 777.

Reglas

• Si corresponde, puede suponer que la entrada / salida se ajustará al tipo entero nativo de su idioma.
• La entrada y salida se pueden dar por cualquier método conveniente .
• Un programa completo o una función son aceptables. Si es una función, puede devolver el resultado en lugar de imprimirlo.
• Las lagunas estándar están prohibidas.
• Este es el código de golf, por lo que se aplican todas las reglas habituales de golf, y gana el código más corto (en bytes).

Python 3 , 38 36 bytes

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

Toma los dígitos como argumentos separados. Gracias a @Rod por sugerir Python 3, ahorrando 2 bytes.

Pruébalo en línea!

APL (Dyalog) , 9 bytes

10⊥≢⍴+/÷≢

Una función monádica que toma un vector de dígitos como argumento.

Pruébalo en línea!

Tomo el promedio de los dígitos +/÷≢, luego lo repito por la longitud de la entrada ≢⍴y finalmente convierto desde la base 10.

Conceptualmente, estoy tomando la suma de las rotaciones (sin llevar):

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

Esto solo se 4+2+9+8repite 4 veces. Luego, convertir desde la base 10(que hace el transporte por mí) y dividir por la longitud. Aunque divido por la longitud anterior porque es equitativo y guarda bytes.

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 gracias a @Nevay .
-61 bytes gracias a @ OlivierGrégoire al crear un puerto de @Dennis 'Python 3 respuesta .
-1 bytes tomando la entrada como una Lista de dígitos en lugar de String.

Explicación:

Pruébalo en línea.

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

Casco , 5 bytes

d´MKA

Pruébalo en línea!

Explicación

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

Casco , 7 bytes

A§modṙŀ

Pruébalo en línea!

Explicación

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

Pruébalo en línea!

Entrada como lista de dígitos.

¡Gracias a MickyT por reducir 11 bytes! 8 bytes afeitados por la prueba de Dennis de que la deduplicación es innecesaria.

05AB1E , 9 bytes

vÀD}\OIg/

Pruébalo en línea!

Stax , 6 bytes

ñJä⌠╤►

Ejecutar y depurarlo

Este programa toma una cadena delimitada por comillas como entrada y expresa el promedio como una fracción reducida. Por ejemplo 777/1 , no es necesario desduplicar las rotaciones. Nunca cambia el resultado.

Desempaquetado, sin golf y comentado, se ve así.

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

Ejecute este

Perl 6 , 15 bytes

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

Pruébalo en línea!

El promedio es el promedio de dígitos aplicado a cada posición decimal, por lo que el promedio de dígitos multiplicado por 111 ... 1 x $_produce una cadena de 1s que se multiplican por cadenas.

Toma una lista de dígitos como entrada. Una secuencia requeriría un .cache antes de la suma, y ​​una entrada de número o cadena necesitaría un .comb.

Wolfram Language (Mathematica) , 22 bytes

FromDigits[0#+Mean@#]&

Pruébalo en línea!

JavaScript (Node.js) , 43 bytes

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

Pruébalo en línea!

¿Podemos tomar la entrada como una lista de dígitos? - Dennis ♦ Hace 7 minutos

@ Dennis Claro, está bien. Ve a guardar algunos bytes. : p - AdmBorkBork Hace 3 minutos

Jalea , 6 5 bytes

ṙJḌÆm

Pruébalo en línea!

Cómo funciona

ṙ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

Toma la entrada como una matriz de cadenas de un solo dígito.

xpUÊ)÷UÊ

Intentalo

Explicación

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

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

Pruébalo en línea!

Función de prefijo tácito. Toma la entrada como una cadena.

Gracias a Adám por un ahorro esclarecedor de 7 bytes .

¿Cómo?

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

EDITAR: -6 bytes gracias a @ovs

Carbón , 11 bytes

Ｉ∕×ΣθＩ⭆θ1Ｌθ

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

    θ  θ  θ 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#.#$+/%#

Este es un puerto de la gran solución APL de H.PWiz para J.

Toma una lista de dígitos como argumento.

Explicación:

+/%#el promedio de los dígitos (divida %la suma de los dígitos +/por su número #)

#$crea una lista de copias del promedio de acuerdo con el número de dígitos

10#. convertir formulario base 10

Pruébalo en línea!

Perl 5 -lpF , 24 22 bytes

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

Pruébalo en línea!

Hacerlo como una lista de dígitos es solo 1 byte más corto y se siente como hacer trampa:

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

Pruébalo en línea!

Rubí , 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}

Pruébalo en línea!

Pari / GP , 34 bytes

Toma la entrada como una lista de dígitos.

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

Pruébalo en línea!

Rubí , 33 bytes

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

Pruébalo en línea!

Un puerto de la respuesta Python 3 de Dennis

Aquí está mi intento cojo (74 bytes)

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

Pruébalo en línea!

C ++, 218 208 bytes

-10 bytes gracias a 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();}

Y, para probar:

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

Pyth, 12 bytes

csms.<zdlzlz

Probablemente mejorable.

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

Pruébalo aquí!

J, 23 bytes

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

Toma la entrada como una cadena

Explicación

          (|."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)))

Voy a trabajar en esto, bastante seguro de que se puede hacer mejor.

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

Funciones de lenguaje bastante subóptimas para convertir secuencias de caracteres en enteros.

cc, 37 bytes

Este es un programa completo, que lee la entrada e imprime la salida:

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

Funciona separando el número en sus dígitos y multiplicando la media de los dígitos por el digito de longitud apropiado (que se acumula a dmedida que avanzamos).

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