Calcola la funzione di Landau

19

La funzione $g(n)$ Landau ( OEIS A000793 ) fornisce l'ordine massimo di un elemento del gruppo simmetrico $S_n$ . Qui, l'ordine di una permutazione $\pi$ è il più piccolo intero positivo $k$ tale che $\pi^k$ è l'identità - che è uguale al multiplo meno comune delle lunghezze dei cicli nella decomposizione del ciclo della permutazione. Ad esempio, $g(14) = 84$ che si ottiene ad esempio da (1,2,3) (4,5,6,7) (8,9,10,11,12,13,14).

Pertanto, $g(n)$ è uguale anche al valore massimo di $\operatorname{lcm}(a_1, \ldots, a_k)$ in cui $a_1 + \cdots + a_k = n$ con $a_1, \ldots, a_k$ interi positivi.

Problema

Scrivi una funzione o un programma che calcola la funzione di Landau.

Ingresso

Un numero intero positivo $n$ .

Produzione

$g(n)$ , l'ordine massimo di un elemento del gruppo simmetrico $S_n$ .

Esempi

Punto

Questo è code-golf : vince il programma più breve in byte. (Tuttavia, le implementazioni più brevi in più lingue sono benvenute.)

Si noti che non sono previsti requisiti per il runtime; pertanto, l'implementazione non deve necessariamente essere in grado di generare tutti i risultati dell'esempio sopra riportato in tempi ragionevoli.

Sono vietate le scappatoie standard.

code-golf math arithmetic permutations integer-partitions

— Daniel Schepler
fonte

Risposte:

9

05AB1E , 6 byte

Åœ€.¿Z

Provalo online!

    Åœ       # integer partitions of the input
      €.¿    # lcm of each
         Z   # maximum

— Grimmy
fonte

10

Wolfram Language (Mathematica) , 44 byte

Max[PermutationOrder/@Permutations@Range@#]&

Provalo online!

Wolfram Language (Mathematica) , 31 byte

@DanielSchepler ha una soluzione migliore:

Max[LCM@@@IntegerPartitions@#]&

Provalo online!

— romano
fonte

Non molto familiare con la lingua, ma Max[Apply@LCM/@IntegerPartitions@#]&sembra funzionare per me e darebbe 36 byte se è corretto.

— Daniel Schepler,

2

@DanielSchepler sì, super! Perché non lo proponi come soluzione separata? Puoi anche fare Max[LCM@@@IntegerPartitions@#]&per 31 byte , perché lo @@@fa Applyal livello 1.

— Roman

4

Python , 87 byte

f=lambda n,d=1:max([f(m,min(range(d,d<<n,d),key=(n-m).__rmod__))for m in range(n)]+[d])

Provalo online!

Una funzione ricorsiva che tiene traccia del resto ndella partizione e dell'LCM in esecuzione d. Si noti che ciò significa che non è necessario tenere traccia dei numeri effettivi nella partizione o di quanti ne abbiamo utilizzati. Proviamo ogni possibile parte successiva n-m, sostituendola ncon ciò che resta me dcon lcm(d,n-m). Prendiamo il massimo di quei risultati ricorsivi e di per dsé. Quando non rimane nulla n=0, il risultato è giustod .

La cosa difficile è che Python non ha alcun built-in per LCM, GCD o fattorizzazione primaria. Per fare lcm(d,m-n), generiamo un elenco di multipli di de prendiamo il valore che raggiunge il modulo minimo n-m, cioè con key=(n-m).__rmod__. Dato minche darà il valore precedente in caso di pareggio, questo è sempre il primo multiplo diverso da zero dche è divisibile per n-m, quindi il loro LCM. Abbiamo solo multipli di dfino a d*(n-m)che sia garantito a colpire il LCM, ma è più breve di scrittura d<<n(che è d*2**n) che basta con limiti superiore di Python essere esclusivo.

La mathlibreria di Python 3 ha gcd(ma non lcm) dopo 3.5, che è più breve di alcuni byte. Grazie a @Joel per abbreviare l'importazione.

Python 3.5+ , 84 byte

import math
f=lambda n,d=1:max([f(m,d*(n-m)//math.gcd(n-m,d))for m in range(n)]+[d])

Provalo online!

L'uso numpydi lcmè ancora più breve.

Python con numpy , 77 byte

from numpy import*
f=lambda n,d=1:max([f(m,lcm(d,n-m))for m in range(n)]+[d])

Provalo online!

— XNOR
fonte

L'uso from math import*è di 85 byte e l'utilizzo di import math+ math.gcd(...)è 84 byte. Lo stesso vale per numpy.

— Joel

@Joel Grazie, me ne sono dimenticato.

— xnor

@Joel Grazie, mi ero dimenticato di aggiornare il conteggio dei byte, sono entrambi 77. numpyLa lunghezza di 5 è il punto di pareggio per import*.

— xnor

Giusto. In quel caso preferisco usare import numpyperché numpy.maxavrebbe la precedenza sul built-in di Python max(lo stesso per min) se from numpy import*usato. Non causa problemi qui, ma sappiamo tutti che import*non è una buona pratica di programmazione in generale.

— Joel

@Joel Anche se import*è senza dubbio una cattiva pratica, non penso che sovrascriva effettivamente Python mine max, quindi la confusione sarebbe qualcuno che si aspetta la funzione del numpy e ottiene quella di base.

— xnor

4

Haskell , 44 byte

(%1)
n%t=maximum$t:[(n-d)%lcm t d|d<-[1..n]]

Provalo online!

— XNOR
fonte

3

Gelatina , 7 byte

Œṗæl/€Ṁ

Provalo online!

Un collegamento monadico che prende un intero come argomento e restituisce un intero.

Spiegazione

Œṗ      | Integer partitions
  æl/€  | Reduce each using LCM
      Ṁ | Maximum

— Nick Kennedy
fonte

3

JavaScript (ES6), 92 byte

$\operatorname{lcm}(a_1,\ldots,a_k)$ $a_1+\ldots+a_k$ $n$

f=(n,i=1,l=m=0)=>n?i>n?m:f(n-i,i,l*i/(G=(a,b)=>b?G(b,a%b):a)(l,i)||i)&f(n,i+1,l)|m:m=l>m?l:m

Provalo online!

JavaScript (ES6), 95 byte

f=(n,i=1,m)=>i>>n?m:f(n,i+1,i<m|(g=(n,k=2,p=0)=>k>n?p:n%k?p+g(n,k+1):g(n/k,k,p*k||k))(i)>n?m:i)

Provalo online!

Come?

Definiamo:

{\begin{cases} g (1) = 0 \\ g (n) = \sum_{j = 1}^{N} {p_{j}}^{k_{j}} for n > 1 and n = \prod_{j = 1}^{N} {p_{j}}^{k_{j}} \end{cases}

$\cases{ g(1)=0\\ g(n)=\sum_{j=1}^{N}{p_j}^{k_j}\quad\text{for}\enspace n>1\enspace\text{and}\enspace n=\prod_{j=1}^{N}{p_j}^{k_j} }$

(questo è A008475 )

Quindi usiamo la formula (da A000793 ):

f (n) = max_{g (k) \leq n} K

$f(n)=\max_{g(k)\le n}k$

— Arnauld
fonte

3

Perl 6 , 50 byte

{max .map:{+(.[$_],{.[@^a]}...$_,)}}o&permutations

Provalo online!

Controlla direttamente tutte le permutazioni, come la soluzione Ruby di @histocrat.

Spiegazione

                                     &permutations  # Permutations of [0;n)
{                                  }o  # Feed into block
     .map:{                       }  # Map permutations
                           ...  # Construct sequence
             .[$_]  # Start with permutation applied to itself [1]
                  ,{.[@^a]}  # Generate next item by applying permutation again
                              $_,  # Until it matches original permutation [2]
           +(                    )  # Length of sequence
 max  # Find maximum

¹ Possiamo usare qualsiasi sequenza di n elementi distinti per il controllo, quindi prendiamo semplicemente la permutazione stessa.

² Se l'endpoint è un contenitore, l' ...operatore di sequenza esegue lo smartmatch rispetto al primo elemento. Quindi dobbiamo passare un elenco di elementi singoli.

— nwellnhof
fonte

2

Rubino , 77 byte

f=->n{a=*0...n;a.permutation.map{|p|(1..).find{a.map!{|i|p[i]}==a.sort}}.max}

Provalo online!

(1..) la sintassi a intervallo infinito è troppo nuova per TIO, quindi il collegamento imposta un limite superiore arbitrario.

Questo utilizza la definizione diretta - enumera tutte le possibili permutazioni, quindi verifica ciascuna mutando afino a quando non torna alla sua posizione originale (il che significa anche che posso semplicemente mutare l'array originale in ciascun loop).

— histocrat
fonte

2

Gaia , 25 23 22 byte

,:Π¤d¦&⊢⌉/
1w&ḍΣ¦¦⇈⊢¦⌉

Provalo online!

Non avere LCM o partizioni intere rende questo approccio piuttosto lungo.

,:Π¤d¦&⊢⌉/		;* helper function: LCM of 2 inputs


1w&ḍΣ¦¦			;* push integer partitions
         ¦		;* for each
       ⇈⊢		;* Reduce by helper function
	  ⌉		;* and take the max

— Giuseppe
fonte

2

Haskell, 70 67 byte

f n=maximum[foldl1 lcm a|k<-[1..n],a<-mapM id$[1..n]<$[1..k],sum a==n]

Provalo online!

Modifica: -3 byte grazie a @xnor.

— Nome del modello
fonte

Penso che dovrebbe funzionare mapM(:[1..n]), dato che l'elemento extra è innocuo.

— xnor

1

Python 3 + numpy, 115 102 99 byte

-13 byte grazie a @Daniel Shepler

-3 più byte da @Daniel Shepler

import numpy
c=lambda n:[n]+[numpy.lcm(i,j)for i in range(1,n)for j in c(n-i)]
l=lambda n:max(c(n))

Provalo online!

Metodo della forza bruta: trova tutte le possibili sequenze a, b, c, ... dove a + b + c + ... = n, quindi scegli quella con il mcm più alto.

— Hiatsu
fonte

Per inciso, ho una soluzione numpy Python 3 + con 87 byte.

— Daniel Schepler,

Non so abbastanza su numpy da capire come farlo, quindi ti suggerisco di pubblicare la soluzione separatamente.

— Hiatsu,

Beh, stavo programmando di aspettare un po 'per pubblicarlo.

— Daniel Schepler,

Ho appena realizzato che hai pubblicato questa sfida. Scusa, farò del mio meglio.

— Hiatsu,

1

Se cambi cper restituire un set e memoize, non funziona affatto male (anche se, certamente, lo fa ungolf un po '): tio.run/##RY1BCsIwEEX3PUWWM1CLoiuhV/AKEsfUTkkmIU3AWnr2Ggvq7vM@//…

— Daniel Schepler

0

Pyth , 24 15 byte

eSm.U/*bZibZd./

Provalo online!

             ./Q  # List of partitions of the input
  m               # map that over lambda d:
   .U       d     # reduce d (with starting value first element of the list) on lambda b,Z:
     /*bZgbZ      # (b * Z) / GCD(b, Z)
 S                # this gives the list of lcms of all partitions. Sort this
e                 # and take the last element (maximum)

-9 byte: prestato attenzione e notato che Pyth ha effettivamente un GCD incorporato ( i).

— ar4093
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.