10

Diciamo che questo array è il numero di flessioni che ho realizzato ogni giorno negli ultimi 28 giorni:

[
  20,20,20,30,30,30,30,
  35,35,40,40,40,45,45,
  50,50,50,50,50,50,50,
  60,70,80,90,100,110,120
]

Come puoi vedere, ha avuto una forte tendenza al rialzo nell'ultima settimana, e questa è la parte di questi dati che mi interessa di più. Più in passato è, meno voglio che quei dati siano presenti nella mia 'media 'numero di flessioni.

A tal fine, voglio elaborare una "media" in cui ogni settimana valga più della settimana precedente.

Informazioni di base, non parte di questo problema.

Media normale:

La somma di tutti i valori / il numero di valori

Per sopra:

1440/28 = 51.42857142857143

Media ponderata:

Dividi l'array in 4 gruppi di 7 e avvia un nuovo array.

Aggiungi il primo gruppo all'array.
Aggiungi il secondo gruppo all'array due volte.
Aggiungi il terzo gruppo all'array tre volte.
Aggiungi il quarto gruppo all'array quattro volte.

Somma tutto il nuovo array e dividi per la lunghezza del nuovo array.

Per sopra:

Converti l'array in questo:

[
  20,20,20,30,30,30,30, # first week once
  35,35,40,40,40,45,45, 
  35,35,40,40,40,45,45, # second week twice
  50,50,50,50,50,50,50,
  50,50,50,50,50,50,50,
  50,50,50,50,50,50,50, # third week thrice
  60,70,80,90,100,110,120,
  60,70,80,90,100,110,120,
  60,70,80,90,100,110,120,
  60,70,80,90,100,110,120 # Fourth week four times
]

Quindi eseguire una media normale su quell'array.

4310/70 = 61.57142857142857

Si noti che è superiore al valore medio normale a causa della tendenza al rialzo dell'ultima settimana.

Le regole:

L'input è un array piatto di 28 numeri interi non negativi.
Qualsiasi lingua in cui desideri scrivere.
Emetti un numero.
Mi piace sempre vedere i link TIO .
Prova a risolvere il problema nel minor numero di byte.
Il risultato dovrebbe essere un decimale accurato di almeno 4 cifre decimali (troncato o arrotondato per eccesso dai valori del test case va bene) o una frazione esatta.

Casi test:

Caso 1: tendenza al rialzo

[
  20,20,20,30,30,30,30,
  35,35,40,40,40,45,45,
  50,50,50,50,50,50,50,
  60,70,80,90,100,110,120
]

Media normale: 51.42857142857143 Media ponderata: 61.57142857142857

Caso 2: lasciare indietro la pausa

(Ho avuto una brutta settimana, ma è stato un po 'di tempo fa)

[
  50,50,50,50,50,50,50,
  10,10,10,10,10,10,10,
  50,50,50,50,50,50,50,
  50,50,50,50,50,50,50
]

Media normale: 40 Media ponderata: 42

Caso 3: arrendersi

Ho avuto una brutta settimana, sta abbassando velocemente la mia media.

[
  50,50,50,50,50,50,50,
  50,50,50,50,50,50,50,
  50,50,50,50,50,50,50,
  10,10,10,10,10,10,10
]

Media normale: 40 Media ponderata: 34

Caso 4: calcolo della media

Va bene, quindi sto solo giocando qui, ho pensato che potesse avere lo stesso valore per le medie normali e ponderate, ma, ovviamente, non lo era.

[
  60,60,60,60,60,60,60,
  30,30,30,30,30,30,30,
  20,20,20,20,20,20,20,
  15,15,15,15,15,15,15
]

Media normale: 31,25 Media ponderata: 24,0

Problema bonus:

Quale combinazione di 28 valori avrebbe la stessa media normale e media ponderata?

Buon golf!

code-golf array-manipulation average

— AJFaraday
fonte

Continuiamo questa discussione in chat .

— AJFaraday,

1

Potresti voler provare anche il livellamento esponenziale - new_avg = α*weekly_sum + (1-α)*old_avgper alcuniα∈(0,1)

— Angs

2

Faccio 0flessioni ogni giorno, quindi la mia media ponderata è la stessa della mia media normale.

— Neil,

@Neil non trarrai beneficio dal sistema di media ponderata;)

— AJFaraday

1

fai attenzione a non sovraccaricare: p

— Brian H.

3

Buccia , 6 byte

AΣΣṫC7

Provalo online!

Usa il trucco usato da Dennis per superare la mia sottomissione di Jelly. Invece di ripetere ogni blocco N volte, recupera i suffissi dell'elenco di blocchi, che dopo l'appiattimento produrranno lo stesso risultato, ad eccezione dell'ordine.

— Mr. Xcoder
fonte

10

Python 3 , 38 byte

lambda x:sum(x+x[7:]+x[14:]+x[21:])/70

Provalo online!

— Dennis
fonte

5

05AB1E , 8 7 byte

Salvato 1 byte grazie a Mr. Xcoder

7ô.s˜ÅA

Provalo online!

Spiegazione

7ô         # split list into groups of 7
  .s       # push suffixes
    ˜      # flatten
     ÅA    # arithmetic mean

— Emigna
fonte

@ Mr.Xcoder: Oh sì, sapevo di aver visto una funzione cattiva, ma non riuscivo a trovarla: P

— Emigna,

4

Gelatina , 7 byte

s7ṫJFÆm

Provalo online!

Come funziona

s7ṫJFÆm  Main link. Argument: A (array of length 28)

s7       Split the array into chunks of length 7.
   J     Indices; yield [1, ..., 28].
  ṫ      Tail; yield the 1st, ..., 28th suffix of the result to the left.
         Starting with the 5th, the suffixes are empty arrays.
    F    Flatten the resulting 2D array.
     Æm  Take the arithmetic mean.

— Dennis
fonte

Eh, quindi x"J$è equivalente a ṫJin questo contesto. Interessante!

— Mr. Xcoder,

Una specie di. Invece di ripetere gli elementi dell'n -esimo array n volte, questo richiede tutti i suffissi. Dopo l'appiattimento, genera gli stessi elementi, ma in un ordine diverso.

— Dennis,

4

R + pryr, 32 28 byte

e lo stesso punteggio medio settimana su settimana comporterebbe l'uguaglianza dei mezzi.

pryr::f(s%*%rep(1:4,e=7)/70)

Provalo online!

Salvato 4 byte utilizzando il prodotto dot grazie a Giuseppe .

Pure R avrebbe altri due byte usando function

— Jayce
fonte

Certo che sarebbe così ovvio, ora ci penso.

— AJFaraday,

1

28 byte usando il prodotto punto anzichésum

— Giuseppe,

Ho avuto 40 byte confunction(s)weighted.mean(s,rep(1:4,e=7))

— Giuseppe,

1

@Giuseppe Per fortuna non me lo ricordavo weighted.mean. Lo Radoro quando superano i lupi Python.

— JayCe,

4

MATL , 10 byte

7es4:*s70/

Provalo online!

Non ho pubblicato una risposta MATL da anni! Ho pensato di poter partecipare come parte di LOTM a maggio 2018 !

Spiegazione:

7e          % Reshape the array into 7 rows (each week is one column)
  s         % Sum each column
   4:       % Push [1 2 3 4]
     *      % Multiply each columnar sum by the corresponding element in [1 2 3 4]
      s     % Sum this array
       70/  % Divide by 70

— Giacomo
fonte

Avevo anche K:7Y"*s70/10 byte.

— Giuseppe,

3

Gelatina , 9 byte

s7x"J$FÆm

Provalo online!

Come funziona

s7x "J $ FÆm - Riceve l'input dal primo argomento della riga di comando e lo invia a STDOUT.
s7 - Dividi in gruppi di 7.
   "- Applica vettorializzare (zipwith):
  x J $: ripete gli elementi di ciascun elenco un numero di volte uguale all'indice dell'elenco.
      F - Appiattire.
       --M - Media aritmetica.

— Mr. Xcoder
fonte

2

Haskell , 35 byte

(/70).sum.zipWith(*)([1..]<*[1..7])

Bonus: se a,b,c,dsono le somme settimanali, la media normale è la stessa della media ponderata iff:

(a + b + c + d)/4 = (a + 2b + 3c + 4d)/10  <=>
10(a + b + c + d) = 4(a + 2b + 3c + 4d)    <=>
5(a + b + c + d)  = 2(a + 2b + 3c + 4d)    <=>
5a + 5b + 5c + 5d = 2a + 4b + 6c + 8d      <=>
3a + b - c - 3d   = 0

Una soluzione è quando la prima e l'ultima settimana hanno le stesse somme, e allo stesso modo la seconda e la terza settimana hanno la stessa somma, ma ci sono infinite soluzioni se il tuo bicipite è all'altezza. Esempio: [15,10,10,10,10,10,5,20,20,20,25,25,20,20,30,20,20,20,20,20,20,20,10,10,20 , 0,10,10,10]

Provalo online!

— Angs
fonte

2

JavaScript (Node.js) , 49 byte

a=>a.map((x,i)=>(I+=d=-~(i/7),s+=x*d),s=I=0)&&s/I

Provalo online!

Soluzione non generica

JavaScript (Node.js) , 39 36 byte

a=>a.reduce((s,x,i)=>s+x*-~(i/7))/70

Provalo online!

— DanielIndie
fonte

1

-1 byte sulla prima soluzione usando a=>a.reduce((s,x,i)=>(I+=d=-~(i/7),s+x*d),I=0)/I. E un breve consiglio: usa <hr>per creare una linea orizzontale in markdown

— Herman L

@HermanL Cosa c'è che non va nell'uso ---(ha bisogno del proprio paragrafo)?

— Neil,

2

Stax , 6 byte

ñI"%"╟

Eseguilo e esegui il debug su staxlang.xyz!

Spacchettato (7 byte) e spiegazione:

7/|]$:V
7/         Split into groups of seven.
  |]       Suffixes
    $:V    Flatten and average. Implicit print as fraction.

— Khuldraeseth na'Barya
fonte

2

Stax , 10 8 byte

äΔ6◙█µøΓ

Esegui ed esegui il debug

Spiegazione (non imballata):

7/4R:B$:V Full program, implicit input
7/        Split into parts of length 7
  4R      Push [1, 2, 3, 4]
    :B    Repeat each element the corresponding number of times
      $   Flatten
       :V Average

— Wastl
fonte

1

Un altro con Stax! Sì! Puoi usare $per appiattire se gli elementi sono tutti numeri interi, controllando ora con OP.

— Khuldraeseth na'Barya,

2

Ottava , 33 byte

@(x)sum(reshape(x,7,4)*(1:4)')/70

Provalo online!

— Luis Mendo
fonte

2

Carbone , 14 byte

Ｉ∕ΣＥ⪪Ａ⁷×Σι⊕κ⁷⁰

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

     Ａ          Input array
    ⪪ ⁷         Split into subarrays of length 7
   Ｅ            Loop over each subarray
         ι      Subarray
        Σ       Sum
           κ    Loop index
          ⊕     Incremented
       ×        Product
  Σ             Sum results
            ⁷⁰  Literal 70
 ∕              Divide
Ｉ               Cast to string
                Implicitly print

— Neil
fonte

2

K4 / K (oK) , 19 16 14 byte

Soluzione:

+/(1+&4#7)%70%

Provalo online!

Esempio:

+/(1+&4#7)%70%50 50 50 50 50 50 50 10 10 10 10 10 10 10 50 50 50 50 50 50 50 50 50 50 50 50 50 50
42

Spiegazione:

La valutazione viene eseguita da destra a sinistra. Dividi 7 1s, 7 2s, 7 3s e 7 4s per 70 diviso per l'input; quindi riassumere.

+/(1+&4#7)%70% / the solution               
           70% / 70 divided by the input
  (      )%    / the stuff in brackets divided by this...
      4#7      / draw from 7, 4 times => 7 7 7 7
     &         / 'where' builds 7 0s, 7 1s, 7 2s, 7 3s
   1+          / add one
+/             / sum (+) over (/) to get the total

— streetster
fonte

2

Excel: 33 byte

(3 byte salvati dalla risposta di @ wernisch eseguendo i dati su 2 righe da A1: N1 e A2: N2)

=AVERAGE(A1:N2,H1:N2,A2:N2,H2:N2)

Ci scusiamo per non aver incluso questo come commento. Non ho abbastanza reputazione per farlo.

— dissemin8or
fonte

2

Japt , 11 10 byte

xÈ/#F*ÒYz7

Provalo

Spiegazione

 È             :Pass each element at index Y through a function
  /#F          :  Divide by 70
       Yz7     :  Floor divide Y by 7
      Ò        :  Negate the bitwise NOT of that to add 1
     *         :  Multiply both results
x               :Reduce by addition

— ispido
fonte

1

Triangolarità , 49 byte

....)....
...D7)...
..14)21..
.WM)IEtu.
}u)70s/..

Provalo online!

Spiegazione

)D7)14)21WM)IEtu}u)70s/ – Full program.
)D7)14)21               – Push the literals 0, 7, 14, 21 onto the stack.
         WM     }       – Wrap the stack to a list and run each element on a separate
                          stack, collecting the results in a list.
           )IEt         – Crop the elements of the input before those indices.
               u        – Sum that list.
                 u      – Then sum the list of sums.
                  )70   – Push the literal 70 onto the stack.
                     s/ – Swap and divide.

— Mr. Xcoder
fonte

1

Perl 5 `-pa` , 28 byte

$\+=$_/70*int$i++/7+1for@F}{

Provalo online!

L'input è separato da spazio anziché da virgola.

— Xcali
fonte

Hai a $.disposizione il moltiplicatore perfetto. Non c'è bisogno di$i

— Ton Hospel,

1

APL + WIN, 13 byte

Richiede array come vettore di numeri interi:

(+/⎕×7/⍳4)÷70

Spiegazione:

7/⍳4) create a vector comprising 7 1s, 7 2s, 7 3s and 7 4s

+/⎕× prompt for input, multiply by the vector above and sum result

(....)÷70 divide the above sum by 70

— Graham
fonte

1

Java 8, 57 byte

a->{int r=0,i=35;for(;i-->7;)r+=i/7*a[i-7];return r/70d;}

Provalo online.

Spiegazione:

a->{              // Method with integer-array parameter and double return-type
  int r=0,        //  Result-sum, starting at 0
      i=35;       //  Index-integer, starting at 35
  for(;i-->7;)    //  Loop `i` downwards in the range (35,7]
    r+=           //   Add the following to the result-sum:
       i/7        //    `i` integer-divided by 7,
       *a[i-7];   //    multiplied by the item at index `i-7`
  return r/70d;}  //  Return the result-sum, divided by 70.0

— Kevin Cruijssen
fonte

1

J , 16 byte

70%~1#.]*7#4{.#\

Spiegazione:

              #\           finds the lengths of all successive prefixes (1 2 3 4 ... 28)
           4{.             takes the first 4 items (1 2 3 4)
         7#                creates 7 copies of each element of the above list
       ]*                  multiplies the input by the above 
    1#.                    sum
70%~                       divide by 70

Provalo online!

— Galen Ivanov
fonte

1

Clojure, 48 46 byte

#(/(apply +(for[i[0 7 14 21]v(drop i %)]v))70)

Questo ha finito per essere più breve della combinazione mapcat + subvec.

— NikoNyrh
fonte

1

TI-Basic, 25 byte

mean(Ansseq(sum(I>{0,7,21,42}),I,1,70

Soluzione alternativa, 39 byte

Input L1
For(I,1,70
Ans+L1(I)sum(I>{0,7,21,42
End
Ans/70

— Timtech
fonte

1

Rubino , 65 byte

->r{(b=(0..r.size/7).map{|a|r[a*7..-1]}.flatten).sum/b.size.to_f}

Provalo online!

— lfvt
fonte

La dimensione di input è specificata per essere fissata su 28 qui, quindi è possibile salvare diversi byte codificando i valori invece di utilizzare la sizeproprietà. Provalo online!

— Sundar - Ripristina Monica il

1

Excel, 36 33 byte

-3 byte grazie a @tsh.

=SUM(1:1,H1:AB1,O1:AB1,V1:AB1)/70

Immettere nella prima riga ( A1a AB1).

— Wernisch
fonte

Forse A1:AB1-> 1:1?

— TSH

1

Julia 0.6 , 27 byte

p->repeat(1:4,inner=7)'p/70

Provalo online!

La repeatchiamata forma una matrice di colonne di 28 valori, contenente sette 1, quindi sette 2, ecc. Quindi la trasponiamo con ', quindi facciamo una moltiplicazione di matrice con l'input (la mutiplicazione è implicita qui). Poiché si tratta di una moltiplicazione di matrice di una matrice 1x28 con una matrice 28x1, finiamo con un singolo valore, che è la somma ponderata di cui abbiamo bisogno. Dividilo 70per ottenere la nostra media ponderata.

— Sundar - Ripristina Monica
fonte

Media ponderata: il problema dell'andamento della flessione

Caso 1: tendenza al rialzo

Caso 2: lasciare indietro la pausa

Caso 3: arrendersi

Caso 4: calcolo della media

Problema bonus:

Buccia , 6 byte

Python 3 , 38 byte

05AB1E , 8 7 byte

Gelatina , 7 byte

Come funziona

R + pryr, 32 28 byte

MATL , 10 byte

Gelatina , 9 byte

Come funziona

Haskell , 35 byte

JavaScript (Node.js) , 49 byte

JavaScript (Node.js) , 39 36 byte

Stax , 6 byte

Spacchettato (7 byte) e spiegazione:

Stax , 10 8 byte

Ottava , 33 byte

Carbone , 14 byte

K4 / K (oK) , 19 16 14 byte

Japt , 11 10 byte

Spiegazione

Triangolarità , 49 byte

Spiegazione

Perl 5 -pa , 28 byte

APL + WIN, 13 byte

Java 8, 57 byte

J , 16 byte

Spiegazione:

Clojure, 48 46 byte

TI-Basic, 25 byte

Rubino , 65 byte

Excel, 36 33 byte

Julia 0.6 , 27 byte

Perl 5 `-pa` , 28 byte