Factorials ve hiç bitmeyen döngüleri!


33

Bildiğiniz gibi, pozitif bir tamsayı faktörü n, eşit veya daha küçük olan tüm pozitif tamsayıların ürünüdür n.

Örneğin :

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

Şimdi, aşağıdaki gibi alakasız bir adla özel bir işlem tanımlayacağız sumFac:

Pozitif bir tam sayı verilen n, sumFac(n)basamak faktöriyellerinin toplamıdır.

Örneğin :

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

Görev

Göreviniz, kabul etmeyi seçip seçmemeniz, uygulamaların sırasını (potansiyel olarak sınırsız) sumFacgirdi içinde verilen bir tamsayıya döndürmektir .

Örnek : 132 -> 132, 9, 362880, 81369, 403927, ...

Ama hepsi bu kadar değil! Gerçekten, uygulamaları sumFacsonunda bir döngü yaratacaktır. Bu çevrimi de iade etmelisin!

Dilinizde yerleşik bir faktoring varsa, onu kullanabilirsiniz. İade türü konusunda seçici değilim, sadece sumFac uygulamalarının sırasını ve çevrimi bir insan tarafından anlaşılabilir bir biçimde geri göndermeniz gerekiyor.

EDIT: Çıktıyı daha iyi görselleştirmenize yardımcı olmak için çıktı, Leaky Nun'un hemen altına kopyaladığım gibi görünmeli:

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

Sadece döngü ikinci kez başlamak üzereyken sırayı durdurmanız gerekir!

Ama bu kod-golf, yani bayt cinsinden en kısa cevap kazanır!

Liderler Sıralaması

Burada hem düzenli bir lider tablosu hem de kazananların dile göre genel bir bakışı oluşturmak için bir Stack Snippet'i var.



PPCG'ye Hoşgeldiniz! Bu iyi bir mücadele gibi görünüyor, BTW.
clismique

@ Qwerp-Derp Çok teşekkürler! Yaratıcı olmaya çalıştım ^^

@ Zgarb Peki tam olarak Leaky Nun'un çıktısı gibi. Başvuruların sırası ve ardından ikinci döngünün başlamasından hemen önce sona erer. Çıktısını soruya kopyalayacağım, böylece herkes net bir anlayışa sahip olabilir. Buna dikkat çektiğiniz için teşekkürler :)

1
@ 2501 Hardcoding değeri aldatma, ancak çıktı biçimlendirme ile ilgili olarak istediğiniz herhangi bir ayırıcı kullanabilirsiniz

Yanıtlar:


19

Jöle , 6 bayt

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

Çevrimiçi deneyin!

Bunu söylenenden daha kısa yapmak için başka bir yol görmüyorum.

gözlük

  • Girdi: 132(komut satırı argümanı olarak)
  • Çıktı: [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]

O kadar kısa bir cevap almayı beklemiyordum. Güzel :)

4
@Antoine Jöle: D Her zaman düşündüğümden daha kısa;)
HyperNeutrino

8
@HyperNeutrino Her nasılsa Dennis daha kısa bir cevap ile gelecek
Leaky Nun

Her nasılsa, evet. Çünkü Dennis. : P
HyperNeutrino 25:17

Yani ... Bu 6 karakter için 6 bayt ile hangi karakter kodlamasını kullanıyorsunuz? Jelly'in UTF-8 kodlu olması gerekmiyor, yani bu program aslında 9 bayt mı?
LordOfThePigs

10

Python 2,8 bayt

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

Çevrimiçi deneyin!


Bir python hayranı olarak, birisinin onunla cevap vermesine sevindim, güzel :)

9

05AB1E , 12 bayt

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

Çevrimiçi deneyin!

açıklama

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

Kısa ve doğru, iyi oynadı!

Kurtulabileceğimi düşündüm s, yanlış, iyi cevap.
Magic Octopus Urn,

8

Brachylog , 17 bayt

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

Çevrimiçi deneyin!

açıklama

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)

Ne Idemek istiyorsun?
Leaky Nun

1
@ LeakyNun Bu bir parametredir ᵃ⁾. ᵃ³"3 kez biriktir" anlamına gelir. ᵃ⁾"Girdideki son öğe kadar toplayın" anlamına gelir I. Yana Itamamen ücretsiz değişkendir, ondan bunun için değerleri çalışacağız 0için +inf.
17'de

8

Wolfram Dili, 62 60 56 bayt

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

Wolfram Dil'in bu kadar uzun süreli fonksiyon isimlerine sahip olması gerçekten çok kötü. *İç çekmek*

Açıklama:

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

Güzel cevap Bunun geliştirilebileceğini sanmıyorum.
Kelly Lowder

1
@KellyLowder Teşekkürler! Faktörü listeye eşleyerek ve sonra toplayarak iki bayt daha biriktirebildim Tr.
Scott Milner

1
Güzel kullanımı NestWhileList[...,All]!
Greg Martin

6

JavaScript (ES6), 91 89 bayt

Fəˈnɛtɪk sayesinde 2 bayt kaydedildi

Diğer JS cevaplarına oldukça benziyor .

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


Faktoring işlevinizde n> 1 yerine n kullanamazsınız, çünkü 0! = 1?
fəˈnəˈtɪk

@ fəˈnɛtɪk Burada ne düşündüğümü bilmiyorum. Teşekkür ederim!
Arnauld,

5

ClojureScript, 146 109 bayt

#(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, bu bir canavarlıktır. Birisi lütfen bu golfü bana yardım etsin ...

@cliffrootBir kuyruklu 37 baytı traş ettiğiniz için teşekkür ederiz !

Bu anonim bir işlevdir, işlevi çalıştırmak için bunu yapmanız gerekir:

(#(...) {arguments})

TIO'da ClojureScript yok, bu yüzden işte bir ClojureScript REPL.

İşte listedeki son elemanı 0 ile 1000 arasında basan bir Clojure programının bağlantısı .

İşte için çıktı 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]

Sonunda tüm sayıların 1ve döngülere yer vermesi gerektiğine dair güçlü bir şüphem var [169 363601 1454].

Ungolfed kod:

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

Açıklama çok yakında!


Oldukça uzun ama doğru;) Bu üzgünüm golf için gerçekten yardımcı

for olabilir (for[a s](apply *(range 1(-(int a)47)))), değil mi?
cliffroot

ve bu diğer kurtulmak için izin vereceklet #(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

ah, (- ... 47)ClojureScript bile ihtiyacınız yok gibi görünüyor , sadece intyeterli olacaktır
cliffroot

peki, (inc(int a))ClojureScript ve (-(int a)47)Clojure için yapmalıyım .
cliffroot

5

Perl 6 , 64 bayt

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

Dene

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

Yukarıdaki her satır, üstü {kapalı bir parametresi olan yeni bir çıplak blok lambda başlatır $_.

Sadece bir mikro optimizasyon [*] 2..$_yerine kullandım [*] 1..$_.


4

JavaScript, 92 bayt

Bir bayt
kapalı golf sahası için teşekkürler @Shaggy İki bayt kapalı golf sahası için teşekkürler @ Neil

Özel fonksiyonlara ayrılan kod 92 bayt

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

Tek satırda kod 92 bayt

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

açıklama

Başlangıçta sadece tek bir argümanla fonksiyonu çağırın, bu nedenle a = [].

Dizide x varsa, a a.includes(x)?a:...

Aksi takdirde, x'i a'ya ekleyin ve faktörel rakam toplamını ve fonksiyona geçin (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

Faktörlü Rakam toplamı, maksimum yineleme sınırını aşmayacak şekilde gerçekleştirilir.

Tüm olası bitiş noktalarının listesi: 1, 2, 145, 169, 871, 872, 1454, 40585, 45361, 45362, 363601

Çevrimiçi deneyin!


1
Gah, çok yakındım! Bir byte ile kaydetf=(x,a=[])=>a.includes(x)?a:(a.push(x),f(k(x),a))
Shaggy

Yazamaz f(k(x),a,a.push(x))mısın Ayrıca, k=n=>n&&başka bir bayttan tasarruf etmek için yazabileceğinizi düşünüyorum .
Neil

4

Haskell , 80 67 bayt

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

Çevrimiçi deneyin! Kullanımı:([]#) 132

Düzenleme: Ørjan Johansen'dan yazanlar ile 13 bayt kaydedildi!


(1) Test et ve ekle nyerine s(ovs'un Python cevabında olduğu gibi), sonra f=([]#). (2) Dalları değiştirin, satır içi sve kullanın elem.
Ørjan Johansen

Sizin ++için :de değiştirin.

1
@ Kanyon Bunun için yanlış bir emirdir, nihai sonucu tersine çevirirdi. Sen edebilirsiniz neredeyse bir ekstra prepending tarafından, sonradan düzeltmek n:ve değişen =giçin =[], ancak yalnızca bir kravat gibi görünüyor.
Ørjan Johansen

4

Pyth, 9 bayt

.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

Çevrimiçi deneyin!

Bu cevap kullanır .u("Kümülatif sabit nokta. Daha önce gerçekleşmiş bir sonuç bulunana kadar uygulayın. Tüm ara sonuçları döndür.")




2

R, 120 Bayt

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

yapabilir o=scan(), el()yerine kullanabilirsiniz [[1]]ve gamma(n+1)=factorial(n)hangisini bayt kurtardığına inanıyorum ve bence tam sayılar için as.numericde aynıdır as.double, ki bu da baytı kurtarır ve toStringyerine kullanabilirsiniz as.character.
Giuseppe

@Giuseppe Giriş için teşekkürler, güncellendi.
Neil

2

Java 9 JSHell, 213 bayt

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

Çevrimiçi deneyin!

Not: Bu çözüm, 48-57 aralığında kod noktalarına sahip bir sayının dizi temsiline dayanır. ASCII, UTF-8, Latin-1, hepsi ISO-8859- * karakter kümeleri, çoğu kod sayfası için çalışıyor. EBCDIC için çalışmıyor. Kimsenin bunun için puan düşeceğini sanmıyorum. :)

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
}

Notlar:

  • Set :: add'in dönüş değeri burada çok yararlıdır; true iff değerini döndürüröğe kümede olmasa
  • "Teşekkürler, Java" dediğimde alay ediyordum
  • factorii gerçekten bir kelime değil; Ben uydurdum

1
Bunun orijinal olduğunu itiraf ediyorum! Güzel iş :)

@Antoine Kabul ediyorum, Java golf oynamak için en iyi dil değil, ancak son zamanlarda yaptığım en çılgınca şey. :) codegolf.stackexchange.com/a/117644/794
David Conrad

2

Pyth, 22 11 bayt

.usm.!sd+Nk

Çevrimiçi deneyin!

Beni tanıtan ve bu programın devasa 11 baytını kurtarmaya yardım eden Leaky Nun'un cevabına çok fazla kredi verildi .u.

Açıklama:

.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, bir hayal ettiğinden daha faydalı fonksiyonlara sahiptir. Cevabımı referans olarak görün .
Leaky Nun

@LeakyNun Kullanılacak cevabımı yeniden yazdım .u. Sanırım burada başka bir yararlı fonksiyon olup olmadığını görmek için tekrar karakter referansına göz atmam gerekecek.
K Zhang

Dizeye `Ndönüştürmek için kullanabilirsiniz +Nk.
Sızdıran Rahibe

@LeakyNun O zamanlar Nmodası geçmiş olacak ve 9 baytlık bir çözüm geliyor ...
Outgolfer Erik

1

Aksiyom, 231 bayt

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

golf fonksiyonları ve bazı testler

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

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

Açıklama:

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 kodu:

Burada dene.

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

Çıktı:

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 bayt

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

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

Çevrimiçi deneyin!

Faktoring kısmı buradan .



1

TI-BASIC, 85 79 64 60 bayt

: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

Bu bir grafik hesap makinesinde çalıştığından, sınırlı RAM var. Hızlı bir şekilde döngü yapan sayılarla test etmeyi deneyin 169.

Daha fazla açıklama:

: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₁-Xyeni öğeyi eski listeden çıkardıktan sonra listenin tüm öğelerini birlikte çarparak çalışır. Öğe zaten listede olsaydı, ürün 0, bir falsey değeri olacaktır. Aksi takdirde, ürün pozitif bir tamsayı, gerçeği aşan bir değer olacaktır.



1

J , 40 31 bayt

Düzenleme: 9 bayt FrownyFrog tarafından geliştirmeler kullanılarak kaydedildi. Teşekkürler!

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

Orijinal kod:

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

Bu durumda, fiil tanımı için baytları saymaya karar verdim, aksi halde tercümanda çalışmaz.

Açıklama:

                         ({:) - Dizinin son elemanını alır
                               ": @ - dizgeye dönüştürür
                          "." 0 & - her karakteri tam sayıya geri dönüştürür
                       ! @ - faktörleri bulur
                     + / - onları toplar
                   [: - kapak (yukarıda 2 türetilmiş fiil var, çatal için 3'e ihtiyacımız var)
          (e. ~) - sonucun listede olup olmadığını kontrol edin    
             -. - yukarıdaki kontrolü olumsuzlar
           [: - kapak
        @. - Özyineleme için gerekli olan Gündem Kavşağı
  ($: @,) - sonuç listede değilse, listeye ekleyin ve yineleyin
[`- sonuç listede ise, görüntüle ve dur    

Çevrimiçi deneyin!


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


@ FrownyFrog Teşekkürler, kodunuz çok daha iyi! Deneme sırasında 10 # .nv denedim, ancak 10 & #. İnv yazdım ve daha uzun oldu, bu yüzden reddettim. Tüm önerileriniz için teşekkürler! Öğrenecek çok şeyim var :)
Galen Ivanov

@ FrownyFrog Gündem davalarını tersine çevirmek çok iyi, görmedim pişmanım :)
Galen Ivanov

[:+/!@"."0@":@{:Aynı uzunluk, bu yüzden bir gelişme yok 10#.inv. Sadece bırakmak zorunda kaldı ().
FrownyFrog

1

Tcl , 143 bayt

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}

Çevrimiçi deneyin!

Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.