Sequenza phi iterata

13

Correlati: Iterated phi (n) function .

La tua sfida è calcolare la funzione phi iterata:

f(n) = number of iterations of φ for n to reach 1.

Dove φè la funzione totient di Eulero .

OEIS correlato .

Ecco il grafico:

enter image description here

Regole:

Il tuo obiettivo è di produrre f(n)da n=2a n=100.

Questo è code-golf, quindi vince il codice più corto.

Ecco i valori che puoi confrontare:

1, 2, 2, 3, 2, 3, 3, 3, 3, 4, 3, 4, 3, 4, 4, 5, 3, 4, 4, 4, 4, 5, 4, 5, 4, 4, 4, 5, 4, 5, 5, 5, 5, 5, 4, 5, 4, 5, 5, 6, 4, 5, 5, 5, 5, 6, 5, 5, 5, 6, 5, 6, 4, 6, 5, 5, 5, 6, 5, 6, 5, 5, 6, 6, 5, 6, 6, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 6, 5, 6, 7, 5, 7, 5, 6, 6, 7, 5, 6, 6, 6, 6, 6, 6, 7, 5, 6, 6
code-golf  math  sequence  kolmogorov-complexity  number-theory 
— Arte semplicemente bella
fonte
@LuisMendo Risolto, e anche aggiunto valori grafici + da verificare. :-)
— Semplicemente bellissimo Art
1
Ho modificato il tag kolmogorov-complessità , poiché questo sta essenzialmente producendo un valore fisso
— caird coinheringaahing
1
@SimplyBeautifulArt In primo luogo dimostrare che ci sono finitamente molti valori xtali che phi(x)è un determinato numero fisso.
— user202729
2
Questa è una bella sfida, ma penso che sarebbe meglio chiedere una soluzione da implementare f(n), piuttosto che eseguirla su un intervallo di numeri fissi. Questo fa anche la differenza tra le lingue con la capacità di applicare funzioni su intervalli con meno byte (in parte una sfida camaleontica?)
— Uriel
1
: P Stai insinuando che dovrei cambiare la sfida per darti un vantaggio? Indipendentemente da come vengono stabilite queste regole, alcune lingue avranno un vantaggio e altre no. @Uriel
— Simply Beautiful Art

Risposte:

10

Haskell , 53 52 byte

Grazie nimi per aver salvato 1 byte!

f<$>[2..100]
f 1=0
f n=1+f(sum[1|1<-gcd n<$>[1..n]])

Provalo online!

sum[1|1<-gcd n<$>[1..n]]dà φ(n)(Tratto da Flawr , grazie!)

fè una funzione ricorsiva che calcola 1+φ(n)se n non lo è 1e genera 0ifn è 1, poiché non ci sono più iterazioni da prendere per raggiungere1

f<$>[2..100]Crea infine un elenco di fapplicato a ciascun elemento di[2..100]

— H.PWiz
fonte
7

Haskell , 70 69 68 byte

La funzione (\n->sum[1|1<-gcd n<$>[1..n]]) è la funzione totient, che applichiamo ripetutamente nella funzione anonima. Grazie @laikoni per -1 byte!

EDIT: Ho appena scoperto che @xnor ha usato questa esatta funzione totient in una precedente sfida .

length.fst.span(>1).iterate(\n->sum[1|1<-gcd n<$>[1..n]])<$>[2..100]

Provalo online!

— flawr
fonte
1
Questo è piuttosto breve per non avere un built-in completo!
— Luis Mendo il
1
@LuisMendo H.PWiz ha trovato una soluzione ancora più breve !
— Flawr
7

MATL , 16 15 byte

99:Q"@`_Zptq}x@

Provalo online!

Spiegazione

99:       % Push [1 2 ... 99]
Q         % Add 1 element-wise: gives [2 3 ... 100]
"         % For each k in that array
  @       %   Push k
  `       %   Do...while
    _Zp   %     Euler's totient function
     tq   %     Duplicate, subtract 1. This is the loop condition
  }       %   Finally (execute on loop exit)
  x       %     Delete
  @       %     Push latest k
          %   End (implicit)
          % End (implicit)
          % Display stack (implicit)

Vecchia versione, 16 byte

99:Qt"t_Zp]v&X<q

Provalo online!

Spiegazione

99:       % Push [1 2 ... 99]
Q         % Add 1 element-wise: gives [1 2 ... 100]
t"        % Duplicate. For each (i.e. do the following 100 times)
  t       %   Duplicate
  _Zp     %   Euler's totient function, element-wise
]         % End
v         % Concatenate vertically. Gives a 100×100 matrix
&X<       % Row index of the first minimizing entry for each column.
          % The minimum is guaranteed to be 1, because the number of
          % iterations is more than sufficient.
q         % Subtract 1. Display stack (implicit)
— Luis Mendo
fonte
1
I valori emessi sono disattivati ​​di uno, penso Provalo online! lo corregge (ma non ho mai usato MATL prima d'ora ...)
— caird coinheringaahing
Controlla la fine del mio post. Fornisce l'output previsto, al quale si è disattivati ​​uno su ciascuno.
— Simply Beautiful Art,
I primi 5 valori emessi dalla tua attuale risposta sono 2 3 3 4 3, quando la sfida dice che dovrebbero essere1 2 2 3 2
— caird coinheringaahing
@cairdcoinheringaahing e SimplyBeautifulArt Ah, capisco. Grazie! Ora corretto
— Luis Mendo il
6

Gelatina , 12 11 10 9 byte

³ḊÆṪÐĿ>1S

Provalo online!

-1 byte grazie a HyperNeutrino!

-1 byte grazie a Mr. Xcoder!

-1 byte grazie a Dennis

Come funziona

³ḊÆṪÐĿ>1S - Main link. No arguments
³         - Yield 100
 Ḋ        - Dequeue. Creates the list [2, 3 ... 99, 100]
    ÐĿ    - For each element, while the results of the next function
          - aren't unique, collect the results...
  ÆṪ      -   Next function: Totient
      >1  - Greater than one?
        S - Sum the columns

Dato che questo è stato fatto da Dennis, (comprensibilmente) non ho idea del perché funzioni, solo che funziona.

— caird coinheringaahing
fonte
1
@dylnan Tutte e tre le risposte emettono l'elenco di f(n)da 2a 100, e la domanda non menziona l'input, quindi penso che questa sia la versione corretta
— caird coinheringaahing
@dylnan La sfida chiede di uscita fper n=2a n=100, non solo un valore.
— Semplicemente bellissimo Art
Hai ragione, avevo letto l'inizio della sfida e non ho letto chiaramente la parte delle regole
— dylnan,
E per quanto riguarda il codice, sarebbe possibile utilizzare #in questo caso? Qualcosa di simile a questo (che chiaramente non funziona, ma scritto da qualcuno che capisce la sintassi chiaramente!)
— dylnan
@dylnan Forse, ma mentre stiamo generando un elenco fisso, applicare su ogni elemento ۏ di solito meglio di #.
— caird coinheringaahing il
6

APL (Dyalog) , 50 29 25 byte

Guarda, no, nessun totient incorporato!

4 byte salvati grazie a @ H.PWiz

{⍵=1:0⋄1+∇+/1=⍵∨⍳⍵}¨1+⍳99

Provalo online!

Come?

Apparentemente ho optato per la formula più completa (e più dura) per prima. Vedi la cronologia delle revisioni.

⍳⍵- 1an

⍵∨ - gcd con n

1= - uguale a 1?

+/ - sommali tutti

Questo è il totale. Tutto il resto è wrapper per il conteggio ( 1+∇) e l'applicazione sull'intervallo 2..100( ¨1+⍳99).

— Uriel
fonte
5

Mathematica, 44 byte

(i=-1;#+1//.x_:>EulerPhi[++i;x];i)&~Array~99

-10 byte da @Misha Lavrov
-2 byte da @ user202729

Provalo online!

— J42161217
fonte
4

J REPL, 23 byte

<:#@(5&p:^:a:)"0|2+i.99

Non ho controllato, ma probabilmente funziona con J normale se lo definisci come un nome (ho giocato a golf sul mio telefono sul REPL).

Incorporati, yo.

Direi che ci sono almeno 2-3 byte da eliminare (uno a uno a causa del modo in cui a:funziona, da usare |come noop, ecc.).

— ravizzone
fonte
1
+/*<:5&p:^:a:2+i.99 per 19 byte Provalo online!
— Galen Ivanov,
Per riferimento futuro, puoi anche usare "+invece di "0, quindi potrebbe anche diventare<:#@(5&p:^:a:)"+i.99
— Conor O'Brien il
2
16 byte con+/1<a:5&p:2+i.99
— miglia il
1
@ miglia: puoi spiegare l'uso di a:nel tuo codice? Come funziona invece ^:?
— Galen Ivanov,
1
@GalenIvanov (5&p:)^:a: mpuò essere fatto come a: 5&p: musando l'altra definizione di &quando una diade è legata a un sostantivo e quindi chiamata diadicamente.
— miglia
4

JavaScript (ES6), 115 ... 104 99 byte

La codifica hardware potrebbe essere più breve, ma proviamo un approccio puramente matematico.

f=n=>n>97?6:(P=(n,s=0)=>k--?P(n,s+(C=(a,b)=>b?C(b,a%b):a<2)(n,k)):s>1?1+P(k=s):1)(k=n+2)+' '+f(-~n)

console.log(f())
Espandi frammento

— Arnauld
fonte
L'hard-coding è di 90 byte ( link pastebin )
— Herman L
@HermanLauenstein Ben fatto.
— Arnauld,
3

Python 2 , 82 byte

l=0,1
exec"n=len(l);p=2\nwhile n%p:p+=1\nl+=l[p-1]+l[n/p]-n%4%3/2,;print l[n];"*99

Provalo online!

Questo utilizza le osservazioni che:

  • f(a*b) = f(a) + f(b) - 1, tranne che -1viene omesso se ae bsono entrambi pari
  • f(p) = f(p-1) + 1quando pè primo, conf(2)=1

Ciò implica che se nha una scomposizione in fattori primi n = 2**a * 3**b * 5**c * 7**d * 11**e * ..., allora f(n) = max(a,1) + b + 2*c + 2*d + 3*e + ..., dove ciascunop>2 contribuisce alla fattorizzazionef(p-1) .

Non sono sicuro se questi continuano a resistere n=100, ma se lo fanno, danno un modo per definire e calcolare fsenza usare φ.

— XNOR
fonte
2

Bubblegum , 49 byte

00000000: 5d88 0511 0020 0003 ab2c 024e ff64 e8a3  ].... ...,.N.d..
00000010: 379f 956b f05d 206c 0545 7274 743a b876  7..k.] l.Ertt:.v
00000020: 2267 27f9 9f4d 9b9d fc85 e7e6 994d 6eb0  "g'..M.......Mn.
00000030: 2b                                       +

Provalo online!

— OVS
fonte
2

PowerShell , 110 byte

$a=,0*101;2..100|%{$i=$_;for($z=$j=0;++$j-lt$i;$z+=$k-eq1){for($k=$j;$j%$k-or$i%$k;$k--){}};($a[$i]=$a[$z]+1)}

Provalo online!

Approccio matematico.

In realtà, guardando attraverso di essa, molto simile alla risposta C , ma sviluppato in modo indipendente. Crea una matrice di 0s, loop da 2a 100, quindi calcola phiutilizzando la gcdformulazione. La parte in parentesi alla fine salva entrambi il risultato $aper il prossimo giro e posiziona una copia sulla pipeline, risultando nell'output implicito.

PowerShell, 112 byte

"122323333434344534444545444545555545455645555655565646555656556656665656565656656757566756666667566"-split'(.)'

Provalo online!

Hard-coded. Ho-hum. Più corto di quanto potrei ottenere un approccio matematico di circa 10-15 byte.

— AdmBorkBork
fonte
Mi chiedo se in realtà hai bisogno di un separatore, poiché tutti i numeri sono a cifre singole :)
— flawr
1
Puoi mostrarci il tuo approccio matematico? Sembra sicuramente molto più interessante: P
— Conor O'Brien,
2
@ ConorO'Brien Per fortuna, sono stato in grado di guardarlo con occhi nuovi stamattina e di golf l'approccio matematico sotto l'approccio hard-coded.
— AdmBorkBork,
2

Python 2 , 83 byte

n=2
exec"print len(bin(n))-3+n%2-~n%9/8-(0x951a5fddc040419d4005<<19>>n&1);n+=1;"*99

Provalo online!

Combina una stima euristica con una costante codificata che corregge ogni stima come -0o -1.

— XNOR
fonte
2

Buccia , 10 17 byte

mö←LU¡Sȯṁε⌋ḣtḣ100

Provalo online!

Modifica : +7 byte per mappare effettivamente la funzione nell'intervallo richiesto, prima che fosse solo la funzione che calcola A003434 .

Spiegazione

Quanto segue calcola A003434 :

←LU¡S(ṁ(ε⌋))ḣ -- takes a number as input, for example: 39
   ¡          -- iterate the following function on the input: [39,24,8,4,2,1,1,1..]
    S(     )ḣ --   with itself (x) and the range [1..x]..
      ṁ(  )   --   ..map and sum the following
        ε⌋    --     0 if gcd not 1 else 1
  U           -- longest unique prefix: [39,24,8,4,2,1]
 L            -- length: 6
←             -- decrement: 5

La m(....)ḣ100parte ha appena mappato quella funzione nell'intervallo [2..100], non sono sicuro di come mi sia sfuggita quella parte prima: S

— ბიმო
fonte
1

PHP, 98 byte

1,2,<?=join(',',str_split(unpack('H*','##3444E4DEEDEEUUEEVEUVUVVFUVVUfVfVVVVVegWVgVffgV')[1]))?>,6

Provalo online!

Ho impacchettato tutte le cifre in una stringa binaria. Dopo averlo decompresso, convertendolo in un array e quindi unendo nuovamente l'array, ho dovuto solo anteporre 1,2 e aggiungere 6 in quanto quelli non si adattavano o causavano la visualizzazione di un codice di controllo.

— RFSnake
fonte
1

05AB1E , 11 byte

тL¦ε[DNs#sÕ

Provalo online!

Spiegazione

тL¦           # push range [2 ... 100]
   ε          # apply to each
    [         # start a loop
     D        # duplicate the current number
      N       # push the loop iteration counter
       s      # swap one copy of the current number to the top of the stack
        #     # if true, break the loop
         s    # swap the second copy of the current number to the top of the stack
          Õ   # calculate eulers totient
— Emigna
fonte
1

C, 112 byte

a[101];f(i,j,k,t){for(a[i=1]=0;i++<100;printf("%d ",a[i]=a[t]+1))for(t=j=0;++j<i;t+=k==1)for(k=j;j%k||i%k;k--);}

Ungolfed:

a[101];
f(i,j,k,t){
    for(a[1]=0,i=2;i<=100;i++) {   // initialize
        for(t=j=0;++j<i;t+=k==1)   // count gcd(i, j) == 1 (t = phi(i))
            for(k=j;j%k||i%k;k--); // calculate k = gcd(i, j)
        printf("%d ",a[i]=a[t]+1); // print and store results
    }
}

Provalo online!

— Colera Su
fonte
0

Allumina , 87 byte

hhhhhdadtqdhcpkkmzyhqkhwzydqhhwdrdhhhwrysrshhwqdrybpkshehhhwrysrarhcpkksyhaydhehycpkkmr

Provalo online!

Spiegazione

hhhhhdadt      CONSTANT 100

RANGE FROM 100 to 0
q
  dhc
p

REMOVE 0 AND 1
kk

OVER EACH ELEMENT...
m
  zyh
  q
    kh
    wzyd
    q
      DUPLICATE TOP TWO ELEMENTS...
      hhwdrdhhhwrysrshhw
      GCD...
      qdryb
    p
    ks
    he
    hhhw
    ry
    s
    rarhc
  p
  IS IT ONE? IF SO TERMINATE (FIXPOINT)
  kksyhaydhehyc
p
kk
m
REVERSE THE VALUES
r
— Conor O'Brien
fonte
0

Pyth, 38 byte (non competitivo)

.e-+1sl+1kb_jC"Éõ4ÕYHø\\uÊáÛ÷â¿"3

Provalo su Pyth Herokuapp , perché non funziona su TIO per qualsiasi motivo.

Non ho dubbi che la soluzione esplicita di Pyth sia più piccola, ma volevo vedere quanto potevo ottenere il codice comprimendo la sequenza e immagino Pyth immagino. Questo utilizza il fatto che è un limite superiore della sequenza log2(n)+1.

Spiegazione

.e-+1sl+1kb_jC"Éõ4ÕYHø\\uÊáÛ÷â¿"3
             C"Éõ4ÕYHø\\uÊáÛ÷â¿"   interpret string as base 256 integer
            j                   3  convert to array of base 3 digits
           _                       invert sequence (original had leading 0s)
.e                                 map with enumeration (k=index, b=element)
       +1k                                   k+1
     sl                            floor(log(   ))
   +1                                             +1
  -       b                                         -b

Ho ottenuto la stringa compressa tramite Ci_.e+1-sl+1ksb"122323333434344534444545444545555545455645555655565646555656556656665656565656656757566756666667566"3, che è esattamente l'opposto del codice sopra con alcune conversioni di tipo.

— stellatedHexahedron
fonte
1
Perché non competere?
— Simply Beautiful Art,
@SimplyBeautifulArt non significava davvero non competere in senso formale; modificato il titolo per renderlo più chiaro
— StellatedHexahedron
0

Ohm v2 , 41 byte

“ ‽W3>€þΣÌιZ§Á HgüυH§u·β}Bā€ΣNπáÂUõÚ,3“8B

Provalo online!

Letteralmente completamente hardcoded ... In realtà ho preso la sequenza sopra, ho rimosso tutto ciò che non era un numero, l'ho interpretato come base 8, quindi l'ho trasformato nella rappresentazione numerica della base 255 di Ohm. Ecco cosa fanno le citazioni. Quindi, il programma semplicemente lo trasforma nuovamente in base 8.

— ThePlasmaRailgun
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.