Media rotazionale

18

Dato un intero di input n >= 10, genera la media di tutte le rotazioni deduplicate dell'intero.

Ad esempio, per l'input 123, le rotazioni sono 123(nessuna rotazione), 231(una rotazione) e 312(due rotazioni). La media di quelli è (123 + 231 + 312) / 3o 222.

Come altro esempio, prendi 4928. Le rotazioni sono 4928, 9284, 2849e 8492. Prendendo la media di questi quattro numeri è uguale 6388.25.

Per un altro esempio, per l'ingresso 445445, le rotazioni sono deduplicati 445445, 454454e 544544, e il suo output 481481.

Per l'input 777, esiste una sola rotazione deduplicata, quindi l'output è 777.

Regole

Se applicabile, puoi supporre che l'input / output si adatti al tipo intero nativo della tua lingua.
L'input e l'output possono essere forniti con qualsiasi metodo conveniente .
È accettabile un programma completo o una funzione. Se una funzione, è possibile restituire l'output anziché stamparlo.
Sono vietate le scappatoie standard .
Si tratta di code-golf quindi si applicano tutte le normali regole del golf e vince il codice più breve (in byte).

code-golf math number-theory

— AdmBorkBork
fonte

Possiamo prendere input come un elenco di cifre?

— Dennis,

3

@Dennis Certo, va bene. Vai a salvare alcuni byte. : p

— AdmBorkBork

3

Hai un esempio in cui la deduplicazione modifica effettivamente l'output? Nel tuo esempio 445445, ogni 3 rotazioni univoche avvengono due volte, quindi lasciarle non cambia l'output.

— Kaldo,

@Kaldo No, non sono stato in grado di crearne (manualmente) uno, ma ciò non significa che non ne esista uno, quindi ho lasciato in atto le regole di deduplicazione.

— AdmBorkBork,

13

@Kaldo Sia d sia il numero di cifre di n e k il più piccolo intero positivo tale che ruotando n k cifre a sinistra riproduce n . Prendi q e 0 ≤ r <k tale che d = qk + r . Ruotando di n sia le cifre d che qk verso sinistra, si deve ottenere n , quindi r = 0 . Ciò significa che ogni rotazione univoca si verifica q volte, quindi non è necessario deduplicare le rotazioni per calcolare la media.

— Dennis,

Risposte:

11

Python 3 , 38 36 byte

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

Prende le cifre come argomenti separati. Grazie a @Rod per aver suggerito Python 3, risparmiando 2 byte.

Provalo online!

— Dennis
fonte

È possibile salvare un byte aggiuntivo tornando a Python 2 e prendendo una matrice di float.

— Dennis,

Non hai bisogno di prendere le cifre come argomenti separati, una vecchia lista normale va bene

— Asone Tuhid

9

APL (Dyalog) , 9 byte

10⊥≢⍴+/÷≢

Una funzione monadica che prende come argomento un vettore di cifre.

Provalo online!

Prendo la media delle cifre +/÷≢, quindi la ripeto per la lunghezza dell'input ≢⍴e infine converto dalla base 10.

Concettualmente, sto prendendo la somma delle rotazioni (senza trasportare):

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

Questo è solo 4+2+9+8ripetuto 4 volte. Quindi la conversione dalla base 10(che fa il trasporto per me) e la divisione per la lunghezza. Anche se divido per la lunghezza in precedenza perché è equivalente e salva byte.

— H.PWiz
fonte

1

È geniale: D

— Leo,

@Leo FWIW le risposte che moltiplicano la media per una cifra rep stanno sostanzialmente facendo la stessa cosa

— H.Pwiz

3

Java 10, 163 137 76 72 71 byte

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

-36 byte grazie a @Nevay .
-61 byte grazie a @ OlivierGrégoire creando un port della risposta Python 3 di @Dennis .
-1 byte prendendo l'input come Elenco di cifre anziché String.

Spiegazione:

Provalo 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

— Kevin Cruijssen
fonte

1

151 byte:

n->{var s=new java.util.HashSet();var r=0d;for(int l=n.length(),x;l-->0;)if(s.add(x=new Integer(n=n.substring(1)+n.charAt(0))))r+=x;return r/s.size();}

avvicinamento al flusso con 137 byte:

n->java.util.stream.IntStream.range(0,n.length()).map(i->new Integer(n.substring(i)+n.substring(0,i))).distinct().average().getAsDouble()

— Nevay,

1

Usa orElse(0)invece di getAsDouble().

— Olivier Grégoire,

69 byte , in base alla soluzione altrui. Arrotondare usando (int)per 5 byte mote, se necessario.

— Olivier Grégoire,

Non è necessario eseguire il cast come doppio: Math.powgià se ne occupa. Ciò ti risparmierà 3 byte.

— Olivier Grégoire,

@ OlivierGrégoire Se lo faccio, darò risultati errati. Viene utilizzato il cast su int in modo che possiamo integer -divide per 9 e moltiplicare per la somma delle cifre. Solo allora dovrebbe raddoppiare per ottenere la media. Se rimuovo entrambi (int)e *.1sarà ad esempio output 6388.888...anziché 6388.25per l'input 4928. E se invece eseguo il cast dell'intero oggetto o solo del .powverso int, verrà emesso 6388.

— Kevin Cruijssen,

3

Buccia , 5 byte

d´MKA

Provalo online!

Spiegazione

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

Buccia , 7 byte

A§modṙŀ

Provalo online!

Spiegazione

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

— Fyr
fonte

1

Per un puzzle, esiste almeno una 5soluzione di byte

— H.Pwiz,

@ H.PWiz Non riesco a capirlo, potresti dare un suggerimento? : P

— Leone,

@Leo Non c'è ṙo ŀ, e il primo personaggio (a sinistra) non èA

— H.Pwiz

3

R , 84 73 64 byte

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

Provalo online!

Immettere come elenco di cifre.

Grazie a MickyT per la rasatura di 11 byte! 8 byte raccolti dalla prova di Dennis secondo cui la deduplicazione non è necessaria.

— Giuseppe
fonte

Con un modo leggermente diverso di ruotare il numero per 73

— MickyT

@MickyT aaahhh uso intelligente del riciclo!

— Giuseppe,

@MickyT array(D,K+1:0)è più corto di matrix(D,K+1,K)un byte.

— Giuseppe,

2

05AB1E , 9 byte

vÀD}\OIg/

Provalo online!

— Kaldo
fonte

vcon no y, interessante.

— Magic Octopus Urn,

gFÀD})¨Osg/era dove stavo pensando.

— Magic Octopus Urn,

Sai come usare .æ = pop a compute permutations by function, usage: .æ<FUNC>}ancora il comando? Nemmeno io, ma sembra adatto a questo.

— Magic Octopus Urn,

@MagicOctopusUrn v senza y è la soluzione più breve che ho trovato per eseguire i tempi di rotazione g (input). Sto controllando il .æ, non sembra che stia registrando <FUNC>}

— Kaldo,

2

Stax , 6 byte

ñJä⌠╤►

Esegui ed esegui il debug

Questo programma accetta come input una stringa delimitata da virgole ed esprime la media come frazione ridotta. es. 777/1 Non è necessario de-duplicare le rotazioni. Non cambia mai il risultato.

Disimballato, non golfato e commentato, sembra così.

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

— ricorsivo
fonte

2

Perl 6 , 15 byte

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

Provalo online!

La media è la media delle cifre applicata a ciascuna posizione decimale, quindi la media delle cifre per 111 .... 1 x $_produce una stringa di 1s che viene forzata in stringhe dal moltiplicare.

Prende un elenco di cifre come input. Una sequenza richiederebbe un .cache prima della somma e un numero o input di stringa avrebbe bisogno di un .comb.

— Phil H
fonte

2

Wolfram Language (Mathematica) , 22 byte

FromDigits[0#+Mean@#]&

Provalo online!

— alephalpha
fonte

1

JavaScript (Node.js) , 43 byte

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

Provalo online!

Possiamo prendere l'input come un elenco di cifre? - Dennis ♦ 7 minuti fa

@Dennis Certo, va bene. Vai a salvare alcuni byte. : p - AdmBorkBork 3 minuti fa

— l4m2
fonte

1

Gelatina , 6 5 byte

ṙJḌÆm

Provalo online!

Come funziona

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

— Dennis
fonte

1

Japt , 8 byte

Accetta l'input come una matrice di stringhe a una cifra.

xpUÊ)÷UÊ

Spiegazione

             :Implicit input of array U
 pUÊ         :Repeat each string length of U times
x   )        :Reduce by addition
     ÷UÊ     :Divide by the length of U

— ispido
fonte

1

APL (Dyalog Unicode) , 21 14 byte ^SBCS

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

Provalo online!

Funzione prefisso tacita. Accetta l'input come stringa.

Grazie ad Adám per un illuminante salvataggio di 7 byte .

Come?

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

— J. Sallé
fonte

: | non riesco ancora ad abituarmi ai commenti APL

— solo ASCII il

1

Python 2, 83 77 byte

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

EDIT: -6 byte grazie a @ovs

— sonrad10
fonte

35, soluzione di Dennis , 38, non soluzione di Dennis

— solo ASCII il

1

Carbone , 11 byte

Ｉ∕×ΣθＩ⭆θ1Ｌθ

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

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

— Neil
fonte

1

J , 10 byte

10#.#$+/%#

Questa è una porta della grande soluzione APL di H.PWiz per J.

Prende un elenco di cifre come argomento.

Spiegazione:

+/%#la media delle cifre (dividere %la somma delle cifre +/per il loro numero #)

#$crea un elenco di copie della media in base al numero di cifre

10#. converti dalla base 10

Provalo online!

— Galen Ivanov
fonte

1

Perl 5 `-lpF` , 24 22 byte

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

Provalo online!

Farlo come un elenco di cifre è solo di 1 byte più corto e sembra come imbrogliare:

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

Provalo online!

— Ton Hospel
fonte

cosa usrt? : P

— ASCII il

@ Solo ASCII Aspetta, non hai i tuoi eseguibili nella /usrtdirectory? Comunque, riparato. Grazie

— Ton Hospel,

1

Rubino , 60 byte

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

Provalo online!

— GB
fonte

1

Pari / GP , 34 byte

Accetta input come un elenco di cifre.

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

Provalo online!

— alephalpha
fonte

1

Rubino , 33 byte

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

Provalo online!

Un port della risposta Python 3 di Dennis

Ecco il mio tentativo zoppo (74 byte)

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

Provalo online!

— Solo Tuhid
fonte

1

C ++, 218 208 byte

-10 byte grazie 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, per testare:

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

— HatsuPointerKun
fonte

1

Non hai bisogno di spazi tra #includee <, e si può rimuovere il {}giro sia ++c;e s+=v;. Potresti essere in grado di spostarti int s=0all'inizio con le altre variabili.

— Zacharý,

1

Inoltre, non penso che tu abbia bisogno del n=0secondo nel ciclo, come avrebbe dovuto raggiungere 0da allora. m/=10;m+=std::pow(10.f,c-1)*t;=> m=m/10+std::pow(10.f,c-1)*t. E non usare al intposto del autolavoro?

— Zacharý,

Puoi ancora spostarti int s=0;con le altre variabili e hai bisogno delle parentesi graffe intorno al s+=v;?

— Zacharý,

168 byte

— plafoniera

n>0=> npotrebbe funzionare.

— Zacharý,

0

Pyth, 12 byte

csms.<zdlzlz

Probabilmente migliorabile.

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

— RK.
fonte

There's a built-in average function o. If you do that and do I/O as lists of digits, you can get it down to 8 bytes.

Ah, I was taking "If applicable, you can assume that the input/output will fit in your language's native Integer type." to mean that it had to be an integer if taken in as Q.

— RK.

0

J, 23 Bytes

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

Takes input as a string

Explanation

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

— Bolce Bussiere
fonte

0

Matlab, 65 bytes

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

Gonna work on this, pretty sure it can be done better.

— Leander Moesinger
fonte

0

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

Quite sub-optimal language features for converting sequences of characters to integers.

— NikoNyrh
fonte

0

dc, 37 bytes

This is a full program, reading input and printing the output:

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

It works by separating the number into its digits, and multiplying the mean of the digits by the appropriate length repdigit (which is built up in d as we go).

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

— Toby Speight
fonte

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.

Licensed under cc by-sa 3.0 with attribution required.