Le titre de la dernière vidéo de Numberphile, 13532385396179 , est un point fixe de la fonction f suivante sur les entiers positifs:

Soit n un entier positif. Écrivez la factorisation des nombres premiers de la manière habituelle, par exemple 60 = 2 ² · 3 · 5, dans laquelle les nombres premiers sont écrits dans un ordre croissant et les exposants de 1 sont omis. Ensuite, ramenez les exposants sur la ligne et omettez tous les signes de multiplication, obtenant un nombre f (n). [...] par exemple, f (60) = f (2 ² · 3 · 5) = 2235.

(La définition ci-dessus est tirée du problème 5 de cinq problèmes de 1 000 $ - John H. Conway )

Notez que f (13532385396179) = f (13 · 53 ² · 3853 · 96179) = 13532385396179.

Tâche

Prenez un entier composite positif nen entrée et en sortie f(n).

Un autre exemple

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

Cas de test

D'autres tests sont disponibles ici .

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

Python, 166 162 159 159 octets

Vous allez beaucoup mieux. C'est ce que j'ai utilisé! (l'algorithme qui l'a résolu l'appelle)

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 octets

ḋoọc;1xc

Essayez-le en ligne!

Explication

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

Vous pouvez utiliser ℕ₂ˢ( sélectionner tous les entiers supérieurs ou égaux à 2 ) au lieu de ;1x, ce qui est probablement plus lisible et plus dans l'esprit de Brachylog.

Gelée , 6 octets

ÆFFḟ1V

Essayez-le en ligne!

Explication

Æ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 octets

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

Essayez-le en ligne!

CJam , 8 octets

limF:~1-

Essayez-le en ligne!

Explication

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 octets

Òγʒ¬?gDië?

Essayez-le en ligne!

Ò          # 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 octets

Òγvy¬sgD≠×J

Essayez-le en ligne!

Explication

Ò            # 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 octets

smjk_>hddr8P

Essayez!

alternative, 12 octets

smjk<_AdGr8P

Essayez ça!

explication

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 octets

jksm_-d1r8P

Essayez ici

Python 2 , 99 octets

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

Essayez-le en ligne!

Si les entrées sont restreintes pour être inférieures 2147483659, les deux str(...)peuvent être remplacées en `...`économisant 6 octets (ce programme sera très lent pour les nombres affectés de toute façon!).

Ohm , 11 octets

o:_]D2<?O;J

Essayez-le en ligne!

Explication

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 octets

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

Testez-le en ligne!

Explication

 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 octets

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

Essayez-le en ligne!

C #, 206 100 octets

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

Version complète / formatée:

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 octets

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

Explication

(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 caractères

Solution assez simple.

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

Non golfé:

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

Octave , 69 octets

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

Essayez-le en ligne!

A fini par être assez long, mais cela générera la sortie souhaitée.

Essentiellement, nous utilisons la fonction d'histogramme pour compter le nombre d'occurrences des valeurs uniques dans la factorisation principale de la valeur d'entrée.

• Le résultat de la factor() fonction donne les facteurs premiers dans l'ordre croissant
• on trouve alors unique() valeurs dans ce tableau
• hist() renvoie le nombre d'occurrences

Une fois que nous avons les deux tableaux (un pour les facteurs uniques, un pour les nombres), nous concaténons les tableaux verticalement (l'un au-dessus de l'autre), puis aplatissons. Cela entrelace les facteurs avec les nombres.

Enfin, nous affichons le résultat sous la forme d'une chaîne garantissant de sauter tout 1 dans le tableau final. Le seul moment où des 1 peuvent apparaître est si le compte était 1 car 1 ne sera jamais un facteur premier. Cette élimination est effectuée avant la conversion en chaîne afin qu'elle n'affecte pas des choses comme le nombre 10.

Rubis , 45 + 7 octets

Nécessite le drapeau -rprime.

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

Essayez-le en ligne!

Pyth - 16 octets

V{PQpNK/PQNItKpK

Essayez-le

Une autre solution:

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

R , 72 octets

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

Nécessite le pracmapackage, qui n'est pas installé sur TIO.