প্রধান শক্তি থেকে শক্তি পুনরুদ্ধার


16

দেখে মনে হচ্ছে অনেক লোক এটি পেতে পছন্দ করবে, তাই এটি এখন এই চ্যালেঞ্জের সিক্যুয়াল !

সংজ্ঞা : একটি মৌলিক শক্তি একটি প্রাকৃতিক সংখ্যা যা p এন আকারে প্রকাশ করা যায় যেখানে p একটি মৌলিক এবং n একটি প্রাকৃতিক সংখ্যা।

কার্য : একটি প্রাথমিক শক্তি দেওয়া হল n n > 1, পাওয়ারটি ফিরে দিন।

টেস্টকেসগুলি :

input output
9     2
16    4
343   3
2687  1
59049 10

স্কোরিং : এটি । বাইট জিতে সংক্ষিপ্ত উত্তর।


2
দ্রষ্টব্য : এই চ্যালেঞ্জটি কিছু গল্ফিং ভাষায় তুচ্ছ হতে পারে তবে কিছু মূলধারার ভাষা, পাশাপাশি জুন ২০১ of, কিউব্যাসিকের ভাষার পক্ষে এটি তুচ্ছ নয়।
এরিক আউটগল্ফার

আমরা 1 এর পরিবর্তে সত্য আউটপুট করতে পারি? বিকল্পভাবে, ints পরিবর্তে ভাসা?
জো কিং

1
@ জোকিং হ্যাঁ, হ্যাঁ
ফাঁস নুন

উত্তর:


7

2
পিপিসিজিতে আপনাকে স্বাগতম!
অলিভার


5

পাইথন 3 , 49 বাইট

f=lambda n,x=2:n%x and f(n,x+1)or n/x<2or-~f(n/x)

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

True1 এর পরিবর্তে আউটপুট ( ওপি দ্বারা অনুমোদিত )। পুনরাবৃত্ত ফাংশন যা বারবার সর্বনিম্ন ফ্যাক্টরটি সন্ধান করে এবং তারপরে পরবর্তী সর্বনিম্ন শক্তির সাথে পুনরায় ফাংশনটি কল করে এটি 1 না পৌঁছানো পর্যন্ত এটি পূর্ববর্তী প্রশ্নের আমার উত্তরের একটি এক্সটেনশন ।



4

পাইথন 2 , 37 বাইট

f=lambda n,i=2:i/n or(n%i<1)+f(n,i+1)

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

কারণ গণনা করে। স্পষ্টতই আমি একই গল্ফ লিখেছি 2015 সালে ।

সংকীর্ণভাবে আউট সংক্ষিপ্তভাবে মারধর করে

পাইথন 2 , 38 বাইট

lambda n:sum(n%i<1for i in range(1,n))

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



3

ডিসি , 50 41 বাইট

1si[dli1+dsi%0<X]dsXx[dli/dli<Y]sYdli<Yzp

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

স্ট্যাকের শীর্ষ থেকে ইনপুট নেয় (টিআইওতে, ফাঁসির আগে স্ট্যাকের উপর এটি লোড করতে শিরোনামে ইনপুটটি রাখুন)। Stdout আউটপুট।

ব্যাখ্যা

ব্যবহৃত নিবন্ধসমূহ:

i: বর্তমান ট্রায়াল বিভাজক, যখন X চলমান চলমান । পরে, বিভাজকটি আমরা খুঁজে পেয়েছি।

X: ম্যাক্রো dli1+dsi%0<X, যার প্রভাব রয়েছে "বৃদ্ধি"i , তারপরে স্ট্যাকের মান সহ মডুলাসটি পরীক্ষা করুন (যা মূল ইনপুট হবে) it's এটি যদি শূন্য না হয় তবে পুনরাবৃত্তি করুন"।

Y: ম্যাক্রো dli/dli<Y, যার প্রভাব রয়েছে "স্ট্যাকের সাথে বিভক্ত স্ট্যাকের বর্তমান শীর্ষের একটি অনুলিপি যুক্ত করুন to iঅবধি পুনরাবৃত্তি করুনi উপনিত।"

সম্পূর্ণ প্রোগ্রাম:

1si                 Initialize i
[dli1+dsi%0<X]dsXx  Define and run X
[dli/dli<Y]sY       Define Y
dli<Y               Run Y, but only if needed (if the input wasn't just i)
z                   The stack is i^n, i^(n-1), ... ,i, so print the stack depth

আমি এর চেয়ে আরও ভাল সমাধান খুঁজে পেয়েছি! এখন সম্পাদনা করা হচ্ছে ...
সোফিয়া ল্যাটারের

3

মুখ , 86 বাইট

(%d@)\$*,c'$,io>Av"[""mN*c?*m1*mp*m%*s1"$pN1p:~+p1p%%Np?%~:=/NNp+?1?-%N1?%=p%'$i?w1'%>

হুরারে, জাভার চেয়ে লম্বা!

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

আমি ফিরে আসার মানটি ব্যবহারের কৌশলটি বিশেষভাবে পছন্দ করি sscanf। সাধারণত রিটার্ন মান বাতিল হয়ে যায়, তবে এখানে সর্বদা 1 হবে, কারণ আমরা সর্বদা ইনপুট হিসাবে একক সংখ্যাটি পড়ছি। আমরা ভেরিয়েবলটির রিটার্ন মান নির্ধারণ করে এটির সুবিধা নিতে পারি 1, 2 বাইটগুলি সংরক্ষণ করে যা অন্যথায় 11 স্পষ্টভাবে নির্ধারণ করতে হবে ।

(%d@)

\$*,c'$,io>  ( setup - assign $ to "%d", * to a number, o to stdout )
Av"[""mN*    ( set " to input and allocate space for N for int conversion )
c?*          ( calloc ?, starting it at zero - this will be the output )
m1*          ( allocate variable "1", which gets the value 1 eventually )
mp*m%*       ( p is the prime, % will be used to store N mod p )

s1"$pN       ( scan " into N with $ as format; also assigns 1 to 1 )

1p:~         ( begin loop, starting p at 1 )
  +p1p       ( increment p )
  %%Np       ( set % to N mod p )
?%~          ( repeat if the result is nonzero, so that we reach the factor )

:=           ( another loop to repeatedly divide N by p )
  /NNp       ( divide N by p in-place )
  +?1?       ( increment the counter )
  -%N1       ( reuse % as a temp variable to store N-1 )
?%=          ( repeat while N-1 is not 0 -- i.e. break when N = 1 )

p%'$i?       ( sprintf ? into ', reusing the input format string )
w1'%>        ( write to stdout )

3

অ্যাটাচি এবং ওল্ফ্রাম ল্যাঙ্গুয়েজ (ম্যাথমেটিকা) বহুভুজ, 10 বাইট

PrimeOmega

অনলাইনে সংযুক্তি চেষ্টা করুন! অনলাইনে গণিত চেষ্টা করুন!

কেবলমাত্র মূল উপাদানগুলির সংখ্যা N গণনা করার জন্য একটি অন্তর্নির্মিত ।

ব্যাখ্যা

যেহেতু এন = পি কে , Ω ( এন ) = Ω ( পি কে ) = কে , কাঙ্ক্ষিত ফলাফল।





2

স্ট্যাক্স ,43 বাইট

|f%

এটি চালান এবং এটি ডিবাগ করুন

প্রাইম ফ্যাক্টরীকরণের দৈর্ঘ্য।


5
আহা .. আপনি ভঙ্গ করছেন (; আউট 4 অতিক্রম এখনও নিয়মিত 4 হয় । যদিও .. তাই ভাল কাজ করেছেন আমি) পৃ (এটা পুরাতন যাহাই হউক না কেন পেয়ে ছিল; মেমে
কেভিন Cruijssen

1
হ্যাঁ, ম্যাথজ্যাক্স!তবে মনে রাখবেন যে লিডারবোর্ড স্নিপেট এটি সনাক্ত করতে সক্ষম না হয়ে আসল বাইটকাউন্টের আগে অন্যটি ক্রস করে রাখবেন put
ব্যবহারকারী 202729



2

হোয়াইটস্পেস, 141 বাইট

[S S S N
_Push_0][S N
S _Duplicate_0][T   N
T   T   _Read_STDIN_as_number][T    T   T   _Retrieve][S S S T  N
_Push_1][N
S S N
_Create_Label_LOOP_1][S S S T   N
_Push_1][T  S S S _Add][S N
S _Duplicate][S T   S S T   S N
_Copy_2nd_input][S N
T   _Swap_top_two][T    S T T   _Modulo][N
T   S S N
_If_0_Jump_to_Label_BREAK_1][N
S N
N
_Jump_to_Label_LOOP_1][N
S S S N
_Create_Label_BREAK_1][S S S N
_Push_0][S T    S S T   S N
_Copy_2nd_input][N
S S T   N
_Create_Label_LOOP_2][S N
S _Duplicate_input][S S S T N
_Push_1][T  S S T   _Subtract][N
T   S S S N
_If_0_Jump_to_Label_BREAK_2][S N
T   _Swap_top_two][S S S T  N
_Push_1][T  S S S _Add][S N
T   _Swap_top_two][S T  S S T   S N
Copy_2nd_factor][T  S T S _Integer_divide][N
S N
T   N
_Jump_to_Label_LOOP_2][N
S S S S N
_Create_Label_BREAK_2][S N
N
_Discard_top][T N
S T _Print_as_number]

বর্ণ S(স্থান), T(ট্যাব), এবংN (নতুন-লাইন) কেবল হাইলাইট হিসাবে যুক্ত করা হয়েছে।
[..._some_action]শুধুমাত্র ব্যাখ্যা হিসাবে যুক্ত।

এটি অনলাইনে চেষ্টা করুন (কেবলমাত্র কাঁচা জায়গা, ট্যাব এবং নতুন লাইন সহ)।

সিউডো-কোডে ব্যাখ্যা:

Integer n = STDIN as input
Integer f = 1
Start LOOP_1:
  f = f + 1
  if(n modulo-f == 0)
    Call function BREAK_1
  Go to next iteration of LOOP_1

function BREAK_1:
  Integer r = 0
  Start LOOP_2:
    if(n == 1)
      Call function BREAK_2
    r = r + 1
    n = n integer-divided by f
    Go to next iteration of LOOP_2

function BREAK_2:
  Print r as number to STDOUT
  Program stops with an error: Exit not defined

উদাহরণ রান: input = 9

Command    Explanation                    Stack           Heap    STDIN   STDOUT   STDERR

SSSN       Push 0                         [0]
SNS        Duplicate top (0)              [0,0]
TNTT       Read STDIN as number           [0]             {0:9}   9
TTT        Retrieve                       [9]             {0:9}
SSSTN      Push 1                         [9,1]           {0:9}
NSSN       Create Label_LOOP_1            [9,1]           {0:9}
 SSSTN     Push 1                         [9,1,1]         {0:9}
 TSSS      Add top two (1+1)              [9,2]           {0:9}
 SNS       Duplicate top (2)              [9,2,2]         {0:9}
 STSSTSN   Copy 2nd from top              [9,2,2,9]       {0:9}
 SNT       Swap top two                   [9,2,9,2]       {0:9}
 TSTT      Modulo top two (9%2)           [9,2,1]         {0:9}
 NTSSN     If 0: Jump to Label_BREAK_1    [9,2]           {0:9}
 NSNN      Jump to Label_LOOP_1           [9,2]           {0:9}

 SSSTN     Push 1                         [9,2,1]         {0:9}
 TSSS      Add top two (2+1)              [9,3]           {0:9}
 SNS       Duplicate top (3)              [9,3,3]         {0:9}
 STSSTSN   Copy 2nd                       [9,3,3,9]       {0:9}
 SNT       Swap top two                   [9,3,9,3]       {0:9}
 TSTT      Modulo top two (9%3)           [9,3,0]         {0:9}
 NTSSN     If 0: Jump to Label_BREAK_1    [9,3]           {0:9}
NSSSN      Create Label_BREAK_1           [9,3]           {0:9}
SSSN       Push 0                         [9,3,0]         {0:9}
STSSTSN    Copy 2nd from top              [9,3,0,9]       {0:9}
NSSTN      Create Label_LOOP_2            [9,3,0,9]       {0:9}
 SNS       Duplicate top (9)              [9,3,0,9,9]     {0:9}
 SSSTN     Push 1                         [9,3,0,9,9,1]   {0:9}
 TSST      Subtract top two (9-1)         [9,3,0,9,8]     {0:9}
 NTSSSN    If 0: Jump to Label_BREAK_2    [9,3,0,9]       {0:9}
 SNT       Swap top two                   [9,3,9,0]       {0:9}
 SSSTN     Push 1                         [9,3,9,0,1]     {0:9}
 TSSS      Add top two (0+1)              [9,3,9,1]       {0:9}
 SNT       Swap top two                   [9,3,1,9]       {0:9}
 STSSTSN   Copy 2nd from top              [9,3,1,9,3]     {0:9}
 TSTS      Integer-divide top two (9/3)   [9,3,1,3]       {0:9}
 NSNTN     Jump to Label_LOOP_2           [9,3,1,3]       {0:9}

 SNS       Duplicate top (3)              [9,3,1,3,3]     {0:9}
 SSSTN     Push 1                         [9,3,1,3,3,1]   {0:9}
 TSST      Subtract top two (3-1)         [9,3,1,3,2]     {0:9}
 NTSSSN    If 0: Jump to Label_BREAK_2    [9,3,1,3]       {0:9}
 SNT       Swap top two                   [9,3,3,1]       {0:9}
 SSSTN     Push 1                         [9,3,3,1,1]     {0:9}
 TSSS      Add top two (1+1)              [9,3,3,2]       {0:9}
 SNT       Swap top two                   [9,3,2,3]       {0:9}
 STSSTSN   Copy 2nd from top              [9,3,2,3,3]     {0:9}
 TSTS      Integer-divide top two (3/3)   [9,3,2,1]       {0:9}
 NSNTN     Jump to Label_LOOP_2           [9,3,2,1]       {0:9}

 SNS       Duplicate top (1)              [9,3,2,1,1]     {0:9}
 SSSTN     Push 1                         [9,3,2,1,1,1]   {0:9}
 TSST      Subtract top two (1-1)         [9,3,2,1,0]     {0:9}
 NTSSSN    If 0: Jump to Label_BREAK_2    [9,3,2,1]       {0:9}
NSSSSN     Create Label_BREAK_2           [9,3,2,1]       {0:9}
 SNN       Discard top                    [9,3,2]         {0:9}
 TNST      Print as integer               [9,3]           {0:9}           2
                                                                                    error

প্রোগ্রামটি একটি ত্রুটি সহ বন্ধ হয়ে যায়: কোনও প্রস্থান খুঁজে পাওয়া যায় নি।



1

পাইথন 2 , 62 বাইট

def f(n,p=2,i=0):
	while n%p:p+=1
	while n>p**i:i+=1
	return i

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

কিছুই এখানে অভিনব।


1
আপনি একটি সম্পূর্ণ প্রোগ্রাম তৈরি করে তিনটি বাইট সংরক্ষণ করতে পারেন: এটি অনলাইনে চেষ্টা করুন!
dylnan



1

হাস্কেল , 27 বাইট

f n=sum$(0^).mod n<$>[2..n]

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

কারণ গণনা করে। তুলনা করা:

হাস্কেল , 28 বাইট

f n=sum[1|0<-mod n<$>[2..n]]

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

হাস্কেল , 28 বাইট

f n=sum[0^mod n i|i<-[2..n]]

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

হাস্কেল , 30 বাইট

f n=sum[1|i<-[2..n],mod n i<1]

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



1

সিজাম, 5 বাইট

rimf,

অনলাইনে চেষ্টা করে দেখুন!

ব্যাখ্যা:

ri      take the input and convert it to an int
  mf    factors the input
    ,   take the length of the list

বিল্টিনগুলি দুর্দান্ত!


জমাগুলি অবশ্যই ডিফল্টরূপে প্রোগ্রাম বা ফাংশন হতে পারে এবং আমরা এটিকে কোনও ফাংশন হিসাবে বিবেচনা করি নাrimf,(সম্পূর্ণ প্রোগ্রাম) এবং {mf,}(ফাংশন) উভয়ই বৈধ হবে।
ডেনিস

@ ডেনিস হ্যাঁ, আমি মনে করি আমি এতে একধরণের বিভ্রান্ত। আমি এর আগে অনুমোদিত স্টার্ডার্ড আইওয়ের দিকেও তাকিয়েছিলাম এবং ভাবছিলাম যে আমার আসলে কী জমা দিতে হবে ... আমি আসলে সে সম্পর্কে মেটাতে একটি প্রশ্ন জিজ্ঞাসা করতে চেয়েছিলাম। তবে আপনি তা নিশ্চিত করেছেন, তাই ধন্যবাদ!
ক্রোমিয়াম

1

কিউ বেসিক, 51 বাইট

INPUT x
p=2
WHILE x/p>x\p
p=p+1
WEND
?LOG(x)/LOG(p)

বেসটি সন্ধান করার জন্য "প্রিমিয়াম পুনরুদ্ধার" সমাধানের মতো একই অ্যালগরিদম ব্যবহার করে , তারপরে ঘাঁটি পেতে লগারিদমের নিয়ম ব্যবহার করে:(পিএন)=এন(পি)




0

পার্ল 6 , 36 বাইট

{round .log/log (2..*).first: $_%%*}

প্রথম ফ্যাক্টরটির সন্ধান করে (2..*).first: $_%%* , তারপরে সেখান থেকে আনুমানিক মান গণনা করুন (লগগুলি এটি সঠিকভাবে পাবেন না) এবং এটি গোল করে।

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





আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.