Générer des chiffres approximatifs

15

Contexte

Un nombre npeut être décrit comme B-rugueux si tous les facteurs premiers de ndépassent strictement B.

Le défi

Étant donné deux entiers positifs Bet k, k Baffichez les premiers chiffres.

Exemples

Soit f(B, k)une fonction qui retourne l'ensemble contenant les premiers k Bnombres.

> f(1, 10)
1, 2, 3, 4, 5, 6, 7, 8, 9, 10

> f(2, 5)
1, 3, 5, 7, 9

> f(10, 14)
1, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59
Addison Crump
la source
2
Pouvez-vous développer le défi? Je ne le comprends pas. Peut-être expliquer les exemples?
db
Je ne comprends pas pourquoi vous incluez 1 dans toutes vos réponses quand il n'est jamais supérieur à B?
kamoroso94
1
1 n'a pas de facteurs premiers, donc chaque facteur premier de 1 est supérieur à B et 1 devrait apparaître dans la sortie indépendamment de B.
Hood
@db Factoriser nen nombres premiers. Si tous ces nombres premiers sont supérieurs à B, n est B-rough.
Addison Crump
@AddisonCrump Ainsi, par exemple, puisque les nombres premiers de 35 sont 5 et 7, 35 est 4-rugueux? S'agit-il d'une terminologie commune reconnue? Je n'en ai jamais entendu parler auparavant. Je ne suis toujours pas sous les exemples, surtout pas le dernier. 14 numéros mais qu'est-ce que 10 ??
db

Réponses:

5

Haskell , 53 44 octets

b%k=take k[n|n<-[1..],all((>0).mod n)[2..b]]

Essayez-le en ligne!

Merci à H.PWiz pour -9 octets!

b%k=                       -- given inputs b and k
 take k                    -- take the first k elements from 
  [n|n<-[1..]              -- the infinite list of all n > 0
   ,all            [2..b]] -- where all numbers from 2 to b (inclusive)
      ((>0).mod n)         -- do not divide n.
Laikoni
la source
Cela peut être quelque peu simplifié
H.PWiz
@ H.PWiz Bon, en quelque sorte, je ne pensais qu'à prendre la (>b)partie à l'intérieur de la compréhension (ce qui ne fonctionne pas) mais pas l'inverse. Merci!
Laikoni
5

Python 3 , 80 , 75 octets

lambda B,k:[i for i in range(1,-~B*k)if all(i%j for j in range(2,B+1))][:k]

Essayez-le en ligne!

Merci à shooqie pour avoir économisé 5 octets.

Cela suppose que le kième nombre approximatif de B ne dépassera jamais Bk , ce que je ne sais pas prouver, mais cela semble être une hypothèse assez sûre (et je ne trouve aucun contre-exemple).

Solution alternative:

Python 2 , 78 octets

B,k=input()
i=1
while k:
 if all(i%j for j in range(2,B+1)):print i;k-=1
 i+=1

Essayez-le en ligne!

Cette solution ne fait pas la solution ci-dessus. Et est beaucoup plus efficace.

DJMcMayhem
la source
3
Hmm, cette hypothèse est probablement vérifiable, mais un problème intéressant néanmoins. Je vais prime pour une preuve.
Addison Crump
1
Pourquoi pas lambda B,k:[i for i in range(1,-~B*k)if all(i%j for j in range(2,B+1))][:k]?
shooqie
1
@BlackOwlKai Cela semble cool. Voir aussi math.stackexchange.com/questions/2983364/…
Anush
@Anush Malheureusement, ma preuve n'a pas fonctionné, car j'ai fait une erreur
Black Owl Kai
3

Perl 6 , 35 32 octets

-3 octets grâce à nwellnof!

{grep(*%all(2..$^b),1..*)[^$^k]}

Essayez-le en ligne!

Un bloc de code anonyme qui prend deux entiers et renvoie une liste d'entiers.

Explication

{                              }  # Anonymous code block
 grep(             ,1..*)        # Filter from the positive integers
      *              # Is the number
       %             # Not divisible by
        all(      )  # All of the numbers
            2..$^b   # From 2 to b
                         [^$^k]   # And take the first k numbers
Jo King
la source
Que fait all-il?
Addison Crump
1
@AddisonCrump allvérifie si tous les éléments de la liste sont véridiques. Je vais ajouter une explication pour le tout prochainement
Jo King
@nwellnhof Wow! Voilà pourquoi les jonctions sont utiles!
Jo King
Oui, notez que vous pouvez également utiliser à la [&]place de all.
nwellnhof
@AddisonCrump Je suppose qu'il alln'est plus utilisé de cette façon, donc je devrais mettre à jour ma réponse. allcrée une jonction des valeurs de la plage 2..bet toutes les opérations effectuées sur la jonction sont exécutées simultanément sur toutes les valeurs. Lorsqu'il est évalué dans le contexte booléen par le grep, cela se réduit à savoir si toutes les valeurs de la jonction sont véridiques, c'est-à-dire non nulles
Jo King
3

Husk , 9 8 octets

↑foΛ>⁰pN

Essayez-le en ligne!

Bk

↑         -- take the first k elements 
       N  -- from the natural numbers
 f        -- filtered by
  o   p   -- the prime factors
   Λ>⁰    -- are all larger than the first input
Laikoni
la source
2

Fusain , 33 octets

NθNη≔⁰ζW‹Lυη«≦⊕ζ¿¬Φθ∧κ¬﹪ζ⊕κ⊞υζ»Iυ

Essayez-le en ligne! Le lien est vers la version détaillée du code. Explication:

NθNη

Entrée Bet k.

≔⁰ζ

Réglez zà 0.

W‹Lυη«

Répétez jusqu'à ce que nous ayons des kvaleurs.

≦⊕ζ

Incrément z.

¿¬Φθ∧κ¬﹪ζ⊕κ

Divisez zpar tous les nombres de 2à Bet voyez si le reste est nul.

⊞υζ»

Sinon, poussez zvers la liste vide prédéfinie.

Iυ

Convertissez la liste en chaîne et exportez-la implicitement.

Neil
la source
2

JavaScript (ES6), 68 octets

Prend l'entrée comme (b)(k).

b=>k=>(o=[],n=1,g=d=>(d<2?o.push(n)==k:n%d&&g(d-1))||g(b,n++))(b)&&o

Essayez-le en ligne!

Commenté

b => k => (             // input = b and k
  o = [],               // o[] = output array
  n = 1,                // n = value to test
  g = d => (            // g = recursive function, taking the divisor d
    d < 2 ?             // if d = 1:
      o.push(n) == k    //   push n into o[] and test whether o[] contains k elements
    :                   // else:
      n % d && g(d - 1) //   if d is not a divisor of n, do a recursive call with d - 1
    ) ||                // if the final result of g() is falsy,
    g(b, n++)           // do a recursive call with d = b and n + 1
)(b)                    // initial call to g() with d = b
&& o                    // return o[]
Arnauld
la source
1

Gelée , 10 octets

1µg³!¤Ịµ⁴#

Essayez-le en ligne!

Comment ça fonctionne

1µg³!¤Ịµ⁴#    Dyadic main link. Left = B, right = k
       µ⁴#    Take first k numbers satisfying...
  g             GCD with
   ³!¤          B factorial
      Ị         is insignificant (abs(x) <= 1)?
1µ            ... starting from 1.
Bubbler
la source
1

APL (NARS), 52 caractères, 104 octets

r←a f w;i
r←,i←1⋄→3
i+←1⋄→3×⍳∨/a≥πi⋄r←r,i
→2×⍳w>↑⍴r

Au-dessus, il semble que les lignes après 'r ← afw; j'ai' ont des noms 1 2 3; test:

  o←⎕fmt
  o 1 h 2
┌2───┐
│ 1 2│
└~───┘
  o 1 h 1
┌1─┐
│ 1│
└~─┘
  o 10 h 14
┌14───────────────────────────────────────┐
│ 1 11 13 17 19 23 29 31 37 41 43 47 53 59│
└~────────────────────────────────────────┘
RosLuP
la source
1

05AB1E , 9 octets

∞ʒÒ¹›P}²£

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

Explication:

          # Infinite list starting at 1: [1,...]
 ʒ    }    # Filter it by:
  Ò        #  Get all prime factors of the current number
   ¹›      #  Check for each if they are larger than the first input
     P     #  And check if it's truthy for all of them
       ²£  # Leave only the leading amount of items equal to the second input
Kevin Cruijssen
la source