Fattoriali e cicli infiniti!


33

Come forse saprai, il fattoriale di un numero intero positivo nè il prodotto di tutti i numeri interi positivi uguali o minori n.

Per esempio :

6! = 6*5*4*3*2*1 = 720
0! = 1

Definiremo ora un'operazione speciale con un nome irrilevante come sumFac:

Dato un numero intero positivo n, sumFac(n)è la somma dei fattoriali delle cifre.

Per esempio :

sumFac(132) = 1! + 3! + 2! = 9

Compito

La tua missione, indipendentemente dal fatto che tu scelga di accettarla o meno, è di restituire la sequenza (potenzialmente infinita) delle applicazioni sumFaca un numero intero fornito in input.

Esempio : 132 -> 132, 9, 362880, 81369, 403927, ...

Ma non è tutto! In effetti, le applicazioni di sumFacalla fine creeranno un ciclo. È inoltre necessario restituire questo ciclo!

Se la tua lingua ha un fattoriale incorporato puoi usarlo. Non sono schizzinoso riguardo al tipo di ritorno, devi solo restituire la sequenza di applicazioni sumFac e il ciclo in un formato comprensibile per un essere umano.

EDIT: Per aiutarti a visualizzare meglio come dovrebbe essere l'output che ho copiato Leaky Nun è appena sotto:

[132, 9, 362880, 81369, 403927, 367953, 368772, 51128, 40444, 97, 367920, 368649, 404670, 5810, 40442, 75, 5160, 842, 40346, 775, 10200, 6, 720, 5043, 151, 122, 5, 120, 4, 24, 26, 722, 5044, 169, 363601, 1454]

Devi solo interrompere la sequenza quando il ciclo sta per iniziare per la seconda volta!

Ma questo è code-golf quindi vince la risposta più breve in byte!

Classifica

Ecco uno snippet di stack per generare sia una classifica regolare che una panoramica dei vincitori per lingua.



Benvenuti in PPCG! Sembra una bella sfida, a proposito.
clismique,

@ Qwerp-Derp Grazie mille! Ho cercato di essere creativo ^^

@Zgarb Beh, è ​​esattamente come l'uscita di Leaky Nun. La sequenza delle applicazioni e quindi deve terminare appena prima dell'inizio del secondo ciclo. Copierò il suo output nella domanda in modo che tutti possano avere una chiara comprensione. Grazie per

1
@ 2501 Hardcoding il valore è barare, ma per quanto riguarda la formattazione dell'output è possibile utilizzare qualsiasi separatore desiderato

Risposte:


19

Gelatina , 6 byte

D!SµÐĿ
    ÐĿ  Repeat until the results are no longer unique. Collects all intermediate results.
D           Convert from integer to decimal (list of digits)
 !          Factorial (each digit)
  S         Sum

Provalo online!

Non vedo altro modo per renderlo più breve se non quello di fare come detto.

Specifiche

  • Input: 132(come argomento della riga di comando)
  • Produzione: [132, 9, 362880, 81369, 403927, 367953, 368772, 51128, 40444, 97, 367920, 368649, 404670, 5810, 40442, 75, 5160, 842, 40346, 775, 10200, 6, 720, 5043, 151, 122, 5, 120, 4, 24, 26, 722, 5044, 169, 363601, 1454]

Non mi aspettavo di avere una risposta così breve. Bello :)

4
@Antoine È Jelly: D È sempre più corto di quanto penso che sarà;)
HyperNeutrino

8
@HyperNeutrino In qualche modo Dennis arriverà con una risposta ancora più breve
Leaky Nun

In qualche modo sì. Perché Dennis. : P
HyperNeutrino,

Quindi ... Quale codifica dei caratteri usi per creare 6 byte per quei 6 caratteri? Jelly non dovrebbe essere codificato UTF-8, il che significa che questo programma è in realtà 9 byte?
LordOfThePigs il

10

Python 2 , 88 byte

import math
f=lambda x,l=[]:l*(x in l)or f(sum(math.factorial(int(i))for i in`x`),l+[x])

Provalo online!


Come fan di Python sono contento che qualcuno abbia risposto, bello :)

9

05AB1E , 12 byte

[DˆS!O©¯så#®

Provalo online!

Spiegazione

[               # infinite loop
 Dˆ             # add a copy of current value to the global list (initialized as input)
   S            # split current number to digits
    !O          # calculate factorial of each and sum
      ©         # save a copy in register
       ¯så#     # if the current number is in the global list, exit loop
           ®    # retrieve the value from the register for the next iteration
                # implicitly output the global list

Breve e corretto, ben suonato!

Pensavo di potermi liberare della srisposta sbagliata, buona.
Magic Octopus Urn

8

Brachylog , 17 byte

g:I{tẹḟᵐ+}ᵃ⁾L¬≠Lk

Provalo online!

Spiegazione

g:I{     }ᵃ⁾         Accumulate I (a variable) times, with [Input] as initial input:
    t                  Take the last integer
     ẹḟᵐ+              Compute the sum of the factorial of its digits
            L        The result of the accumulation is L
            L­      Not all elements of L are different
               Lk    Output is L minus the last one (which is the start of the loop)

Cosa Isignifica?
Leaky Nun,

1
@LeakyNun È un parametro per ᵃ⁾. ᵃ³significa "accumula 3 volte". ᵃ⁾significa "accumula tante volte quanto l'ultimo elemento dell'input", che in quel caso è I. Dal momento che Iè una variabile completamente gratuito, si cercherà valori per esso da 0a +inf.
Fatalizza il

8

Wolfram Language, 62 60 56 byte

Most@NestWhileList[Tr[IntegerDigits@#!]&,#,UnsameQ,All]&

È davvero un peccato che Wolfram Language abbia nomi di funzioni così abominevolmente lunghi. *Sospiro*

Spiegazione:

Most[NestWhileList[Tr[IntegerDigits[#]!]&,#,UnsameQ,All]]&
                      IntegerDigits[#]                     (*Split input into list of digits*)
                                      !                    (*Factorial each element in the list*)
                   Tr[                 ]&                  (*Sum the list together*)
     NestWhileList[                      ,#,UnsameQ,All]   (*Iterate the function over itself, pushing each to a list, until a repeat is detected*)
Most[                                                   ]& (*Remove the last element in the list*)

Bella risposta. Non penso che questo possa essere migliorato.
Kelly Lowder,

1
@KellyLowder Grazie! Sono stato effettivamente in grado di salvare altri due byte mappando il fattoriale all'elenco, quindi riassumendolo con Tr.
Scott Milner,

1
Bel uso di NestWhileList[...,All]!
Greg Martin,

6

JavaScript (ES6), 91 89 byte

Salvato 2 byte grazie a fəˈnɛtɪk

Risulta essere abbastanza simile all'altra risposta di JS .

f=(n,x=!(a=[n]))=>n?f(n/10|0,x+(F=n=>n?n--*F(n):1)(n%10)):~a.indexOf(x)?a:f(x,!a.push(x))


Nella tua funzione fattoriale non dovresti essere in grado di usare n invece di n> 1 perché 0! = 1?
fəˈnɛtɪk,

@ fəˈnɛtɪk Non so cosa stavo pensando qui. Grazie!
Arnauld,

5

ClojureScript, 146 109 byte

#(loop[n[%]](let[f(apply +(for[a(str(last n))](apply *(range 1(int a))))](if(some #{f}n)n(recur(conj n f)))))

Yikes, questa è una mostruosità. Qualcuno, per favore, aiutami a giocare a golf ...

Grazie @cliffroot per esserti rasato ben 37 byte!

Questa è una funzione anonima, per eseguire la funzione, devi fare questo:

(#(...) {arguments})

TIO non ha ClojureScript, quindi ecco un link a un REPL ClojureScript.

Ecco un link a un programma Clojure che stampa l'ultimo elemento nell'elenco da 0 a 1000.

Ecco l'output per 9999:

[9999 1451520 269 363602 1455 265 842 40346 775 10200 6 720 5043 151 122 5 120 4 24 26 722 5044 169 363601 1454]

Ho il forte sospetto che tutti i numeri alla fine debbano sistemarsi 1o andare in loop[169 363601 1454] .

Codice non golfato:

(defn fact-cycle [n]
  (loop [nums [n]]
    (let [fact-num
          (let [str-n (str (last nums))]
            (apply +
              (for [a (range (count str-n))]
                (apply *
                  (range 1
                    (inc (int (nth str-n a))))))))]
      (if (some #{fact-num} nums) nums
        (recur
          (conj nums fact-num))))))

Spiegazione in arrivo!


Abbastanza lungo ma corretto;) Non posso davvero aiutarti a giocare a golf con questa scusa ^^

l'interno forpuò essere (for[a s](apply *(range 1(-(int a)47)))), no?
cliffroot,

e questo permetterà di sbarazzarsi dell'altrolet #(loop[n[%]](let[f(apply +(for[a(str(last n))](apply *(range 1(-(int a)47)))))](if(some #{f}n)n(recur(conj n f)))))
cliffroot il

oh, sembra che non ti serva nemmeno (- ... 47) in ClojureScript, intbasterà
cliffroot il

bene, (inc(int a))dovrebbe fare per ClojureScript e (-(int a)47)per Clojure.
cliffroot,

5

Perl 6 , 64 byte

{my@a;$_,{[+] .comb.map:{[*] 2..$_}}...^{$_@a||!@a.push: $_}}

Provalo

Allargato:

{

  my @a;             # array of values already seen

  $_,                # seed sequence with the input

  {
    [+]              # reduce using &infix:<+>
      .comb          # the digits of $_ (implicit method call)
      .map:          # do the following for each
      {
        [*] 2..$_    # get the factorial of
      }
  }


  ...^               # keep generating values until
                     # (「^」 means throw away the last value when done)

  {
      $_  @a        # is it an elem of @a? (「∈」 is shorter than 「(cont)」)

    ||               # if it's not

      !              # boolean invert so this returns False
        @a.push: $_  # add the tested value to @a
  }
}

Ogni riga sopra che ha {inizio un nuovo lambda a blocco nudo con un parametro implicito di$_ .

Ho usato [*] 2..$_invece [*] 1..$_semplicemente come micro ottimizzazione.


4

JavaScript, 92 byte

Grazie @Shaggy per giocare a golf su un byte con include
Grazie @Neil per giocare a golf su due byte

Codice separato in singole funzioni 92 byte

f=(x,a=[])=>a.includes(x)?a:f(k(x),a,a.push(x))
p=y=>y?y*p(y-1):1
k=n=>n?p(n%10)+k(n/10|0):0

Codice su una riga 92 byte

f=(x,a=[])=>a.includes(x)?a:f((k=n=>n?(p=y=>y?y*p(y-1):1)(n%10)+k(n/10|0):0)(x),a,a.push(x))

Spiegazione

Inizialmente chiama la funzione con un solo argomento, quindi a = [].

Se x esiste nell'array, viene restituito a a.includes(x)?a:...

Altrimenti, aggiungi x a a e passa la somma delle cifre fattoriali e a alla funzione (a.push(x),f(k(x),a))

p=y=>y?y*p(y-1):1
k=n=>n?p(n%10)+k(n/10|0):0

Somma della cifra fattoriale eseguita in modo tale da non superare il limite massimo di ricorsione.

Elenco di tutti i possibili endpoint: 1, 2, 145, 169, 871, 872, 1454, 40585, 45361, 45362, 363601

Provalo online!


1
Gah, ero così vicino! Salvare un byte conf=(x,a=[])=>a.includes(x)?a:(a.push(x),f(k(x),a))
Shaggy il

Non sai scrivere f(k(x),a,a.push(x))? Inoltre, penso che tu possa scrivere k=n=>n&&per salvare un altro byte.
Neil,

4

Haskell , 80 67 byte

g#n|elem n g=g|h<-g++[n]=h#sum[product[1..read[d]]|d<-show n]
([]#)

Provalo online! Uso:([]#) 132

Modifica: salvato 13 byte con caratteri da Ørjan Johansen!


(1) Prova e aggiungi ninvece di s(come nella risposta Python di ovs), quindi f=([]#). (2) Cambia i rami, in linea se usa elem.
Ørjan Johansen,

Cambia anche ++per :.

1
@Canyon È un ordine sbagliato per quello, darebbe il risultato finale invertito. Puoi quasi aggiustarlo in seguito, anteponendo un extra n:e cambiando =gin =[], ma sembra essere solo un pareggio.
Ørjan Johansen,

4

Pyth, 9 byte

.us.!MjNT
.us.!MjNTQ  implicit Q

.u          explained below
       N      current value
      j T     convert to decimal (list of digits)
   .!M        factorial of each digit
  s           sum

Provalo online!

Questa risposta utilizza .u("Punto fisso cumulativo. Applica fino a quando non viene trovato un risultato precedente. Restituisci tutti i risultati intermedi.")




2

R, 120 byte

o=scan()
repeat {
q=sum(factorial(as.double(el(strsplit(as.character(o[length(o)]), "")))))
if(q%in%o)break
o=c(o,q)
}
o

puoi fare o=scan(), usare al el()posto di [[1]], e gamma(n+1)=factorial(n)credo che salvi un byte, e penso che as.numericsia lo stesso che as.doubleper gli interi, che salva anche un byte, e puoi usare toStringinvece di as.character.
Giuseppe,

@Giuseppe Grazie per l'input, aggiornato.
Neil

2

Java 9 JSHell, 213 byte

n->{Set<Integer>s=new HashSet<>();
return IntStream.iterate(n,i->(""+i).chars()
.map(x->x<50?1:IntStream.rangeClosed(2,x-48)
.reduce(1,(a,b)->a*b)).sum()).boxed()
.takeWhile(x->s.add(x)).collect(Collectors.toList());}

Provalo online!

Nota: questa soluzione si basa sulla rappresentazione di stringa di un numero con punti di codice nell'intervallo 48-57. Funziona con ASCII, UTF-8, Latin-1, tutti i set di caratteri ISO-8859- *, la maggior parte delle pagine di codice. Non funziona per EBCDIC. Non credo che nessuno detrarrà punti per quello. :)

Ungolfed:

Function<Integer, List<Integer>> f =        // function from Integer to List of Integer
n -> {
    Set<Integer> s = new HashSet<>();       // memo of values we've seen
    return IntStream.iterate(n,             // iterate over n, f(n), f(f(n)), etc.
    i -> (""+i).chars()                     // the sumFac function; for all chars
        .map(x -> x < 50? 1 :               // give 1 for 0! or 1!
        IntStream.rangeClosed(2, x-48)      // else produce range 2..d 
        .reduce(1,(a,b)->a*b))              // reduction to get the factorial
        .sum())                             // and sum up the factorii!

                                            // now we have a stream of ints
                                            // from applying sumFac repeatedly
        .boxed()                            // box them into Integers (thanks, Java)
        .takeWhile(x->s.add(x))             // and take them while not in the memo
        .collect(Collectors.toList());      // collect them into a list
}

Gli appunti:

  • Il valore di ritorno di Set :: add è molto utile qui; restituisce vero iff l'articolo non era nel set
  • Ero sarcastico quando ho detto "Grazie, Java"
  • factorii non è proprio una parola; L'ho appena inventato

1
Ammetto che questo è originale! Bel lavoro :)

@Antoine Lo ammetto, Java non è la lingua migliore per giocare a golf, ma non è certo la cosa più folle che ho fatto di recente. :) codegolf.stackexchange.com/a/117644/794
David Conrad

2

Pyth, 22 11 byte

.usm.!sd+Nk

Provalo online!

Molto merito alla risposta di Leaky Nun , che mi ha fatto conoscere.u aiutato a salvare ben 11 byte di questo programma.

Spiegazione:

.usm.!sd+NkQ | ending Q is implicitly added
             | Implicit: Q = eval(input())
.u         Q | Repeat the function with initial value Q until a previous value is found. Return all intermediate values
  s          | Summation
   m.!sd     | For each character 'd' in the string, convert to integer and take the factorial
        +Nk  | Convert function argument to string

Pyth ha funzioni più utili di quanto si possa immaginare. Vedi la mia risposta come riferimento.
Leaky Nun,

@LeakyNun Ho riscritto la mia risposta per l'uso .u. Immagino che dovrò dare nuovamente un'occhiata al riferimento al personaggio per vedere se ci sono altre funzioni utili lì.
K Zhang,

È possibile utilizzare `Nper convertire in stringa anziché +Nk.
Leaky Nun,

@LeakyNun Dove Nallora sarebbe obsoleto, e arriva una soluzione a 9 byte ...
Erik the Outgolfer

1

Assioma, 231 byte

l(a:NNI):List NNI==(r:List NNI:=[];repeat(r:=cons(a rem 10,r);a:=a quo 10;a=0=>break);r)
g(a:NNI):NNI==reduce(+,[factorial(x) for x in l(a)])
h(a:NNI):List NNI==(r:=[a];repeat(a:=g(a);member?(a,r)=>break;r:=cons(a,r));reverse(r))

funzioni non golfate e alcuni test

-- convert one NNI in its list of digits
listify(a:NNI):List NNI==
    r:List NNI:=[]
    repeat
        r:=cons(a rem 10,r)
        a:=     a quo 10
        a=0=>break
    r

-- g(1234)=1!+2!+3!+4!
SumfactorialDigits(a:NNI):NNI==reduce(+,[factorial(x) for x in listify(a)])

ListGenerateFromSumFactorialDigits(a:NNI):List NNI==
    r:=[a]
    repeat
       a:=SumfactorialDigits(a)
       member?(a,r)=>break
       r:=cons(a,r)
    reverse(r)

(9) -> h 132
   (9)
   [132, 9, 362880, 81369, 403927, 367953, 368772, 51128, 40444, 97, 367920,
    368649, 404670, 5810, 40442, 75, 5160, 842, 40346, 775, 10200, 6, 720,
    5043, 151, 122, 5, 120, 4, 24, 26, 722, 5044, 169, 363601, 1454]

1

Java 7, 220 byte

String c(int n){String r=n+",",c;for(;!r.matches("^"+(c=(n=d(n))+",")+".*|.*,"+c+".*");r+=c);return r;}int d(int n){int s=0;for(String i:(n+"").split(""))s+=f(new Long(i));return s;}long f(long x){return x<2?1:x*f(x-1);}

Spiegazione:

String c(int n){                            // Method with integer parameter and String return-type
  String r=n+",",                           //  Result-String (which starts with the input integer + a comma
         c;                                 //  Temp String
  for(;!r.matches(                          //  Loop as long as the result-String doesn't match the following regex:
    "^"+(c=(n=d(n))+",")+".*|.*,"+c+".*");  //    "^i,.*|.*,i,.*" where `i` is the current integer
                                            //   `n=d(n)` calculates the next integer in line
                                            //   `c=(n=d(n))+","` sets the temp String to this integer + a comma
    r+=c                                    //   And append the result-String with this temp String
  );                                        //  End of loop
  return r;                                 //  Return the result-String
}                                           // End of method

int d(int n){                               // Separate method (1) with integer parameter and integer return-type
  int s=0;                                  //  Sum
  for(String i:(n+"").split(""))            //  Loop over the digits of `n`
    s+=f(new Long(i));                      //   And add the factorial of these digits to the sum
                                            //  End of loop (implicit / single-line body)
  return s;                                 //  Return the sum
}                                           // End of separate method (1)

long f(long x){                             // Separate method (2) with long parameter and long return-type (calculates the factorial)
                                            // (NOTE: 2x `long` and the `new Long(i)` is shorter than 2x `int` and `new Integer(i)`, hence long instead of int)
  return x<2?                               //  If `x` is 1:
      1                                     //   return 1
    :                                       //  Else:
      x*f(x-1);                             //   return `x` multiplied by the recursive-call of `x-1`
}                                           // End of method (2)

Codice di prova:

Provalo qui.

class M{
  String c(int n){String r=n+",",c;for(;!r.matches("^"+(c=(n=d(n))+",")+".*|.*,"+c+".*");r+=c);return r;}int d(int n){int s=0;for(String i:(n+"").split(""))s+=f(new Long(i));return s;}long f(long x){return x<2?1:x*f(x-1);}

  public static void main(String[] a){
    System.out.println(new M().c(132));
  }
}

Produzione:

132,9,362880,81369,403927,367953,368772,51128,40444,97,367920,368649,404670,5810,40442,75,5160,842,40346,775,10200,6,720,5043,151,122,5,120,4,24,26,722,5044,169,363601,1454,

1

GolfScript , 44 byte

~]{..)\;10base{,1\{)*}/}%{+}*.@\+@@?)!}do);`

~                                             eval input
 ]                                            initialization
  {                                   }do     do...
   ..)\;                                          initialization
        10base                                    get digits
              {,1\{)*}/}%                         factorial each
                         {+}*                     sum
                             .@\+@@?)!        while result not found
                                         );   drop last element
                                           `  tostring

Provalo online!

La parte fattoriale è di qui .


1

C, 161 byte

f(a){return a?a*f(a-1):1;}
a(l){return l?f(l%10)+a(l/10):0;}
c,t,o;r(i){for(t=o=i;t=a(t),o=a(a(o)),c=t^o;);for(t=i;t^c;printf("%d ",t),c=c|t^o?c:o,t=a(t),o=a(o));}

Guardalo funzionare online.


1

TI-BASIC, 85 79 64 60 byte

:Prompt L₁                             //Get input as 1 length list, 4 bytes
:Lbl C                                //create marker for looping, see below, 3 bytes
:int(10fPart(Xseq(10^(~A-1),A,0,log(X //split input into list of digits, 20 bytes
:sum(Ans!→X                           //factorial and sum the list, write to new input, 6 bytes
:If prod(L₁-X                         //Test to see if new element is repeated, see below, 7 bytes
:Then                                 //Part of If statement, 2 bytes
:augment(L₁,{X→L₁                     //Push new input to List 1, 10 bytes
:Goto C                               //Loop back to beginning, 3 bytes
:Else                                 //Part of If statement, 2 bytes
:L₁                                   //Print Answer, 2 bytes

Poiché questo è in esecuzione su una calcolatrice grafica, la RAM è limitata. Prova a testarlo con numeri che si ripetono rapidamente, ad esempio 169.

Più spiegazione:

:int(10fPart(Xseq(10^(~A-1),A,0,log(X
              seq(10^(~A-1),A,0,log(X //Get a list of powers of 10 for each digit (i.e. 1, 0.1, 0.01, etc.)
             X                        //Multiply by input
       fPart(                         //Remove everything but the decimal
     10                               //Multiply by 10 (move one digit in front of the decimal
:int(                                 //Truncate to an integer

If prod(L₁-Xfunziona sottraendo il nuovo elemento dalla vecchia lista, quindi moltiplicando tutti gli elementi della lista insieme. Se l'elemento era già nell'elenco, il prodotto sarà 0un valore falso. Altrimenti, il prodotto sarà un numero intero positivo, un valore veritiero.



1

J , 40 31 byte

Modifica: 9 byte salvati utilizzando i miglioramenti di FrownyFrog. Grazie!

f=.$:@,~`]@.e.~[:+/@:!10#.inv{:

Codice originale:

f = [ `($: @,) @.. ([: -. e ~.) [: + / @ (0 & ": @ {:)!"."

In questo caso ho deciso di contare i byte per la definizione del verbo, poiché altrimenti non funziona nell'interprete.

Spiegazione:

                         ({:) - Accetta l'ultimo elemento dell'array
                               ": @ - lo converte in stringa
                          "." 0 & - converte ogni carattere in numero intero
                       ! @ - trova i fattoriali
                     + / - li somma
                   [: - cap (ci sono 2 verbi derivati ​​sopra, ne abbiamo bisogno 3 per un fork)
          (e. ~) - controlla se il risultato è presente nell'elenco    
             -. - annulla il controllo sopra riportato
           [: - cap
        @. - Congiunzione dell'agenda, necessaria per la ricorsione
  ($: @,) - se il risultato non è nell'elenco, aggiungerlo all'elenco e ricorrere
[`- se il risultato è nell'elenco, visualizzalo e interrompi    

Provalo online!


1
([:-.e.~)->(1-e.~)
FrownyFrog


@FrownyFrog Grazie, il tuo codice è molto meglio! Ho provato 10 # .inv all'inizio mentre sperimentavo, ma poi l'ho scritto 10 & # inv ed è stato più lungo, quindi l'ho rifiutato. Grazie per tutti i tuoi suggerimenti! Ho molto da imparare :)
Galen Ivanov,

@FrownyFrog Invertire i casi all'ordine del giorno è così buono, mi dispiace di non averlo visto :)
Galen Ivanov,

[:+/!@"."0@":@{:è della stessa lunghezza, quindi non ci sono miglioramenti 10#.inv. Ho appena lasciato cadere il file ().
FrownyFrog,

1

Tcl , 143 byte

proc P {n L\ ""} {proc F n {expr $n?($n)*\[F $n-1]:1}
while {[set n [expr [join [lmap d [split $n ""] {F $d}] +]]] ni $L} {lappend L $n}
set L}

Provalo online!

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.