Fatoriais e ciclos sem fim!

33

Como você deve saber, o fatorial de um número inteiro positivo né o produto de todos os números inteiros positivos iguais ou menores a n.

Por exemplo :

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

Vamos agora definir uma operação especial com um nome irrelevante como sumFac:

Dado um número inteiro positivo n,sumFac(n) é a soma dos fatoriais dos dígitos.

Por exemplo :

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

Tarefa

Sua missão, independentemente de você optar por aceitá-la ou não, é retornar a sequência (potencialmente infinita) dos aplicativos sumFacpara um número inteiro fornecido na entrada.

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

Mas isso não é tudo! De fato, as aplicações de sumFaceventualmente criarão um ciclo. Você também deve retornar este ciclo!

Se seu idioma tiver um fatorial incorporado, você poderá usá-lo. Não sou exigente quanto ao tipo de retorno, basta retornar a sequência de aplicativos sumFac e o ciclo em um formato compreensível por um ser humano.

EDIT: Para ajudá-lo a visualizar melhor como deve ser a saída, copiei as Leaky Nun's logo abaixo:

[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]

Você só precisa parar a sequência quando o ciclo estiver prestes a começar pela segunda vez!

Mas isso é código-golfe então a resposta mais curta em bytes vence!

Entre os melhores

Aqui está um snippet de pilha para gerar uma classificação regular e uma visão geral dos vencedores por idioma.

Mostrar snippet de código

code-golf  math  number  sequence  factorial 
— Freira Furada
fonte
— Leaky Nun
Bem-vindo ao PPCG! Parece um bom desafio, BTW.
— Clismique
@ Qwerp-Derp Muito obrigado! Eu tentei ser criativo ^^
@ Zgarb Bem, é exatamente como a saída de Leaky Nun. A sequência dos pedidos e, em seguida, deve terminar imediatamente antes do início do segundo ciclo. Vou copiar a saída dele na pergunta para que todos possam ter um entendimento claro. Obrigado por apontar isso :)
1
@ 2501 codificar o valor é batota, mas sobre a saída de formatação que você pode usar qualquer separador que você deseja

Respostas:

19

Gelatina , 6 bytes

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

Experimente online!

Não vejo outra maneira de torná-lo mais curto do que fazer o que foi dito.

Especificações

  • Entrada: 132(como argumento da linha de comandos)
  • Saída: [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]
— Freira Furada
fonte
Eu não esperava ter uma resposta tão curta. Nice :)
4
@Antoine É Jelly: D É sempre mais curto do que eu acho que vai ser;)
— HyperNeutrino
8
@HyperNeutrino alguma forma Dennis virá com uma resposta ainda mais curto
— Leaky Nun
De alguma forma, sim. Porque o Dennis. : P
— HyperNeutrino
Então ... Qual codificação de caracteres você usa para criar 6 bytes para esses 6 caracteres? Jelly não deveria ser codificado em UTF-8, o que significa que este programa é na verdade 9 bytes?
— LordOfThePigs
10

Python 2 , 88 bytes

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

Experimente online!

— ovs
fonte
Como um fã de python Eu estou feliz que alguém respondeu com ele, nice :)
9

05AB1E , 12 bytes

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

Experimente online!

Explicação

[               # 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
— Emigna
fonte
Curto e correto, bem jogado!
Achei que poderia me livrar da sresposta errada e agradável.
— Urna de polvo mágico
8

Braquilog , 17 bytes

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

Experimente online!

Explicação

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)
— Fatalizar
fonte
O que Isignifica isso ?
— Leaky Nun
1
@LeakyNun É um parâmetro para ᵃ⁾. ᵃ³significa "acumular 3 vezes". ᵃ⁾significa "acumular quantas vezes o último elemento da entrada", que nesse caso é I. Desde Ié uma variável completamente livre, ele vai tentar valores para que a partir 0de +inf.
— Fatalize
8

Wolfram Language, 62 60 56 bytes

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

É realmente muito ruim que a Wolfram Language tenha nomes de funções tão abomináveis. *Suspiro*

Explicação:

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*)
— Scott Milner
fonte
Boa resposta. Eu não acho que isso possa ser melhorado.
— Kelly Lowder
1
@KellyLowder Thanks! Consegui salvar mais dois bytes mapeando o fatorial para a lista e depois somando-o Tr.
— Scott Milner
1
Bom uso de NestWhileList[...,All]!
— Greg Martin
6

JavaScript (ES6), 91 89 bytes

Economizou 2 bytes graças a fəˈnɛtɪk

Acontece ser bastante semelhante à outra resposta 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))

Mostrar snippet de código

— Arnauld
fonte
In your factorial function shouldn't you be able to use n instead of n>1 because 0!=1?
— fəˈnɛtɪk
@fəˈnɛtɪk I don't know what I was thinking here. Thank you!
— Arnauld
5

ClojureScript, 146 109 bytes

#(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, that is a monstrosity. Someone please help me golf this...

Thanks @cliffroot for shaving off a whopping 37 bytes!

This is an anonymous function, to run the function, you have to do this:

(#(...) {arguments})

TIO doesn't have ClojureScript, so here's a link to a ClojureScript REPL.

Here's a link to a Clojure program which prints the last element in the list from 0 to 1000.

Here's the output for 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]

I have a strong suspicion that all numbers must eventually settle at 1 or the loop [169 363601 1454].

Ungolfed code:

(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))))))

Explanation coming soon!

— clismique
fonte
Quite long but correct ;) I cannot really help you to golf this sorry ^^
the inner for can be (for[a s](apply *(range 1(-(int a)47)))), can't it?
— cliffroot
and this will allow to get rid of the other let #(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
oh, seems you don't even need (- ... 47) in ClojureScript, just int will suffice
— cliffroot
well, (inc(int a)) should do for ClojureScript and (-(int a)47) for Clojure.
— cliffroot
5

Perl 6, 64 bytes

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

Try it

Expanded:

{

  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
  }
}

Every line above that has { starts a new bare block lambda with an implicit parameter of $_.

I used [*] 2..$_ instead of [*] 1..$_ purely as a micro optimization.

— Brad Gilbert b2gills
fonte
4

JavaScript, 92 bytes

Thanks @Shaggy for golfing off one byte with includes
Thanks @Neil for golfing off two bytes

Code separated into individual functions 92 bytes

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

Code on one line 92 bytes

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))

Explanation

Initially call the function with just a single argument, therefore a=[].

If x exists in the array a return a a.includes(x)?a:...

Otherwise, append x to a and pass the factorial digit sum and a to the function (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

Factorial Digit sum performed so that it will not exceed the maximum recursion limit.

List of all possible endpoints: 1, 2, 145, 169, 871, 872, 1454, 40585, 45361, 45362, 363601

Try it online!

— fəˈnɛtɪk
fonte
1
Gah, I was so close! Save a byte with f=(x,a=[])=>a.includes(x)?a:(a.push(x),f(k(x),a))
— Shaggy
Can you not write f(k(x),a,a.push(x))? Also, I think you can write k=n=>n&& to save another byte.
— Neil
4

Haskell, 80 67 bytes

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

Try it online! Usage: ([]#) 132

Edit: Saved 13 bytes with typs from Ørjan Johansen!

— Laikoni
fonte
(1) Test and append n instead of s(same as in ovs's Python answer), then f=([]#). (2) Switch the branches, inline s, and use elem.
— Ørjan Johansen
Switch out your ++ for : also.
1
@Canyon It's the wrong order around for that, it would give the final result reversed. You can almost fix it up afterwards, by prepending an extra n: and changing =g to =[], but it seems to be only a tie.
— Ørjan Johansen
4

Pyth, 9 bytes

.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

Try it online!

This answer uses .u ("Cumulative fixed-point. Apply until a result that has occurred before is found. Return all intermediate results.")

— Leaky Nun
fonte
2

R, 120 Bytes

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
— Neil
fonte
you can do o=scan(), use el() instead of [[1]], and gamma(n+1)=factorial(n) which I believe saves a byte, and I think as.numeric is the same as as.double for integers, which also saves a byte, and you can use toString instead of as.character.
— Giuseppe
@Giuseppe Thanks for the input, updated.
— Neil
2

Java 9 JSHell, 213 bytes

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());}

Try it online!

Note: This solution relies on the string representation of a number having code points in the range 48-57. Works for ASCII, UTF-8, Latin-1, all ISO-8859-* character sets, most code pages. Does not work for EBCDIC. I don't think anyone will deduct points for that. :)

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
}

Notes:

  • The return value of Set::add is very helpful here; returns true iff the item was not in the set
  • I was being sarcastic when I said "Thanks, Java"
  • factorii isn't really a word; I just made that up
— David Conrad
fonte
1
I admit this is original ! Nice job :)
@Antoine I admit, Java isn't the best language to golf in, but it's hardly the craziest thing I've done lately. :) codegolf.stackexchange.com/a/117644/794
— David Conrad
2

Pyth, 22 11 bytes

.usm.!sd+Nk

Try it online!

Lots of credit to Leaky Nun's answer, which introduced me to .u, and helped save a massive 11 bytes of this program.

Explanation:

.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
— K Zhang
fonte
Pyth has more useful functions than one imagines. See my answer as reference.
— Leaky Nun
@LeakyNun I've rewritten my answer to use .u. I guess I'll need to take a look through the character reference again to see if there are any other useful functions there.
— K Zhang
You can use `N to convert to string instead of +Nk.
— Leaky Nun
@LeakyNun Where the N would be obsolete then, and there comes a 9-byte solution...
— Erik the Outgolfer
1

Axiom, 231 bytes

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))

not golfed functions and some 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]
— RosLuP
fonte
1

Java 7, 220 bytes

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);}

Explanation:

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)

Test code:

Try it here.

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));
  }
}

Output:

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,
— Kevin Cruijssen
fonte
1

GolfScript, 44 bytes

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

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

Try it online!

The factorial part is from here.

— Leaky Nun
fonte
1

C, 161 bytes

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));}

See it work online.

— 2501
fonte
1

TI-BASIC, 85 79 64 60 bytes

: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

Since this is running on a graphing calculator, there is limited RAM. Try testing it with numbers that loop quickly, like 169.

More Explanation:

: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₁-X works by subtracting the new element from the old list, then multiplying all the elements of the list together. If the element was already in the list, the product will be 0, a falsey value. Otherwise, the product will be a positive integer, a truthy value.

— Scott Milner
fonte
1

J, 40 31 bytes

Edit: 9 bytes saved using the improvements by FrownyFrog. Thanks!

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

Original code:

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

In this case I decided to count the bytes for the verb definition, since otherwise it doesn't work in the interpreter.

Explanation:

                         (        {:) - Takes the last element of the array
                               ":@    - converts it to string
                          "."0&       - converts each character back to integer
                       !@             - finds the factorials
                     +/               - sums them
                   [:                 - cap (there are 2 derived verbs above, we need 3 for a fork)
          (    e.~)                   - check if the result is present in the list    
             -.                       - negates the above check
           [:                         - cap
        @.                            - Agenda conjunction, needed for the recursion
  ($:@,)                              - if the result is not in the list, add it to the list and recur
[`                                    - if the result is in the list, display it and stop

Try it online!

— Galen Ivanov
fonte
1
([:-.e.~) -> (1-e.~)
— FrownyFrog
1
— FrownyFrog
@FrownyFrog Thanks, your code is much better! I tried 10#.inv early while experimenting, but then I wrote it 10&#.inv and it was longer, so I rejected it. Thanks for all your suggestions! I have much to learn :)
— Galen Ivanov
@FrownyFrog Reversing the cases for the agenda is so good, I regret I didn't see it :)
— Galen Ivanov
[:+/!@"."0@":@{: is the same length, so there's no improvement with 10#.inv. Just had to drop the ().
— FrownyFrog
1

Tcl, 143 bytes

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}

Try it online!

— sergiol
fonte
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.