Dado um número inteiro de entrada n >= 10, produza a média de todas as rotações deduplicadas do número inteiro.

Por exemplo, para entrada 123, as rotações são 123(sem rotação), 231(uma rotação) e 312(duas rotações). A média desses é (123 + 231 + 312) / 3ou 222.

Como outro exemplo, tome 4928. As rotações são 4928, 9284, 2849, e 8492. Tomando a média desses quatro números é igual 6388.25.

Para um outro exemplo, para a entrada 445445, as rotações são deduplicados 445445, 454454, e 544544, portanto, a saída é 481481.

Para entrada 777, há apenas uma rotação deduplicada, portanto a saída é 777.

Regras

• Se aplicável, você pode supor que a entrada / saída caiba no tipo Inteiro nativo do seu idioma.
• A entrada e saída podem ser fornecidas por qualquer método conveniente .
• Um programa completo ou uma função são aceitáveis. Se uma função, você pode retornar a saída em vez de imprimi-la.
• As brechas padrão são proibidas.
• Isso é código-golfe, portanto todas as regras usuais de golfe se aplicam e o código mais curto (em bytes) vence.

Python 3 , 38 36 bytes

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

Aceita os dígitos como argumentos separados. Obrigado a @Rod por sugerir Python 3, economizando 2 bytes.

Experimente online!

APL (Dyalog) , 9 bytes

10⊥≢⍴+/÷≢

Uma função monádica tomando um vetor de dígitos como argumento.

Experimente online!

Pego a média dos dígitos +/÷≢, repito-a pelo comprimento da entrada ≢⍴e, finalmente, converto da base 10.

Conceitualmente, estou tomando a soma das rotações (sem carregar):

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

Isso é 4+2+9+8repetido apenas 4 vezes. Em seguida, convertendo da base 10(que carrega para mim) e dividindo pelo comprimento. Embora eu divida pelo comprimento anteriormente, porque é equivalente e salva 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 graças a @Nevay .
-61 bytes graças a @ OlivierGrégoire , criando uma porta de resposta do @Dennis 'Python 3 .
-1 bytes, tomando a entrada como uma lista de dígitos em vez de String.

Explicação:

Experimente online.

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

Casca , 5 bytes

d´MKA

Experimente online!

Explicação

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

Casca , 7 bytes

A§modṙŀ

Experimente online!

Explicação

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

Experimente online!

Insira como lista de dígitos.

Obrigado ao MickyT por remover 11 bytes! 8 bytes raspados pela prova de Dennis de que a desduplicação é desnecessária.

05AB1E , 9 bytes

vÀD}\OIg/

Experimente online!

Stax , 6 bytes

ñJä⌠╤►

Execute e depure

Este programa usa uma string delimitada por aspas como entrada e expressa a média como uma fração reduzida. Por exemplo 777/1 , não é necessário duplicar as rotações. Isso nunca muda o resultado.

Descompactado, não jogado e comentado, parece com isso.

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

Execute este

Perl 6 , 15 bytes

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

Experimente online!

A média é a média de dígitos aplicada a cada posição decimal, portanto, a média dos dígitos vezes 111 .... 1 x $_produz uma sequência de 1s que é coagida pelas seqüências pela multiplicação.

Leva uma lista de dígitos como entrada. Uma sequência exigiria um .cache antes da soma, e uma entrada de número ou sequência precisaria de um .comb.

Wolfram Language (Mathematica) , 22 bytes

FromDigits[0#+Mean@#]&

Experimente online!

JavaScript (Node.js) , 43 bytes

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

Experimente online!

Podemos considerar a entrada como uma lista de dígitos? - Dennis ♦ 7 mins atrás

@ Dennis Claro, tudo bem. Vá salvar alguns bytes. : p - AdmBorkBork 3 mins atrás

Gelatina , 6 5 bytes

ṙJḌÆm

Experimente online!

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

Japonês , 8 bytes

Recebe a entrada como uma matriz de cadeias de um dígito.

xpUÊ)÷UÊ

Tente

Explicação

             :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

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

Experimente online!

Função de prefixo tácito. Recebe a entrada como uma sequência.

Agradecemos a Adám por uma economia esclarecedora de 7 bytes .

Quão?

+/≢÷⍨⍳∘≢(⍎⌽)¨⊂ ⍝ 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 graças a @ovs

Carvão , 11 bytes

Ｉ∕×ΣθＩ⭆θ1Ｌθ

Experimente online! Link é a versão detalhada do código. Explicação:

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

Esta é uma porta da ótima solução de APL da H.PWiz para a J.

Leva uma lista de dígitos como argumento.

Explicação:

+/%#a média dos dígitos (divida %a soma dos dígitos +/pelo número #)

#$cria uma lista de cópias da média de acordo com o número de dígitos

10#. converter base de formulário 10

Experimente online!

Perl 5 -lpF , 24 22 bytes

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

Experimente online!

Fazer isso como uma lista de dígitos é apenas 1 byte mais curto e parece trapaça:

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

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

Experimente online!

Pari / GP , 34 bytes

Recebe a entrada como uma lista de dígitos.

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

Experimente online!

Ruby , 33 bytes

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

Experimente online!

Um porto de resposta Dennis's Python 3

Aqui está minha tentativa de coxo (74 bytes)

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

Experimente online!

C ++, 218 208 bytes

-10 bytes graças 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();}

E, para testar:

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

Pitão, 12 bytes

csms.<zdlzlz

Provavelmente improvável.

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

Experimente aqui!

J, 23 bytes

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

Recebe entrada como uma string

Explicação

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

Vou trabalhar nisso, com certeza pode ser melhor.

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

Recursos de linguagem bastante otimizados para converter seqüências de caracteres em números inteiros.

dc, 37 bytes

Este é um programa completo, lendo a entrada e imprimindo a saída:

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

Ele funciona separando o número em seus dígitos e multiplicando a média dos dígitos pelo repdigit de comprimento apropriado (que é construído à dmedida que avançamos).

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