কারমাইকেল ফাংশন গণনা করুন


36

কার্য বিবরণী

সংখ্যা তত্ত্ব, কারমাইকেল ফাংশন  λ একটি ধনাত্মক পূর্ণসংখ্যা লাগে  এন এবং আয় অন্তত ধনাত্মক পূর্ণসংখ্যা যাতে প্রতিটি পূর্ণসংখ্যা এর -th ক্ষমতা coprime করার এন সমান 1 মডিউল এন

একটি ধনাত্মক পূর্ণসংখ্যা এন দেওয়া হয়েছে , আপনার সমাধান অবশ্যই গণনা করতে হবে λ (n) । বাইটের মধ্যে সংক্ষিপ্ততম কোডটি জয়ী।

আপনার প্রোগ্রামটি তাত্ত্বিকভাবে ইচ্ছামত বৃহত ইনপুটগুলির জন্য কাজ করা উচিত, তবে দক্ষ হওয়ার দরকার নেই।

পরামর্শ

সব ক্রম λ (ঢ) হয় OEIS A002322

একটি অবারিত পাইথন বাস্তবায়ন এর মতো দেখাবে

from fractions import gcd

def carmichael(n):
    coprimes = [x for x in range(1, n) if gcd(x, n) == 1]
    k = 1
    while not all(pow(x, k, n) == 1 for x in coprimes):
        k += 1
    return k

(পাইথনে, pow(A, B, C)দক্ষতার সাথে গণনা করুন pow(A, B) % C))

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

Input    Output
1        1
2        1
3        2
10       4
35       12
101      100
530      52
3010     84
6511     3056
10000    500

তাত্ত্বিকভাবে এখানে অর্থ কী ? আমি অনুমান করতে পারেন যে ইনপুট এন একটি 16 বিট পূর্ণসংখ্যা মধ্যে ফিট করে? আমি কি ধরে নিতে পারি যে এন ^ λ (n) একটি ডাবল ফিট করে?
ডেনিস

2
হ্যাঁ এবং হ্যাঁ, আমি বলব। হিসাবে, তাত্ত্বিক অন্তর্ভুক্ত সাজা আপনার স্থানীয় ধরনের ইচ্ছামত সুনির্দিষ্ট এবং বড় (আমি যে ঐক্যমত্য ছিল, কিন্তু আমি নিশ্চিত নই)।
লিন

উত্তর:



29

পাইথন, 76 73 67 বাইট

f=lambda n,k=1:1-any(a**-~k*~-a**k%n for a in range(n))or-~f(n,k+1)

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

আরও 1 বাইট 1 এর পরিবর্তে ট্রু ফিরে দিয়ে বাঁচানো যায় ।

বিকল্প বাস্তবায়ন

একই পদ্ধতির ব্যবহার করে, @ ফেয়ারসাম দ্বারা নিম্নলিখিত প্রয়োগগুলি রয়েছে যা তালিকার বোধগম্যতা ব্যবহার করে না।

f=lambda n,k=1,a=1:a/n or(a**-~k*~-a**k%n<1)*f(n,k,a+1)or-~f(n,k+1)

নোট করুন যে এই প্রয়োগের জন্য O (n λ (n) ) সময় প্রয়োজন। দক্ষতা নাটকীয়ভাবে উন্নত করা যেতে পারে যখন আসলে স্কোর হ্রাস 66 বাইট , কিন্তু ফাংশন ইনপুট 2 জন্য সত্য ফিরে আসবে ।

f=lambda n,k=1,a=1:a/n or~-a**k*a**-~k%n<1==f(n,k,a+1)or-~f(n,k+1)

পটভূমি

সংজ্ঞা এবং স্বরলিপি

সমস্ত নিয়োগকৃত ভেরিয়েবলগুলি পূর্ণসংখ্যা বোঝায়; এন , k , এবং α নির্দেশ করবে ইতিবাচক পূর্ণসংখ্যার; এবং পি একটি ইতিবাচক প্রধানমন্ত্রীকে বোঝায় ।

ক | খ যদি দিয়ে বিভাজ্য একটি , অর্থাত আছে যদি কুই যেমন যে খ = QA

a ≡ b ( mod m) যদি a এবং b এর একই অবশিষ্টাংশ Modulo m থাকে , অর্থাৎ, যদি m | ক - খ

λ (ঢ) সবচেয়ে ছোট যেমন যে একটি ≡ 1 ( গেলিক ভাষার ঢ) - অর্থাত, যেমন যে এন | একটি - 1 - সবার জন্য একটি করে coprime হয় এন

চ (ঢ) সবচেয়ে ছোট যেমন যে একটি 2k +1 ≡ একটি ট + 1 টি ( গেলিক ভাষার ঢ) - অর্থাত, যেমন যে এন | a কে + 1 (একটি কে - 1) - সকলের জন্য একটি

λ (n) ≤ f (n)

ফিক্স এন দিন একটি হতে coprime এন

সংজ্ঞা দ্বারা , এন | a f (n) +1 (a f (n) - 1) । যেহেতু একটি এবং এন একটি সাধারণ মৌলিক উত্পাদক নেই, তন্ন তন্ন না একটি চ (ঢ) + 1 এবং এন , যা বোঝা এন | a f (n) - 1

যেহেতু λ (n) হ'ল ক্ষুদ্রতম পূর্ণসংখ্যা কে যেমন এন | একটি - 1 সব পূর্ণসংখ্যার জন্য একটি যে coprime হয় এন , এটা যে অনুসরণ করে λ (ঢ) ≤ চ (ঢ)

λ (n) = f (n)

যেহেতু আমরা ইতিমধ্যে qu (n) ≤ f (n) বৈষম্য প্রতিষ্ঠা করেছি , তাই কে = λ (এন) , অর্থাৎ যে এন সংজ্ঞায়িত শর্তটি সন্তুষ্ট করে তা যাচাই করা যথেষ্ট to a λ (n) +1 (a λ (n) - 1) সমস্ত a এর জন্য । এ জন্যে আমরা যে প্রতিষ্ঠা করব পি α | a λ (n) +1 (a λ (n) - 1) যখনই পি α | এন

λ (কে) | λ (এন) যখনই কে | n ( উত্স ), সুতরাং (a λ (k) - 1) (a λ (n) -λ (k) + a λ (n) -2λ (k) + ⋯ + a λ (কে) + 1) = a λ (এন) - 1 এবং, অতএব, একটি λ (কে) - 1 | a λ (n) - 1 | a λ (n) +1 (a λ (n) - 1)

যদি একটি এবং পি α coprime হয়, এর সংজ্ঞা দ্বারা λ এবং উপরোক্ত, পৃ α | a λ (p α ) - 1 | a λ (n) +1 (a λ (n) - 1) পছন্দসই অনুসারে অনুসরণ করে।

যদি a = 0 হয় তবে একটি λ (n) +1 (a λ (n) - 1) = 0 , যা সমস্ত পূর্ণসংখ্যার দ্বারা বিভাজ্য।

পরিশেষে, আমরা যদি যেখানে অবশ্যই বিবেচনা একটি এবং পি α একটি সাধারণ মৌলিক উত্পাদক আছে। যেহেতু পি মূল, তাই এটি পি ককারমাইকেল এর উপপাদ্য প্রমাণ করেন যে, λ (P α ) = (P - 1) পৃ α - 1 যদি পি> 2 বা α <3 এবং যে λ (P α ) = P α - 2 অন্যথায়। সমস্ত ক্ষেত্রে, λ (পি α ) ≥ পি α - 2 ≥ 2 α - 2 > α - 2

অতএব, λ (ঢ) + 1 টি ≥ λ (P α ) +1> α - 1 , তাই λ (ঢ) + 1 টি ≥ α এবং পি α | p λ (n) +1 | a λ (n) +1 | a λ (n) +1 (a λ (n) - 1) । এটি প্রমাণ সম্পূর্ণ করে।

কিভাবে এটা কাজ করে

যদিও f (n) এবং λ (n) এর সংজ্ঞাগুলি ক এর সমস্ত সম্ভাব্য মান বিবেচনা করে , [0, ..., n - 1] এর মধ্যে থাকা তাদের পরীক্ষা করা যথেষ্ট ।

যখন এফ (এন, কে) বলা হয়, তখন এটি একটি পরিসরে একটি মানের সমস্ত মানের জন্য একটি কে + 1 (একটি কে - 1)% এন গুণায়, যা 0 হয় এবং কেবল যদি এন | a k + 1 (a কে - 1)

সব নির্ণিত তলানি শূন্য হন, ট = λ (ঢ) এবং anyআয় মিথ্যা , তাই চ (ঢ, ট) ফেরৎ 1

অন্যদিকে, যখন ট <λ (ঢ) , 1-any(...)ফিরে আসবে 0 তাই হয়, একজন বৃদ্ধি মান যাও recursively বলা হয় । নেতৃস্থানীয় -~বাড়তি ফেরত মান চ (ঢ, K + 1 টি) , তাই আমরা যোগ 1 থেকে চ (ঢ, λ (ঢ)) = 1 প্রতিটি পূর্ণসংখ্যা জন্য একবার [1, ..., λ (ঢ) - 1 ] । চূড়ান্ত ফলাফল এইভাবে λ (এন)


আপনি তালিকা বোধের পরিবর্তে পুনরাবৃত্তি সহ কমপক্ষে 4 টি সঞ্চয় করতে পারেন: f=lambda n,k=1,a=1:a/n or(a**k*~-a**k%n<1)*f(n,k,a+2-n%2)or-~f(n,k+1)(এন বাই * λ (এন) সময় নিতে পছন্দ না হলে একটি বাইট পিছনে যুক্ত করুন)।
feersum

1
ধন্যবাদ! ইতিমধ্যে আমি আমার অ্যালগরিদমে এমন একটি উন্নতি পেয়েছি যা মনে হয় একটি তালিকা বোধগম্য ব্যবহারের পরিবর্তে পুনরাবৃত্তি করার সুবিধাটিকে বাতিল করে দেয়।
ডেনিস

14

ম্যাথমেটিকা ​​বিল্ট-ইন ছাড়াই, 58 57 বাইট

মার্টিন ইন্ডারকে একটি ত্রুটি সন্ধান করার জন্য ধন্যবাদ, তারপরে এটি ঠিক করতে আমার যে বাইটগুলি নিয়েছিল তা সংরক্ষণ করুন!

মাইল 1 বাইট সংরক্ষণ করার জন্য ধন্যবাদ! (যা আমার কাছে 2-এর মতো মনে হয়েছিল)

বিল্ট-ইনগুলি সম্পূর্ণ সুক্ষ্ম ... তবে যারা নিষ্ঠুর শক্তি ব্যবহার না করে এটি প্রয়োগ করতে চান তাদের জন্য কারমাইকেল ফাংশনের একটি সূত্র এখানে রয়েছে:

LCM@@(EulerPhi[#^#2]/If[#==2<#2,2,1]&@@@FactorInteger@#)&

যদি পি একটি মৌলিক হয় তবে কারমাইকেল ফাংশন ^ (p equ r) = p (p) r) = (p-1) * পি ^ (আর -1) - পি = 2 এবং r≥3 ব্যতীত , কোন ক্ষেত্রে এটি অর্ধেক, অর্থাৎ 2 ^ (আর -2)।

এবং যদি n এর প্রাইম-পাওয়ার ফ্যাক্টরিজেশন পি 1 ^ আর 1 * পি 2 ^ আর 2 * এর সমান হয়, তবে λ (এন) {λ (পি 1 ^ আর 1), λ (পি 2 ^ আর 2), এর কমপক্ষে সাধারণ এককটির সমান .. ।}।

প্রথম স্থানে পূর্ণসংখ্যার ফ্যাক্টরিংয়ের চেয়ে রানটাইম এক তাত্ক্ষণিক।


আপনি 57 বাইটে EulerPhiপেতে ব্যবহার করতে পারেন LCM@@(EulerPhi[#^#2]/If[#==2<#2,2,1]&@@@FactorInteger@#)&
মাইল 13

@ মাইলস সুন্দর দাগ! আমি 56 বাইট গণনা, আপনি পরীক্ষা করতে পারেন?
গ্রেগ মার্টিন

হ্যাঁ, এটি 57 বাইট
মাইলস

স্পষ্টত আমি এমনকি আমার গণনা গল্ফ করার চেষ্টা করি ....: /
গ্রেগ মার্টিন

12

টেমপ্লেটগুলি ক্ষতিকারক , 246 বাইট হিসাবে বিবেচিত

Fun<Ap<Fun<If<Eq<A<2>,T>,A<1>,And<Eq<Ap<Fun<If<A<1>,Ap<A<0>,Rem<A<2>,A<1>>,A<1>>,A<2>>>,A<1,1>,A<2>>,T>,Sub<Ap<Fun<Rem<If<A<1>,Mul<A<2,1>,Ap<A<0>,Sub<A<1>,T>>>,T>,A<1,2>>>,A<1>>,T>>,Ap<A<0>,Add<A<1>,T>,A<1,1>>,Ap<A<0>,A<1>,Sub<A<2>,T>>>>,T,A<1>>>

একটি নামহীন ফাংশন (নামযুক্ত ফাংশনগুলি নয়)।

এটি আমার একটি ভুলে যাওয়া ইসল্যাং যা একটি সি ++ সংকলক তাত্ক্ষণিক টেম্পলেট দ্বারা ব্যাখ্যা করা হয়। এর ডিফল্ট সর্বাধিক টেম্পলেট গভীরতার সাথে g++, এটি λ (35) করতে পারে, তবে এটি can't (101) করতে পারে না (অলস মূল্যায়ন বিষয়টিকে আরও খারাপ করে তোলে)।



8

31
............. ._।
মালটিসেন

10
এইরকম হাস্যকরভাবে নির্দিষ্ট বিল্ট-ইনগুলি বাস্তবায়নের বিষয়টি আমি কখনই বুঝতে পারি না।
18-28-2008

31
বিশেষত এই চ্যালেঞ্জের জন্য তৈরি করা ভাষায় এটি প্রায় একটি সংযোজন। লিন দ্বারা প্রতিশ্রুতি দিন 2 দিন আগে, আজ @ লিন দ্বারা চ্যালেঞ্জ
edc65

5
@ edc65 উল্লেখ করার দরকার নেই যে এই অন্তর্নির্মিতটি এই চ্যালেঞ্জের বাইরে এবং এর ডেরাইভেটিভসের বাইরে অনেকটা বেহুদা।
19:38

3
ঠিক আছে, কারমাইকেল ফাংশনটি সংখ্যা তত্ত্বের ক্ষেত্রে গুরুত্বপূর্ণ (বর্তমানে শীর্ষের উত্তরটি প্রতিফলিত হয়েছে), সুতরাং আমি এটিকে অকেজো বলব না।
গ্রেগ মার্টিন

6

পাইথ - 19 18 17 বাইট

একটি বাইট @ দ্য বাইকিংভিকিংকে ধন্যবাদ সংরক্ষণ করেছে।

ব্রুট ফোর্স আপ।

f!sm*t.^dTQq1iQdQ

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


f!smtএক বাইট খাটো।
TheBikingViking

@ দ্য বাইকিংভিাইকিং ওহ, হ্যাঁ ধন্যবাদ
মাল্টেসেন

আমার চোখের ক্ষতি করে, হ্যাক এই অজগরটি কেমন ..? যাইহোক এটি হাহা :)
Yohan ওবাদিয়া


5

জে, 28 27 বাইট

[:*./@(5&p:%2^0=8&|)2^/@p:]

কারমাইকেল ফাংশনটি λ ( n ) এবং সামগ্রিক ফাংশনটি φ ( n )।

যেখানে সংজ্ঞাটি ব্যবহার করে যেখানে λ ( পি কে ) = φ ( পি কে ) / 2 যদি পি = 2 এবং কে > 2 অন্য φ ( পি কে ) থাকে। তারপরে, সাধারণ n = p এর জন্য 1 কে 1 পি 2 কে 2পি আই কে আই , λ ( এন ) = এলসিএম [λ ( পি 1 কে 1 ) λ ( পি 2 কে 2 ) ⋯ λ ( পি আই কে আমি )] ।

ব্যবহার

একাধিক ইনপুট / আউটপুট বিন্যাস করতে অতিরিক্ত কমান্ড ব্যবহার করা হয়।

   f =: [:*./@(5&p:%2^0=8&|)2^/@p:]
   f 530
52
   (,.f"0) 1 2 3 10 35 101 530 3010 6511 10000
    1    1
    2    1
    3    2
   10    4
   35   12
  101  100
  530   52
 3010   84
 6511 3056
10000  500

ব্যাখ্যা

[:*./@(5&p:%2^0=8&|)2^/@p:]  Input: integer n
                          ]  Identity function, get n
                    2   p:   Get a table of prime/exponent values for n
                     ^/@     Raise each prime to its exponent to get the prime powers of n
[:    (            )         Operate on the prime powers
                8&|            Take each modulo 8
              0=               Test if its equal to 0, 1 if true else 0
            2^                 Raise 2 to the power of each
       5&p:                    Apply the totient function to each prime power
           %                   Divide it by the powers of 2
  *./@                       Reduce using LCM and return

এটি 10000 (সঠিক 500 এর পরিবর্তে 1000) এর জন্য ভুল উত্তর দেয় এবং প্রকৃতপক্ষে 8 এর প্রতিটি এককটির জন্য একটি বিচিত্র প্রাইম এবং λ (2 ^ a) = 2 ^ {a-2} (2 ^ not নয়) a-1}) যখন a≥3।
গ্রেগ মার্টিন

এটি ধরার জন্য ধন্যবাদ, মনে হচ্ছে আমি নিজের
মাইল

আপনি কখনও কখনও একা হন না .... :)
গ্রেগ মার্টিন

5

আসলে, 30 28 25 19 26 বাইট

কারমাইকেল ফাংশনটি λ(n)যেখানে সর্বাধিক প্রধান শক্তিগুলির মধ্যে ভাগ করা n = p_0**k_0 * p_1**k_1 * ... * p_a**k_aহয় তার সর্বনিম্ন সাধারণ একাধিক (এলসিএম) হিসাবে সংজ্ঞায়িত হয় । প্রদত্ত যে প্রাইমটি রয়েছে সেখানে বাদে প্রতিটি মৌলিক শক্তির জন্য , কারমাইকেল ফাংশনটি ইউলারের সমষ্টিযুক্ত ফাংশনের সমতুল্য , আমরা তার পরিবর্তে ব্যবহার করি । বিশেষ মামলায় যেখানে , আমরা শুধু যদি পরীক্ষা ভাগ মধ্যে প্রোগ্রামের শুরুতে, এবং ডিভাইড 2 দ্বারা যদি এটা আছে।λ(p_i**k_i)p_i**k_in2λ(n) == φ(n)φ(n)2**kk ≥ 32**3 = 8n

দুর্ভাগ্যক্রমে, আসলে বর্তমানে একটি এলসিএম অন্তর্নির্মিত নেই, তাই আমি একটি নিষ্ঠুর শক্তি এলসিএম তৈরি করেছি। গল্ফিং পরামর্শ স্বাগত জানাই। এটি অনলাইন চেষ্টা করুন!

;7&Yu@\w`iⁿ▒`M╗2`╜@♀%ΣY`╓N

Ungolfing

         Implicit input n.
;        Duplicate n.
7&       n&7 == n%8.
Yu       Logical NOT and increment. If n%8 == 0, return 2. Else, return 1.
@\       Integer divide n by 2 if n%8==0, by 1 otherwise.
          Thus, we have dealt with the special case where p_i == 2 and e_i >= 3.
w        Full prime factorization of n as a list of [prime, exponent] lists.
`...`M   Map the following function over the prime factorization.
  i        Flatten the array, pushing exponent, then prime to the stack.
  ⁿ▒       totient(pow(prime, exponent)).
╗        Save that list of totients in register 0.
2`...`╓  Get the first two values of n where the following function f(n) is truthy.
         Those two numbers will be 0 and our LCM.
  ╜@       Push the list in register 0 and swap with our n.
  ♀%       Get n mod (every number in the list)
  Σ        Sum the modulos. This sum will be 0, if and only if this number is 0 or LCM.
  Y        Logical NOT, so that we only get a truthy if the sum of modulos is 0.
N        Grab the second number, our LCM. Implicit return.

2
আসলে, আমার জানা নেই আপনি কেবল 19 বাইটে এটি কীভাবে করেছিলেন।
বাফার ওভার পড়ুন

@ দ্য বিটবাইট ব্যবহারের সাথে totient এবং gcdবিল্টিনগুলির সহ। প্রকৃতপক্ষে lcmসরাসরি থাকলে এটি আরও সংক্ষিপ্ত হবে , তবে আমি এটিকে তেমন কিছু মনে করি না এবং এটি কেবলমাত্র যাই হোক না কেন, 4 বাইটগুলি ছিটকে যায়।
শার্লক 9

1
LC (* a) = product (* a) / gcd (* a) - এর দৃ true় সত্যতা যখন * a ঠিক দুই সংখ্যার একটি তালিকা; তবে এটি দীর্ঘ তালিকার জন্য সাধারণভাবে মিথ্যা (উদাহরণস্বরূপ: * a যদি, 6,10,15} হয় তবে এটি 60 এর সঠিক উত্তরের পরিবর্তে 900 দেয়)। [এই বিষয়টির জন্য, এটি ভুল এটি * একটিও একটি সংখ্যার একটি তালিকা!] এবং আপনি পরীক্ষা করতে পারেন যে আপনি ওপিতে তালিকাভুক্ত অর্ধেকেরও বেশি পরীক্ষার মামলার জন্য ভুল উত্তর পেয়েছেন।
গ্রেগ মার্টিন

@ গ্রেগমার্টিন মাথা উঁচু করার জন্য ধন্যবাদ। সংশোধন করা হয়েছে।
শার্লক 9

4

জাভাস্ক্রিপ্ট (ES6), 143 135 বাইট

সম্পাদনা করুন: নিলকে ধন্যবাদ 8 টি বাইট

ক্রিয়ামূলক প্রোগ্রামিং ব্যবহার করে একটি বাস্তবায়ন।

n=>(A=[...Array(n).keys()]).find(k=>k&&!c.some(c=>A.slice(0,k).reduce(y=>y*c%n,1)-1),c=A.filter(x=>(g=(x,y)=>x?g(y%x,x):y)(x,n)==1))||1

অবহেলিত এবং মন্তব্য

n =>                                          // Given a positive integer n:
  (A = [...Array(n).keys()])                  // Build A = [0 ... n-1].
  .find(k =>                                  // Try to find k in [1 ... n-1] such as
    k && !c.some(c =>                         // for each coprime c: c^k ≡ 1 (mod n).
      A.slice(0, k).reduce(y =>               // We use reduce() to compute
        y * c % n, 1                          // c^k mod n.
      ) - 1                                   // Compare it with 1.
    ),                                        // The list of coprimes is precomputed
    c = A.filter(x =>                         // before the find() loop is executed:
      (                                       // for each x in [0 ... n-1], keep
        g = (x, y) => x ? g(y % x, x) : y     // only integers that verify:
      )(x, n) == 1                            // gcd(x, n) = 1
    )                                         // (computed recursively)
  ) || 1                                      // Default result is 1 (for n = 1)

ডেমো

যদিও এটি কাজ করে 6511 এবং 10000, আমি এগুলিকে এখানে অন্তর্ভুক্ত করব না কারণ এটি কিছুটা ধীর হয়ে যায়।

let f =
n=>(A=[...Array(n).keys()]).find(k=>k&&!c.some(c=>A.slice(0,k).reduce(y=>y*c%n,1)-1),c=A.filter(x=>(g=(x,y)=>x?g(y%x,x):y)(x,n)==1))||1

console.log(f(1));     // 1
console.log(f(2));     // 1
console.log(f(3));     // 2
console.log(f(10));    // 4
console.log(f(35));    // 12
console.log(f(101));   // 100
console.log(f(530));   // 52
console.log(f(3010));  // 84


1
জাতীয় কি করতে পারেন 0..n-1বেশ সহজে রেঞ্জ: [...Array(n).keys()]। এটির জন্য একটি নয় দুটি বিশেষ ক্ষেত্রে প্রয়োজন তবে আমি এখনও এগিয়ে আছি:n=>(a=[...Array(n).keys()]).find(k=>k&&!c.some(c=>a.slice(0,k).reduce(y=>y*c%n,1)-1),c=a.filter(x=>(g=(x,y)=>x?g(y%x,x):y)(x,n)==1))||1
নীল

2

রুবি, 101 86 91 90 বাইট

একটি রুবি বন্দর আমার প্রকৃত উত্তরটির । গল্ফিং পরামর্শ স্বাগত জানাই।

সম্পাদনা করুন: -4 বাইট অপসারণ থেকে aকিন্তু +9 বাইটগুলি যেখানে বাগ 1ফিরে এসেছে সেখানে স্থির করতে পারেনnil । -1 বাইট ধন্যবাদ সাইওসকে।

require'prime'
->n{((n%8<1?n/2:n).prime_division<<[2,1]).map{|x,y|x**~-y*~-x}.reduce :lcm}

Ungolfing

require 'prime'
def carmichael(n)
  if n%8 < 1
    n /= 2
  end
  a = []
  n.prime_division.do each |x,y|
    a << x**(y-1)*(x-1)
  end
  return a.reduce :lcm
end

আপনি প্রয়োজন হবে না a=। দুর্ভাগ্যবশত, আপনি আসতে nilজন্য এন = 1 :(। (n.prime_division<<[2,1])যে সংশোধন করা হয়েছে সেখানে না নিশ্চিত একটি golfier
M-chrzan

(n%8<1?n/2:n).prime_division...আরও 2 বাইট সংরক্ষণ করে
এম-ক্রিজান

@ এম-ক্রজান aহ'ল পূর্বের গল্ফিং প্রচেষ্টার একটি অবশিষ্টাংশ। সম্পর্কে অনুস্মারক জন্য ধন্যবাদ aএবং আপ উপর মাথা জন্য 1
শার্লক 9

.reduce :lcmপরিবর্তে ব্যবহার করে আপনি একটি বাইট সংরক্ষণ করতে পারেন .reduce(:lcm)
সাইয়েস

1

জাভাস্ক্রিপ্ট (ES 2016) 149

পাইথন রেফারেন্স বাস্তবায়ন জেএসকে পোর্ট করা হয়েছে। কিছু অভিনব Pyhton builtin JS অনুপস্থিত, মত gcdএবং powএবং অ্যারে ধী ইএস 6. ফায়ারফক্স এই কাজে মান নয়।

n=>eval('for(g=(a,b)=>b?g(b,a%b):a,p=(a,b,c)=>eval("for(r=1;b--;)r=r*a%c"),c=[for(_ of Array(i=n))if(g(i--,n)<2)i+1],k=1;c.some(x=>p(x,k,n)-1);)++k')

কম গল্ফড

n=>{
  g=(a,b)=>b?g(b,a%b):a
  p=(a,b,c)=>{ 
    for(r=1;b--;)
      r=r*a%c
    return r
  }
  c=[for(_ of Array(i=n)) if(g(i--,n)<2) i+1]
  for(k=1;c.some(x=>p(x,k,n)-1);)
    ++k
  return k
} 

পুনরাবৃত্ত মোডপা ছোট:p=(a,b,c)=>b?a*p(a,b-1,c)%c:1;
অলিভিয়ার

1

জাভা, 209 207 202 194 192 বাইট

কোড (96 বাইট):

n->{for(int x,k=1,a;;k++){for(a=1,x=0;++x<=n&&a<2;)a=g(x,n)<2?p(x,k,n):1;if(a<2||n<2)return k;}}

অতিরিক্ত ফাংশন (96 বাইট):

int g(int a,int b){return b<1?a:g(b,a%b);}int p(int n,int p,int m){return p<2?n:n*p(n,p-1,m)%m;}

পরীক্ষা ও নিরবচ্ছিন্ন

import java.util.Arrays;
import java.util.function.IntUnaryOperator;

public class Main2 {

  static int g(int a,int b) { // recursive gcd
    return b < 1
        ? a
        : g(b,a%b);
  }

  static int p(int n, int p, int m) { // recursive modpow
    return p < 2
      ? n
      : n * p(n, p - 1, m) % m;
  }

  public static void main(String[] args) {

    IntUnaryOperator f = n -> {
      for(int x,k=1,a;;k++) { // for each k
        for(a=1,x=0;++x<=n&&a<2;) // for each x
          a=g(x,n)<2?p(x,k,n):1; // compute modpow(x,k,n) if g(x,n)
        if(a<2||n<2) // if all modpow(x,k,n)=1. Also check for weird result for n=1.
          return k;
      }
    };

    Arrays.stream(new int[]{1, 2, 3, 10, 35, 101, 530, 3010, 6511, 10000})
        .map(f)
        .forEach(System.out::println);
  }
}

নোট

  • ব্যবহারের aএকটি হচ্ছে intআমি যদি ব্যবহার ছিল তুলনায় খাটো booleanআমার পরীক্ষা সঞ্চালন করা হয়।
  • হ্যাঁ, এটি খাটো এর valueOfসব নতুন BigIntegerএকটি পৃথক ফাংশন তৈরি চেয়ে (5 হয়, প্লাস ONEধ্রুবক একটি freebie যায়)।
  • অ্যালগরিদম @ মাস্টার_এক্স 'অ্যালগরিদমের চেয়ে আলাদা, সুতরাং এটি কেবল গল্ফযুক্ত পোস্ট নয়। এছাড়াও, এই অ্যালগরিদমটি অনেক কম দক্ষ কারণ gcdএকই মানের জন্য বারবার গণনা করা হয়।

shaves

  1. 209 -> 207 বাইট:
    • if(...)a=...; -> a=...?...:1;
    • a==1 -> a<2
  2. 207 -> 202 বাইট
    • BigIntegerগল্ফ করে gcdএবং এর modPowথেকে মুক্তি পেয়েছি int
  3. 202 -> 194 বাইট
    • looping modPow-> রিকার্সিভ
  4. 194 -> 192 বাইট
    • ==1-> <2(সমস্ত টেস্টের ক্ষেত্রে কাজ করে বলে মনে হচ্ছে, অন্যান্য সংখ্যার জন্য জানা নেই))

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

হুম ... আমি অবাক, আমি আমার পরীক্ষাগুলি প্রতিটি পরিবর্তনে চালাতে দিয়েছি। আমি কি ভুল আছে তা যাচাই করবো।
অলিভিয়ের গ্রাগোয়ার

1
@ মাস্টার_এক্স আমি এটি ঠিক করেছি। পূর্ববর্তী সংস্করণে ফিরে যাওয়া ঠিক আছে।
অলিভিয়ার গ্রাগোয়ার

আমি আপনার পুনরাবৃত্ত মোডপো পদ্ধতিটি pবেশ চালাক বলে মনে করি। আমি প্রথমে কেবলমাত্র পূর্ণসংখ্যা ব্যবহার করার চেষ্টা করেছি, তবে আমি আমার উত্তরে উল্লেখ করেছি যে আমার কাছে যথার্থ সমস্যা ছিল এবং সে কারণেই আমি চলে এসেছি BigInteger(অর্থাৎ পরিবর্তে Math.pow(3, 100)%101ফিরে এসেছি )। আপনার বাস্তবায়ন এটির জন্য প্রতিরোধক কারণ এটি প্রতিটি পুনরাবৃত্তির মোডটি সম্পাদন করে। তবে এটি এখনও একটি বাগ দ্বারা ভুগছে। বড় জন্য এখনও ভুল ফলাফল ফিরে আসতে পারে। এছাড়াও, পুনরাবৃত্তির কারণে, সহজেই ডিফল্ট স্ট্যাক আকারের সাথে বড় ইনপুটের জন্য ঘটতে পারে। 60.01m pStackOverflowError
মাস্টার_এক্স

@ মাস্টার_এক্স হ্যাঁ, এটি intধরণের সীমাবদ্ধতার একটি পরিণতি । আমি ইনটগুলির পরিবর্তে লম্বা ব্যবহার করতে পারি, এটি 8 অতিরিক্ত বাইট হবে। তবে আমার দৃষ্টিতে, সমস্ত পরীক্ষার কেস বৈধ তাই আমি এটি এর মতো ছেড়ে দিই। StackOverflowErrorঘটতে পারে, কিন্তু এটি পুনরাবৃত্তির কাজ করে। 32 স্ট্যাকের মধ্যে সীমাবদ্ধ করার জন্য পদ্ধতিগুলি বিদ্যমান, তবে এগুলি আরও অনেকগুলি বাইট ব্যবহার করে। এই বাস্তবায়নটি ভঙ্গুর, হ্যাঁ, আপনি পুরোপুরি ঠিক বলেছেন। তবে এটি পরীক্ষার ক্ষেত্রে যথেষ্ট শক্তিশালী।
অলিভিয়ার গ্রাগোয়ার

1

জাভা 8 38 19 + 287 295 253 248 241 = 325 333 272 267 260 বাইট

BigInteger B(int i){return new BigInteger(""+i);}int c(int...k){int n=k[0];for(k[0]=1;n>1&!java.util.stream.IntStream.range(0,n).filter(i->B(n).gcd(B(i)).equals(B(1))).allMatch(x->B(x).modPow(B(k[0]),B(n)).equals(B(1)));k[0]++);return k[0];}

আমদানি, 19 বাইট

import java.math.*;

ব্যাখ্যা

এটি একটি সরাসরি এগিয়ে বাস্তবায়ন। কো-প্রাইমগুলি গণনা করা হয় Set pএবং প্রত্যেকের kth পাওয়ার এটি 1 টি মডুলোর এন এর সমান কিনা তা পরীক্ষা করতে ব্যবহৃত হয়।

BigIntegerনির্ভুলতার কারণে আমাকে ব্যবহার করতে হয়েছিল ।

ব্যবহার

public static void main(String[] args) {
    Carmichael c = new Carmichael();
    System.out.println(c.c(3)); // prints 2
}

Ungolfed

// returns the BigInteger representation of the given interger
BigInteger B(int i) {
    return new BigInteger(""+i);
}
// for a given integer it returns the result of the carmichael function again as interger
// so the return value cannot be larger
int c(int... k) {
    int n = k[0];
    // iterate k[0] until for all co-primes this is true: (x^n) mod n == 1, if n==1 skip the loop
    for (k[0]=1;n > 1 && !java.util.stream.IntStream.range(0, n)
                .filter(i -> B(n).gcd(B(i)).equals(B(1)))
                .allMatch(x -> B((int) x).modPow(B(k[0]), B(n)).equals(B(1)));k[0]++);
    return k[0];
}

এটি আরও গল্ফ করার জন্য কোনও পরামর্শ স্বাগত :-)

হালনাগাদ

  • রাষ্ট্রকে ধরে রাখে এমন কার্যগুলির বাইরে কোনও উপাদান নেই
  • অলিভিয়ার গ্রাগোয়ারের পরামর্শ অনুসরণ করে এবং 1 বাইট থেকে সেভ করে B()
  • k()পদ্ধতি এবং p(কো-প্রাইমস) সেট সরানো হয়েছে ।
  • ইনট এ কাস্টিংয়ের প্রয়োজন নেই।
  • পরিবর্তিত varags এবং কিছু সময়ের পরিবর্তে ব্যবহার করুন।

আপনার কি একটি বর্ণা version্য সংস্করণ থাকতে পারে (লাইনব্রেকস, মন্তব্যগুলি এখানে এবং সেখানে রয়েছে ইত্যাদি)
OldBunny2800

@ ওল্ডবুনি 2800: হ্যাঁ, নিশ্চিত। যাইহোক, আমি এটি পরে করব কারণ এখন আমি ব্যস্ত!
মাস্টার_এক্স

@ ওল্ডবুনি 2800: আমি একটি অবারিত সংস্করণ যুক্ত করেছি :-)
মাস্টার_এক্স

হুম ... আমি নিশ্চিত নই যে এটি গণ্য হয় এটি কোনও ফাংশন বা কোনও প্রোগ্রাম নয়। যদি এটি কোনও ফাংশন হয় তবে এর বাইরে এমন কিছু উপাদান রয়েছে যা রাষ্ট্রকে বজায় রাখে, এটি একটি ডি ফ্যাক্টো পদ্ধতি তৈরি করে (ফাংশনটি খাঁটি ইনপুট-> বহিরাগত অবস্থা ব্যতীত আউটপুট হয়), যদি এটি কোনও প্রোগ্রাম হয় তবে পুরো মূল পদ্ধতিটি অনুপস্থিত। যদি আমার ব্যাখ্যাগুলি ভুল হয় তবে দয়া করে আমাকে বলুন! আমি মনে করি k(int)লুপের মধ্যে অন্তর্ভুক্ত করা ভাল কারণ এটি ওয়ান-লাইনার এবং এটি করা যেতে পারে। এছাড়াও, ধ্রুবক ও cপদ্ধতিতেও রাখা যেতে পারে । আমার ধারণা আপনি এগুলি করে বাইট জিতবেন!
অলিভিয়ার গ্রাগোয়ার

কংক্রিটের সাথে, while(n>1&&!p.stream().allMatch(x->B((int)x).modPow(B(k), B(n)).equals(O)))বাইটগুলি শেভ করে এবং আমি উল্লেখ করা সমস্যাগুলি সমাধান করে যদি আপনি সেটটিতে এবং ধ্রুবকটি পদ্ধতিতে ফিরিয়ে দেন। এছাড়াও, আপনি Oদুবার ব্যবহার করেন, B(1)বাইট শেভ করার জন্য প্রতিস্থাপন করুন ।
অলিভিয়ার গ্রাগোয়ার



0

218 বাইট রেকেট

(λ(n)(let((fl #f)(cl(for/list((i n) #:when(coprime? n i))i)))(for/sum((k(range 1 n))#:break fl)(set! fl #t)
(for((i(length cl))#:break(not fl))(when(not(= 1(modulo(expt(list-ref cl i)k)n)))(set! fl #f)))(if fl k 0))))

অবরুদ্ধ সংস্করণ:

(require math)
(define f
  (λ(n)
    (let ((fl #f)
          (cl (for/list ((i n) #:when (coprime? n i))
                i)))
             (for/sum ((k (range 1 n)) #:break fl)
               (set! fl #t)
               (for ((i (length cl)) #:break (not fl))
                 (when (not (= 1 (modulo (expt (list-ref cl i) k) n)))
                   (set! fl #f)))
               (if fl k 0)))))

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

(f 2) 
(f 3)
(f 10)
(f 35)
(f 101)
(f 530)
(f 3010)
(f 6511)
(f 10000)

আউটপুট:

1
2
4
12
100
52
84
3056
500

0

সি, 278 276 272 265 256 243 140 134 125 বাইট

k,x,a,b,t,d;l(n){for(k=d=1;d;)for(d=x=0;++x<n;d=a<2&t>1?k++:d){for(a=x,b=n;t=b;a=t)b=a%b;for(t=1,b=k;b--;t=t*x%n);}return k;}

এটি একটি ধীর মডুলার এক্সফেনসিয়েশন অ্যালগরিদম ব্যবহার করে, খুব বেশি বার GCD গণনা করে এবং আর মেমরি ফাঁস করে না!

Ungolfed:

int gcd( int a, int b ) {
  int t;
  while( b ) {
    t = b;
    b = a%b;
    a = t;
  }
  return a;
}
int pw(int a,int b,int c){
  int t=1;
  for( int e=0; e<b; e++ ) {
    t=(t*a)%c;
  }
  return t;
}
int carmichael(int n) {
  int k = 1;
  for( ;; ) {
    int done = 1;
    for( int x=1; x<n; x++ ) {
      if( gcd(x,n)==1 && pw(x,k,n) != 1 ) {
        done = 0;
        k++;
      }
    }
    if( done ) break;
  }
  return k;
}

আইডিয়নে চেষ্টা করে দেখুন


0

এক্সিয়ম 129 বাইট

c(n)==(r:=[x for x in 1..n|gcd(x,n)=1];(v,k):=(1,1);repeat(for a in r repeat(v:=powmod(a,k,n);v~=1=>break);v<=1=>break;k:=k+1);k)

কম গল্ফড

cml(n)==
 r:=[x for x in 1..n|gcd(x,n)=1];(v,k):=(1,1)
 repeat 
   for a in r repeat(v:=powmod(a,k,n);v~=1=>break)
   v<=1=>break
   k:=k+1
 k

ফলাফল

(3) -> [i,c(i)] for i in [1,2,3,10,35,101,530,3010,6511,10000]
   Compiling function c with type PositiveInteger -> PositiveInteger

   (3)
   [[1,1], [2,1], [3,2], [10,4], [35,12], [101,100], [530,52], [3010,84],
    [6511,3056], [10000,500]]
                                             Type: Tuple List PositiveInteger
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.