एक कदम एक प्रधानमंत्री पर चढ़ो

24

नंबरफाइल के नवीनतम वीडियो का शीर्षक, 13532385396179 , सकारात्मक पूर्णांक पर निम्नलिखित फ़ंक्शन f का एक निश्चित बिंदु है :

चलो n एक सकारात्मक पूर्णांक होना। प्राइम फैक्टराइजेशन को सामान्य तरीके से लिखें, जैसे 60 = 2 2 · 3 · 5, जिसमें प्राइम्स को बढ़ते क्रम में लिखा गया है, और 1 के एक्सपोर्टर को छोड़ दिया गया है। फिर, लाइन करने के लिए नीचे एक्स्पोनेंट्स लाने के लिए और छोड़ सभी गुणा संकेत एक नंबर प्राप्त करने के च (एन)। [...] उदाहरण के लिए, f (60) = f (2 2 · 3 · 5) = 2235।

(उपरोक्त परिभाषा को $ 1,000 की पाँच समस्याओं में से एक लिया गया है - जॉन एच। कोनवे )

ध्यान दें कि f (13532385396179) = f (13 · 53 2 · 3853 · 96179) = 13532385396179।

कार्य

nइनपुट और आउटपुट के रूप में एक सकारात्मक समग्र पूर्णांक लें f(n)।

एक और उदाहरण

48 = 2 4 · 3, इसलिए एफ (48) = 243।

परीक्षण के मामलों

अधिक टेस्टकेस यहां उपलब्ध हैं ।

   4 -> 22
   6 -> 23
   8 -> 23
  48 -> 243
  52 -> 2213
  60 -> 2235
 999 -> 3337
9999 -> 3211101
code-golf  number  arithmetic  primes 
— लीक नन
स्रोत
11
+1 मैं अभी भी चकित हूं कि कोई व्यक्ति अनुमान के एक अवरोधक के रूप में 13532385396179 को खोजने में कामयाब रहा। मुझे लगता है कि $ 1000 का पुरस्कार किसी तरह से इस्तेमाल की जाने वाली बिजली के भुगतान के लिए जाएगा! :)
— Wossname
7
लिंक का पालन किए बिना यह स्पष्ट नहीं था कि अनुमान यह है कि f (n) के बार-बार आने वाले अनुप्रयोग हमेशा एक अभाज्य (और निश्चित रूप से f (p) = p यदि p अभाज्य हैं) तक पहुंच जाएंगे । 13532385396179 अनुमान को नापसंद करता है क्योंकि यह समग्र और एक निश्चित ओपिन्ट दोनों है।
— क्रिस एच

जवाबों:

16

पायथन, 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)
— jchd
स्रोत
2
@LeakyNun ने अपने जवाब को बेहतर बनाने में मदद करने के बजाय किसी नवागंतुक को क्यों अपमानित किया? :(
— झबरा
3
क्षमा करें- वास्तव में यही वह है जिसका मैंने उपयोग किया (मुझे संख्या मिली)। मुझे लगा कि क्रमी कोड मजाकिया होगा। आप इसे नीचे ले जा सकते हैं।
— jchd
9
साइट पर आपका स्वागत है। यह वास्तव में आप हमारे साथ अपने समाधान साझा करने के लिए अच्छा है। (जो लोग नहीं जानते हैं, जिम डेविस वह हैं जिन्होंने पहली बार में इस समस्या को हल किया है)। हालांकि, चुनौतियों के जवाब के लिए कुछ नियमों का पालन करने की आवश्यकता है। यदि आप केवल @LeakyNun से सुझावों का पालन करते हैं, तो आप उत्तर मान्य करेंगे। (शायद अन्य उत्तरों पर एक नज़र डालें कि वे आम तौर पर कैसे दिखते हैं)
— दादा
4
हे भगवान, मुझे उम्मीद नहीं थी कि जिम डेविस खुद इस साइट में दिखाई देंगे, और मेरी चुनौती का जवाब देने के लिए ... मैं अब बहुत सम्मानित महसूस कर रहा हूं ...
— लीक नून
2
एह, वैसे भी ट्रोल नहीं। मेरा ईमेल पता Happyhoboexpress.blogspot.ca/2014/10/climb-to-prime.html पर है ... मैंने पोस्ट छोड़ दी, कोई भी आपको गणित के साथ ईमेल नहीं करता।
— jchd
9

ब्रेकीलॉग , 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, जो शायद अधिक पठनीय है और ब्रेललॉग की भावना में अधिक है।

— Fatalize
स्रोत
9

जेली , 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.
— मार्टिन एंडर
स्रोत
V= "एक स्ट्रिंग के
— लिए संक्षिप्त
@EriktheOutgolfer हां, इसलिए "प्रभावी रूप से"।
— मार्टिन एंडर
@MartinEnder कोई विशेष कारण जिसका आप उपयोग नहीं करते Ḍ(दशमलव से पूर्णांक में कनवर्ट करें)?
— तितर बितर
@Christian Because the list might contain multi-digit integers.
— Martin Ender
@MartinEnder Ah, clever. I've used FḌ in the past - that's a good tip!
— scatter
4

CJam, 8 bytes

limF:~1-

Try it online!

Explanation

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.
— Martin Ender
स्रोत
I would have used e_ to flatten, since that's what it's there for, but it doesn't change the score.
— Peter Taylor
1
@PeterTaylor Hm yeah, I can never decide which one to use, but tend to go with e_ for deep flatten only and use :~ whenever it's just a single level.
— Martin Ender
4

05AB1E, 10 bytes

Òγʒ¬?gDië?

Try it 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
— Riley
स्रोत
3

05AB1E, 12 11 bytes

Òγvy¬sgD≠×J

Try it online!

Explanation

Ò            # 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
— Emigna
स्रोत
Fails for 48.
— Leaky Nun
2

Pyth, 12 bytes

smjk_>hddr8P

Try it!

alternative, 12 bytes

smjk<_AdGr8P

Try that!

explanation

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
— KarlKastor
स्रोत
2

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

Try it online!

If inputs are restricted to be below 2147483659, both str(...) may be replaced by `...` saving 6 bytes (this program will be very slow for numbers affected anyway!).

— Jonathan Allan
स्रोत
2

Ohm, 11 bytes

o:_]D2<?O;J

Try it online!

Explanation

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
— Datboi
स्रोत
1

Japt, 19 bytes

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

Test it online!

Explanation

 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
— ETHproductions
स्रोत
0

सी #, 206 100 बाइट्स

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();
    }
}
— TheLethalCoder
स्रोत
0

जावास्क्रिप्ट - 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
)
— asgallant
स्रोत
0

जावा 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;}

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;
};
— Computronium
स्रोत
— सीलिंगकैट
0

ऑक्टेव , 69 बाइट्स

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

इसे ऑनलाइन आज़माएं!

काफी लंबे समय से समाप्त हो रहा है, लेकिन यह वांछित आउटपुट उत्पन्न करेगा।

मूलतः हम हिस्टोग्राम फ़ंक्शन का उपयोग इनपुट मूल्य के मुख्य कारक में अद्वितीय मूल्यों की घटनाओं की संख्या को गिनने के लिए करते हैं।

  • factor()फ़ंक्शन का परिणाम आरोही क्रम में प्रमुख कारक देता है
  • हम तब unique()उस ऐरे में मान पाते हैं
  • hist() घटनाओं की संख्या लौटाता है

एक बार जब हमारे पास दो सरणियाँ होती हैं (अद्वितीय कारकों में से एक, मायने रखता है के लिए), हम सरणियों को लंबवत (एक के ऊपर एक), और फिर समतल करते हैं। यह मायने रखता है कारकों के साथ मायने रखता है।

अंत में हम अंतिम सरणी में किसी भी 1 को छोड़ना सुनिश्चित करने वाले स्ट्रिंग के रूप में परिणाम प्रदर्शित करते हैं। केवल 1 का समय दिखाई दे सकता है यदि गिनती 1 थी, क्योंकि 1 कभी भी प्रमुख कारक नहीं होगा। यह उन्मूलन एक स्ट्रिंग में परिवर्तित करने से पहले किया जाता है ताकि यह संख्या 10 जैसी चीजों को प्रभावित न करे।

— टॉम बढ़ई
स्रोत
0

आर , 72 बाइट्स

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

की आवश्यकता है pracmaपैकेज की , जो टीआईओ पर स्थापित नहीं है।

— ग्यूसेप
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.