Vamos falar sobre divisores ...

Deixando quadrados perfeitos (por um momento), todos os números inteiros positivos podem ser expressos como o produto de 2 de seus divisores. Exemplo rápido para 126: Aqui estão todos os divisores de126

Como você pode ver, todos os divisores podem ser emparelhados. Aqui está o que chamaremos de pares divisores :
[1, 126], [2, 63], [3, 42], [6, 21], [7, 18], [9, 14]

Para esse desafio, precisaremos apenas do último par desta lista (que é o par central da figura):. Vamos
[9,14] chamar esse par de Par MaxMin Divisor .
A diferença do par MaxMin divisor (DMDP) é a diferença dos dois elementos do par, que é [9,14]=5
mais um exemplo 544. Os divisores são:

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

e DMDP (544) = 15 porque32-17=15

E os quadrados perfeitos ? Todos os quadrados perfeitos têm DMDP = 0
Vamos pegar, por exemplo, 64com divisores

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

Como você pode ver neste caso, o MaxMin Divisor Pair é o [8,8]que DMDP=0
temos quase pronto.

O desafio

Dado um número inteiro n>0, a saída quantas inteiros menor ou igual a 10000 , têm DMDP menos de n

Casos de teste

entrada -> saída

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

Este é o código-golfe . A resposta mais curta em bytes vence .

JavaScript (ES7), 60 bytes

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

Provavelmente excede seu limite de recursão, portanto, você pode preferir a versão iterativa para 70 bytes:

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

Gelatina , 13 bytes

1 byte graças a Jonathan Allan.

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

Experimente online!

Java 8, 151 111 110 101 bytes

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 bytes graças a @Nevay .

Explicação:

Experimente aqui.

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 bytes

Obrigado a @Guiseppe pelos 4 bytes

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

Experimente online!

Perdeu a função vetorizar para calcular o DMDP e agora está usando um sapply sobre a função. As verdades para itens menores que a entrada são somadas para o resultado.

Mathematica, 64 bytes

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

Experimente na Wolfram Sandbox

Uso

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}

Explicação

Divisors~Array~1*^4

Gere as listas de divisores, de 1para 10000. (as listas de divisores são classificadas automaticamente)

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

Contar as ocorrências de elementos a, de modo que ...

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

(input) + (left one of the middle element(s)) > (right one of the middle element(s)) Se houver apenas um elemento do meio, esquerda = direita.

05AB1E , 19 18 17 16 15 12 bytes

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

Experimente online!

Explicação

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 bytes

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

O código atinge o tempo limite no TIO. Aqui está um exemplo executado com o compilador offline:

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

R , 91 bytes

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

Adota uma abordagem (pior) diferente para calcular o DMDP do que a solução da MickyT usando indexação de matriz ediff calculá-la. Alas.

Experimente online!

Mathematica, 119 115 bytes

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

Eu finalmente tenho essa coisa trabalhando e eu tenho tentado durante a última meia hora. ._.

Exemplo de execução

Mathematica, 78 bytes

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

Casca , 19 bytes

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

Nenhum link TIO, pois o tempo limite é excedido. Esta versão usa 100 no lugar de 10000 e termina em alguns segundos.

Explicação

Husk ainda não possui divisores ou suporte para notação científica.

#ȯ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 bytes

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

Teste-o

Explicação

Entrada implícita de número inteiro U.

L²õ

Gere uma matriz de números inteiros ( õ) de 1 a 100 ( L) ao quadrado.

Èâ          Ã

Passe cada um por uma função (onde Xestá o elemento atual) que gera uma matriz dos divisores ( â) de X.

®    Ã

Mapeie essa matriz de divisores, onde Zestá o elemento atual.

aX/Z

Obtenha a diferença absoluta ( a) de Ze Xdividida por Z.

d<U

Algum dos elementos ( d) na matriz resultante é menor que U?

è

Conte os elementos verdadeiros e produza implicitamente o resultado.

Ruby, 62 bytes

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

Experimente online.

TI-BASIC, 46 bytes

Observe que o TI-BASIC é um idioma tokenizado. Além disso, o E na linha 2 é um pequeno E maiúsculo, encontrado pressionando 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

O resultado estará em D e Ans imediatamente após a execução do programa. Para que seja exibido, Ansbasta adicionar mais dois bytes (nova linha e ).

Python 2 , 134 bytes

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)]))

Experimente online!

Eugh ... precisa fazer muito melhor.

Python 2 , 83 bytes

Um pouco devagar, usa 5 segundos por caso de teste

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))

Experimente online!

PHP, 94 + 1 bytes

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

Execute como pipe -nRou experimente online .

VB.NET (.NET 4.5) 116 115 bytes

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

Explicação:

Uma função que assume ncomo parâmetro e retorna o resultado.

Inicia na raiz quadrada e procura o número inteiro mais próximo que divide uniformemente (será o menor do MaxMin Divisor Pair). Em seguida, obtém o maior do par ( i/s), encontra a diferença e compara com a entrada.

Estratégias de golfe usadas:

• Dim é caro, então, quanto menos variáveis ​​eu declarar, melhor.
• Começo a procurar na raiz quadrada, mas só quero olhar para números inteiros. Ao declarars como um tipo integral, ele lança no chão para mim.
• VB usa ^como expoente. Então, enquanto 10000tem 5 caracteres, 10^4é apenas 4.
• O VB cria uma variável automática com o mesmo nome e tipo da definição da função (no meu caso A). No final da função, se não houver return, o valor da variável da função será retornado. Então, eu salvo os caracteres, não declarando uma variável separada e não usando uma instrução de retorno.
• O VB tem digitação / transmissão muito tolerantes. ié assumido Integerporque eu atribuí um literal inteiro. Aé assumido, Objectmas assim que adiciono um número inteiro, ele se comporta como um Integer.
• Em vez de ifverificar se a diferença é satisfatória, adicione-a diretamente ao resultado convertendo o booleano em um número inteiro. No entanto, o VB usa -1paraTrue , então subtraia para obter o sinal correto.
• Tecnicamente, queremos Modnão ser 0. Tomar o módulo de um número negativo no VB.NET dará um resultado negativo. Mas, tudo é positivo para que eu possa salvar um byte, transformando-o <>em >.
• O maior número a ser verificado é 10000. A raiz quadrada disso é 100. Então, eu só preciso Bytearmazenar isso, salvando bytes na declaração usando um tipo nomeado mais curto.

Experimente online!

C # (.NET Core) , 104 bytes

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;}

Experimente online!