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।

বিধি এবং আইও ফর্ম্যাট

স্ট্যান্ডার্ড বিধি প্রয়োগ।
ইনপুটটি স্ট্রিং বা সংখ্যা হতে পারে (তবে স্ট্রিংয়ের ক্ষেত্রে এটি অবশ্যই বেস 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

চিপযুক্ত ভাষাগুলিতে প্রাইম বিল্ট-ইন নেই।

— মিঃ এক্সকোডার

3

@Paul। "[...] সমস্ত এন এর মূল উপাদানগুলি সাজানো

1

@Quelklef। আমি এটিপি বাস্তবায়নের জন্য কাজ করছিলাম (কেবল মজাদার জন্য, গুরুতর কিছুই নয়) এবং নেস্টেড অ্যারে ব্যবহার করে আমি প্রতিটি সংখ্যার উপস্থাপন করার চেষ্টা করেছি। সুতরাং, এই এনকোডিংটি আমি প্রথম ধারণাটি নিয়ে এসেছি।

1

@WheatWizard। আমি পূর্ণসংখ্যার শব্দের সঠিক গাণিতিক বোধ বোঝাতে চাইছি না । আমি এটি ছেড়ে যাচ্ছি। :-)

12

হুশ , 35 31 30 29 26 25 24 22 20 19 15 বাইট

-8 বাইটস @ জগারবকে ধন্যবাদ!

জাগরবকে ধন্যবাদ, অপ্রত্যক্ষভাবে অতিরিক্ত 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 বাইট এবং কাজ করছে। অবশেষে ব্যবহারের ক্ষেত্রে φফিক্সপয়েন্ট লম্বা!

— জগারব

বাহ, আমি এখন পর্যন্ত এর ব্যবহারের ঘটনাগুলি সত্যই বুঝতে পারি নি

— এইচ.পি.উইজ

মাল্টি-লাইন প্রোগ্রামগুলি কার্যকর হওয়ার আগে আমরা খুব তাড়াতাড়ি হুসে ফিক্সপয়েন্ট ল্যাম্বডাস যুক্ত করেছি। আমি অনুমান করি আমরা ভেবেছিলাম তারা পুনরাবৃত্তি হ্যান্ডেল করার সেরা উপায়। তবে এগুলি বিশেষ ক্ষেত্রে একটি বাইট সংরক্ষণ না করে বেশ অস্পষ্ট।

— জাগারব

`:0:1হতে পারে `Jḋ2।

— জগারব

7

জেলি , 22 20 19 বাইট

-১ এরিক দ্য আউটগোল্ফারকে ধন্যবাদ (উভয় পক্ষের লেজ জিরো t, ডান দিক থেকে নয় œr)

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

একটি মোনাডিক লিঙ্কটি 2 এর চেয়ে বেশি পূর্ণসংখ্যার গ্রহণ করে এবং 0 এর চেয়ে বেশি সংখ্যক পূর্ণসংখ্যাকে প্রত্যাবর্তন করে (2 মূল সংখ্যা অনুসারে 0 ফিরে আসবে)।

এটি অনলাইন চেষ্টা করুন!

কিভাবে?

এটি প্রায় সঠিকভাবে বাইনারি অ্যারে তৈরির জন্য কিছু সাধারণ ম্যানিপুলেশন দিয়ে দেওয়া বর্ণনাকে ঠিক প্রতিলিপি করে ...

Æ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

এটি অনলাইন চেষ্টা করুন!

প্রাইম বিল্টিনগুলির অভাব সত্যিই বাইট গণনাটিকে ব্যথা করে এবং এটি টিআইওর সাথে আরও বড় প্রাইমগুলির সাথে বেরিয়ে যায়। ব্যবহার xnor এর primality চেক।

পাইথন 2 + জিপিপি 2 , 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) শেষ হয় না time

— 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 নম্বরের জন্য একটি নমুনা কল দিয়ে হাঁটব, যা বর্ণহীন বিন্যাসে প্রকাশিত হয়েছে is

   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]'ফাংশনটি এমনভাবে মূল্যায়ন করে যে এটি আরপিএলে ছিল প্রতিটি যুক্তির প্রতিস্থাপন করে সঠিক যুক্তি দিয়ে 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_1 টি চাপানো হয় এবং _2 টি সংযুক্ত থাকে যা বন্ধনী হিসাবে কাজ করে। যখন এই উপাদানগুলিতে ফাংশনটি ডাকা হয়, এটি কেবল তাদের হিসাবে ফেরত দেয় যেহেতু q:একটি নেতিবাচক সংখ্যাকে গুণিত করার চেষ্টা করার সময় ত্রুটি ঘটবে। এটি ভাগ্যবান যে 1 টি গুণক করার চেষ্টা করেও ত্রুটি q:করে না এবং পরিবর্তে খালি অ্যারেটি (পছন্দসইভাবে) ফেরত দেয়।

রূপান্তর

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

রূপান্তর অনেক সহজ। এটি কেবল প্রথম বক্সিং হিসাবে সমস্ত বক্সিং সরিয়ে দেয় এবং তারপরে সবকিছুকে 1 ও 0 সেটে রূপান্তরিত করে (কেবল 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

এটি তালিকাটি বিপরীত করে, প্রথমটি সন্ধান করে এবং তারপরে সমস্ত মানগুলি একটিকে ফেলে দেয়, তারপরে তালিকাটি আবার বিপরীত করে।

পাঠোদ্ধার করা

ডিকোড হ'ল বিল্ট-ইন ফাংশন #.যা 1 এবং 0 এর তালিকা নিয়ে থাকে এবং এটিকে বাইনারি সংখ্যায় রূপান্তর করে।

— কপি
সূত্র

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]]মৌলিক সংখ্যার 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 একটি সম্পূর্ণরূপে কার্যকরী লেজ-পুনরাবৃত্তীয় ফ্যাক্টেরাইজেশন অ্যালগরিদম।

crপ্রধান সংখ্যাটি কোন স্থানে pপ্রধান সংখ্যাগুলি সংখ্যায় ঘটে তা গণনা করে এবং হয় [](যদি p=2এবং r=1) হয় বা rপুনরাবৃত্তির মাধ্যমে আরও কার্যকর প্রক্রিয়াগুলি প্রদান করে further

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/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

05 এ বি 1 ই , 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

— Grimmy
সূত্র

একটি পূর্ণসংখ্যা এনকোড করুন

ইনপুট

আউটপুট

বিধি এবং আইও ফর্ম্যাট

পরীক্ষার মামলা

স্যান্ডবক্স

হুশ , 35 31 30 29 26 25 24 22 20 19 15 বাইট

Explaination

জেলি , 22 20 19 বাইট

কিভাবে?

পাইথন 2 , 212 177 বাইট

পাইথন 2 + জিপিপি 2 , 175 বাইট

গণিত, 125 119 বাইট

জেলি , 35 বাইট

জে, 74 73 66 বাইট

ব্যাখ্যা (অবরুদ্ধ)

প্রস্তাবনা

সঙ্কেতাক্ষরে লিখা

রূপান্তর

ড্রপ

পাঠোদ্ধার করা

রেটিনা , 244 227 225 বাইট

ব্যাখ্যা:

হাস্কেল , 162 160 155 বাইট

জাভাস্ক্রিপ্ট, 289 বাইট

টিনাইলিস্প , 209 বাইট

প্রাক-গল্ফিং সংস্করণ

05 এ বি 1 ই , 18 বাইট