Tiêu đề của video mới nhất của Numberphile, 13532385394179 , là một điểm cố định của hàm f sau trên các số nguyên dương:

Đặt n là số nguyên dương. Viết hệ số nguyên tố theo cách thông thường, ví dụ 60 = 2 ² · 3 · 5, trong đó các số nguyên tố được viết theo thứ tự tăng dần và số mũ của 1 được bỏ qua. Sau đó đưa số mũ xuống dòng và bỏ qua tất cả các dấu nhân, thu được một số f (n). [...] Ví dụ: f (60) = f (2 ² · 3 · 5) = 2235.

(Định nghĩa trên được lấy từ Bài toán 5 trong Năm vấn đề $ 1.000 - John H. Conway )

Lưu ý rằng f (13532385394179) = f (13 · 53 ² · 3853 · 96179) = 13532385394179.

Bài tập

Lấy một số nguyên tổng hợp dương nlàm đầu vào và đầu ra f(n).

Một vi dụ khac

48 = 2 ⁴ · 3, vì vậy f (48) = 243.

Tủ thử

Nhiều testcase có sẵn ở đây .

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

Python, 166 162 159 byte

Các bạn tốt hơn nhiều. Đây là những gì tôi đã sử dụng! (thuật toán đã giải quyết nó gọi đây)

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

Hãy thử trực tuyến!

Giải trình

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

Bạn có thể sử dụng ℕ₂ˢ( chọn tất cả các số nguyên lớn hơn hoặc bằng 2 ) thay vì ;1x, có lẽ dễ đọc hơn và nhiều hơn theo tinh thần của Brachylog.

Thạch , 6 byte

ÆFFḟ1V

Hãy thử trực tuyến!

Giải trình

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

Toán học, 43 36 byte

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

Hãy thử trực tuyến!

CJam , 8 byte

limF:~1-

Hãy thử trực tuyến!

Giải trình

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ë?

Hãy thử trực tuyến!

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

Hãy thử trực tuyến!

Giải trình

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

Bình thường, 12 byte

smjk_>hddr8P

Thử nó!

thay thế, 12 byte

smjk<_AdGr8P

Hãy thử điều đó!

giải trình

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

Bình thường, 11 byte

jksm_-d1r8P

Thử ở đây

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

Hãy thử trực tuyến!

Nếu các đầu vào bị hạn chế ở dưới 2147483659, cả hai str(...)có thể được thay thế bằng cách `...`lưu 6 byte (chương trình này sẽ rất chậm đối với các số bị ảnh hưởng!).

Ồ , 11 byte

o:_]D2<?O;J

Hãy thử trực tuyến!

Giải trình

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

Kiểm tra nó trực tuyến!

Giải trình

 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;

Hãy thử trực tuyến!

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

Phiên bản đầy đủ / được định dạng:

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}

Giải trình

(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 ký tự

Giải pháp khá đơn giản.

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

Ung dung:

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 byte

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

Hãy thử trực tuyến!

Kết thúc khá dài, nhưng điều này sẽ tạo ra đầu ra mong muốn.

Về cơ bản, chúng tôi sử dụng hàm biểu đồ để đếm số lần xuất hiện của các giá trị duy nhất trong hệ số nguyên tố của giá trị đầu vào.

• Kết quả của factor()hàm đưa ra các thừa số nguyên tố theo thứ tự tăng dần
• sau đó chúng ta tìm thấy unique()các giá trị trong mảng đó
• hist() trả về số lần xuất hiện

Khi chúng ta có hai mảng (một cho các yếu tố duy nhất, một cho các số đếm), chúng ta ghép các mảng theo chiều dọc (một trên các mảng khác), và sau đó làm phẳng. Điều này xen kẽ các yếu tố với số lượng.

Cuối cùng, chúng tôi hiển thị kết quả dưới dạng một chuỗi đảm bảo bỏ qua bất kỳ 1 nào trong mảng cuối cùng. Lần duy nhất 1 giây có thể xuất hiện là nếu số đếm là 1 vì 1 sẽ không bao giờ là yếu tố chính. Việc loại bỏ này được thực hiện trước khi chuyển đổi thành một chuỗi để nó không ảnh hưởng đến những thứ như số 10.

Ruby , 45 + 7 byte

Yêu cầu cờ -rprime.

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

Hãy thử trực tuyến!

Pyth - 16 byte

V{PQpNK/PQNItKpK

Thử nó

Giải pháp khác:

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

Yêu cầu pracmagói không được cài đặt trên TIO.