Wenn eine positive ganze Zahl (streng) weniger Primfaktoren hat (ohne Multiplizitäten zu zählen) als ihr Nachfolger und ihr Vorgänger, nennen wir sie eine faktorarme Zahl .$N > 2$

Mit anderen Worten, und , wobei die Anzahl der eindeutigen Primfaktoren von .$\omega(N) < \omega(N - 1)$$\omega(N) < \omega(N + 1)$$\omega(N)$$N$

Aufgabe

Sie können zwischen folgenden E / A-Formaten wählen:

• Nehmen Sie eine ganze Zahl und geben Sie die faktorarme Zahl . Wenn Sie diesen auswählen, kann entweder 0 oder 1 indiziert sein.$N$$N^{\text{th}}$$N$
• Nehmen Sie eine positive ganze Zahl und geben Sie die ersten faktorarmen Zahlen aus.$N$$N$
• Drucken Sie die Sequenz auf unbestimmte Zeit.

Sie können Eingaben und Ausgaben mit jeder Standardmethode und in jeder Programmiersprache vornehmen. Beachten Sie dabei, dass diese Lücken standardmäßig verboten sind. Dies ist Codegolf, also gewinnt das kürzeste Einreichen, das sich an die Regeln hält.

Ich werde keine separaten Testfälle einschließen, da die Methoden des Wettbewerbs unterschiedlich sind. Sie können jedoch auf die ersten 100 Begriffe dieser Sequenz verweisen, die OEIS A101934 lautet :

11, 13, 19, 23, 25, 27, 29, 37, 41, 43, 47, 49, 53, 59, 61, 64, 67, 71, 73, 79, 81, 83, 89, 97, 101, 103, 107, 109, 113, 121, 125, 131, 137, 139, 149, 151, 155, 157, 163, 167, 169, 173, 179, 181, 191, 193, 197, 199, 211, 221, 223, 227, 229, 233, 239, 241, 243, 251, 259, 263, 265, 269, 271, 277, 281, 283, 289, 293, 307, 309, 311, 313, 317, 331, 337, 341, 343, 347, 349, 353, 359, 361, 365, 367, 371, 373, 379, 383, 389, 397, 401, 407, 409, 419, 421, 431, 433, 439, 441, 443

Beispielsweise tritt in dieser Sequenz auf, weil (5), (2 und 13) und (2 und 3), also und .$25$$\omega(25) = 1$$\omega(26) = 2$$\omega(24) = 2$$\omega(25) < \omega(24)$$\omega(25) < \omega(26)$

Brachylog , 21 Bytes

⟨+₁≡-₁⟩{ḋdl}ᵐ⌋>~↰₂?ẉ⊥

Probieren Sie es online!

Druckt unendlich.

Erläuterung

⟨+₁≡-₁⟩                  Fork: The output of the fork is [Input + 1, Input -1]
       {   }ᵐ            Map:
        ḋdl                (predicate 2) the output is the length of the prime decomposition
                           of the input with no duplicates
             ⌋           Take the minimum result of that map
              >          This minimum is bigger than…
               ~↰₂?      …the output of predicate 2 with Input as input
                  ?ẉ     Write Input followed by a new line if that's the case
                    ⊥    False: backtrack and try another value for Input

Jelly , 13-12 Bytes

Cr~ÆvÐṂN⁼Wø#

Gibt die ersten n faktorarmen Zahlen aus.

Probieren Sie es online!

Wie es funktioniert

Cr~ÆvÐṂN⁼Wø#  Main link. No arguments.

          ø   Wrap the links to the left into a chain and begin a new chain.
           #  Read an integer n from STDIN and call the chain to the left with
              arguments k = 0, 1, 2, ... until n of them return a truthy value.
              Return those n values of k as an array.
C                 Complement; yield -k+1.
  ~               Bitwise NOT; yield -k-1.
 r                Range; yield [-k+1, -k, -k-1].
     ÐṂ           Yield those elements of [-k+1, -k, -k-1] for which the link to
                  the left returns the minimal value.
   Æv                 Count the number of unique prime factors.
                      Note that, for a negative argument, Æv counts -1 as well, and
                      0 is counted as a/the factor of 0. Negating the the arguments
                      eliminates the edge case 1 (no factors), which would be a
                      false positive otherwise.
                  For a factor-poor number, this yields [-k].
       N          Take the negatives of the resulting integers.
         W        Wrap; yield [k].
        ⁼         Test the results to both sides for equality.

Python 2 , 123 119 Bytes

q=lambda n:sum(n%i<all(i%j for j in range(2,i))for i in range(2,n+1))
i=2
while 1:
 i+=1
 if q(i-1)>q(i)<q(i+1):print i

Probieren Sie es online!

MATL , 26 24 22 Bytes

`T@3:q+YFg!sdZSd0>?@QD

Druckt die Sequenz auf unbestimmte Zeit.

Probieren Sie es online!

Erläuterung

`         % Do...while loop
  T       %   Push true. Will be used as loop condition
  @       %   Push (1-based) iteration index, k 
  3:q     %   Push [1 2 3] minus 1, that is, [0 1 2]
  +       %   Add, element-wise. Gives [k k+1 k+2]
  YF      %   Exponents of prime-factor decomposition. Gives a 3-row matrix
  g       %   Convert to logical: non-zero numbers become 1
  !s      %   Transpose, sum of each column. Gives a row vector of 3 elements, 
          %   which are the number of unique prime factors of k, k+1 and k+2 
  d       %   Consecutive differences. Gives a row vector of 2 elements
  ZS      %   Sign: replaces each number by -1, 0 or 1
  d       %   Consecutive difference. Gives a single number
  0>      %   Is it positive?
  ?       %   If so
    @Q    %     Push k+1
    D     %     Display
          %   End (implicit)
          % End (implicit). The stack contains true, which (is consumed and)
          % causes an infinite loop

Schale , 22 Bytes

f(ΠtSM<←ṙ1mȯLup§…←→)tN

Druckt die Sequenz auf unbestimmte Zeit, probiert sie online aus oder zeigt das erste N an !

Alternativ §oΛ>←t könnte statt ΠtSM<←.

Erläuterung

f(                  )tN  -- filter the tail of the naturals ([2,3…]) by:
  ΠtSM<←ṙ1m(Lup)§…←→     -- | takes a number as argument, example 11
                §…       -- | range of..
                  ←      -- | | the argument decremented (10)
                   →     -- | | to the argument incremented (12)
                         -- | : [10,11,12]
          m(   )         -- | map the following (example on 12) ..
              p          -- | | prime factors: [2,2,3]
             u           -- | | deduplicate: [2,3]
            L            -- | | length: 2
                         -- | : [2,1,2]
        ṙ1               -- | rotate by 1: [1,2,2]
    SM<                  -- | map the function (< X) over the list where X is ..
       ←                 -- | | the first element (1)
                         -- | : [0,1,1]
   t                     -- | tail: [1,1]
  Π                      -- | product: 1
                         -- : [11,13,19,23,25,27,29…

Pyth , 14 Bytes

.f!-.ml{Pb}tZh

Probieren Sie es hier aus!

Es war ursprünglich ein Vorschlag zu Dopapps Antwort , aber sie sagten mir , ich solle ihn separat posten.

Wie es funktioniert?

.f! -. ml {Pb} tZh | Volles Programm. Übernimmt die Eingabe von STDIN und gibt das erste N an STDOUT aus.

.f | (var: Z) Gibt die ersten N Werte aus, die das Prädikat erfüllen.
          } tZh | Erstellt die Liste [Z - 1, Z, Z + 1].
    .m | (var: b) Nehmen Sie die Elemente mit minimalem Funktionswert.
        Pb | Primfaktoren von b.
      l {| Deduplizieren, Länge ermitteln.
               | Für eine faktorarme Zahl ergibt sich daraus ein Singleton.
   - | Entferne Z davon.
  ! | Logische Verneinung.

Haskell, 105-86 Bytes

Vielen Dank an @Wheat Wizard, @Bruce Forte und @Laikoni für die Einsparung von 19 Bytes.

[n|n<-[2..],d n<d(n-1),d n<d(n+1)] d x=[1|n<-[1..x],x`rem`n<1,all((>0).rem n)[2..n-1]]

Oktave ,  87   83  79 Bytes

Danke an @Cows quack für das Speichern eines Bytes und danke an @Luis Mendo für das Speichern von drei, sechs Bytes!

f=@(n)nnz(unique(factor(n)));n=9;while++n if[f(n-1) f(n+1)]>f(n)disp(n);end;end

Druckt die Sequenz auf unbestimmte Zeit.

Probieren Sie es online!

73 Bytes mit vorangestelltem n =Wert:

f=@(n)nnz(unique(factor(n)));n=9;while++n if[f(n-1) f(n+1)]>f(n)n end;end

Probieren Sie es online!

05AB1E , 14 13 Bytes

Gibt die n-te faktorarme Zahl aus (1-indiziert)

µ3LN+Íf€gÀć›P

Probieren Sie es online!

Erläuterung

µ                 # loop over N (1,2,3, ...) until counter equals input
 3L               # push the range [1,2,3]
   N+             # add current N
     Í            # subtract 2
      f           # get unique prime factors of each
       €g         # get length of each factor list
         À        # rotate left
          ć       # extract the head
           ›      # check if the remaining elements are strictly greater
            P     # product
                  # if 1, increment counter
                  # implicitly output final N

Pyth, 30 25 Bytes

#=hTI&>l{PhTKl{PT>l{PtTKT

Dies ist mein erstes richtiges Pythgolf, daher sind Kommentare sehr willkommen.

Ein großes Dankeschön an Xcoder!

Erläuterung

#                         | Loop until error
 =hT                      | Add one to T (initially 10)
    I&                    | If both...
      >l{PhTKl{PT         | The number of unique prime factors of T+1 is greater than that of T (store in K) 
                 >l{PtTK  | And the number of unique prime factors of T-1 is greater than K (from before)
                        T | Then implicitly print T

TIO .

JavaScript (ES6), 94 Byte

Gibt die N-te faktorarme Zahl mit dem Index 0 zurück.

f=(i,n=9)=>(P=(n,i=k=1)=>++k>n?0:n%k?P(n,1):i+P(n/k--,0))(n)>P(++n)&P(n)<P(n+1)&&!i--?n:f(i,n)

Probieren Sie es online!

Wie?

Wir definieren zunächst die P () -Funktion, die die Anzahl der eindeutigen Primfaktoren einer bestimmten Ganzzahl zurückgibt.

P = (                   // P = recursive function taking:
  n,                    //   n = input number to test
  i =                   //   i = flag to increment the number of prime factors
  k = 1                 //   k = current divisor
) =>                    //
  ++k > n ?             // increment k; if k is greater than n:
    0                   //   stop recursion
  :                     // else:
    n % k ?             //   if k is not a divisor of n:
      P(n, 1)           //     do a recursive call with n unchanged and i = 1
    :                   //   else:
      i +               //     add i and
      P(n / k--, 0)     //     do a recursive call with n / k and i = 0; decrement k

Der Umhüllungscode lautet nun:

f = (                   // given:
  i,                    //   i = input index
  n = 9                 //   n = counter
) =>                    //
  P(n) > P(++n) &       // increment n; if P(n - 1) is greater than P(n)
  P(n) < P(n + 1) &&    // and P(n) is less than P(n + 1)
  !i-- ?                // and we have reached the correct index:
    n                   //   return n
  :                     // else:
    f(i, n)             //   go on with the next value

Japt , 29 27 26 Bytes

Ich bin damit nicht ganz zufrieden, aber es ist zumindest besser als mein erster Versuch, der über 40 Bytes dauerte!

Gibt die Nth Zahl in der Sequenz 1-indiziert aus.

È=Jõ_+X k â ÊÃé)e>Xo)«´U}a

Versuch es

Erläuterung

Implizite Eingabe einer Ganzzahl U.

È                       }a

Gibt die erste Ganzzahl Xzurück, die true zurückgibt, wenn sie die folgende Funktion durchlaufen hat.

=Jõ             )

Ordnen Sie das Array [-1,0,1]zu X.

 _+X      Ã

Leiten Sie jedes Element dieses Arrays durch eine Funktion, die zuerst den aktuellen Wert von addiert X.

k â Ê

Liefert die Länge ( Ê) der eindeutigen ( â) Primfaktoren ( k) des Ergebnisses.

é

Drehen Sie das resultierende Array um eins nach rechts.

e>Xo)

Pop ( o) das letzte Element aus Xund überprüfen Sie, ob alle verbleibenden Elemente größer als es sind.

«´U

Wenn ja, dekrementieren Sie Uund überprüfen Sie, ob es gleich 0 ist.

Python 3 , 97 Bytes

n,g=9,lambda m,k=2,p=1:m//k and(m%k<p%k)+g(m,k+1,p*k*k)
while 1:n+=1;g(n-1)>g(n)<g(n+1)!=print(n)

Theoretisch wird die Sequenz auf unbestimmte Zeit ausgedruckt. In der Praxis güberschreitet schließlich die Rekursionsgrenze.

Probieren Sie es online!

C (gcc) 126 Bytes

j,t;o(n){for(j=t=0;j++<n;)if(n%j<1)for(t--;j>1>n%j;)n/=j;t=~t;}
m(J){for(J=3;;J++)if(o(J-1)>o(J)&o(J)<o(J+1))printf("%d,",J);}

Probieren Sie es online!

Sauber , 130 123 117 Bytes

import StdEnv
?n=[1\\q<-[p\\p<-[2..n]|and[gcd p i<2\\i<-[2..p-1]]]|n rem q<1]
f=[n\\n<-[3..]| ?n<min(?(n-1))(?(n+1))]

Entspricht einer unendlichen Anzahl von Begriffen der Sequenz. Da es sich um verschachtelte Verstehen handelt, kann es die Grafikverkleinerung nicht sehr gut nutzen und ist daher auch bei einem so schlechten Algorithmus recht langsam.

Probieren Sie es online!

APL NARS, 124 Bytes, 62 Zeichen

{(⍵>1E4)∨⍵≤0:¯1⋄x←9+⍳10×⍵⋄⍵↑(∊{v←⍴∘∪∘π¨⍵+2-⍳3⋄2=+/v>2⌷v}¨x)/x}

Es sollte Antwort bis 1E4 zurückgeben, dann -1 Fehler zurückgeben; es wird angenommen, dass 9..10xargument genug richtige Zahlen hat; Prüfung:

  z←{(⍵>1E4)∨⍵≤0:¯1⋄x←9+⍳10×⍵⋄⍵↑(∊{v←⍴∘∪∘π¨⍵+2-⍳3⋄2=+/v>2⌷v}¨x)/x}  
  z 0
¯1
  z 1
11 
  z 20
11 13 19 23 25 27 29 37 41 43 47 49 53 59 61 64 67 71 73 79