Numberphile의 최신 비디오 제목 13,532,385,396,179 다음 함수의 고정 점 인 F 양의 정수는 :

n을 양의 정수로 하자 . 소인수 분해를 일반적인 방식으로 작성하십시오 (예 : 60 = 2 ² · 3 · 5). 소인수가 증가하는 순서로 작성되고 지수 1은 생략됩니다. 그런 다음 지수를 줄로 가져오고 모든 곱셈 부호를 생략하고 숫자 f (n)를 얻습니다 . [...] 예를 들어, f (60) = f (2 ² · 3 · 5) = 2235입니다.

(위의 정의는 5 개의 $ 1,000 문제 중 5 번 문제-John H. Conway 에서 발췌 한 것입니다 )

참고 F (13,532,385,396,179) = F (13 · 53 ² * 3853 * 96,179)가 13,532,385,396,179 =.

태스크

양의 복합 정수 n를 입력으로 사용하고 출력하십시오 f(n).

또 다른 예

48 = 2 ⁴ · 3이므로 f (48) = 243입니다.

테스트 케이스

더 많은 테스트 케이스가 여기에 있습니다 .

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

파이썬 166 162 159 바이트

너희들은 훨씬 낫다. 이것이 내가 사용한 것입니다! (해결 한 알고리즘은 이것을 호출합니다)

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 바이트

ḋoọc;1xc

온라인으로 사용해보십시오!

설명

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

당신은 사용할 수 있습니다 ℕ₂ˢ( 모든 2보다 크거나 정수 선택 대신에) ;1x아마 더 읽기 더 Brachylog의 정신입니다.

젤리 , 6 바이트

ÆFFḟ1V

온라인으로 사용해보십시오!

설명

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

매스 매 티카, 43 36 바이트

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

온라인으로 사용해보십시오!

CJam , 8 바이트

limF:~1-

온라인으로 사용해보십시오!

설명

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 바이트

Òγʒ¬?gDië?

온라인으로 사용해보십시오!

Ò          # 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 바이트

Òγvy¬sgD≠×J

온라인으로 사용해보십시오!

설명

Ò            # 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 바이트

smjk_>hddr8P

시도 해봐!

대안, 12 바이트

smjk<_AdGr8P

해봐!

설명

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 바이트

jksm_-d1r8P

여기를보십시오

파이썬 2 , 99 바이트

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

온라인으로 사용해보십시오!

입력이 아래로 제한 2147483659되면 둘 다 6 바이트 str(...)를 `...`절약 할 수 있습니다 (이 프로그램은 영향을받는 숫자 가 매우 느리게 진행됩니다 !).

옴 , 11 바이트

o:_]D2<?O;J

온라인으로 사용해보십시오!

설명

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 바이트

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

온라인으로 테스트하십시오!

설명

 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 바이트

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

온라인으로 사용해보십시오!

C #, 206100 바이트

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

풀 / 포맷 버전 :

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

자바 스크립트-91 바이트

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

설명

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

자바 8,103 자

매우 간단한 솔루션입니다.

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

언 골프 드 :

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

옥타브 , 69 바이트

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

온라인으로 사용해보십시오!

꽤 길어졌지만 원하는 출력을 생성합니다.

기본적으로 히스토그램 함수를 사용하여 입력 값의 소인수 분해에서 고유 한 값의 발생 횟수를 계산합니다.

• factor()함수 의 결과는 오름차순으로 주요 요소를 제공합니다
• 그런 다음 unique()해당 배열에서 값 을 찾습니다
• hist() 발생 횟수를 반환

일단 두 개의 배열 (하나는 고유 한 요인, 하나는 카운트)을 가지면 배열을 수직으로 연결하고 (하나는 다른 하나의 상단에) 평탄화합니다. 계수와 계수를 인터리브합니다.

마지막으로 결과를 문자열로 표시하여 최종 배열에서 1을 건너 뜁니다. 1이 나타날 수있는 유일한 시간은 1이 절대 요인이 아니므로 카운트가 1 인 경우입니다. 이 제거는 문자열로 변환하기 전에 수행되므로 숫자 10과 같은 것에 영향을 미치지 않습니다.

루비 , 45 + 7 바이트

플래그가 필요합니다 -rprime.

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

온라인으로 사용해보십시오!

Pyth-16 바이트

V{PQpNK/PQNItKpK

시도 해봐

다른 해결책 :

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

R , 72 바이트

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

pracmaTIO에 설치되지 않은 패키지가 필요합니다 .