Parlons des diviseurs ...

En laissant de côté les carrés parfaits (pendant un moment), tous les entiers positifs peuvent être exprimés comme le produit de 2 de leurs diviseurs. Exemple rapide pour 126: Voici tous les diviseurs de126

Comme vous pouvez le voir, tous les diviseurs peuvent être jumelés. Voici ce que nous appellerons les paires de diviseurs :
[1, 126], [2, 63], [3, 42], [6, 21], [7, 18], [9, 14]

Pour ce défi, nous n'aurons besoin que de la dernière paire de cette liste (qui est la paire centrale de l'image):
[9,14]Nous appellerons cette paire la paire de diviseurs MaxMin .
La différence de la paire de diviseurs MaxMin (DMDP) est la différence des deux éléments de la paire qui est [9,14]=5
un exemple de plus 544. Les diviseurs sont:

[1, 2, 4, 8, 16, 17, 32 , 34, 68, 136, 272, 544]

et DMDP (544) = 15 car32-17=15

Et les carrés parfaits ? Tous les carrés parfaits ont DMDP = 0
Prenons par exemple 64avec des diviseurs

{1, 2, 4, 8 , 16, 32, 64}

Comme vous pouvez le voir dans ce cas, la paire de diviseurs MaxMin est [8,8]ce que DMDP=0
nous avons presque terminé.

Le défi

Étant donné un entier n>0, affichez combien d'entiers inférieurs ou égaux à 10000 , ont DMDP inférieur à n

Cas de test

entrée -> sortie

1->100 (those are all the perfect squares)
5->492  
13->1201
369->6175  
777->7264  
2000->8478  
5000->9440  
9000->9888  
10000->10000   
20000->10000

C'est le code-golf . La réponse la plus courte en octets gagne .

JavaScript (ES7), 60 octets

f=(n,i=1e4,j=i**.5|0)=>i?i%j?f(n,i,j-1):(i/j-j<n)+f(n,i-1):0

Dépasse probablement votre limite de récursivité, vous pouvez donc préférer la version itérative pour 70 octets:

n=>[...Array(1e4)].map(g=(j=++i**.5|0)=>i%j?g(j-1):k+=i/j-j<n,i=k=0)|k

Gelée , 13 octets

1 octet merci à Jonathan Allan.

ȷ4RÆDạU$Ṃ€<⁸S

Essayez-le en ligne!

Java 8, 151 111 110 101 101 octets

n->{int r=0,x=10000,i;for(;x-->0;r-=i-n>>-1)for(i=x;i-->1;)if(x>=i*i&x%i<1){i=x/i-i;break;}return r;}

-10 octets grâce à @Nevay .

Explication:

Essayez-le ici.

n->{               // Method with integer as parameter and return-type
  int r=0,         //  Result-integer
      x=10000,     //  Index-integer starting at 10,000
      i;           //  Another index-integer for the inner loop
  for(;x-->0;      //  Loop (1) from 10,000 down to 0
      r-=i-n>>-1)  //   If the MaxMin-Divisor Pair's difference is lower than the input,
                   //    add 1 to the result (after every iteration)
    for(i=x,       //   Set `i` to `x`
        i-->1;)    //   Inner loop (2) from `i` downwards to 1
      if(x>=i*i    //    If the current square-root of `x` is smaller than or equal to `i`,
         &x%i<1){  //    and if the current `x` is divisible by `i`:
        i=x/i-i;   //     Calculate the MaxMin-Division difference
        break;}    //     And leave the inner loop (2)
                   //   End of inner loop (2) (implicit / single-line body)
                   //  End of loop (1) (implicit / single-line body)
  return r;        //  Return the result
}                  // End of method

R , 73 77 octets

Merci à @Guiseppe pour les 4 octets

sum(sapply(1:1e4,function(x)min(abs((w=which(x%%1:x<1))-rev(w))))<scan())

Essayez-le en ligne!

J'ai perdu la fonction vectorisation pour calculer le DMDP et utilise maintenant un sapply sur la fonction. Les vérités pour les éléments inférieurs à l'entrée sont additionnées pour le résultat.

Mathematica, 64 octets

Count[Divisors~Array~1*^4,a_/;#+a[[i=⌈Tr[1^a]/2⌉]]>a[[-i]]]&

Essayez-le sur Wolfram Sandbox

Usage

f = Count[Divisors~Array~1*^4,a_/;#+a[[i=⌈Tr[1^a]/2⌉]]>a[[-i]]]&

f[1]

100

f /@ {1, 5, 13, 369, 777, 2000, 5000, 9000, 10000, 20000}

{100, 492, 1201, 6175, 7264, 8478, 9440, 9888, 10000, 10000}

Explication

Divisors~Array~1*^4

Générez les listes de diviseurs, de 1à 10000. (les listes de diviseurs sont triées automatiquement)

Count[ ..., a_/; ... ]

Comptez les occurrences d'éléments a, tels que ...

#+a[[i=⌈Tr[1^a]/2⌉]]>a[[-i]]]

(input) + (left one of the middle element(s)) > (right one of the middle element(s)) S'il n'y a qu'un seul élément central, gauche = droite.

05AB1E , 19 18 17 16 15 12 octets

4°ƒNÑÂα{нI‹O

Essayez-le en ligne!

Explication

4°ƒ            # for N in [0 ... 10**4] do:
   NÑ          # push divisors of N 
     Â         # bifurcate
      α        # element-wise absolute difference
       {       # sort
        н      # pop the head (smallest difference)
         I‹    # is it smaller than the input?
           O   # sum the stack

MATL , 20 octets

1e4:"@Z\2Y"dJ2/)G<vs

Le code expire dans TIO. Voici un exemple exécuté avec le compilateur hors ligne:

>> matl 1e4:"@Z\2Y"dJ2/)G<vs
> 13
1201

R , 91 octets

function(n)sum(sapply(1:1e4,function(x,d=(1:x)[x%%1:x<1])diff(d[median(seq(d))+.5*0:1]))<n)

Adopte une approche (pire) différente pour calculer le DMDP que la solution de MickyT en utilisant l'indexation de tableaux et diffpour le calculer. Hélas.

Essayez-le en ligne!

Mathematica, 119 115 octets

(n=#;Tr[1^Select[Last@#-First@#&/@(Take[Divisors@#,Round[{-.1,.1}+(1+Length@Divisors@#)/2]]&/@Range@10000),#<n&]])&

J'ai finalement réussi à faire fonctionner cette chose et j'essaie depuis une demi-heure. ._.

Exemple d'exécution

Mathematica, 78 octets

(s=#;Tr[1^Select[Table[#2-#&@@Quantile[Divisors@i,{.5,.51}],{i,10^4}],#<s&]])&

Husk , 19 octets

#ȯV<⁰Sz≠↔§f`¦ḣḣ□100

Pas de lien TIO, car il arrive à expiration. Cette version utilise 100 au lieu de 10000 et se termine en quelques secondes.

Explication

Husk n'a pas encore de diviseurs intégrés ni de support pour la notation scientifique.

#ȯV<⁰Sz≠↔§f`¦ḣḣ□100  Input is n (accessed with ⁰).
               □100  Square of 100: 10000
              ḣ      Inclusive range from 1.
#                    Count number of elements for which
 ȯ                   this composition of 3 functions gives truthy result:
                       Argument k, say k = 12.
         §f`¦ḣ         Divisors of k:
             ḣ           Range: [1,2,3,..,12]
         §f              Filter by
           `¦            divides k: [1,2,3,4,6,12]
     Sz≠↔              Absolute differences of divisor pairs:
        ↔                Reverse: [12,6,4,3,2,1]
     Sz                  Zip with divisor list
       ≠                 using absolute difference: [11,4,1,1,4,11]
  V<⁰                  Is any of these less than n?

Japt , 25 19 17 octets

L²õÈâ ®aX/ZÃd<UÃè

Essaye-le

Explication

Saisie implicite d'entier U.

L²õ

Générez un tableau d'entiers ( õ) de 1 à 100 ( L) au carré.

Èâ          Ã

Passez chacun par une fonction (où Xest l'élément courant) qui génère un tableau des diviseurs ( â) de X.

®    Ã

Mappez sur ce tableau de diviseurs, où Zest l'élément actuel.

aX/Z

Obtenez la différence absolue ( a) de Zet Xdivisée par Z.

d<U

L'un des éléments ( d) du tableau résultant est-il inférieur à U?

è

Comptez les éléments véridiques et sortez implicitement le résultat.

Rubis, 62 octets

->n{(1..1e4).count{|x|(1..x).any?{|i|1>x%i&&x/i<=i&&i-x/i<n}}}

Essayez-le en ligne.

TI-BASIC, 46 octets

Notez que TI-BASIC est un langage tokenisé. De plus, le E de la ligne 2 est un petit E majuscule, trouvé en appuyant sur 2ND +,.

Input A
DelVar DFor(B,1,E4
For(C,1,√(B
If not(fPart(B/C
B/C-C<A
End
D+Ans→D
End

Le résultat sera en D et Ans immédiatement après l'exécution du programme. S'il doit être affiché, l'ajout de deux octets supplémentaires (nouvelle ligne et Ans) suffirait.

Python 2 , 134 octets

lambda i:len(filter(lambda n:n<i,[reduce(lambda x,y:y-x,[[x,n/x]for x in range(1,int(n**.5+1))if n%x<1][-1])for n in range(1,10001)]))

Essayez-le en ligne!

Euh ... il faut faire beaucoup mieux.

Python 2 , 83 octets

Un peu lent, utilise 5 secondes par test

lambda x:sum(x>min(abs(y/t-t)for t in range(1,y+1)if y%t<1)for y in range(1,10001))

Essayez-le en ligne!

PHP, 94 + 1 octets

for(;$n++<1e4;$c+=$d<$argn)if(($i=$n**.5)>~~$i){while($n%++$i);for($d=1;$n%--$i;)$d++;}echo$c;

Exécuter en tant que pipe avec -nRou l' essayer en ligne .

VB.NET (.NET 4.5) 116 115 octets

Function A(n)
For i=1To 10^4
Dim s As Byte=Math.Sqrt(i)
While i Mod s>0
s-=1
End While
A-=i/s-s<n
Next
End Function

Explication:

Une fonction qui prend ncomme paramètre et renvoie le résultat.

Commence à la racine carrée et recherche l'entier le plus proche qui se divise également (sera le plus petit des MaxMin Divisor Pair). Obtient ensuite le plus grand de la paire (i/s ), trouve la différence et compare avec l'entrée.

Stratégies de golf utilisées:

• Dim est cher, donc moins je déclare de variables, mieux c'est.
• Je commence à chercher à la racine carrée, mais je veux seulement regarder les entiers. En déclarant scomme un type intégral, il jette au sol pour moi.
• VB utilise ^comme exposant. Donc, alors qu'il 10000y a 5 caractères, 10^4c'est seulement 4.
• VB crée une variable automatique avec le même nom et type que la définition de fonction (dans mon cas A). À la fin de la fonction, s'il n'y a pasreturn , la valeur de la variable de fonction sera renvoyée à la place. J'enregistre donc des caractères en ne déclarant pas de variable distincte et en n'utilisant pas de déclaration de retour.
• VB a une dactylographie / casting très indulgente. iest supposé Integerparce que j'ai attribué un littéral entier. Aest supposé Objectmais dès que j'ajoute un entier, il se comporte comme unInteger .
• Plutôt que de ifvérifier que la différence est satisfaisante, ajoutez-la directement au résultat en convertissant le booléen en un entier. Cependant, VB utilise -1pour True, donc soustrayez pour obtenir le signe correct.
• Techniquement, nous voulons Modne pas l'être 0. Prendre le module d'un nombre négatif dans VB.NET donnera un résultat négatif. Mais, tout est positif pour que je puisse enregistrer un octet en tournant <>dans >.
• Le plus grand nombre à vérifier est 10000. La racine carrée de ce nombre est 100. Je n'ai donc besoin que d'un Bytepour le stocker, en économisant des octets dans la déclaration en utilisant un type nommé plus court.

Essayez-le en ligne!

C # (.NET Core) , 104 octets

x=>{int o=0,i=1;for(;i<=10000;i++)for(int j=1;j<=i;j++)if(i%j<1&Math.Abs(j-i/j)<x){o++;break;}return o;}

Essayez-le en ligne!