J'étais chez un ami pour le dîner et ils ont suggéré l'idée d'un "espace vectoriel à facteur premier". Dans cet espace, les entiers positifs sont exprimés comme un vecteur de telle sorte que le n ème élément dans le vecteur soit le nombre de fois que le n e premier divise le nombre. (Notez que cela signifie que nos vecteurs ont un nombre infini de termes.) Par exemple, 20 est

2 0 1 0 0 0 ...

Parce que sa factorisation première est 2 * 2 * 5 .

Puisque la factorisation première est unique, chaque nombre correspond à un vecteur.

Nous pouvons ajouter des vecteurs en ajoutant par paire leurs entrées. Cela revient à multiplier les nombres auxquels ils sont associés. Nous pouvons également faire une multiplication scalaire, ce qui revient à élever le nombre associé à une puissance.

Le problème est que cet espace n'est pas en fait un espace vectoriel car il n'y a pas d'inverses. Si nous allons de l'avant et ajoutons les inverses et fermons l'espace vectoriel, nous avons maintenant un moyen d'exprimer chaque nombre rationnel positif comme un vecteur. Si l'on garde le fait que l'addition vectorielle représente la multiplication. L'inverse d'un nombre naturel est alors sa réciproque.

Par exemple, le nombre 20 avait le vecteur

2 0 1 0 0 0 ...

La fraction 1/20 est donc son inverse

-2 0 -1 0 0 0 ...

Si nous voulions trouver le vecteur associé à une fraction comme 14/15, nous trouverions 14

1 0 0 1 0 0 ...

et 1/15

0 -1 -1 0 0 0 ...

et les multiplier en effectuant l'addition de vecteurs

1 -1 -1 1 0 0 ...

Maintenant que nous avons un espace vectoriel, nous pouvons le modifier pour former un espace de produit intérieur en lui donnant un produit intérieur. Pour ce faire, nous volons le produit intérieur que les espaces vectoriels sont donnés de façon classique. Le produit intérieur de deux vecteurs est défini comme la somme de la multiplication par paire de leurs termes. Par exemple, 20 · 14/15 serait calculé comme suit

20    =  2  0  1  0  0  0 ...
14/15 =  1 -1 -1  1  0  0 ...
         2  0 -1  0  0  0 ...  -> 1

Comme autre exemple, le produit 2/19 · 4/19

2/19 = 1 0 0 0 0 0 0 -1 0 0 0 ...
4/19 = 2 0 0 0 0 0 0 -1 0 0 0 ...
       2 0 0 0 0 0 0  1 0 0 0 ... -> 3

Votre tâche consiste à implémenter un programme qui exécute ce produit scalaire. Il doit prendre deux nombres rationnels positifs via une paire d'entiers positifs (numérateur et dénominateur) ou un type rationnel (les flottants ne sont pas autorisés, car ils posent des problèmes de précision et de divisibilité) et doit générer un entier représentant le produit scalaire des deux. contributions.

Il s'agit de code-golf donc les réponses seront notées en octets avec moins d'octets mieux.

Cas de test

4 · 4 = 4
8 · 8 = 9
10 · 10 = 2
12 · 12 = 5
4 · 1/4 = -4
20 · 14/15 = 1
2/19 · 4/19 = 3

MATL , 12 octets

YF2:&Y)dwd*s

L'entrée est un tableau [num1 den1 num2 den2].

Essayez-le en ligne! Ou vérifiez tous les cas de test .

Explication

Considérez l'exemple d'entrée [20 1 14 15].

YF      % Implicit input: array of 4 numbers. Exponents of prime factorization.
        % Gives a matrix, where each row corresponds to one of the numbers in
        % the input array. Each row may contain zeros for non-present factors
        % STACK: [2 0 1 0
                  0 0 0 0
                  1 0 0 1
                  0 1 1 0]
2:&Y)   % Push a submatrix with the first two rows, then a submatrix with the
        % other two rows
        % STACK: [2 0 1 0
                  0 0 0 0],
                 [1 0 0 1
                  0 1 1 0]
d       % Consecutive difference(s) along each column
        % STACK: [2 0 1 0
                  0 0 0 0],
                 [-1 1 -1 1]
wd      % Swap, and do the same for the other submatrix
        % STACK: [-1 1 -1 1]
                 [-2 0 -1 0]
*       % Element-wise product
        % STACK: [2 0 -1 0]
s       % Sum. Implicit display
        % STACK: 1

C (gcc) , 99 + 32 = 131 octets

• L' utilisation d' un indicateur de compilation nécessitant 32 octets, -D=F(v,V,e)for(;v%p<1;V+=e)v/=p;.

T,p,A,C;f(a,b,c,d){T=0;for(p=2;a+b+c+d>4;p++){A=C=0;F(a,A,1)F(b,A,~0)F(c,C,1)F(d,C,~0)T+=A*C;}a=T;}

Essayez-le en ligne!

Gelée , 12 11 octets

ÆEz0_2/€P€S

Essayez-le en ligne!

Python 2 , 110 octets

l=input()
p=t=2
while~-max(l):r=i=0;exec"while l[i]%p<1:l[i]/=p;r+=1j**i\ni+=1\n"*4;t+=r*r;p+=1
print t.imag/2

Essayez-le en ligne!

Prend l'entrée comme [num1, num2, den1, den2]. Utilise un nombre complexe rpour stocker les entrées de prime ppour les deux rationnels et (r*r).imag/2pour extraire leur produit r.real*r.imagdans la somme globale t. L'addition 1j**ide i=0,1,2,3fait chaque combinaison d'incrémentation ou de décrémentation de la partie réelle ou imaginaire pour les quatre nombres d'entrée.

Bubbler a enregistré 2 octets en combinant les valeurs initiales p=t=2.

Wolfram Language (Mathematica) , 55 octets

Dot@@PadRight[SparseArray[Rule@@@FactorInteger@#]&/@#]&

Essayez-le en ligne!

JavaScript (Node.js) , 104 ... 100 94 octets

F=(A,i=2)=>A.some(x=>x>1)&&([a,b,c,d]=A.map(G=(x,j)=>x%i?0:1+G(A[j]/=i,j)),a-b)*(c-d)+F(A,i+1)

Essayez-le en ligne!

Passez les nombres sous forme de tableau de [Num1, Den1, Num2, Den2].

Merci pour Arnauld d'avoir corrigé les disparus F=sans octets supplémentaires, et 2 octets de moins.

Explication & non golfé

function F(A, i = 2) {                 // Main function, recursing from i = 2
 if (A.some(function(x) {              // If not all numbers became 1:
  return x > 1;
 })) {
  var B = A.map(G = function(x, j) {   // A recursion to calculate the multiplicity
   if (x % i)
    return 0;
   else
    return 1 + G(A[j] /= i, j);        // ...and strip off all powers of i
  });
  return (B[0] - B[1]) * (B[2] - B[3]) // Product at i
   + F(A, i + 1);                      // Proceed to next factor. All composite factors 
 }                                     // will be skipped effectively
 else 
  return 0;                            // Implied in the short-circuit &&
}

J , 19 octets

1#.*/@,:&([:-/_&q:)

Essayez-le en ligne!

Explication:

Un verbe dyadique, les arguments sont à la fois à gauche et à droite

         &(        ) - for both arguments (which are lists of 2 integers)
               _&q:  - decompose each number to a list of prime exponents
           [:-/      - and find the difference of these lists
       ,:            - laminate the resulting lists for both args (to have the same length)
   */@               - multiply them
1#.                  - add up 

Stax , 11 octets

ä÷ß½♂←√:=Ü]

Exécuter et déboguer

La représentation ascii correspondante du même programme est la suivante.

{|nmMFE-~-,*+

Fondamentalement, il obtient les exposants de la factorisation principale pour chaque partie. Il prend la différence de chaque paire, puis le produit, et résume enfin tous les résultats.

Python 2 , 133 127 octets

a=input();s=0;p=2;P=lambda n,i=0:n%p and(n,i)or P(n/p,i+1)
while~-max(a):a,(w,x,y,z)=zip(*map(P,a));s+=(w-x)*(y-z);p+=1
print s

Essayez-le en ligne!

A volé la condition de boucle de la soumission de xnor .

Merci pour les conseils de @mathmandan de changer la fonction en programme (Oui, il a en effet économisé quelques octets).

Solution obsolète et incorrecte (124 octets):

lambda w,x,y,z:sum((P(w,p)-P(x,p))*(P(y,p)-P(z,p))for p in[2]+range(3,w+x+y+z,2))
P=lambda n,p,i=1:n%p and i or P(n/p,p,i+1)

Haskell , 153 octets

(2%)
n%m|all(<2)m=0|(k,[a,b,c,d])<-unzip[(,)=<<div x.max 1.(n*)$until((>0).mod x.(n^))(+1)1-1|x<-m]=(a-b)*(c-d)+[i|i<-[n..],all((>0).rem i)[2..i-1]]!!1%k

Essayez-le en ligne! Exemple d' utilisation pour 20 · 14/15: (2%) [20,1,14,15].