33

सकारात्मक पूर्णांक दिया n > 2। हम इसे एक सरणी में रूपांतरित करते हैं:

यदि यह 2खाली सरणी को वापस करने के बराबर है
अन्यथा nआरोही क्रमबद्ध किए गए सभी प्रमुख कारकों की सारणी बनाएं , फिर प्रत्येक तत्व अपनी संख्याओं को अभाज्य संख्या अनुक्रम में बदल देता है और अंत में अपने तत्व को सरणी में परिवर्तित करता है।

उदाहरण के लिए, संख्या 46को सरणी में बदलने देता है । सबसे पहले, इसे इसके प्रमुख कारकों की सरणी में बदलें:

[2, 23]

संख्या 23है 9वें प्रधानमंत्री, इसलिए की जगह 2खाली सरणी के साथ और 23साथ [9]। अब ऐरे हो गए:

[[], [9]]

के प्रधान कारकों 9हैं 3और 3, इसलिए:

[[], [3, 3]]

दोनों के लिए समान करें 3:

[[], [[2], [2]]]

और अंत में:

[[], [[[]], [[]]]]

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

[ ] [ [ [ ] ] [ [ ] ] ]

| | | | | | | | | | | |
| | | | | | | | | | | |
V V V V V V V V V V V V

1 0 1 1 1 0 0 1 1 0 0 0

अब बस अंतिम तीन शून्य और अंतिम छोड़ें 1। वह संख्या बन जाती है 10111001जो 185दशमलव में होती है। वह अपेक्षित आउटपुट है। ध्यान दें कि मुख्य सरणी के द्विआधारी रूपांतरण ब्रैकेट में सरणी शामिल नहीं हैं।

इनपुट

nसे अधिक सकारात्मक पूर्णांक 2।

उत्पादन

एन्कोडेड पूर्णांक n।

नियम और IO प्रारूप

मानक नियम लागू होते हैं।
इनपुट स्ट्रिंग या संख्या हो सकता है (लेकिन स्ट्रिंग के मामले में यह बेस 10 में होना चाहिए)।
आउटपुट स्ट्रिंग या संख्या हो सकता है (लेकिन स्ट्रिंग के मामले में यह बेस 10 में होना चाहिए)।
यह कोड-गोल्फ है , बाइट्स जीत में सबसे छोटा जवाब!

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

अनुरोध पर अधिक परीक्षण के मामले।

3 ---> 1
4 ---> 2
5 ---> 3
6 ---> 5
7 ---> 6
8 ---> 10
9 ---> 25
10 ---> 11
10000 ---> 179189987
10001 ---> 944359
10002 ---> 183722
10003 ---> 216499
10004 ---> 2863321
10005 ---> 27030299
10006 ---> 93754
10007 ---> 223005
10008 ---> 1402478

सैंडबॉक्स

— H.PWiz
स्रोत

आपको परीक्षण मामले को हटा देना चाहिए 2क्योंकि इसे संभालने के लिए प्रस्तुतियाँ आवश्यक नहीं हैं।

— श्री एक्सकोडर

4

रिप भाषाएं जिनमें मुख्य बिल्ट-इन नहीं होते हैं।

— श्री Xcoder

3

@Paul। "[...] आरोहित किए गए सभी n प्रमुख कारकों की

1

@Quelklef। मैं एटीपी (केवल मनोरंजन के लिए, गंभीर कुछ भी नहीं) को लागू करने पर काम कर रहा था और मैंने किसी न किसी तरह से नेस्टेड सरणियों का उपयोग करने का प्रयास किया। इसलिए, यह एन्कोडिंग पहला विचार है जिसके साथ मैं आया था।

1

@WheatWizard। मेरा मतलब पूर्णांक के सटीक गणितीय अर्थ से नहीं है । मैं इसे छोड़ने जा रहा हूं। :-)

12

भूसी , 35 31 30 29 26 25 24 22 20 19 15 बाइट्स

-7 बाइट्स @Zbb को धन्यवाद!

परोक्ष रूप से, ज़गरब के लिए धन्यवाद, अतिरिक्त 4 बाइट्स बचाता है

ḋhΣhgφṁȯ`Jḋ2⁰ṗp

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

explaination

     φ             -- Define a recursive function which calls itself ⁰ and is applied to an Integer
      ṁ       p    -- map then concatenate over its prime factors
             ṗ     --   return their indices into the primes
            ⁰      --   and then recur, applying ⁰ to that number
       ȯ`Jḋ2       --   then surround it between the list [1,0] (binary 2)
    g              -- group adjacent equal elements
   h               -- drop last element (trailing 0s)
  Σ                -- concatenate
 h                 -- drop the last element
ḋ                  -- interpret as base 2

— H.PWiz
स्रोत

मुझे लगता है कि यह 27 बाइट्स के लिए काम करना चाहिए, लेकिन टाइप

— इंक्वायरी के

2

कोई बात नहीं, 25 बाइट्स और काम करना। अंत में φ, के लिए एक उपयोग के मामले में , ठीक बिंदु लैम्ब्डा!

— जर्गब

वाह, मैं वास्तव में इसके उपयोग के मामलों को कभी नहीं समझ पाया हूं, अब तक

— H.PWiz

हमने बहु-पंक्ति कार्यक्रमों को लागू करने से पहले, हस्क के लिए फिक्स पॉइंट लैम्ब्डा को बहुत पहले जोड़ा। मुझे लगता है कि हमने सोचा था कि वे पुनरावृत्ति को संभालने का सबसे अच्छा तरीका होगा। लेकिन वे इस तरह से विशेष मामलों में एक बाइट को बचाने के अलावा बहुत अस्पष्ट हैं।

— जर्बगर्बर

`:0:1हो सकता है `Jḋ2।

— ज़गर्ब

7

जेली , 22 20 19 बाइट्स

-1 एग्रीकॉल आउटगॉल्फ के लिए धन्यवाद ( tदाएं से बजाय दोनों तरफ से टेल ज़ीरोœr )

ÆfÆC$ÐLŒṘO%3ḟ2Ḋt0ṖḄ

2 से अधिक पूर्णांक और 0 से अधिक पूर्णांक लौटाते समय एक मोनैडिक लिंक (मूल युक्ति के अनुसार 2 वापस लौटेगा)।

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

कैसे?

यह लगभग पूरी तरह से दिए गए विवरण को दोहराता है, बस द्विआधारी सरणी के निर्माण के लिए कुछ क्रमिक हेरफेर के साथ ...

ÆfÆC$ÐLŒṘO%3ḟ2Ḋt0ṖḄ - Link: number n (>=2)
     ÐL             - loop until no more changes occur:
    $               -   last two links as a monad:
Æf                  -     prime factorisation (includes duplicates & vectorises)
  ÆC                -     count primes less than or equal (vectorises)
                    -   ...note for entries of 2 this yields [1]
                    -      then for entries of 1 it yields [], as required
       ŒṘ           - get a Python representation - just like in the OP,
                    -    something like: "[[], [[[]], [[]]]]" (for an input of 46)
         O          - convert to ordinals e.g. [91,91,93,44,32,91,91,91,93,93,44,32,91,91,93,93,93,93]
          %3        - modulo by 3         e.g. [ 1, 1, 0, 2, 2, 1, 1, 1, 0, 0, 2, 2, 1, 1, 0, 0, 0, 0]
            ḟ2      - filter discard twos e.g. [ 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 0, 0, 0, 0]
              Ḋ     - dequeue             e.g. [ 1, 0, 1, 1, 1, 0, 0, 1, 1, 0, 0, 0, 0]
               t0   - strip zeros         e.g. [ 1, 0, 1, 1, 1, 0, 0, 1, 1]
                 Ṗ  - pop                 e.g. [ 1, 0, 1, 1, 1, 0, 0, 1]
                  Ḅ - binary to decimal   e.g. 185

— जोनाथन एलन
स्रोत

आह, हाँ, मैं निश्चित रूप से कर सकता हूं; धन्यवाद।

— जोनाथन एलन

6

पायथन 2 , 212 177 बाइट्स

lambda n:int(g(n).rstrip("0")[1:-1],2)
g=lambda n:"1%s0"%"".join(map(g,p(n)))
def p(n,i=0,j=1):
 while n>1:
  j+=1;P=q=1;exec"P*=q*q;q+=1;"*~-j;i+=P%q
  while n%j<1:yield i;n/=j

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

प्राइम बिल्डरों की कमी वास्तव में बाइट काउंट को नुकसान पहुँचाती है, और यह TIO पर बड़े अपराधों से बाहर है। उपयोग XNOR के primality जांच।

अजगर 2 + gmpy2 , 175 बाइट्स

lambda n:int(g(n).rstrip("0")[1:-1],2)
g=lambda n:"1%s0"%"".join(map(g,p(n)))
def p(n,i=0,j=1):
 while n>1:
  j+=1;i+=is_prime(j)
  while n%j<1:yield i;n/=j
from gmpy2 import*

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

यह संस्करण बड़े परीक्षण मामलों (अर्थात 10000 - 10008) पर समय नहीं देता है।

— notjagan
स्रोत

5

गणितज्ञ, 125 119 बाइट्स

Flatten[#//.{{1}->{1,0},a_/;a>1:>{1,List/@PrimePi[Join@@Table@@@FactorInteger@a],0}}]/.{1,d__,1,0..}:>{d}~FromDigits~2&

थोड़ा अलग दृष्टिकोण का उपयोग करता है; अभिकलन को प्रमुख सूचकांकों {1, index, 0}, और 2 को {1, 0}।

इसे वुल्फ्राम सैंडबॉक्स पर आज़माएं

उपयोग:

f = Flatten[ ...

f[10008]

1402478

— जंगवान मिन
स्रोत

मूल उत्तर 10008 पर काम करता है, लेकिन यह विफल रहता है

— केली लोडर

1

@ केलीलौड फिक्स्ड!

— जुंगह्वान मिन

2

जेली , 35 बाइट्स

ÆfẎW€ÆC2,“”y¹ß€Ṇ?
ÇŒṘḊ⁾][iÐ€ḟ0t1Ṗ’Ḅ

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

— आउटगोल्फर को एरिक करें
स्रोत

2

जे, 74 73 66 बाइट्स

3 :'#.(}.~ >:@i.&1)&.|.2+}.;<@(_2,~_1,[:>:[:_1&p:q:) ::<"0@;^:_ y'

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

यह एक वास्तविक गड़बड़ है जो निश्चित रूप से आगे गोल्फिंग की आवश्यकता है (उदाहरण के लिए स्पष्ट फ़ंक्शन परिभाषा को हटाने)। मुझे लगता है कि मैं जो मुक्केबाजी कर रहा हूं, वह विशेष रूप से है जो बायटेकाउंट ला रहा है क्योंकि मुझे नहीं पता कि मैं वहां क्या कर रहा हूं (यह बहुत परीक्षण और त्रुटि है)। इसके अलावा, मुझे पूरा यकीन है कि कुछ बिल्ट-इन हैं जिन्हें मैं भूल रहा हूं (जैसे मुझे लगता है कि _2,~_1,शायद एक अंतर्निहित है)।

स्पष्टीकरण (अपुष्ट)

प्रस्तावना

कसकर बैठें, क्योंकि यह संक्षिप्त विवरण नहीं है। विडंबना यह है कि, एक गद्य भाषा को एक क्रियात्मक व्यक्ति के साथ जोड़ा गया है।

मैं इसे कुछ कार्यों में विभाजित करूँगा

encode  =. 3 : '<@(_2,~_1, [: >: [: _1&p: q:) ::<"0@;^:_ y'
convert =. 3 : '2 + }. ; y'
drop    =. (}.~ >:@i.&1)&.|.
decode  =. #.

encode [और] के बजाय _1 और _2 का उपयोग करके पूर्णांक को एन्कोड करता है
convert _1 और _2 की सूची को 1 और 0 की सूची में परिवर्तित करता है
drop अंतिम 1 और शून्य को पीछे छोड़ता है
decode एक बाइनरी सूची से एक संख्या में कनवर्ट करता है

मैं 46 के लिए एक नमूना कॉल के माध्यम से चल रहा हूँ, जो ungolfed प्रारूप में व्यक्त किया जाता है

   decode drop convert encode 46
185

सांकेतिक शब्दों में बदलना

यहाँ समझाने के लिए बहुत कुछ है।

3 : '<@(_2,~_1, [: >: [: _1&p: q:) ::< "0@;^:_ y'
                                           ^:_      Do until result converges
                                          ;          Raze (remove all boxing)
                                       "0            For each
                               q:                     Factorize
                         _1&p:                        Get index of prime
                   >:                                 Add 1 (J zero-indexes)
            _1,                                       Prepend -1
        _2,~                                          Append -2
     <                                                Box resulting array
                                   ::                If there is an error
                                     <                Box the element

ध्यान दें कि स्पष्ट फ़ंक्शन परिभाषा फ़ंक्शन का 3 : '[function]'मूल्यांकन करती है जैसे कि यह REPL पर थे सही तर्क के साथ हर उदाहरण की जगह y(इसका मतलब है कि मैं कैप्स ( [:), टॉप्स ( @) और एटीएस ( @:) की कीमत पर उपयोग करने से बच सकता हूं कुछ बाइट्स)।

46 के इनपुट पर प्रत्येक क्रमिक पुनरावृत्ति के लिए यह कैसा दिखता है

┌─────────┐    ┌──┬─────┬─────────┬──┐    ┌──┬──┬──┬──┬───────┬───────┬──┬──┐
│_1 1 9 _2│ => │_1│_1 _2│_1 2 2 _2│_2│ => │_1│_1│_2│_1│_1 1 _2│_1 1 _2│_2│_2│ =>
└─────────┘    └──┴─────┴─────────┴──┘    └──┴──┴──┴──┴───────┴───────┴──┴──┘

┌──┬──┬──┬──┬──┬─────┬──┬──┬─────┬──┬──┬──┐    
│_1│_1│_2│_1│_1│_1 _2│_2│_1│_1 _2│_2│_2│_2│ => the final iteration is just every
└──┴──┴──┴──┴──┴─────┴──┴──┴─────┴──┴──┴──┘    value in its own box

यह फ़ंक्शन ::"कोष्ठक" (यहां प्रयुक्त ब्रैकेट -1 और -2 हैं) में मूल्यों को घोंसला बनाने के लिए प्रतिकूल ( ) का उपयोग करता है । मूल रूप से, हर बार हम अभाज्य संख्याओं को अभाज्य और परिवर्तित करते हैं, _1 पूर्व निर्धारित होता है और _2 संलग्न होता है, जो कोष्ठक के रूप में कार्य करता है। जब फ़ंक्शन को उन तत्वों पर कॉल किया जाता है, तो यह उन्हें उसी रूप में वापस करता है, जब से q:एक नकारात्मक संख्या को कारक बनाने की कोशिश करने में त्रुटि होगी। यह भी भाग्यशाली है कि q:है नहीं 1 गुणनखंड की कोशिश कर रहा पर त्रुटि और इसके बजाय खाली सरणी देता है (जैसा कि आवश्यक होने पर)।

धर्मांतरित

3 : '2 + }. ; y'
            ;     Raze (remove boxing)
         }.       Behead (remove head)
     2 +          Add 2

कन्वर्ट बहुत सरल है। यह सिर्फ सभी मुक्केबाजी को हटाता है, साथ ही साथ पहला तत्व, और फिर सब कुछ 1s और 0s में परिवर्तित करता है (बस 2 जोड़कर)

ड्रॉप

(}.~ >:@i.&1)&.|.
             &.|.  Reverse, apply the left function, and then undo
 }.~ >:@i.&1        Drop the leading zeroes and first 1
        i.&1         Index of first one
     >:              Add 1
 }.~                 Drop

यह सूची को उलट देता है, पहले एक को ढूंढता है और फिर उस तक के सभी मूल्यों को गिरा देता है, फिर सूची को फिर से बदल देता है।

व्याख्या करना

Decode एक अंतर्निहित फ़ंक्शन है #.जो 1s और 0s की सूची लेता है और इसे एक बाइनरी नंबर में परिवर्तित करता है।

— गोभी
स्रोत

2

रेटिना , 244 227 225 बाइट्स

+%(G`
\d+
$*0¶$&$*
+`^00(0+)
0$1¶$0
A`^(00+?)\1+$
^0+
$0;1
+`(1+)¶0+(?=¶)
$0;1$1
+`¶(11+?)(\1)*$
¶$1¶1$#2$*1
1$

m`^11$
[]
m`^1+
[¶$.0$*0¶]
+s`(0+);(1+)(.+¶)\1¶
$1;$2$3$2¶
0+;1+¶

)`1+
$.0
T`[]¶`10_
10+$

1
01
+`10
011
^0+

1

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

यह प्रश्न में प्रदर्शित एल्गोरिथम के बाद एक सीधा आगे का दृष्टिकोण है। प्राइम इंडेक्स जेनरेशन एक्सपोनेंशियल कॉम्प्लेक्सिटी है इसलिए बड़े इनपुट्स के लिए टाइम आउट हो जाएगा

स्पष्टीकरण:

+%(G`                Repeatedly apply on each line:
\d+                      If the line is a number, convert it to unary 0s and 1s
$*0¶$&$*
+`^00(0+)                Generate all prefixes of the zeros greater than 1
0$1¶$0
A`^(00+?)\1+$            Remove non-prime strings of zeros
^0+                      Index the first zero set (00) as 1
$0;1
+`(1+)¶0+(?=¶)           Index the rest of the zeroes as their prime index
$0;1$1
+`¶(11+?)(\1)*$          Compute prime factors of input value
¶$1¶1$#2$*1
1$                       Remove the 1 factor (not really prime)

m`^11$                   Turn all 2 prime factors to []
[]
m`^1+                    Surround all non-2 prime factors in brackets
[¶$.0$*0¶]
+s`(0+);(1+)(.+¶)\1¶     Convert non-2 prime factors to their index
$1;$2$3$2¶
0+;1+¶                   Remove the list of primes

)`1+                     Return all primes back to decimal ready to be repeated
$.0
T`[]¶`10_            Then convert all [ to 1 and ] to 0, and remove linefeeds
10+$                 Remove the final 1 and trailing zeroes

1                    Convert from binary to unary
01
+`10
011
^0+

1                    Convert from unary to decimal

— PunPun1000
स्रोत

1

हास्केल , 162 160 155 बाइट्स

sum.zipWith((*).(2^))[0..].tail.snd.span(<1).(r%)
r=zip[1..][x|x<-[2..],all((>0).mod x)[2..x-1]]
_%1=[]
((i,q):p)%n|mod n q<1=r%div n q++0:r%i++[1]|1<3=p%n

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

स्पष्टीकरण:

r=zip[1..][x|x<-[2..],all((>0).mod x)[2..x-1]]primes और उनके सूचकांक के tuples की एक अनंत सूची को परिभाषित करता है [(1,2),(2,3),(3,5),(4,7),(5,11),(6,13), ...]:।

फ़ंक्शन (%)इस सूची rऔर एक संख्या को लेता है और nसंख्या को उल्टे कारक-सरणी प्रतिनिधित्व में परिवर्तित करता है। यह कदम के माध्यम से किया जाता है rजब तक हम एक प्रमुख नहीं पाते हैं जो विभाजित करता है n। हम तो रिकर्सिवली इस प्रधानमंत्री के सूचकांक के प्रतिनिधित्व का निर्धारण और इसे बंद 0और 1और के प्रतिनिधित्व पहले जोड़ें nकि प्रधानमंत्री से विभाजित।

इसके लिए n=46, यह उस सूची की पैदावार करता [0,0,0,1,1,0,0,1,1,1,0,1]है जिसमें से अग्रणी शून्य ( snd.span(<1)) और अगला 1( tail) गिराया जाता है। बाद में सूची को दो की शक्तियों की सूची के साथ तत्व-वार गुणा करके दशमलव संख्या में बदल दिया जाता है और परिणामी सूची को संक्षेप में प्रस्तुत किया जाता है sum.zipWith((*).(2^))[0..]।

— Laikoni
स्रोत

0

जावास्क्रिप्ट, 289 बाइट्स

बाइट्स कॉमा के बाद लाइनब्रीक के बिना जावास्क्रिप्ट कोड का योग होता है (जो केवल बेहतर स्वरूपण और पठनीयता के लिए डाला जाता है) (256 बाइट्स) और कमांड लाइन स्विच के लिए अतिरिक्त वर्ण, जो क्रोम (33 बाइट्स) का उपयोग करते समय आवश्यक होता है।

'use strict'
var f=(n,i=2,r=[])=>n>1?n%i?f(n,i+1,r):f(n/i,i,r.concat(i)):r,
c=(p,r=1,i=2)=>i<p?f(i)[1]?c(p,r,i+1):c(p,r+1,i+1):r-1?f(r).map(h):[],
h=a=>c(a),
s=a=>a.reduce((r,e)=>r+s(e),'1')+' ',
o=i=>+('0b'+s(f(i).map(h)).trim().replace(/ /g,'0').slice(1,-1))

और एक लंबा, बेहतर पठनीय संस्करण:

'use strict';
const f = (n,i=2,r=[]) => n>1 ? n%i ? f(n,i+1,r) : f(n/i,i,r.concat(i)) : r;
const c = (p,r=1,i=2) => i<p ? f(i)[1] ? c(p,r,i+1) : c(p,r+1,i+1) : r-1 ? f(r).map(h) : [];
const h = i => c(i);
const s = a => a.reduce((r,e) => r+s(e),'1')+' ';
const o = i => +('0b'+s(f(i).map(h)).trim().replace(/ /g,'0').slice(1,-1));

कुछ संक्षिप्त स्पष्टीकरण:

f एक विशुद्ध रूप से कार्यात्मक पूंछ-पुनरावर्ती कारक एल्गोरिथ्म है।

cमायने रखता है कि किस स्थान rपर अभाज्य संख्या pके अनुक्रम में अभाज्य संख्या होती है और पुनरावृत्ति के माध्यम से या तो [](यदि p=2और r=1) या फैक्टराइज़ करता है और आगे की प्रक्रिया करता rहै।

hएक छोटा सहायक कार्य है जो दुर्भाग्यवश आवश्यक है क्योंकि mapआपूर्ति किए गए फ़ंक्शन numberOfCurrentElementको दूसरे और wholeArrayतीसरे तर्क के रूप में कॉल किया जाता है, इस प्रकार प्रदान किए गए डिफ़ॉल्ट मानों को ओवरराइड करते हुए cयदि हम इस फ़ंक्शन को सीधे पास करेंगे (इस नुकसान के बाद मुझे मिलने में कुछ समय लगा; जगह hअपनी परिभाषा से कुछ बाइट्स लंबे समय तक हो जाएगा)।

sउत्पन्न सरणी को एक स्ट्रिंग में बदल देता है। हम का उपयोग blankकरने के बजाय 0, ताकि हम उपयोग कर सकते हैं trim()में o।

oवह इनपुट वैल्यू है iजिसे आउटपुट देता है। यह विनिर्देश द्वारा आवश्यक बाइनरी स्ट्रिंग प्रतिनिधित्व उत्पन्न करता है और इसे एक (दशमलव) संख्या में परिवर्तित करता है।

संपादित करें:chrome --js-flags="--harmony-tailcalls" पूंछ-पुनरावृत्ति के अनुकूलन को सक्षम करने के लिए Chrome को प्रारंभ किया जाना चाहिए ( https://v8project.blogspot.de/2016/04/04/es6-es7-and-beyond.html देखें )। इसके लिए भी सख्त मोड का उपयोग करना पड़ता है।

निम्न परीक्षण से पता चलता है कि गणना कुछ मूल्यों के लिए थोड़ी धीमी है (सबसे लंबे समय तक 10007मेरे कंप्यूटर पर छह सेकंड से अधिक है )। दिलचस्प है, पूंछ-पुनरावृत्ति के अनुकूलन के बिना गणना बहुत तेजी से होती है (कारक 5 के बारे में) जब कोई स्टैक अतिप्रवाह नहीं होता है।

for (let i=3; i<=10008; i==10 ? i=10000 : ++i) {
    let time = new Date().getTime();
    let val = o(i);
    time = new Date().getTime() - time;
    document.write(i + ': ' + o(i) + ' (computed in ' + time + ' ms)<br>');
}

— अवसर की प्रतीक्षा करनेवाला
स्रोत

0

टिनिइलिस , 209 बाइट्स

(load library
(d [(q((N)(map(q((P)([(length(filter prime?(1to P))))))(reverse(prime-factors N
(d B(q((L)(c 1(insert-end 0(foldl concat(map B L
(d T(q((N)(if(mod N 2)(/ N 2)(T(/ N 2
(q((N)(T(from-base 2(t(B([ N

अंतिम पंक्ति एक अनाम फ़ंक्शन है जो निर्दिष्ट एन्कोडिंग की गणना करती है। इसे ऑनलाइन आज़माएं!

पूर्व-गोल्फ संस्करण

यह कोड है जो मैंने इससे पहले कि मैं इसे नीचे गोल्फ शुरू कर दिया है:

(load library)

(def prime-index
 (lambda (P)
  (length (filter prime? (1to P)))))

(def to-list
 (lambda (N)
  (map to-list
   (map prime-index
    (reverse (prime-factors N))))))

(def to-bits
 (lambda (L)
  (cons 1
   (insert-end 0
    (foldl concat
     (map to-bits L))))))

(def trim
 (lambda (N)
  (if (mod N 2)
   (div2 N 2)
   (trim (div2 N 2)))))

(def encode
 (lambda (N)
  (trim
   (from-base 2
    (tail (to-bits (to-list N)))))))

— DLosc
स्रोत

0

05AB1E , 18 बाइट्स

ΔÒ.Ø>}¸»Ç3%2K0Ü¨2β

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

स्पष्टीकरण:

Δ    }       # loop until a fixed point
 Ò           # replace each number with its prime factorization
  .Ø>        # replace each prime with its 1-based index
¸»           # after the loop: join to a string
  Ç          # get ASCII value of each character
   3%        # modulo 3 (maps '[' to 1, ']' to 0, ' ' to 2, ',' to 2)
     2K      # remove 2s
       0Ü    # trim trailing 0s
         ¨   # remove the last 1
          2β # parse as base 2

— ग्रिमी
स्रोत

एक पूर्णांक एनकोड करें

इनपुट

उत्पादन

नियम और IO प्रारूप

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

सैंडबॉक्स

भूसी , 35 31 30 29 26 25 24 22 20 19 15 बाइट्स

explaination

जेली , 22 20 19 बाइट्स

कैसे?

पायथन 2 , 212 177 बाइट्स

अजगर 2 + gmpy2 , 175 बाइट्स

गणितज्ञ, 125 119 बाइट्स

जेली , 35 बाइट्स

जे, 74 73 66 बाइट्स

स्पष्टीकरण (अपुष्ट)

प्रस्तावना

सांकेतिक शब्दों में बदलना

धर्मांतरित

ड्रॉप

व्याख्या करना

रेटिना , 244 227 225 बाइट्स

स्पष्टीकरण:

हास्केल , 162 160 155 बाइट्स

जावास्क्रिप्ट, 289 बाइट्स

टिनिइलिस , 209 बाइट्स

पूर्व-गोल्फ संस्करण

05AB1E , 18 बाइट्स