Factoriels et cycles sans fin!

33

Comme vous le savez peut-être, la factorielle d'un entier positif nest le produit de tous les entiers positifs égaux ou inférieurs à n.

Par exemple :

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

Nous allons maintenant définir une opération spéciale avec un nom non pertinent, tel que sumFac:

Étant donné un entier positif n,sumFac(n) est la somme des factorielles des chiffres.

Par exemple :

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

Tâche

Votre mission, que vous choisissiez ou non de l’accepter, est de renvoyer la séquence (potentiellement infinie) des applications de sumFac à un entier donné en entrée.

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

Mais ce n'est pas tout! En effet, les applications desumFac créeront éventuellement un cycle. Vous devez également retourner ce cycle!

Si votre langue a une factorielle intégrée, vous pouvez l'utiliser. Je ne suis pas pointilleux sur le type de retour, il vous suffit de renvoyer la séquence d'applications sumFac et le cycle dans un format compréhensible par un humain.

EDIT: Pour vous aider à mieux visualiser à quoi ressemblerait la sortie, j’ai copié Leaky Nun's juste en dessous:

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

Vous devez juste arrêter la séquence lorsque le cycle est sur le point de commencer pour la deuxième fois!

Mais c'est du code-golf alors la réponse la plus courte en octets gagne!

Classement

Voici un extrait de pile permettant de générer à la fois un classement régulier et un aperçu des gagnants par langue.

Fuite, nonne
la source
Related
Leaky Nun
Bienvenue chez PPCG! Cela ressemble à un beau défi, BTW.
clismique
@ Qwerp-Derp Merci beaucoup! J'ai essayé d'être créatif ^^
@Zgarb Eh bien, c'est exactement comme la sortie de Leaky Nun. La séquence des applications et ensuite elle doit se terminer juste avant le début du deuxième cycle. Je recopierai sa sortie dans la question pour que tout le monde puisse bien comprendre. Merci de l'avoir signalé :)
1
@ 2501 Le codage en dur de la valeur est une tricherie, mais en ce qui concerne le formatage de la sortie, vous pouvez utiliser le séparateur de votre

Réponses:

19

Gelée , 6 octets

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

Essayez-le en ligne!

Je ne vois pas d'autre moyen de le rendre plus court que de faire ce qui est dit.

Spécifications

  • Entrée: 132(comme argument de ligne de commande)
  • Sortie: [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]
Fuite, nonne
la source
Je ne m'attendais pas à une réponse aussi courte. Nice :)
4
@Antoine c'est de la gelée: D C'est toujours plus court que ce que je pense;)
HyperNeutrino
8
@HyperNeutrino En quelque sorte, Dennis viendra avec une réponse encore plus courte
Leaky Nun
D'une certaine manière, oui. Parce que Dennis. : P
HyperNeutrino
Alors ... Quel codage de caractères utilisez-vous pour créer 6 octets pour ces 6 caractères? Jelly n'est-elle pas supposée être encodée en UTF-8, ce qui signifie que ce programme est en réalité de 9 octets?
LordOfThePigs
10

Python 2 , 88 octets

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

Essayez-le en ligne!

ovs
la source
En tant que fan de python, je suis heureux que quelqu'un y ait répondu, sympa :)
9

05AB1E , 12 octets

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

Essayez-le en ligne!

Explication

[               # 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
la source
Bref et correct, bien joué!
J'ai pensé que je pouvais me débarrasser du s, bonne réponse.
Urne Magique Octopus
8

Brachylog , 17 octets

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

Essayez-le en ligne!

Explication

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)
Fataliser
la source
Que Isignifie
Leaky Nun
1
@ LeakyNun C'est un paramètre pour ᵃ⁾. ᵃ³signifie "accumuler 3 fois". ᵃ⁾signifie "accumuler autant de fois que le dernier élément de l'entrée", ce qui est dans ce cas I. Puisqu'il Is'agit d'une variable totalement libre, il essaiera les valeurs de 0à +inf.
Fataliser
8

Wolfram Language, 62 60 56 octets

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

Il est vraiment dommage que Wolfram Language ait des noms de fonction si longs. *Soupir*

Explication:

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
la source
Bonne réponse. Je ne pense pas que cela puisse être amélioré.
Kelly Lowder
1
@ KellyLowder Merci! En fait, j'ai pu sauvegarder deux autres octets en mappant la factorielle sur la liste, puis en la additionnant Tr.
Scott Milner
1
Belle utilisation de NestWhileList[...,All]!
Greg Martin
6

JavaScript (ES6), 91 89 octets

2 octets sauvés grâce à fəˈnɛtɪk

Il s’avère être assez similaire à l’autre réponse de 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))

Arnauld
la source
Dans votre fonction factorielle, vous ne devriez pas pouvoir utiliser n au lieu de n> 1 car 0! = 1?
Fəˈnɛtɪk
@ fəˈnɛtɪk Je ne sais pas ce que je pensais ici. Merci!
Arnauld
5

ClojureScript, 146 109 octets

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

Ouais, c'est une monstruosité. Quelqu'un s'il vous plaît aidez-moi à golf cette ...

Merci de vous @cliffrootêtre débarrassé de 37 octets!

Ceci est une fonction anonyme, pour exécuter la fonction, vous devez faire ceci:

(#(...) {arguments})

TIO n'a pas ClojureScript, alors voici un lien vers un REPL ClojureScript.

Voici un lien vers un programme Clojure qui affiche le dernier élément de la liste de 0 à 1000.

Voici la sortie pour 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]

Je soupçonne fortement que tous les chiffres doivent finalement s'installer à 1ou en boucle [169 363601 1454].

Code non golfé:

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

Explication à venir bientôt!

clismique
la source
Assez long mais correct;) Je ne peux pas vraiment vous aider à
L'intérieur forpeut être (for[a s](apply *(range 1(-(int a)47)))), n'est-ce pas?
Cliffroot
et cela permettra de se débarrasser de l'autrelet #(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, semble que tu (- ... 47)n'aies même pas besoin de ClojureScript, ça intsuffira
cliffroot
bien, (inc(int a))devrait faire pour ClojureScript et (-(int a)47)pour Clojure.
cliffroot
5

Perl 6 , 64 octets

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

L'essayer

Étendu:

{

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

Chaque ligne au-dessus de qui {commence un nouveau bloc lambda avec un paramètre implicite de $_.

J'ai utilisé [*] 2..$_au lieu de[*] 1..$_ purement comme une micro optimisation.

Brad Gilbert b2gills
la source
4

JavaScript, 92 octets

Merci @Shaggy pour le golf d'un octet avec comprend
Merci @Neil pour le golf de deux octets

Code séparé en fonctions individuelles 92 octets

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 sur une ligne 92 octets

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

Explication

Initialement, appelez la fonction avec un seul argument, donc a = [].

Si x existe dans le tableau, retourne a a.includes(x)?a:...

Sinon, ajoutez x à a et transmettez la somme des chiffres factoriels et a à la fonction (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

Factorielle La somme en chiffres effectuée de manière à ne pas dépasser la limite de récursivité maximale.

Liste de tous les points de terminaison possibles: 1, 2, 145, 169, 871, 872, 1454, 40585, 45361, 45362, 363601

Essayez-le en ligne!

fəˈnɛtɪk
la source
1
Gah, j'étais si proche! Enregistrer un octet avecf=(x,a=[])=>a.includes(x)?a:(a.push(x),f(k(x),a))
Shaggy
Pouvez-vous pas écrire f(k(x),a,a.push(x))? De plus, je pense que vous pouvez écrire k=n=>n&&pour sauvegarder un autre octet.
Neil
4

Haskell , 80 à 67 octets

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

Essayez-le en ligne! Usage:([]#) 132

Edit: Sauvegardé 13 octets avec des types de Ørjan Johansen!

Laikoni
la source
(1) Testez et ajoutez à la nplace de s(comme dans la réponse Python de ovs), puis f=([]#). (2) Basculez les branches, en ligne set utilisez elem.
Ørjan Johansen
Éteignez votre ++pour :aussi.
1
@ Canyon C'est le mauvais ordre pour cela, le résultat final serait inversé. Vous pouvez presque résoudre le problème par la suite, en ajoutant un point supplémentaire n:et en changeant =gà =[], mais cela ne semble être qu'une égalité.
Ørjan Johansen
4

Pyth, 9 octets

.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

Essayez-le en ligne!

Cette réponse utilise .u("Point fixe cumulatif. Appliquer jusqu'à ce qu'un résultat obtenu auparavant soit trouvé. Renvoyer tous les résultats intermédiaires.")

Fuite, nonne
la source
3

Pyth, 30 octets

W!hxYQQ=+YQKQ=Q0WK=+Q.!%KT=/KT

Essayez-le ici

Maria
la source
Pyth a plus de fonctions utiles qu'on ne l'imagine. Voir ma réponse comme référence.
Leaky Nun
2

R, 120 octets

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
la source
vous pouvez faire o=scan(), utiliser à la el()place de [[1]], et gamma(n+1)=factorial(n)je pense que cela enregistre un octet, et je pense que as.numericc'est la même chose que as.doublepour les entiers, ce qui enregistre également un octet, et vous pouvez utiliser à la toStringplace de as.character.
Giuseppe
@ Giuseppe Merci pour l'entrée, mis à jour.
Neil
2

Java 9 JSHell, 213 octets

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

Essayez-le en ligne!

Remarque: Cette solution repose sur la représentation sous forme de chaîne d'un nombre comportant des points de code compris entre 48 et 57. Fonctionne pour ASCII, UTF-8, Latin-1, tous les jeux de caractères ISO-8859- *, la plupart des pages de codes. Ne fonctionne pas pour EBCDIC. Je ne pense pas que quiconque va déduire des points pour cela. :)

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
}

Remarques:

  • La valeur de retour de Set :: add est très utile ici; renvoie vrai si le produit n'était pas dans le jeu
  • J'étais sarcastique quand j'ai dit "Merci, Java"
  • factorii n'est pas vraiment un mot; Je viens d'inventer ça
David Conrad
la source
1
J'avoue que c'est original! Nice job :)
@Antoine J'admets que Java n'est pas la meilleure langue pour jouer au golf, mais ce n'est pas la chose la plus folle que j'ai faite ces derniers temps. :) codegolf.stackexchange.com/a/117644/794
David Conrad
2

Pyth, 22 à 11 octets

.usm.!sd+Nk

Essayez-le en ligne!

Beaucoup de crédit à la réponse de Leaky Nun , qui m'a présenté à.u et aidé à économiser 11 octets de ce programme, a .

Explication:

.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
la source
Pyth a plus de fonctions utiles qu'on ne l'imagine. Voir ma réponse comme référence.
Leaky Nun
@ LeakyNun, j'ai réécrit ma réponse à utiliser .u. Je suppose que je devrai regarder à nouveau dans la référence du personnage pour voir s'il y a d'autres fonctions utiles là-bas.
K Zhang
Vous pouvez utiliser `Npour convertir en chaîne au lieu de +Nk.
Leaky Nun
@LeakyNun Où le Nserait obsolète alors, et il y a une solution de 9 octets ...
Erik the Outgolfer
1

Axiome, 231 octets

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

pas de fonctions de golf et certains tests

-- 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
la source
1

Java 7, 220 octets

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

Explication:

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)

Code de test:

Essayez ici.

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

Sortie:

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
la source
1

GolfScript , 44 octets

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

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

Essayez-le en ligne!

La partie factorielle est à partir d' ici .

Fuite, nonne
la source
1

C, 161 octets

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

Voir le travail en ligne.

2501
la source
1

TI-BASIC, 85 79 64 60 octets

: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

Comme cela fonctionne sur une calculatrice graphique, la RAM est limitée. Essayez de le tester avec des nombres qui tournent rapidement, comme 169.

Plus d'explication:

: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₁-Xfonctionne en soustrayant le nouvel élément de l'ancienne liste, puis en multipliant tous les éléments de la liste. Si l'élément était déjà dans la liste, le produit sera 0une valeur de falsey. Sinon, le produit sera un entier positif, une valeur de vérité.

Scott Milner
la source
1

J , 40 31 octets

Edit: 9 octets enregistrés en utilisant les améliorations apportées par FrownyFrog. Merci!

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

Code d'origine:

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

Dans ce cas, j'ai décidé de compter les octets pour la définition du verbe, sinon cela ne fonctionne pas dans l'interpréteur.

Explication:

                         ({:) - Prend le dernier élément du tableau
                               ": @ - le convertit en chaîne
                          "." 0 & - convertit chaque caractère en entier
                       ! @ - trouve les factorielles
                     + / - les résume
                   [: - cap (il y a 2 verbes dérivés ci-dessus, il en faut 3 pour une fourchette)
          (e. ~) - vérifie si le résultat est présent dans la liste    
             - - nie le contrôle ci-dessus
           [: - casquette
        @. - Conjonction de l'ordre du jour, nécessaire pour la récursion
  ($: @,) - si le résultat n'est pas dans la liste, ajoutez-le à la liste et répétez
[`- si le résultat est dans la liste, affiche-le et arrête    

Essayez-le en ligne!

Galen Ivanov
la source
1
([:-.e.~)->(1-e.~)
FrownyFrog
1
31 octets
FrownyFrog
@FrownyFrog Merci, votre code est bien meilleur! J'ai essayé 10 # .inv tôt en expérimentant, mais je l'ai écrit 10 & #. Inv et c'était plus long, donc je l'ai rejeté. Merci pour toutes vos suggestions! J'ai beaucoup à apprendre :)
Galen Ivanov
@FrownyFrog Inverser les cas pour l'ordre du jour est tellement bon, je regrette de ne pas l'avoir vu :)
Galen Ivanov
[:+/!@"."0@":@{:est la même longueur, donc il n'y a pas d'amélioration avec 10#.inv. Il fallait juste laisser tomber le ().
FrownyFrog
1

Tcl , 143 octets

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}

Essayez-le en ligne!

sergiol
la source