Media di 3 numeri interi lunghi

Ho 3 numeri interi con segno molto grandi.

long x = long.MaxValue;
long y = long.MaxValue - 1;
long z = long.MaxValue - 2;

Voglio calcolare la loro media troncata. Il valore medio atteso è long.MaxValue - 1, ovvero 9223372036854775806.

È impossibile calcolarlo come:

long avg = (x + y + z) / 3; // 3074457345618258600

Nota: ho letto tutte quelle domande sulla media di 2 numeri, ma non vedo come questa tecnica possa essere applicata alla media di 3 numeri.

Sarebbe molto facile con l'uso di BigInteger, ma supponiamo che non possa usarlo.

BigInteger bx = new BigInteger(x);
BigInteger by = new BigInteger(y);
BigInteger bz = new BigInteger(z);
BigInteger bavg = (bx + by + bz) / 3; // 9223372036854775806

Se mi converto in double, ovviamente, perdo la precisione:

double dx = x;
double dy = y;
double dz = z;
double davg = (dx + dy + dz) / 3; // 9223372036854780000

Se mi converto in decimal, funziona, ma supponiamo anche che non possa usarlo.

decimal mx = x;
decimal my = y;
decimal mz = z;
decimal mavg = (mx + my + mz) / 3; // 9223372036854775806

Domanda: esiste un modo per calcolare la media troncata di 3 numeri interi molto grandi solo con l'utilizzo del longtipo? Non considerare questa domanda come specifica per C #, solo che è più facile per me fornire esempi in C #.

Questo codice funzionerà, ma non è così carino.

Per prima cosa divide tutti e tre i valori (mette a terra i valori, quindi "perdi" il resto), quindi divide il resto:

long n = x / 3
         + y / 3
         + z / 3
         + ( x % 3
             + y % 3
             + z % 3
           ) / 3

Si noti che l'esempio sopra non funziona sempre correttamente quando si hanno uno o più valori negativi.

Come discusso con Ulugbek, poiché il numero di commenti sta esplodendo di seguito, ecco l'attuale soluzione MIGLIORE sia per i valori positivi che per quelli negativi.

Grazie alle risposte e ai commenti di Ulugbek Umirov , James S , KevinZ , Marc van Leeuwen , gnasher729 questa è la soluzione attuale:

static long CalculateAverage(long x, long y, long z)
{
    return (x % 3 + y % 3 + z % 3 + 6) / 3 - 2
            + x / 3 + y / 3 + z / 3;
}

static long CalculateAverage(params long[] arr)
{
    int count = arr.Length;
    return (arr.Sum(n => n % count) + count * (count - 1)) / count - (count - 1)
           + arr.Sum(n => n / count);
}

NB - Patrick ha già dato un'ottima risposta . Espandendo questo potresti fare una versione generica per qualsiasi numero di interi in questo modo:

long x = long.MaxValue;
long y = long.MaxValue - 1;
long z = long.MaxValue - 2;

long[] arr = { x, y, z };
var avg = arr.Select(i => i / arr.Length).Sum() 
        + arr.Select(i => i % arr.Length).Sum() / arr.Length;

Patrick Hofman ha pubblicato un'ottima soluzione . Ma se necessario può ancora essere implementato in molti altri modi. Usando l'algoritmo qui ho un'altra soluzione. Se implementato con attenzione, potrebbe essere più veloce delle divisioni multiple nei sistemi con divisori hardware lenti. Può essere ulteriormente ottimizzato utilizzando la tecnica di divisione per costanti dalla gioia degli hacker

public class int128_t {
    private int H;
    private long L;

    public int128_t(int h, long l)
    {
        H = h;
        L = l;
    }

    public int128_t add(int128_t a)
    {
        int128_t s;
        s.L = L + a.L;
        s.H = H + a.H + (s.L < a.L);
        return b;
    }

    private int128_t rshift2()  // right shift 2
    {
        int128_t r;
        r.H = H >> 2;
        r.L = (L >> 2) | ((H & 0x03) << 62);
        return r;
    }

    public int128_t divideby3()
    {
        int128_t sum = {0, 0}, num = new int128_t(H, L);
        while (num.H || num.L > 3)
        {
            int128_t n_sar2 = num.rshift2();
            sum = add(n_sar2, sum);
            num = add(n_sar2, new int128_t(0, num.L & 3));
        }

        if (num.H == 0 && num.L == 3)
        {
            // sum = add(sum, 1);
            sum.L++;
            if (sum.L == 0) sum.H++;
        }
        return sum; 
    }
};

int128_t t = new int128_t(0, x);
t = t.add(new int128_t(0, y));
t = t.add(new int128_t(0, z));
t = t.divideby3();
long average = t.L;

In C / C ++ su piattaforme a 64 bit è molto più semplice con __int128

int64_t average = ((__int128)x + y + z)/3;

È possibile calcolare la media dei numeri in base alle differenze tra i numeri anziché utilizzare la somma.

Diciamo che x è il massimo, y è la mediana, z è il minimo (come hai). Li chiameremo max, median e min.

Controllo condizionale aggiunto secondo il commento di @ UlugbekUmirov:

long tmp = median + ((min - median) / 2);            //Average of min 2 values
if (median > 0) tmp = median + ((max - median) / 2); //Average of max 2 values
long mean;
if (min > 0) {
    mean = min + ((tmp - min) * (2.0 / 3)); //Average of all 3 values
} else if (median > 0) {
    mean = min;
    while (mean != tmp) {
        mean += 2;
        tmp--;
    }
} else if (max > 0) {
    mean = max;
    while (mean != tmp) {
        mean--;
        tmp += 2;
    }
} else {
    mean = max + ((tmp - max) * (2.0 / 3));
}

Poiché C utilizza la divisione con pavimento anziché la divisione euclidea, potrebbe essere più semplice calcolare una media correttamente arrotondata di tre valori senza segno rispetto a tre valori con segno. Aggiungi semplicemente 0x8000000000000000UL a ogni numero prima di prendere la media senza segno, sottrailo dopo aver preso il risultato e usa un cast non controllato Int64per ottenere una media con segno .

Per calcolare la media senza segno, calcolare la somma dei primi 32 bit dei tre valori. Quindi calcola la somma dei 32 bit inferiori dei tre valori, più la somma dall'alto, più uno [il più uno è quello di produrre un risultato arrotondato]. La media sarà 0x55555555 volte la prima somma, più un terzo della seconda.

Le prestazioni sui processori a 32 bit potrebbero essere migliorate producendo tre valori di "somma" ciascuno dei quali è lungo 32 bit, in modo che il risultato finale sia ((0x55555555UL * sumX)<<32) + 0x55555555UL * sumH + sumL/3; potrebbe essere ulteriormente migliorato sostituendolo sumL/3con ((sumL * 0x55555556UL) >> 32), sebbene quest'ultimo dipenda dall'ottimizzatore JIT [potrebbe sapere come sostituire una divisione per 3 con un moltiplicatore, e il suo codice potrebbe effettivamente essere più efficiente di un'operazione di moltiplicazione esplicita].

Applicando la patch alla soluzione di Patrick Hofman con la correzione di supercat , ti do quanto segue:

static Int64 Avg3 ( Int64 x, Int64 y, Int64 z )
{
    UInt64 flag = 1ul << 63;
    UInt64 x_ = flag ^ (UInt64) x;
    UInt64 y_ = flag ^ (UInt64) y;
    UInt64 z_ = flag ^ (UInt64) z;
    UInt64 quotient = x_ / 3ul + y_ / 3ul + z_ / 3ul
        + ( x_ % 3ul + y_ % 3ul + z_ % 3ul ) / 3ul;
    return (Int64) (quotient ^ flag);
}

E il caso dell'elemento N:

static Int64 AvgN ( params Int64 [ ] args )
{
    UInt64 length = (UInt64) args.Length;
    UInt64 flag = 1ul << 63;
    UInt64 quotient_sum = 0;
    UInt64 remainder_sum = 0;
    foreach ( Int64 item in args )
    {
        UInt64 uitem = flag ^ (UInt64) item;
        quotient_sum += uitem / length;
        remainder_sum += uitem % length;
    }

    return (Int64) ( flag ^ ( quotient_sum + remainder_sum / length ) );
}

Questo dà sempre il floor () della media ed elimina ogni possibile caso limite.

Potresti usare il fatto che puoi scrivere ciascuno dei numeri come y = ax + b, dove xè una costante. Ciascuno asarebbe y / x(la parte intera di quella divisione). Ogni b sarebbe y % x(il resto / modulo di quella divisione). Se scegli questa costante in modo intelligente, ad esempio scegliendo come costante la radice quadrata del numero massimo, puoi ottenere la media dei xnumeri senza avere problemi di overflow.

La media di un elenco arbitrario di numeri può essere trovata trovando:

( ( sum( all A's ) / length ) * constant ) + 
( ( sum( all A's ) % length ) * constant / length) +
( ( sum( all B's ) / length )

dove %denota modulo e /denota la parte "intera" della divisione.

Il programma sarebbe simile a:

class Program
{
    static void Main()
    {
        List<long> list = new List<long>();
        list.Add( long.MaxValue );
        list.Add( long.MaxValue - 1 );
        list.Add( long.MaxValue - 2 );

        long sumA = 0, sumB = 0;
        long res1, res2, res3;
        //You should calculate the following dynamically
        long constant = 1753413056;

        foreach (long num in list)
        {
            sumA += num / constant;
            sumB += num % constant;
        }

        res1 = (sumA / list.Count) * constant;
        res2 = ((sumA % list.Count) * constant) / list.Count;
        res3 = sumB / list.Count;

        Console.WriteLine( res1 + res2 + res3 );
    }
}

Se sai di avere N valori, puoi semplicemente dividere ogni valore per N e sommarli insieme?

long GetAverage(long* arrayVals, int n)
{
    long avg = 0;
    long rem = 0;

    for(int i=0; i<n; ++i)
    {
        avg += arrayVals[i] / n;
        rem += arrayVals[i] % n;
    }

    return avg + (rem / n);
}

L'ho anche provato e ho trovato una soluzione più veloce (anche se solo di un fattore circa 3/4). Utilizza una singola divisione

public static long avg(long a, long b, long c) {
    final long quarterSum = (a>>2) + (b>>2) + (c>>2);
    final long lowSum = (a&3) + (b&3) + (c&3);
    final long twelfth = quarterSum / 3;
    final long quarterRemainder = quarterSum - 3*twelfth;
    final long adjustment = smallDiv3(lowSum + 4*quarterRemainder);
    return 4*twelfth + adjustment;
}

dove smallDiv3è la divisione per 3 usando la moltiplicazione e lavorando solo per piccoli argomenti

private static long smallDiv3(long n) {
    assert -30 <= n && n <= 30;
    // Constants found rather experimentally.
    return (64/3*n + 10) >> 6;
}

Ecco l' intero codice compreso un test e un benchmark, i risultati non sono così impressionanti.

Questa funzione calcola il risultato in due divisioni. Dovrebbe generalizzarsi bene ad altri divisori e dimensioni delle parole.

Funziona calcolando il risultato dell'addizione di due parole, quindi elaborando la divisione.

Int64 average(Int64 a, Int64 b, Int64 c) {
    // constants: 0x10000000000000000 div/mod 3
    const Int64 hdiv3 = UInt64(-3) / 3 + 1;
    const Int64 hmod3 = UInt64(-3) % 3;

    // compute the signed double-word addition result in hi:lo
    UInt64 lo = a; Int64 hi = a>=0 ? 0 : -1;
    lo += b; hi += b>=0 ? lo<b : -(lo>=UInt64(b));
    lo += c; hi += c>=0 ? lo<c : -(lo>=UInt64(c));

    // divide, do a correction when high/low modulos add up
    return hi>=0 ? lo/3 + hi*hdiv3 + (lo%3 + hi*hmod3)/3
                 : lo/3+1 + hi*hdiv3 + Int64(lo%3-3 + hi*hmod3)/3;
}

Matematica

(x + y + z) / 3 = x/3 + y/3 + z/3

(a[1] + a[2] + .. + a[k]) / k = a[1]/k + a[2]/k + .. + a[k]/k

Codice

long calculateAverage (long a [])
{
    double average = 0;

    foreach (long x in a)
        average += (Convert.ToDouble(x)/Convert.ToDouble(a.Length));

    return Convert.ToInt64(Math.Round(average));
}

long calculateAverage_Safe (long a [])
{
    double average = 0;
    double b = 0;

    foreach (long x in a)
    {
        b = (Convert.ToDouble(x)/Convert.ToDouble(a.Length));

        if (b >= (Convert.ToDouble(long.MaxValue)-average))
            throw new OverflowException ();

        average += b;
    }

    return Convert.ToInt64(Math.Round(average));
}

Prova questo:

long n = Array.ConvertAll(new[]{x,y,z},v=>v/3).Sum()
     +  (Array.ConvertAll(new[]{x,y,z},v=>v%3).Sum() / 3);