sfondo

La disuguaglianza di riorganizzazione è una disuguaglianza che si basa sulla riorganizzazione dei numeri. Se ho due elenchi di numeri della stessa lunghezza, x ₀ , x ₁ , x ₂ ... x _n-1 e y ₀ , y ₁ , y ₂ ... y _n-1 della stessa lunghezza, dove I posso riorganizzare i numeri nell'elenco, un modo per massimizzare la somma x ₀ y ₀ + x ₁ y ₁ + x ₂ y ₂ + ... + x _n-1 y _n-1 è quello di ordinare i 2 elenchi in ordine non decrescente.

Leggi l' articolo di Wikipedia qui.

Compito

Si scriverà un programma che accetta input da STDIN o una funzione che accetta 2 matrici (o relativi contenitori) di numeri (che sono della stessa lunghezza).

Supponendo che tu scriva una funzione che accetta 2 array (aeb), troverai il numero di modi in cui puoi riorganizzare i numeri nel secondo array (b) per massimizzare:

a[0]*b[0]+a[1]*b[1]+a[2]*b[2]+...+a[n-1]*b[n-1]

In questo caso, se l'array b è [1 ₀ , 2 ₁ , 2 ₂ , 3 ₃ , 3 ₄ ] (indici per chiarezza),

[1 ₀ , 2 ₁ , 2 ₂ , 3 ₃ , 3 ₄ ],

[1 ₀ , 2 ₁ , 2 ₂ , 3 ₄ , 3 ₃ ], (scambia le due 3)

[1 ₀ , 2 ₂ , 2 ₁ , 3 ₃ , 3 ₄ ] (scambia i due 2)

[1 ₀ , 2 ₂ , 2 ₁ , 3 ₄ , 3 ₃ ] (scambia i due 3 e scambia i due 2)

sono considerati accordi diversi. L'array originale, di per sé, conta anche come possibile riorganizzazione se massimizza anche la somma.

Per l'input STDIN, è possibile supporre che la lunghezza delle matrici sia fornita prima delle matrici (si prega di indicare in modo da utilizzarla) o che le matrici siano fornite su linee diverse (si prega di indicare anche).

Ecco i 4 possibili ingressi (per comodità):

5 1 1 2 2 2 1 2 2 3 3 (length before arrays)

1 1 2 2 2 1 2 2 3 3 (the 2 arrays, concatenated)

1 1 2 2 2
1 2 2 3 3 (the 2 arrays on different lines)

5
1 1 2 2 2
1 2 2 3 3 (length before arrays and the 2 arrays on different lines)

Per l'output, è possibile restituire la risposta (se si scrive una funzione) o stampare la risposta su STDOUT. Puoi scegliere di emettere la risposta mod 10 ⁹ +7 (da 0 a 10 ⁹ +6) se è più conveniente.

Casi di prova (e spiegazione):

[1 1 2 2 2] [1 2 2 3 3] => 24

Le prime 2 voci devono essere 1 e 2. Le ultime 3 voci sono 2, 3 e 3. Esistono 2 modi per disporre i 2 tra le prime 2 voci e le ultime 2 voci. Tra le prime 2 voci, ci sono 2 modi per riordinarle. Tra le ultime 2 voci, ci sono 6 modi per riordinarle.

[1 2 3 4 5] [6 7 8 9 10] => 1

C'è solo 1 modo, che è la disposizione data negli array.

[1 1 ... 1 1] [1 1 ... 1 1] (10000 numbers) => 10000! or 531950728

Ogni possibile permutazione del secondo array è valida.

Dennis 'Testcase: Pastebin => 583159312 (mod 1000000007)

punteggio:

Questo è code-golf, quindi vince la risposta più breve.

In caso di parità, i legami verranno interrotti al momento della presentazione, favorendo la presentazione precedente.

Prendi nota:

I contenitori potrebbero non essere ordinati.

I numeri interi nei contenitori possono essere zero o negativi.

Il programma deve funzionare abbastanza velocemente (al massimo un'ora) per array di dimensioni modeste (circa 10000 di lunghezza).

Ispirato da questa domanda sullo scambio di stack di matematica.

— Element118
fonte

2

Fornisci un caso di test con 10000 elementi per array, in modo da poter verificare che il nostro codice funzioni correttamente e sia abbastanza veloce.

— Dennis,

1

Nell'esempio fornito per lo scambio del secondo array [1_0, 2_2, 2_1, 3_4, 3_3] (scambia i due 2 e scambia i due 3) è mancante

— Willem,

accettate input come [. . .]plz respond

— Abr001am

Se inviamo una funzione, dobbiamo prendere due argomenti separati o potremmo prendere una matrice di array?

— Dennis,

Bene, la matrice di array sembra a posto e non influisce troppo sulla sfida. Lavorerò sul test case.

— Element118,

4

CJam, 30 26 byte

q~](/:$_za+{e`0f=:m!:*}//*

Provalo online nell'interprete CJam .

Completa questo test in meno di un secondo:

$ time cjam <(echo 'q~](/:$_za+{e`0f=:m!:*}%)\:*\/N') < test-large.in | md5sum
5801bbf8ed0f4e43284f7ec2206fd3ff  -

real    0m0.308s
user    0m0.667s
sys     0m0.044s

L'esecuzione nell'interprete online dovrebbe richiedere meno di 10 secondi.

Algoritmo

Il risultato non dipende dall'ordine di A , quindi possiamo presumere che sia ordinato. Ciò significa che anche B deve essere ordinato per ottenere il prodotto punto massimo.

Ora, se r ₁ , ... r _n è la lunghezza delle corse della A ordinata , ci sono kr _k ! diversi riarrangiamenti degli elementi di A che risultano ancora in ordine crescente.

Allo stesso modo, se s ₁ , ... s _n è la lunghezza delle corse della B ordinata , ci sono ∏s _k ! diversi riarrangiamenti degli elementi di B che risultano ancora in ordine crescente.

Tuttavia, questo conta tutti gli accoppiamenti più volte. Se prendiamo le coppie degli elementi corrispondenti di A ordinati e B ordinati e definiamo t ₁ , ... t _n come la lunghezza delle corse dell'array risultante, ∏t _k ! è il moltiplicatore di cui sopra.

Pertanto, il risultato desiderato è (∏r _k !) × (∏s _k !) ÷ (∏t _k !) .

Codice

 q~                          Read and evaluate all input.
   ]                         Wrap the resulting integers in an array.
    (                        Shift out the first (length).
     /                       Split the remainder into chunks of that length.
      :$                     Sort each chunk.
        _z                   Push a copy and transpose rows with columns.
                             This pushes the array of corresponding pairs.
          a+                 Wrap in array and concatenate (append).
            {          }/    For A, B, and zip(A,B):
             e`                Perform run-length encoding.
               0f=             Select the runs.
                  :m!          Apply factorial to each.
                     :*        Reduce by multiplication.
                         /   Divide the second result by the third.
                          *  Multiply the quotient with the first result.

— Dennis
fonte

6

Pyth, 29 28 byte

M/*FPJm*F.!MhMrd8aFCB,SGSHeJ

Provalo online nel compilatore Pyth .

Algoritmo

Il risultato non dipende dall'ordine di A , quindi possiamo presumere che sia ordinato. Ciò significa che anche B deve essere ordinato per ottenere il prodotto punto massimo.

Ora, se r ₁ , ... r _n è la lunghezza delle corse della A ordinata , ci sono kr _k ! diversi riarrangiamenti degli elementi di A che risultano ancora in ordine crescente.

Allo stesso modo, se s ₁ , ... s _n è la lunghezza delle corse della B ordinata , ci sono ∏s _k ! diversi riarrangiamenti degli elementi di B che risultano ancora in ordine crescente.

Tuttavia, questo conta tutti gli accoppiamenti più volte. Se prendiamo le coppie degli elementi corrispondenti di A ordinati e B ordinati e definiamo t ₁ , ... t _n come la lunghezza delle corse dell'array risultante, ∏t _k ! è il moltiplicatore di cui sopra.

Pertanto, il risultato desiderato è (∏r _k !) × (∏s _k !) ÷ (∏t _k !) .

Codice

M/*FPJm*F.!MhMrd8aFCB,SGSHeJ

M                             Define g(G,H):
                      SGSH      Sort G and H.
                     ,          For the pair of the results.
                   CB           Bifurcated zip (C).
                                This returns [[SG, SH], zip([SG, SH])].
                 aF             Reduce by appending.
                                This returns [SG, SH, zip([SG, SH])].
      m                         Map; for each d in the resulting array:
              rd8                 Perform run-length encoding on d.
            hM                    Mapped "head". This returns the lengths.
         .!M                      Mapped factorial.
       *F                         Reduce by multiplication.
     J                          Save the result in J.
    P                           Discard the last element.
  *F                            Reduce by multiplication.
 /                  
                          eJ    Divide the product by the last element of J.
                                Return the result of the division.

Verifica

Ho generato pseudo-casualmente 100 casi di test di lunghezza 6, che ho risolto con il codice sopra e questo approccio a forza bruta:

Ml.Ms*VGZ.pH

M             Define g(G,H) (or n(G,H) on second use):
         .pH    Compute all permutations of H.
  .M            Filter .pH on the maximal value of the following;
                 for each Z in .pH:
     *VGZ         Compute the vectorized product of G and Z.
    s             Add the products.
                  This computes the dot product of G and Z.
 l              Return the length of the resulting array.

Questi erano i risultati:

$ cat test.in
6,9,4,6,8,4,5,6,5,0,8,2
0,7,7,6,1,6,1,7,3,3,8,0
3,6,0,0,6,3,8,2,8,3,1,1
2,3,0,4,0,6,3,4,5,8,2,4
9,1,1,2,2,8,8,1,7,4,9,8
8,3,1,1,9,0,2,8,3,4,9,5
2,0,0,7,7,8,9,2,0,6,7,7
0,7,4,2,2,8,6,5,0,5,4,9
2,7,7,5,5,6,8,8,0,5,6,3
1,7,2,7,7,9,9,2,9,2,9,8
7,2,8,9,9,0,7,4,6,2,5,3
0,1,9,2,9,2,9,5,7,4,5,6
8,4,2,8,8,8,9,2,5,4,6,7
5,2,8,1,9,7,4,4,3,3,0,0
9,3,6,2,5,5,2,4,6,8,9,3
4,2,0,6,2,3,5,3,6,3,1,4
4,8,5,2,5,0,5,1,2,5,9,5
6,8,4,4,9,5,9,5,4,2,8,7
8,9,8,1,2,2,9,0,5,6,4,9
4,7,6,8,0,3,7,7,3,9,8,6
7,5,5,6,3,9,3,8,8,4,8,0
3,8,1,8,5,6,6,7,2,8,5,3
0,9,8,0,8,3,0,3,5,9,5,6
4,2,7,7,5,8,4,2,6,4,9,4
3,5,0,8,2,5,8,7,3,4,5,5
7,7,7,0,8,0,9,8,1,4,8,6
3,9,7,7,4,9,2,5,9,7,9,4
4,5,5,5,0,7,3,4,0,1,8,2
7,4,4,2,5,1,7,4,7,1,9,1
0,6,2,5,4,5,1,8,0,8,9,9
3,8,5,3,2,1,1,2,2,2,8,4
6,1,9,1,8,7,5,6,9,2,8,8
6,2,6,6,6,0,2,7,8,6,8,2
0,7,1,4,5,5,3,4,4,0,0,2
6,0,1,5,5,4,8,5,5,2,1,6
2,6,3,0,7,4,3,6,0,5,4,9
1,4,8,0,5,1,3,2,9,2,6,5
2,7,9,9,5,0,1,5,6,8,4,6
4,0,1,3,4,3,6,9,1,2,7,1
6,5,4,7,8,8,6,2,3,4,1,2
0,3,6,3,4,0,1,4,5,5,5,7
5,4,7,0,1,3,3,0,2,1,0,8
8,6,6,1,6,6,2,2,8,3,2,2
7,1,3,9,7,4,6,6,3,1,5,8
4,8,3,3,9,1,3,4,1,3,0,6
1,4,0,7,4,9,8,4,2,1,0,3
0,4,1,6,4,4,4,7,5,1,4,2
0,0,4,4,9,6,7,2,7,7,5,4
9,0,5,5,0,8,8,9,5,9,5,5
5,7,0,4,2,7,6,1,1,1,9,1
3,1,7,5,0,3,1,4,0,9,0,3
4,4,5,7,9,5,0,3,7,4,7,5
7,9,7,3,0,8,4,0,0,3,1,0
2,4,4,3,1,2,5,2,9,0,8,5
4,8,7,3,0,0,9,3,7,3,0,6
8,9,1,0,7,7,6,0,3,1,8,9
8,3,1,7,3,3,6,1,1,7,6,5
6,5,6,3,3,0,0,5,5,0,6,7
2,4,3,9,7,6,7,6,5,6,2,0
4,8,5,1,8,4,4,3,4,5,2,5
7,5,0,4,6,9,5,0,5,7,5,5
4,8,9,5,5,2,3,1,9,7,7,4
1,5,3,0,3,7,3,8,5,5,3,3
7,7,2,6,1,6,6,1,3,5,4,9
9,7,6,0,1,4,0,4,4,1,4,0
3,5,1,4,4,0,7,1,8,9,9,1
1,9,8,7,4,9,5,2,2,1,2,9
8,1,2,2,7,7,6,8,2,3,9,7
3,5,2,1,3,5,2,2,4,7,0,7
9,6,8,8,3,5,2,9,8,7,4,7
8,8,4,5,5,1,5,6,5,1,3,3
2,6,3,5,0,5,0,3,4,4,0,5
2,2,7,6,3,7,1,4,0,3,8,3
4,8,4,2,6,8,5,6,2,5,0,1
7,2,4,3,8,4,4,6,5,3,9,4
4,6,1,0,6,0,2,6,7,4,9,5
6,3,3,4,6,1,0,8,6,1,7,5
8,3,4,2,8,3,0,1,8,9,1,5
9,6,1,9,1,1,8,8,8,9,1,4
3,6,1,6,1,4,5,1,0,1,9,1
6,4,3,9,3,0,5,0,5,3,2,4
5,2,4,6,1,2,6,0,1,8,4,0
3,5,7,6,3,6,4,5,2,8,1,5
6,3,6,8,4,2,7,1,5,3,0,6
9,1,5,9,9,1,1,4,5,7,3,0
1,6,7,3,5,8,6,5,5,2,6,0
2,8,8,6,5,5,2,3,8,1,9,8
0,4,5,3,7,6,2,5,4,3,2,5
5,1,2,3,0,3,4,9,4,9,4,9
5,8,2,2,0,2,4,1,1,7,0,3
0,6,0,0,3,6,3,6,2,2,2,9
2,4,8,1,9,4,0,8,8,0,4,7
3,9,1,0,5,6,8,8,2,5,2,6
5,3,8,9,1,6,5,9,7,7,6,1
8,6,9,6,1,1,6,7,7,3,2,2
7,2,1,9,8,8,5,3,6,3,3,6
9,9,4,8,7,9,8,6,6,0,3,1
8,3,0,9,1,7,4,8,0,1,6,2
8,2,6,2,4,0,2,8,9,6,3,7
1,0,8,5,3,2,3,7,1,7,8,2
$ while read; do
> pyth -c 'M/*FPJm*F.!MhMrd8aFCB,SGSHeJMl.Ms*VGZ.pHAc2Q,gGHnGH' <<< "$REPLY"
> done < test.in
[4, 4]
[4, 4]
[8, 8]
[4, 4]
[8, 8]
[2, 2]
[4, 4]
[4, 4]
[4, 4]
[36, 36]
[2, 2]
[8, 8]
[24, 24]
[8, 8]
[2, 2]
[2, 2]
[6, 6]
[2, 2]
[8, 8]
[2, 2]
[12, 12]
[2, 2]
[8, 8]
[12, 12]
[4, 4]
[12, 12]
[4, 4]
[6, 6]
[8, 8]
[8, 8]
[6, 6]
[4, 4]
[48, 48]
[8, 8]
[4, 4]
[1, 1]
[4, 4]
[4, 4]
[8, 8]
[4, 4]
[12, 12]
[2, 2]
[96, 96]
[2, 2]
[4, 4]
[2, 2]
[6, 6]
[24, 24]
[24, 24]
[48, 48]
[4, 4]
[8, 8]
[12, 12]
[8, 8]
[4, 4]
[2, 2]
[24, 24]
[16, 16]
[2, 2]
[8, 8]
[24, 24]
[4, 4]
[24, 24]
[4, 4]
[12, 12]
[8, 8]
[12, 12]
[4, 4]
[8, 8]
[4, 4]
[16, 16]
[4, 4]
[8, 8]
[8, 8]
[4, 4]
[4, 4]
[4, 4]
[4, 4]
[72, 72]
[24, 24]
[4, 4]
[4, 4]
[4, 4]
[2, 2]
[12, 12]
[4, 4]
[8, 8]
[4, 4]
[36, 36]
[6, 6]
[12, 12]
[8, 8]
[4, 4]
[2, 2]
[8, 8]
[24, 24]
[6, 6]
[1, 1]
[2, 2]
[2, 2]

Per verificare che la mia richiesta soddisfi i requisiti di velocità, l'ho eseguita con questo caso di test .

$ time pyth -c 'M/*FPJm*F.!MhMrd8aFCB,SGSHeJAc2QgGH' < test-large.in | md5sum
5801bbf8ed0f4e43284f7ec2206fd3ff  -

real    0m0.233s
user    0m0.215s
sys     0m0.019s

— Dennis
fonte

2

Matlab, 230 byte

Modifica: molte cose sono state corrette per corrispondere ai casi di test di dennis e nnz è sostituito da numel a causa di valori nulli.

f=1;t=-1;q=1;a=sort(input(''));b=sort(input(''));for i=unique(a)c=b(find(a==i));r=numel(c(c==t));f=f*factorial(numel(c))*sum(arrayfun(@(u)nchoosek(max(q,r),u),0:min(q,r)));z=c(end);y=numel(c(c==z));q=(t==z)*(q+r)+(t~=z)*y;t=z;end,f

Esecuzione

[2 2 1 2 1]
[3 2 3 2 1]

f =

    24

Dennis 'Testcase:

   A = importdata('f:\a.csv'); for i=1:100,a=sort(A(i,1:6));b=sort(A(i,7:12));
   f=1;t=-1;q=1;for i=unique(a)c=b(find(a==i));r=numel(c(c==t));f=f*factorial(numel(c))*sum(arrayfun(@(u)nchoosek(max(q,r),u),0:min(q,r)));z=c(end);y=numel(c(c==z));q=(t==z)*(q+r)+(t~=z)*y;t=z;end;
   disp(f);end

Uscite:

— Abr001am
fonte

Bene, risolve il problema, quindi l'input non dovrebbe importare troppo.

— Element118,

1

C ++, 503 byte

(solo per divertimento, un linguaggio non golfistico)

#import<iostream>
#import<algorithm>
#define U 12345
#define l long long
using namespace std;int N,X=1,Y=1,Z=1,x[U],y[U],i=1;l p=1,M=1000000007,f[U];l e(l x,int y){return y?y%2?(x*e(x,y-1))%M:e((x*x)%M,y/2):1;}main(){for(f[0]=1;i<U;i++)f[i]=(f[i-1]*i)%M;cin>>N;for(i=0;i<N;i++)cin>>x[i];for(i=0;i<N;i++)cin>>y[i];sort(x,x+N);sort(y,y+N);for(i=1;i<N;i++)x[i]^x[i-1]?p=p*f[X]%M,X=1:X++,y[i]^y[i-1]?p=p*f[Y]%M,Y=1:Y++,x[i]^x[i-1]|y[i]^y[i-1]?p=p*e(f[Z],M-2)%M,Z=1:Z++;cout<<p*f[X]%M*f[Y]%M*e(f[Z],M-2)%M;}

Versione non golfata:

#include <cstdio>
#include <algorithm>
#define MOD 1000000007
using namespace std;
int N; // number of integers
int x[1000010]; // the 2 arrays of integers
int y[1000010];
long long product = 1;
long long factorial[1000010]; // storing factorials mod 1000000007
long long factorialInv[1000010]; // storing the inverse mod 1000000007
long long pow(long long x, int y) {
    if (y == 0) return 1;
    if (y == 1) return x;
    if (y%2 == 1) return (x*pow(x, y-1))%MOD;
    return pow((x*x)%MOD, y/2);
}
int main(void) {
    //freopen("in.txt", "r", stdin); // used for faster testing
    //precomputation
    factorial[0] = factorial[1] = 1;
    for (int i=2;i<=1000000;i++) {
        factorial[i] = (factorial[i-1]*i)%MOD;
        factorialInv[i] = pow(factorial[i], MOD-2);
    }
    // input
    scanf("%d", &N);
    for (int i=0;i<N;i++) {
        scanf("%d", &x[i]);
    }
    for (int i=0;i<N;i++) {
        scanf("%d", &y[i]);
    }
    // sort the 2 arrays
    sort(x, x+N);
    sort(y, y+N);
    int sameX = 1;
    int sameY = 1;
    int sameXY = 1;
    for (int i=1;i<N;i++) {
        if (x[i]==x[i-1]) {
            sameX++;
        } else {
            product *= factorial[sameX];
            product %= MOD;
            sameX = 1;
        }
        if (y[i]==y[i-1]) {
            sameY++;
        } else {
            product *= factorial[sameY];
            product %= MOD;
            sameY = 1;
        }
        if (x[i]==x[i-1] && y[i]==y[i-1]) {
            sameXY++;
        } else {
            product *= factorialInv[sameXY];
            product %= MOD;
            sameXY = 1;
        }
    }
    product *= factorial[sameX];
    product %= MOD;
    product *= factorial[sameY];
    product %= MOD;
    product *= factorialInv[sameXY];
    product %= MOD;
    printf("%lld\n", product);
    return 0;
}

— Element118
fonte

Disuguaglianza di riorganizzazione

sfondo

Compito

Casi di prova (e spiegazione):

punteggio:

Prendi nota:

CJam, 30 26 byte

Algoritmo

Codice

Pyth, 29 28 byte

Algoritmo

Codice

Verifica

Matlab, 230 byte

Esecuzione

Dennis 'Testcase:

C ++, 503 byte