Bir girdi tamsayı verildiğinde, tamsayıdaki n >= 10tüm tekilleştirilen rotasyonların ortalamasını alın.

Örneğin, giriş 123için dönüşler 123(dönüş yok), 231(bir dönüş) ve 312(iki dönüş) şeklindedir. Bunların ortalaması (123 + 231 + 312) / 3veya 222.

Başka bir örnek olarak alın 4928. Rotasyonları vardır 4928, 9284, 2849, ve 8492. Bu dört sayının ortalamasını almak eşittir 6388.25.

Başka bir örnek olarak, giriş için 445445, deduplicated rotasyonlar vardır 445445, 454454ve 544544çıkış, bu yüzden 481481.

Giriş 777için tek bir yinelenen tekil döndürme vardır, bu nedenle çıkış olur 777.

kurallar

• Varsa, giriş / çıktının dilinizin yerel Tamsayı türüne uygun olacağını varsayabilirsiniz.
• Giriş ve çıkış herhangi bir uygun yöntemle verilebilir .
• Tam bir program veya bir işlev kabul edilebilir. Bir işlev varsa, çıktıyı yazdırmak yerine döndürebilirsiniz.
• Standart boşluklar yasaktır.
• Bu kod golfüdür, bu nedenle her zamanki golf kuralları geçerlidir ve en kısa kod (bayt cinsinden) kazanır.

Python 3 , 38 36 bayt

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

Basamakları ayrı argümanlar olarak alır. @Rod sayesinde Python 3'ü önerdiği için 2 bayt tasarruf etti.

Çevrimiçi deneyin!

APL (Dyalog) , 9 bayt

10⊥≢⍴+/÷≢

Bağımsız değişken olarak bir basamak vektörü alan monadik bir fonksiyon.

Çevrimiçi deneyin!

Rakamların ortalamasını alıyorum +/÷≢, daha sonra giriş uzunluğuna göre tekrar ediyorum ≢⍴ve son olarak taban 10'dan dönüştürüyorum.

Kavramsal olarak, rotasyonların toplamını alıyorum (taşımadan):

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

Bu sadece 4+2+9+84 kez tekrarlanır. Sonra tabandan dönüştürme 10(benim için taşıma yapar) ve uzunluğa bölünür. Her ne kadar uzunluğa göre bölünsem de, eşit olduğu ve bayt tasarrufu sağladığı için.

Java 10, 163 137 76 72 71 bayt

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

@Nevay sayesinde -36 bayt .
-61 sayesinde bayt @ OlivierGrégoire bir port oluşturarak @Dennis 'Python 3 cevap .
Girdi, String yerine bir rakam listesi olarak alınarak -1 bayt.

Açıklama:

Çevrimiçi deneyin.

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

Kabuk , 5 bayt

d´MKA

Çevrimiçi deneyin!

açıklama

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

Kabuk , 7 bayt

A§modṙŀ

Çevrimiçi deneyin!

açıklama

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 bayt

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

Çevrimiçi deneyin!

Rakam listesi olarak girin.

11 baytlık tıraş için MickyT'a teşekkürler! 8 bayt, Dennis'in tekilleştirmenin gereksiz olduğuna dair kanıtıyla tıraş edildi.

05AB1E , 9 bayt

vÀD}\OIg/

Çevrimiçi deneyin!

Stax , 6 bayt

ñJä⌠╤►

Çalıştır ve hata ayıkla

Bu program girdi olarak bir alıntı ile sınırlandırılmış dize alır ve ortalamayı azaltılmış bir kesir olarak ifade eder. Örneğin777/1 , dönüşlerin çoğaltılması gerekli değildir. Sonucu asla değiştirmez.

Ambalajından çıkarılmış, golf edilmemiş ve yorum yapılmış gibi görünüyor.

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

Bunu çalıştır

Perl 6 , 15 bayt

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

Çevrimiçi deneyin!

Ortalama, her ondalık konuma uygulanan basamak ortalamasıdır, bu nedenle basamak ortalaması 111'dir. 1 x $_ , çarpma ile dizelere zorlanan 1 saniyelik bir dize üretir.

Rakamların bir listesini girdi olarak alır. Bir sekans, toplamdan önce bir .cache gerektirir ve bir sayı veya dize girişinin .comb olması gerekir.

Wolfram Dili (Mathematica) , 22 bayt

FromDigits[0#+Mean@#]&

Çevrimiçi deneyin!

JavaScript (Node.js) , 43 bayt

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

Çevrimiçi deneyin!

Girdileri rakam listesi olarak alabilir miyiz? - Dennis ♦ 7 dakika önce

@Dennis Tabii, sorun değil. Git biraz bayt kaydet. : p - AdmBorkBork 3 dakika önce

Jöle , 6 5 bayt

ṙJḌÆm

Çevrimiçi deneyin!

Nasıl çalışır

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

Girişi tek haneli dizelerden oluşan bir dizi olarak alır.

xpUÊ)÷UÊ

Dene

açıklama

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

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

Çevrimiçi deneyin!

Ön ek önek işlevi. Girişi dize olarak alır.

Aydınlatıcı 7 baytlık tasarruf için Adám'a teşekkürler .

Nasıl?

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

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

EDIT: @ovs sayesinde -6 bayt

Kömür , 11 bayt

Ｉ∕×ΣθＩ⭆θ1Ｌθ

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı versiyonudur. Açıklama:

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

10#.#$+/%#

Bu, H.PWiz'in J için harika APL çözümünün bir limanıdır.

Bağımsız değişken olarak rakamların listesini alır.

Açıklama:

+/%#basamak ortalama (bölmek %basamak toplamı +/sayılarına göre #)

#$basamak sayısına göre ortalamanın kopyalarının bir listesini oluşturur

10#. form tabanı 10 dönüştürmek

Çevrimiçi deneyin!

Perl 5 -lpF , 24 22 bayt

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

Çevrimiçi deneyin!

Rakamların bir listesi olarak yapmak sadece 1 bayt daha kısa ve hile gibi geliyor:

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

Çevrimiçi deneyin!

Yakut , 60 bayt

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

Çevrimiçi deneyin!

Pari / GP , 34 bayt

Girdiyi rakam listesi olarak alır.

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

Çevrimiçi deneyin!

Ruby , 33 bayt

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

Çevrimiçi deneyin!

Bir liman Dennis'in Python 3 cevabı

İşte topallama girişimim (74 bayt)

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

Çevrimiçi deneyin!

C ++, 218 bayt

Zacharý sayesinde -10 bayt

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

Ve test etmek için:

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

Pyth, 12 bayt

csms.<zdlzlz

Muhtemelen geliştirilebilir.

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

Burada deneyin!

J, 23 Bayt

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

Girişi dize olarak alır

açıklama

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

Matlab, 65 bayt

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

Bunun üzerinde çalışacağım, daha iyi yapılabileceğinden eminim.

Clojure, 139 bayt

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

Karakter dizilerini tamsayılara dönüştürmek için oldukça uygun olmayan dil özellikleri.

dc, 37 bayt

Bu tam bir program, girişi okumak ve çıktıyı yazdırmak:

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

Sayıyı rakamlarına ayırarak ve rakamların ortalamasını uygun uzunluktaki repdigit ile çarparak çalışır (ki bu da dilerledikçe oluşturulur).

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