Der Titel von Numberphiles neuestem Video, 13532385396179 , ist ein Fixpunkt der folgenden Funktion f auf den positiven ganzen Zahlen:

Sei n eine positive ganze Zahl. Schreiben Sie die Primfaktorisierung wie gewohnt, zB 60 = 2 ² · 3 · 5, wobei die Primzahlen in aufsteigender Reihenfolge geschrieben werden und Exponenten von 1 weggelassen werden. Bringen Sie dann die Exponenten auf die Linie und lassen Sie alle Multiplikationszeichen weg, um eine Zahl f (n) zu erhalten. [...] zum Beispiel ist f (60) = f (2 ² · 3 · 5) = 2235.

(Die obige Definition stammt aus Aufgabe 5 von fünf 1.000-Dollar-Problemen - John H. Conway )

Man beachte , dass f (13532385396179) = f (13 · 53 ² · 3853 · 96179) = 13532385396179.

Aufgabe

Nehmen Sie eine positive zusammengesetzte Ganzzahl nals Eingabe und Ausgabe f(n).

Ein anderes Beispiel

48 = 2 ⁴ · 3, also f (48) = 243.

Testfälle

Weitere Testfälle finden Sie hier .

   4 -> 22
   6 -> 23
   8 -> 23
  48 -> 243
  52 -> 2213
  60 -> 2235
 999 -> 3337
9999 -> 3211101

Python, 166 162 159 Bytes

Ihr seid viel besser. Das habe ich benutzt! (Der Algorithmus, der das gelöst hat, nennt das)

from primefac import*
def c(n):
 x=factorint(n)
 a=''
 for i in range(len(x)):
  l=min(x.keys())
  a+=str(l)
  if x[l]>1:a+=str(x[l])
  x.pop(l)
 return int(a)

Brachylog , 8 Bytes

ḋoọc;1xc

Probieren Sie es online!

Erläuterung

Example input: 60

ḋ          Prime decomposition: [5,3,2,2]
 o         Order: [2,2,3,5]
  ọ        Occurences: [[2,2],[3,1],[5,1]]
   c       Concatenate: [2,2,3,1,5,1]
    ;1x    Execute 1s: [2,2,3,5]
       c   Concatenate: 2235

Sie können ℕ₂ˢ( wählen Sie alle ganzen Zahlen größer oder gleich 2 aus ) anstelle von verwenden ;1x, was wahrscheinlich besser lesbar und eher im Sinne von Brachylog ist.

Gelee , 6 Bytes

ÆFFḟ1V

Probieren Sie es online!

Erläuterung

ÆF      Get prime factorisation of input as prime-exponent pairs.
  F     Flatten.
   ḟ1   Remove 1s.
     V  Effectively flattens the list into a single integer.

Mathematica, 43 36 Bytes

Row@Flatten@FactorInteger@#/. 1->""&

Probieren Sie es online!

CJam , 8 Bytes

limF:~1-

Probieren Sie es online!

Erläuterung

li  e# Read input and convert to integer.
mF  e# Get prime factorisation as prime-exponent pairs.
:~  e# Flatten.
1-  e# Remove 1s.
    e# Implicitly print a flattened representation of the list.

05AB1E , 10 Bytes

Òγʒ¬?gDië?

Probieren Sie es online!

Ò          # Push list of prime factors with duplicates
 γ         # Break into chunks of consecutive elements
  ʒ        # For each
   ¬?      #   Print the first element
     gD    #   Push the length of this chunk twice
       ië  #   If not 1
         ? #     Print the length

05AB1E , 12 11 Bytes

Òγvy¬sgD≠×J

Probieren Sie es online!

Erläuterung

Ò            # calculate prime factors with duplicates
 γ           # group consecutive equal elements
  vy         # for each group
    ¬        # get the head without popping
     sg      # push the length of the group
       D≠×   # repeat the length (length != 1) times
          J  # join

Pyth, 12 Bytes

smjk_>hddr8P

Versuch es!

alternativ 12 Bytes

smjk<_AdGr8P

Versuch das!

Erläuterung

smjk_>hddr8P
           PQ  # prime factorization (already in correct order) of the implicit input: [3, 3, 11, 101]
         r8    # length encode: [[2, 3], [1, 11], [1, 101]]
 m             # map over the length encoded list (lambda variable: d)
     >hdd      # take the d[0] last elements of d (so only the last for d[0]==1 and all else)
    _          # reverse that list
  jk           # join into a string
s              # conatenate the list of strings

Pyth, 11 Bytes

jksm_-d1r8P

Versuch es hier

Python 2 , 99 Bytes

n=input()
r=''
p=2
while~-n:
 e=0
 while n%p<1:e+=1;n/=p
 r+=str(p)*(e>0)+str(e)*(e>1);p+=1
print r

Probieren Sie es online!

Wenn die Eingaben auf weniger als 6 beschränkt sind 2147483659, können beide str(...)durch `...`Speichern von 6 Bytes ersetzt werden (dieses Programm ist für betroffene Nummern ohnehin sehr langsam!).

Ohm , 11 Bytes

o:_]D2<?O;J

Probieren Sie es online!

Erläuterung

o:_]D2<?O;J
o           # Push prime factors with powers from input (Format [[prime,power],...]
 :          # For each...
  _          # Push current element
   ]         # flatten
    D        # Duplicate power
     2<? ;   # Is the power smaller than 2?
        O     # Delete top of stacks
          J  # Join

Japt , 19 Bytes

k ó¥ ®¯1 pZlÃc fÉ q

Testen Sie es online!

Erläuterung

 k ó¥  ®   ¯  1 pZlà c fÉ  q
Uk ó== mZ{Zs0,1 pZl} c f-1 q  // Ungolfed
                              // Implicit: U = input number
Uk                            // Break U into its prime factors.
   ó==                        // Group into runs of equal items.
       mZ{         }          // Map each item Z in this to
          Zs0,1               //   Z.slice(0, 1) (the array of the first item),
                pZl           //   with Z.length added at the end.
                              // This returns an array of prime-exponent pairs (Jelly's ÆF).
                     c        // Flatten.
                       f-1    // Filter to the items X where X - 1 is truthy (removes '1's).
                           q  // Join the resulting array into a single string.
                              // Implicit: output result of last expression

PHP , 88 Bytes

for($i=2;1<$a=&$argn;)$a%$i?$i++:$a/=$i+!++$r[$i];foreach($r as$k=>$v)echo$k,$v<2?"":$v;

Probieren Sie es online!

C #, 206 100 Bytes

n=>{var r="";for(int d=1,c;++d<=n;){c=0;while(n%d<1){c++;n/=d;}r+=c>0?d+(c>1?c+"":""):"";}return r;}

Voll / Formatierte Version:

using System;

class P
{
    static void Main()
    {
        Func<int, string> func = n =>
        {
            var r = "";
            for (int d = 1, c; ++d <= n;)
            {
                c = 0;
                while (n % d < 1)
                {
                    c++;
                    n /= d;
                }

                r += c > 0 ? d + (c > 1 ? c + "" : "") : "";
            }

            return r;
        };

        Console.WriteLine(func(4));
        Console.WriteLine(func(6));
        Console.WriteLine(func(8));
        Console.WriteLine(func(48));
        Console.WriteLine(func(52));
        Console.WriteLine(func(60));
        Console.WriteLine(func(999));
        Console.WriteLine(func(9999));

        Console.ReadLine();
    }
}

Javascript - 91 Bytes

(x,r='',i=1,n)=>{while(x>i++){for(n=0;x%i<1;n++)x/=i;r+=(n>0?i+'':'')+(n>1?n:'')}return r}

Erläuterung

(x,r='',i=1,n)=>(          // input x is the number to process, r, i, n are default values only
    while(x>i++){          // iterate over i until x
        for(n=0;x%i<1;n++) // iterate over n until i is not a factor of x
            x/=i;          // factor i out of x
        r+=(n>0?i+'':'')   // append i to r if n > 0
            +(n>1?n:'')    // append n to r if n > 1
                           // i+'' prevents adding i and n before appending to r
    }
    return r               // return r by comma-operator and arrow function syntax
)

Java 8, 103 Zeichen

Ziemlich einfache Lösung.

n->{String r="";int d=2,c;while(n>1){c=0;while(n%d<1){c++;n/=d;}if(c>0)r+=d;if(c>1)r+=c;d++;}return r;}

Ungolfed:

private static Function<Integer, String> f = n->{
    String result = "";
    int divisor = 2, count;
    while (n>1) {
        count = 0;
        while (n % divisor < 1) {
            count++;
            n /= divisor;
        }
        if (count > 0) result += divisor;
        if (count > 1) result += count;
        divisor++;
    }
    return result;
};

Oktave , 69 Bytes

@(a)printf('%d',(f=[[~,c]=hist(b=factor(a),d=unique(b));d](:))(f~=1))

Probieren Sie es online!

Hat sich als ziemlich lang erwiesen, erzeugt aber die gewünschte Ausgabe.

Im Wesentlichen verwenden wir die Histogrammfunktion, um die Anzahl der Vorkommen der eindeutigen Werte in der Primfaktorisierung des Eingabewerts zu zählen.

• Das Ergebnis der factor()Funktion gibt die Primfaktoren in aufsteigender Reihenfolge an
• wir finden dann unique()Werte in diesem Array
• hist() Gibt die Anzahl der Vorkommen zurück

Sobald wir die beiden Arrays haben (eines für eindeutige Faktoren, eines für Zählungen), verknüpfen wir die Arrays vertikal (übereinander) und reduzieren sie dann. Dies verschachtelt die Faktoren mit Zählungen.

Schließlich zeigen wir das Ergebnis als Zeichenfolge an, um sicherzustellen, dass keine Einsen im endgültigen Array übersprungen werden. Die einzige Zeit, zu der Einsen auftreten können, ist, wenn die Zählung 1 war, da 1 niemals ein Hauptfaktor sein wird. Diese Eliminierung erfolgt vor der Konvertierung in einen String, sodass Dinge wie die Zahl 10 davon nicht betroffen sind.

Ruby , 45 + 7 Bytes

Benötigt die Flagge -rprime.

->n{(n.prime_division.flatten-[1]).join.to_i}

Probieren Sie es online!

Pyth - 16 Bytes

V{PQpNK/PQNItKpK

Versuch es

Eine andere Lösung:

sm`d-.nm(d/PQd){PQ1

R , 72 Bytes

x=rle(pracma::factors(scan()));x$l[x$l<2]='';paste0(x$v,x$l,collapse='')

Benötigt das pracmaPaket, das nicht auf TIO installiert ist.