Il titolo del video più recente di Numberphile , 13532385396179 , è un punto fisso della seguente funzione f sugli interi positivi:

Sia n un numero intero positivo. Scrivi la scomposizione in fattori primi nel solito modo, ad esempio 60 = 2 ² · 3 · 5, in cui i numeri primi sono scritti in ordine crescente e gli esponenti di 1 sono omessi. Quindi porta gli esponenti sulla linea e ometti tutti i segni di moltiplicazione, ottenendo un numero f (n). [...] ad esempio, f (60) = f (2 ² · 3 · 5) = 2235.

(La definizione sopra è presa dal Problema 5 di Cinque $ 1,000 Problems - John H. Conway )

Si noti che f (13532385396179) = f (13 · 53 ² · 3853 · 96179) = 13532385396179.

Compito

Prendi un intero composito positivo ncome input e output f(n).

Un altro esempio

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

Casi test

Ulteriori test sono disponibili qui .

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

Python, 166 162 159 byte

Ragazzi, state molto meglio. Questo è quello che ho usato! (l'algoritmo che l'ha risolto chiama questo)

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 byte

ḋoọc;1xc

Provalo online!

Spiegazione

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

Puoi usare ℕ₂ˢ( seleziona tutti i numeri interi maggiori o uguali a 2 ) invece di ;1x, che è probabilmente più leggibile e più nello spirito di Brachylog.

Gelatina , 6 byte

ÆFFḟ1V

Provalo online!

Spiegazione

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

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

Provalo online!

CJam , 8 byte

limF:~1-

Provalo online!

Spiegazione

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 byte

Òγʒ¬?gDië?

Provalo 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 byte

Òγvy¬sgD≠×J

Provalo online!

Spiegazione

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

smjk_>hddr8P

Provalo!

alternativa, 12 byte

smjk<_AdGr8P

Prova questo!

spiegazione

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 byte

jksm_-d1r8P

Prova qui

Python 2 , 99 byte

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

Provalo online!

Se gli input sono limitati al di sotto 2147483659, entrambi str(...)possono essere sostituiti `...`salvando 6 byte (questo programma sarà comunque molto lento per i numeri interessati!).

Ohm , 11 byte

o:_]D2<?O;J

Provalo online!

Spiegazione

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 byte

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

Provalo online!

Spiegazione

 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 byte

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

Provalo online!

C #, 206 100 byte

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

Versione completa / formattata:

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 byte

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

Spiegazione

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

Soluzione piuttosto semplice.

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

Ottava , 69 byte

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

Provalo online!

Finì per essere piuttosto lungo, ma questo genererà l'output desiderato.

Sostanzialmente usiamo la funzione istogramma per contare il numero di occorrenze dei valori univoci nella fattorizzazione primaria del valore di input.

• Il risultato di factor() funzione fornisce i fattori primi in ordine crescente
• poi troviamo unique() valori in quell'array
• hist() restituisce il numero di occorrenze

Una volta che abbiamo le due matrici (una per i fattori unici, una per i conteggi), concateniamo le matrici in verticale (una sopra l'altra), quindi appiattiamo. Questo interlaccia i fattori con i conteggi.

Alla fine visualizziamo il risultato come una stringa assicurandoci di saltare qualsiasi 1 nell'array finale. L'unica volta in cui 1 può apparire è se il conteggio era 1 perché 1 non sarà mai un fattore primo. Questa eliminazione viene eseguita prima della conversione in una stringa in modo da non influire su cose come il numero 10.

Rubino , 45 + 7 byte

Richiede la bandiera -rprime.

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

Provalo online!

Pyth - 16 byte

V{PQpNK/PQNItKpK

Provalo

Un'altra soluzione:

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

R , 72 byte

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

Richiede il pracmapacchetto, che non è installato su TIO.