Parliamo di divisori ...

Tralasciando i quadrati perfetti (per un momento), tutti i numeri interi positivi possono essere espressi come il prodotto di 2 dei loro divisori. Esempio rapido di 126: Ecco tutti i divisori di126

Come puoi vedere, tutti i divisori possono essere associati. Ecco cosa chiameremo le Divisor Pairs :
[1, 126], [2, 63], [3, 42], [6, 21], [7, 18], [9, 14]

Per questa sfida avremo bisogno solo dell'ultima coppia di questo elenco (che è la coppia centrale dell'immagine):.
[9,14]Chiameremo questa coppia la Coppia Divisore MaxMin .
La differenza di MaxMin Divisor Pair (DMDP) è la differenza dei due elementi della coppia che è [9,14]=5
un altro esempio per 544. I divisori sono:

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

e DMDP (544) = 15 perché32-17=15

E i quadrati perfetti ? Tutti i quadrati perfetti hanno DMDP = 0
Prendiamo ad esempio 64con i divisori

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

Come puoi vedere in questo caso, MaxMin Divisor Pair è ciò [8,8]che DMDP=0
abbiamo quasi finito.

La sfida

Dato un numero intero n>0, visualizza quanti numeri interi inferiori o uguali 10000 , hanno DMDP minore di n

Casi test

input -> output

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

Questo è il codice-golf .Shortest risposta in byte vittorie .

JavaScript (ES7), 60 byte

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

Probabilmente supera il limite di ricorsione, quindi potresti preferire la versione iterativa per 70 byte:

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 byte

1 byte grazie a Jonathan Allan.

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

Provalo online!

Java 8, 151 111 110 101 byte

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 byte grazie a @Nevay .

Spiegazione:

Provalo qui.

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 byte

Grazie a @Guiseppe per i 4 byte

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

Provalo online!

Hanno perso la funzione vettorializzare per calcolare il DMDP e ora sta utilizzando una funzione sappily. Le verità per gli elementi che sono inferiori all'input vengono sommate per il risultato.

Mathematica, 64 byte

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

Provalo su 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}

Spiegazione

Divisors~Array~1*^4

Genera gli elenchi dei divisori, da 1a 10000. (gli elenchi dei divisori vengono ordinati automaticamente)

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

Conta le occorrenze di elementi a, in modo tale che ...

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

(input) + (left one of the middle element(s)) > (right one of the middle element(s)) Se esiste un solo elemento centrale, sinistra = destra.

05AB1E , 19 18 17 16 15 12 byte

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

Provalo online!

Spiegazione

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 byte

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

Il codice scade in TIO. Ecco un esempio eseguito con il compilatore offline:

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

R , 91 byte

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

Adotta un approccio (peggiore) diverso per calcolare il DMDP rispetto alla soluzione di MickyT usando l'indicizzazione dell'array e diffper calcolarlo. Ahimè.

Provalo online!

Matematica, 119 115 byte

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

Finalmente ho fatto funzionare questa cosa e ci provo da mezz'ora. ._.

Esempio di esecuzione

Mathematica, 78 byte

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

Buccia , 19 byte

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

Nessun collegamento TIO, poiché è scaduto. Questa versione utilizza 100 al posto di 10000 e termina in un paio di secondi.

Spiegazione

Husk non ha ancora divisori integrati o supporto per la notazione scientifica.

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

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

Provalo

Spiegazione

Input implicito di numero intero U.

L²õ

Genera una matrice di numeri interi ( õ) da 1 a 100 ( L) al quadrato.

Èâ          Ã

Passa ciascuno attraverso una funzione (dove Xè l'elemento corrente) che genera un array dei divisori ( â) di X.

®    Ã

Mappa su quella matrice di divisori, dove si Ztrova l'elemento corrente.

aX/Z

Ottieni la differenza assoluta ( a) di Ze Xdivisa per Z.

d<U

Qualcuno degli elementi ( d) nella matrice risultante è inferiore a U?

è

Conta gli elementi di verità e genera implicitamente il risultato.

Rubino, 62 byte

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

Provalo online.

TI-BASIC, 46 byte

Si noti che TI-BASIC è un linguaggio tokenizzato. Inoltre, la E nella riga 2 è una piccola E maiuscola, trovata premendo 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

Il risultato sarà in D e Ans immediatamente dopo l'esecuzione del programma. Se deve essere visualizzato, è Anssufficiente aggiungere altri due byte (newline e ).

Python 2 , 134 byte

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

Provalo online!

Eugh ... devo fare molto meglio.

Python 2 , 83 byte

Un po 'lento, usa 5 secondi per test case

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

Provalo online!

PHP, 94 + 1 byte

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

Esegui come pipe -nRo provalo online .

VB.NET (.NET 4.5) 116 115 byte

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

Spiegazione:

Una funzione che accetta n come parametro e restituisce il risultato.

Inizia dalla radice quadrata e cerca il numero intero più vicino che divide uniformemente (sarà il più piccolo di MaxMin Divisor Pair). Quindi ottiene la più grande della coppia ( i/s), trova la differenza e confronta con l'input.

Strategie di golf utilizzate:

• Dim è costoso, quindi meno variabili dichiaro meglio.
• Comincio a cercare la radice quadrata, ma voglio solo guardare numeri interi. Dichiarandos come un tipo integrale, si lancia sul pavimento per me.
• VB usa ^come esponente. Quindi, mentre 10000è di 5 caratteri, 10^4è solo 4.
• VB crea una variabile automatica con lo stesso nome e tipo della definizione della funzione (nel mio caso A). Al termine della funzione, se non è presente return, verrà invece restituito il valore della variabile funzione. Quindi salvo i caratteri non dichiarando una variabile separata e non usando un'istruzione return.
• VB ha una battitura / casting molto tollerante. iè assunto Integerperché ho assegnato un numero intero letterale. Aè assunto Objectma non appena aggiungo un numero intero, si comporta come un Integer.
• Invece di ifverificare che la differenza sia soddisfacente, aggiungila direttamente al risultato lanciando il valore booleano su un numero intero. Tuttavia, VB utilizza -1per True, quindi sottrai per ottenere il segno corretto.
• Tecnicamente, non vogliamo Modesserlo 0. Prendere il modulo di un numero negativo in VB.NET darà un risultato negativo. Ma tutto è positivo, quindi posso salvare un byte trasformandolo <>in >.
• Il numero più grande da controllare è 10000. La radice quadrata di questo è 100. Quindi ho solo bisogno Bytedi memorizzarlo, salvando i byte nella dichiarazione usando un tipo di nome più breve.

Provalo online!

C # (.NET Core) , 104 byte

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

Provalo online!