তাত্ত্বিকভাবে গ্রাহামের সংখ্যা আউটপুট করুন


44

গ্রাহামের সংখ্যাটি Gএইভাবে সংজ্ঞায়িত করা হয়েছে:

u(3,n,1) = 3^n
u(3,1,m) = 3
u(3,n,m) = u(3,u(3,n-1,m),m-1)
[Knuth's up-arrow notation]
[Conway chained arrow notation]

THEN

g1 = u(3,3,4)
g2 = u(3,3,g1)
g3 = u(3,3,g2)
...
G = u(3,3,g63)

u(3,3,2)=7625597484987আপনার কোড যাচাই করার জন্য আপনাকে তা দেওয়া হয়েছে ।

আপনার কাজটি এমন একটি প্রোগ্রাম / ফাংশন লিখতে হবে Gযা যথেষ্ট সংখ্যার আকার এবং পর্যাপ্ত সময় প্রদত্ত নির্ধারিত মানের মান নির্ধারণ করে।

তথ্যসূত্র

লিডারবোর্ড



7
এলোমেলো অনুমতি দেওয়া হয়? যদি আমি কেবল এলোমেলো মানগুলি আউটপুট করি তবে অবশেষে গ্রাহামের সংখ্যাটি প্রস্তুত করা উচিত।
মাইল

15
@ মাইলস পৃথিবীতে কেন এটি ইতিমধ্যে একটি আদর্শ ফাঁক নয়? ব্যাখ্যা।
ফাঁস নুন

18
সতর্কতা: আপনি (3, 3, 2) = উ (3, 2, 3) = 7625597484987, সুতরাং আপনি অন্যান্য (যেমন, ইউ (3, 5, 1) = 243 এর মতো অন্যান্য মানও পরীক্ষা করে দেখতে চান তা নিশ্চিত করতে যুক্তি আদেশ ডান।
অ্যান্ডারস ক্যাসরগ

উত্তর:


48

বাইনারি ল্যাম্বদা ক্যালকুলাস , 114 বিট = 14.25 বাইট

Hexdump:

00000000: 4457 42b0 2d88 1f9d 740e 5ed0 39ce 80    DWB.-...t.^.9..

বাইনারি:

010001000101011101000010101100000010110110001000000111111001110101110100000011100101111011010000001110011100111010

ব্যাখ্যা

01 00                                           (λx.
│    01 00                                        (λy.
│    │    01 01 01 110                              x
│    │    │  │  └─ 10                               y
│    │    │  └─ 00                                  (λm.
│    │    │       01 01 01 10                         m
│    │    │       │  │  └─ 00                         (λg.
│    │    │       │  │       00                         λn.
│    │    │       │  │         01 01 10                  n
│    │    │       │  │         │  └─ 110                 g
│    │    │       │  │         └─ 00                     (λz.
│    │    │       │  │              10                     z))
│    │    │       │  └─ 00                            (λn.
│    │    │       │       00                            λf.
│    │    │       │         01 111110                    x
│    │    │       │         └─ 01 110                    (n
│    │    │       │            └─ 10                      f))
│    │    │       └─ 1110                             x)
│    │    └─ 10                                     y)
│    └─ 00                                        (λf.
│         00                                        λz.
│           01 110                                   f
│           └─ 01 01 1110                            (x
│              │  └─ 110                              f
│              └─ 10                                  z)))
└─ 00                                           (λf.
     00                                           λz.
       01 110                                      f
       └─ 01 110                                   (f
          └─ 01 110                                 (f
             └─ 10                                   z)))

এটি (λ x । (Λ yX ymMg । Λ nN g 1)) (λ n । Λ fX ( n f )) x ) y ) (λ f । Λ zf ( x f z )) 3, যেখানে সমস্ত সংখ্যা চার্চ সংখ্যা হিসাবে প্রতিনিধিত্ব করা হয়। চার্চ সংখ্যাসমূহ স্বাভাবিক সংখ্যার মান ল্যামডা ক্যালকুলাস উপস্থাপনা, এবং কারণ একটি চার্চ সংখ্যা ফাংশন পুনরাবৃত্তির দ্বারা সংজ্ঞায়িত করা হয় তারা ভালো এই সমস্যার উপযুক্ত করা হয়: এন জি হয় এন ম ফাংশনের বারবার

উদাহরণস্বরূপ, যদি জি ফাংশন হয় λ n । λ । 3 ( এন ) যা চার্চের সংখ্যায় 3 দিয়ে গুন করে, তারপরে λ nn g 1 হ'ল ফাংশন যা 3 চার্চের সংখ্যার শক্তিতে লাগে। এই অপারেশন iterating মি বার দেয়

mg । λ nn g 1) (λ n । λ f । 3 ( n f )) n = u (3, n , m )।

(আমরা বেস (যেমন - - - -, 1) হিসাবে ক্ষয়ক্ষতি ছাড়াই ইউ (-, -, 0) ব্যবহার করি কারণ চার্চের সংখ্যার 1 থেকে বিয়োগ করাই অপ্রীতিকর )

বিকল্প এন = 3:

mg । λ nn g 1) (λ n । λ f । 3 ( n f )) 3 = u (3, 3, মি )

এম = 4 থেকে শুরু করে operation৪ বার এই অপারেশনটি চিহ্নিত করা হয়

64 (λ মিমি । Λ এনএন জি 1) (λ এন । Λ । 3 ( এন )) 3) 4 = জি

এই অভিব্যক্তিটি অনুকূলকরণের জন্য, বিকল্প = 64৪ = ৪ 4 ৩ = ৩ ৪:

3 4 (λ মিমি । Λ এনএন জি 1) (λ এন । Λ । 3 ( এন )) 3) 4 = জি

4 = suc 3 = λ f মনে রাখবেন । λ z- রf (3 f z ) ল্যাম্বডা যুক্তি হিসাবে:

y । 3 ymmg । λ nn g 1) (λ n । λ f । 3 ( n f )) 3) y ) (λ f । λ zf (3 f z )) = জি

পরিশেষে, 3 = λ f মনে রাখবেন । λ z- রf ( f ( f z )) ল্যাম্বডা আর্গুমেন্ট হিসাবে:

x । (λ yx ymmg । λ nn g 1)) (λ n । λ fx ( n f )) x ) y ) (λ f । λ zf ( x f z )) 3 = জি


এই ভাষার জন্য একজন অনুবাদক কোথায় পাবেন?
ডেনিস

4
@Dennis tromp.github.io/cl/cl.html তাদের একটি দম্পতি আছে।
আন্ডারস ক্যাসরগ

1
এটা দুর্দান্ত । এটি একটি আকারের অনুগ্রহের দাবিদার
বিড়াল

1
14.25 bytesলিডারবোর্ডে গোলমাল হচ্ছে বলে মনে হচ্ছে। এটি পার্স করা হয় 25 bytesএবং সুতরাং আপনাকে দ্বিতীয় হিসাবে স্থান দেওয়া হয়।
ড্যান

1
@ ড্যান আমি নেতা বোর্ড স্নিপেট ঠিক করেছি, আমি মনে করি।
অ্যান্ডারস ক্যাসরগ

40

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

i=((!!).).iterate
i(($3).i(`i`1)(*3))4 64

ব্যাখ্যা:

(`i`1)f n= থেকে শুরু করে ফাংশনটির তম পুনরাবৃত্তি i f 1 nগণনা করে । বিশেষত, = 3 ^ n , এবং এই নির্মাণের পুনরাবৃত্তিটি m বার দেয় = ইউ (3, এন , মি )। আমরা এটিকে = ইউ (3, এন , মি ) হিসাবে পুনরায় লিখতে পারি এবং = জি _ কে পেতে এই নির্মাণ কে কে পুনরাবৃত্তি করতে পারি ।nf1(`i`1)(*3)ni(`i`1)(*3)m n(($n).i(`i`1)(*3))mi(($3).i(`i`1)(*3))4 k


16

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

q=((!!).).iterate
g=q(`q`1)(3*)
q(`g`3)4$64

gইনলাইন ফ্লিপ করার আরও ভাল উপায় আছে ।

46 বাইট:

i=iterate
n%0=3*n
n%m=i(%(m-1))1!!n
i(3%)4!!64

48 বাইট:

n%1=3^n
1%m=3
n%m=(n-1)%m%(m-1)
iterate(3%)4!!64

শুধু সংজ্ঞা লিখছি।

বেস কেসগুলি 0 পর্যন্ত ব্যাক আপ কিছুটা ক্লিনার, যদিও এটি কোনও বাইট সংরক্ষণ করে না। সম্ভবত এটি একটি বিকল্প সংজ্ঞা লিখতে সহজ করবে।

n%0=3*n
0%m=1
n%m=(n-1)%m%(m-1)
z=iterate(3%)2!!1

এর +মধ্যে প্রথম বন্ধনটি অপসারণ করার জন্য আপনি আরও একটি ফাংশন ব্যবহার করতে পারেন যা এর চেয়ে কম রয়েছে m-1?
লিকি নুন

আমি 44 বাইট গণনা করছি, এবং 4 এবং 64 এর কি হয়েছিল?
লিকি নুন

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

মানে, আপনি এটি আবার
লিক নুন

আমি মনে করি আপনি বোঝাতে চেয়েছেন (`g`3), না (3`g`)
অ্যান্ডারস ক্যাসরগ

10

পাইথ, 25 বাইট

M?H.UgbtH*G]3^3Gug3tG64 4

প্রথম অংশটি M?H.UgbtH*G]3^3Gএকটি পদ্ধতি সংজ্ঞায়িত করে g(G,H) = u(3,G,H+1)

প্রথম অংশ পরীক্ষা করার জন্য, চেক করুন যে 7625597484987=u(3,3,2)=g(3,1): g3 1

দ্বিতীয় অংশটি ug3tG64 4শুরু হয় r0 = 4এবং তারপরে times৪ rn = u(3,3,r(n-1)) = g(3,r(n-1))বার গণনা করে চূড়ান্ত মান আউটপুট করে ( বিভ্রান্তি এড়ানোর rপরিবর্তে বেছে নেওয়া হয় g)।

এই অংশ পরীক্ষা করার জন্য, থেকে শুরু r0=2এবং তারপর গনা r1: ug3tG1 2


যদি g (G, H) = u (3, G, H + 1), আপনার r (n) = u (3, 3, r (n - 1)) = g (3, r (n - 1) হওয়া উচিত ) - 1), জি নয় (3, আর (এন - 1))। আমি মনে করি আপনার কোডটি সঠিক তবে আপনার ব্যাখ্যাটি 1
আন্ডারস কাসের্গ

আপনি unoffsetted তোমার দর্শন লগ করা আর্গুমেন্টগুলি (ব্যবহার করে একটি বাইট সংরক্ষণ করতে পারবেন ^3*3, tGG), এবং সাথে অন্য বাইট .UgbtH*G]3e.ugNtHG1
অ্যান্ডারস ক্যাসরগ

দ্বিতীয় বাইট সংরক্ষণ করতে একটি বিকল্প উপায় *G]3ShG
অ্যান্ডারস ক্যাসরগ

8

সেসোস , 30 বাইট

0000000: 286997 2449f0 6f5d10 07f83a 06fffa f941bb ee1f33  (i.$I.o]...:....A...3
0000015: 065333 07dd3e 769c7b                              .S3..>v.{

অনেকত্রিত

set numout
add 4
rwd 2
add 64
jmp
    sub 1
    fwd 3
    add 3
    rwd 1
    add 1
    jmp
        sub 1
        jmp
            fwd 1
            jmp
                jmp
                    sub 1
                    fwd 1
                    add 1
                    rwd 1
                jnz
                rwd 1
                jmp
                    sub 1
                    fwd 3
                    add 1
                    rwd 3
                jnz
                fwd 3
                jmp
                    sub 1
                    rwd 2
                    add 1
                    rwd 1
                    add 1
                    fwd 3
                jnz
                rwd 1
                sub 1
            jnz
            rwd 1
            jmp
                sub 1
            jnz
            add 1
            rwd 1
            sub 1
        jnz
        fwd 1
        jmp
            sub 1
            rwd 1
            add 3
            fwd 1
        jnz
        rwd 2
    jnz
    rwd 1
jnz
fwd 2
put

বা ব্রেইনফাক স্বরলিপি:

++++<<++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
[->>>+++<+[-[>[[->+<]<[->>>+<<<]>>>[-<<+<+>>>]<-]<[-]+<-]>[-<+++>]<<]<]>>.

পরীক্ষামূলক

গনা তোমার দর্শন লগ করা (3, এন , ইউ (3, এন , ... তোমার দর্শন লগ করা (3, এন , এম ) ...)) সঙ্গে করার নেস্টেড কল U , প্রথম তিনটি প্রতিস্থাপন addনির্দেশাবলী add 4, add 64, add 3সঙ্গে add m, add k, add nযথাক্রমে। যেহেতু সিসোস লিনিয়ার সময়ের চেয়ে দ্রুত সংখ্যা তৈরি করতে পারে না, আপনি ব্যবহারিকভাবে u (3, 2, 2) = 27, u (3, 5, 1) = 243 এবং u (3, 1 ) এর মতো ছোট মানগুলিতে সীমাবদ্ধ থাকেন , ইউ (3, 1,… ইউ (3, 1, মি ) ...)) = 3


ইওএফ হওয়ায় আপনি এর [-]সাথে প্রতিস্থাপন করতে পারেন । ,0
mbomb007

6

জাভাস্ক্রিপ্ট (ES7), 63 বাইট

u=(n,m)=>n>1&m>1?u(u(n-1,m),m-1):3**n
g=n=>n?u(3,g(n-1)):4
g(64)

@ আন্ডারস ক্যাসরগ উগ, সে ক্ষেত্রে আমিও সেই পরিবর্তনটি ফিরিয়ে দিতে পারি।
নীল

এটি স্ট্যাকের ওভারফ্লোর কারণ ঘটায়, আপনার পুনর্বিবেচনার প্যাটার্নটি আবার পরীক্ষা করা দরকার।
নোডনোড নোড

এটি সাধারণ ES7 নয়। এটি আনবাউন্ডেড ES7 (ES7 এর একটি কাল্পনিক বৈকল্পিক তবে বিগনাম সহ, অসীমভাবে ওરેકল করতে সক্ষম এবং শর্টহ্যান্ড হিসাবে / # xE with সহ দশমিক ব্যবহার করছে)।
ব্যবহারকারী 75200

5

ব্র্যাচল্যাগ , 57 বাইট

4:64:1iw
:3{[1:N],3:N^.|t1,3.|hM:1-X,?t:1-:Mr:2&:Xr:2&.}.

কোনও ইনপুট বা আউটপুট প্রত্যাশা করে না এবং ফলাফলটি লিখে STDOUT। এটি এক পর্যায়ে একটি স্ট্যাক ওভারফ্লো উত্পাদন করবে।

এটি ছোট মানগুলির জন্য কাজ করে কিনা তা পরীক্ষা করতে (উদাঃ u(3,3,2)) আপনি 4এর মান mএবং এর 64সাথে প্রতিস্থাপন করতে পারেন 1

ব্যাখ্যা

এটি মূলত সংখ্যার কম্পিউটিংয়ের ব্যাখ্যা করা পদ্ধতির একটি সরল বাস্তবায়ন।

  • প্রধান শিকারী:

    4:64:1i                    Call Predicate 1 64 times with 4 as initial input (the second
                               call takes the output of the first as input, etc. 64 times).
           w                   Write the final output to STDOUT
    
  • ভবিষ্যদ্বাণী 1:

    :3{...}.                   Call predicate 2 with input [Input, 3]. Its output is the 
                               output of predicate 1.
    
  • ভবিষ্যদ্বাণী 2:

    [1:N],                     M = 1
          3:N^.                Output = 3^N
    |                          Or
    t1,                        N = 1
       3.                      Output = 3
    |                          Or
    hM:1-X,                    X is M - 1
           ?t:1-:Mr:2&         Unify an implicit variable with u(3,N-1,M)
                      :Xr:2&.  Unify Output with u(3,u(3,N-1,M),X)
    

5

ক্যারামেল , 38 বাইট

(64 ((f->(f,1)),(n f->(3 (n f))),3) 4)

এই (λ ল্যামডা ক্যালকুলাস অভিব্যক্তি 64 জন্য অন্বিত চিনি মিমি । Λ এনএন (1) λ এন λ। । 3 ( এন )) 3) 4, যেখানে সব সংখ্যার হিসাবে প্রতিনিধিত্ব করা হয় চার্চ সংখ্যাসমূহ


(n f->3 (n f))এটা পড়া উচিত নয় n-1?
লিকি নুন

@ ল্যাকইন নং চার্চ সংখ্যায়(n f->3 (n f)) তিন দ্বারা গুণনের জন্য একটি ফাংশন ।
অ্যান্ডারস ক্যাসরগ

2
ল্যাম্বডা ক্যালকুলাসে এই চ্যালেঞ্জটি অত্যধিক সহজ বলে মনে হচ্ছে। কেন?
বিড়াল

3

প্রোলোগ (এসডাব্লুআইপিএল), 129/137 বাইট

g(1,R):-u(3,4,R).
g(L,R):-M is L-1,g(M,P),u(3,P,R).
u(N,1,R):-R is 3**N.
u(1,_,3).
u(N,M,R):-K is N-1,L is M-1,u(K,M,Y),u(Y,L,R).

গ্রাহামের সংখ্যা আউটপুট করতে, এর জন্য ক্যোয়ারী g(64,G).(যদি এই কোয়েরির 8 টি বাইট গণনা করা হয় তবে দৈর্ঘ্য 137 বাইট):

?- g(64, G).
ERROR: Out of local stack

তবে যেমনটি আশা করা যায়, এটি স্ট্যাকের বাইরে চলে গেছে।

পরীক্ষা

?- u(3, 2, X).
X = 7625597484987

ব্যাকট্র্যাকিংয়ের কারণে এটি স্ট্যাকের বাইরে চলে যায়:

?- u(3, 2, X).
X = 7625597484987 ;
ERROR: Out of local stack

Ungolfed

নিরবচ্ছিন্ন সংস্করণটি কেবলমাত্র 3 এর জন্য নয়, সাধারণ আপ-তীর চিহ্ন চিহ্নিত করে এবং ব্যাকট্র্যাকিং এবং অপরিজ্ঞাত পরিস্থিতি এড়াতে কাট এবং চেক ব্যবহার করে uses

% up-arrow notation
u(X, 1, _M, X) :- !.
u(X, N, 1, R) :-
    R is X**N, !.
u(X, N, M, R) :-
    N > 1,
    M > 1,
    N1 is N - 1,
    M1 is M - 1,
    u(X, N1, M, R1),
    u(X, R1, M1, R).

% graham's number
g(1,R) :- u(3, 3, 4, R), !.
g(L,R) :-
    L > 1,
    L1 is L - 1,
    g(L1,G1),
    u(3, G1, R).

আপনার কোডটিতে 64কোথাও নম্বর না থাকলে আপনি কীভাবে এটি পরিচালনা করবেন ?
লিকি নুন

@ লিকিউন আমি স্পষ্ট করার জন্য সম্পাদনা করেছি; উত্তম?
এসকিউবি

ঠিক আছে, তারপরে এটিকে আপনার কোডের পাশাপাশি আপনার বাইট-কাউন্টে যুক্ত করুন।
ফাঁস নুন

3

সি, 161 বাইট

u(int a, int b){if(a==1)return 3;if(b==1)return pow(3,a);return u(u(a-1,b),b-1);}
g(int a){if(a==1)return u(3,4);return u(3,g(a-1));}
main(){printf("%d",g(64));}

সম্পাদনা: ট্যাব এবং নিউলাইনগুলি সরিয়ে 11 বাইট সংরক্ষণ করা হয়েছে। সম্পাদনা: thx auhmann আরেকটি বাইট সংরক্ষণ করেছে এবং আমার প্রোগ্রামটি ঠিক করেছে


1
আপনি এটি অপসারণ করতে পারেন g(int a){if(a==1)return u(3,4);return g(a-1);}যেহেতু এটি মোটেও ব্যবহৃত হচ্ছে না ... বা আপনি কিছু ভুলে যাচ্ছেন?
auhmaan

@ অহমান উফফফফ, আমি এই নম্বরটি পরীক্ষার জন্য ব্যবহার করেছি এবং এটি আবার বদলাতে ভুলে গেছি। ধন্যবাদ !!
thepiercingarrow

আপনার return g(a-1)হওয়া উচিত return u(3,g(a-1))
অ্যান্ডারস ক্যাসরগ

1
আমার কোনও সঠিক উত্তর দেওয়া উচিত বা এটি সম্পর্কে মন্তব্য করা উচিত কিনা তা আমি জানি না তবে আপনি এই সমাধানটি খুব সহজেই উপলব্ধি করে 114 বাইটে নামাতে পারবেন: ফাংশনগুলির মধ্যে থাকা নিউলাইনগুলি বাদ দেওয়া যেতে পারে। সমস্ত আর্গুমেন্টের জন্য প্রকারের ছাড় দেওয়ার ফলে সেগুলি ডিফল্ট হয় (মনে হয় কে ওআর)। এর মতো বিবৃতি যদি নেস্টেড টের্নারি অপ্স দিয়ে লেখা যায়। কোড:u(a,b){return a<2?3:b<2?pow(3,a):u(u(a-1,b),b-1);}g(a){return a<2?u(3,4):u(3,g(a-1));}main(){printf("%d",g(64));}
অ্যালগমির

@ অ্যালগমির বাহ আশ্চর্য! আপনার নিজের উত্তর এক্সডি পোস্ট করা উচিত।
thepiercingarrow

2

গণিত, 59 বাইট

n_ ±1:=3^n
1 ±m_:=3
n_ ±m_:=((n-1)±m)±(m-1)
Nest[3±#&,4,64]

একটি অনির্ধারিত ইনফিক্স অপারেটর ব্যবহার করে ±যার জন্য আইএসও 8859-1 এ এনকোড করা হলে কেবল 1 বাইট প্রয়োজন। আরও তথ্যের জন্য @ মার্টিনের পোস্ট দেখুন। গাণিতিক তাদের আর্গুমেন্টগুলির সাথে মেটানোর প্যাটার্ন সমর্থন করে, যেমন দুটি বেস কেস পৃথকভাবে সংজ্ঞায়িত করা যায়।


1
ম্যাথমেটিকা ​​কখন থেকে আইএসও 8859-1 ব্যবহার করেছেন?
ফাঁস নুন

n_ ±m_:=Nest[#±(m-1)&,3,n]
ফাঁস নুন

2

সি, 114 109 বাইট

@ থিপিয়েরসিংরো ( লিঙ্ক ) এর উত্তরের ভিত্তিতে আমি উত্তরটি বেশ খানিকটা নীচে গল্ফ করেছি। কে ওআরআর স্টাইলের কাজগুলি করার সময় আর্গুমেন্টের ডিফল্ট টাইপিংয়ের অপব্যবহার এবং টের্নারি অপারেটরগুলির সাথে বিবৃতি প্রতিস্থাপনের কারণে বেশিরভাগ সঞ্চয় হয়। পাঠযোগ্যতার জন্য ফাংশনগুলির মধ্যে alচ্ছিক নিউলাইনগুলি যুক্ত করা হয়েছে।

@ লিকইনুনকে ধন্যবাদ 109-এ উন্নত করা হয়েছে

u(a,b){return a<2?3:b<2?pow(3,a):u(u(a-1,b),b-1);}
g(a){return u(3,a<2?4:g(a-1));}
main(){printf("%d",g(64));}

g(a){return u(3,a<2?4:g(a-1));}
লিকি নুন

পছন্দ করুন ধন্যবাদ।
অ্যালগমির

1

পাইথন, 85 বাইট

v=lambda n,m:n*m and v(v(n-1,m)-1,m-1)or 3**-~n
g=lambda n=63:v(2,n and g(n-1)-1or 3)

vফাংশন পাওয়া এক হিসাবে একই ফাংশন সংজ্ঞায়িত ডেনিস এর উত্তর : v(n,m) = u(3,n+1,m+1)gফাংশন ঐতিহ্যগত পুনরাবৃত্তির একটি শূন্য সূচীবদ্ধ সংস্করণ: g(0) = v(2,3), g(n) = v(2,g(n-1))। সুতরাং, g(63)গ্রাহাম নম্বর। এতে ফাংশনটির nপ্যারামিটারের ডিফল্ট মান সেট করে , প্রয়োজনীয় আউটপুট কল করে (কোনও পরামিতি ছাড়াই) পাওয়া যায়, এইভাবে কোনও ফাংশন জমা দেওয়ার জন্য আমাদের প্রয়োজনীয়তা পূরণ করে যা কোনও ইনপুট নেয় না।g63g()

অনলাইনে v(2,1) = u(3,3,2)এবং v(4,0) = u(3,5,1)পরীক্ষার কেসগুলি যাচাই করুন : পাইথন 2 , পাইথন 3


1
এটি যাচাই করা খুব সহজ, তবে আপনার ফাংশনটি gবন্ধ বলে মনে হচ্ছে। বা কিছু অনুরূপ v(2,n-1)হওয়া উচিত নয় g(n-1)?
ডেনিস

@ ডেনিস ভাল ক্যাচ আমি এটা ঠিক করব।
মেগো

আসলে অফসেটের মধ্যে uএবং এর vঅর্থ হওয়া উচিত g(n-1)-1
অ্যান্ডারস ক্যাসরগ

@ অ্যান্ডারস ক্যাসরগ আমার ঘুমের সময় প্রোগ্রামিং করা উচিত নয়। আমাকে প্রতি কয়েকদিন পরেই এটি আবার শিখতে হবে।
মেগো

@ অ্যান্ডারস ক্যাসরগ ভবিষ্যতে, দয়া করে আপনার প্রস্তাবিত উন্নতি / বাগফিক্সটিতে কোনও ভুল সংশোধন করার পরেও অন্য লোকের জমাগুলিতে সম্পাদনা করবেন না।
মেগো

1

ডায়ালগ এপিএল, 41 বাইট

u←{1=⍺:3⋄1=⍵:3*⍺⋄(⍵∇⍨⍺-1)∇⍵-1}
3u 3u⍣64⊣4

পরীক্ষা ক্ষেত্রে:

      3u 2
7625597484987

আপনি 1=⍺:3⋄1=⍵:3*⍺ঠিক 1=⍵:3*⍺( 3=3*1)
জাকারি

1

রুবি, 64 বাইট

গ্রাহামের সংখ্যা গণনা করার জন্য তাত্ত্বিক অ্যালগরিদম থেকে ধার নেওয়া ।

def f(a,b=3)b<2?3:a<1?3*b:f(a-1,f(a,b-1))end;a=4;64.times{a=f a};p a

সহজ কথায় বলতে f a = u(3,3,a)গেলে এবং এটি এটি times৪ বার প্রয়োগ করে।


এই কোডটি কেন এবং কীভাবে কাজ করে সে সম্পর্কে একটি দুর্দান্ত ব্যাখ্যাটি দুর্দান্ত।
মনীষ কুণ্ডু

এটি গ্রাহামের সংখ্যার সংজ্ঞা সংজ্ঞা দেওয়ার জন্য একটি সহজ প্রয়োগ।
কেবল সুন্দর আর্ট

0

জে, 107 বাইট

u=:4 :0
if.y=1 do.3^x
elseif.x=1 do.3
elseif.1 do.x:(y u~<:x)u<:y
end.
)
(g=:(3 u 4[[)`(3 u$:@<:)@.(1&<))64

আমি uএকটি এজেন্ডা রূপান্তর উপর কাজ করছি , কিন্তু আপাতত এটি করতে হবে।


এরকম কিছু u=:3^[`[:(3$:])/[#<:@]@.*@](পরীক্ষিত নয়)
লিকি নুন

0

এফ #, 111 108 বাইট

সম্পাদন করা

এটি গ্রাহামের নম্বর ক্যালকুলেট করতে নীচের ফাংশনটি ব্যবহার করছে

let rec u=function|b,1->int<|3I**b|1,c->3|b,c->u(u(b-1,c),c-1)
and g=function|1->u(3.,4.)|a->u(3.,g (a-1))
g 63

এখানে আমার পূর্ববর্তী উত্তর যা ভাল, না:

অনেকটাই অকপট. uফাংশনটির একটি সংজ্ঞা মাত্র ।

let rec u=function|a,b,1->a**b|a,1.,c->a|a,b,c->u(a,u(a,b-1.,c),c-1)

ব্যবহার:

u(3.,3.,2)
val it : float = 7.625597485e+12

যদি আমি 3 এর জন্য মান হিসাবে ধরে নিয়েছি, তবে আমি এটি 60 কেটে ফেলতে পারি:

let rec u=function|b,1->3.**b|1.,c->3.|b,c->u(u(b-1.,c),c-1)

ব্যবহার:

u(3.,2)
val it : float = 7.625597485e+12

চ্যালেঞ্জ হ'ল গ্রাহামের নাম্বারটি লেখা, নয় u। আপনি অবশ্যই যে কোনও মধ্যবর্তী ফাংশন অন্তর্ভুক্ত করতে পারেন, যেমন uতার প্রথম যুক্তিটি 3 এর সাথে বা ছাড়াই নির্ধারণ করা হয়েছে
অ্যান্ডারস ক্যাসরগ

@ আন্ডারস ক্যাসরগ এটিকে সম্পাদনা করেছেন Thanks ধন্যবাদ। আমার আগের মন্তব্যটি অদৃশ্য হয়ে গেছে বলে মনে হচ্ছে।
আসিবিহি

0

আর, 154 142 128 126 118 বাইট

u=function(n,b)return(if(n&!b)1 else if(n)u(n-1,u(n,b-1))else 3*b)
g=function(x)return(u(if(x-1)g(x-1)else 4,3))
g(64)

আমি এই পুনরাবৃত্তির ফাংশনের উইকিপিডিয়া সংজ্ঞাটি ব্যবহার করেছি কারণ কিছু অদ্ভুত কারণে প্রস্তাবিতটি কাজ করে না ... বা আমি কেবল আর গল্ফকে চুষছি।

ইউপিডি: 12 + 14 = 26 বাইট শ্যাভ অফ লিক নুনের একটি টিপকে ধন্যবাদ । পূর্ববর্তী সংস্করণটি ভারী এবং কম দক্ষ ব্যবহৃত হয়েছিল

u=function(n,b)if(n==0)return(3*b)else if(n>0&b==0)return(1)else return(u(n-1,u(n,b-1)))
g=function(x)if(x==1)return(u(4,3))else return(u(g(x-1),3))

ইউপিডি: 2 + 6 + 2 আরও বাইট বেঁধে (আবার লুচি নুনের কাছে কুডোস ) "আইফ (এক্স)" এর পরিবর্তে "যদি (x == 0)" এর সাথে একটি প্রতিস্থাপন প্রতিস্থাপনের কারণে x <0 কখনও খাওয়ানো হয় না ফাংশন ... তাই না?


@ ল্যাকিয়ুন আপনাকে ধন্যবাদ, উত্তরটি স্বীকারোক্তি সহ আপডেট করেছে।
আন্দ্রে কোস্টায়ারকা

মাত্র এক সেকেন্ড ... আজ আমার কোড গল্ফের প্রথম দিন, শেখার মতো আরও অনেক কিছুই আছে!
আন্দ্রে কোস্টায়ারকা

আপনি আমাদের চ্যাটে যোগদানের জন্য আমন্ত্রিত হন ।
লিকি নুন

আরও গল্ফিং, দয়া করে উন্নতি দেখুন।
আন্দ্রে কোস্টায়ারকা

টা-বাঁধ, সম্পন্ন, uআপনার একই কিতে ফাংশনটি পরিবর্তন করেছে gএবং আরও 6 টি বাইট সংরক্ষণ করেছে - দুর্দান্ত!
আন্দ্রে কোস্টায়ারকা

0

পিএইচপি, 114 বাইট

লাইন বিরতি উপেক্ষা করুন; এগুলি কেবল পাঠযোগ্যতার জন্য।

function u($n,$m){return$m>1&$n>1?u(u($n-1,$m),$m-1):3**$n;}
function g($x){return u(3,$x>1?g($x-1):4);}
echo g(63);

দ্বিতীয় কেসটিকে প্রথম একের সাথে সংহত করা সম্ভব: কারণ n=1, 3^nসমান 3
এটি কয়েকটা বাইট সংরক্ষণ করবে - যতদূর আমি দেখতে পাচ্ছি - সমস্ত বিদ্যমান উত্তরগুলি; আমার উপর দুটি বাইট সংরক্ষণ

পূর্ববর্তী সংস্করণ, 62 + 43 + 11 = 116 বাইট

function u($n,$m){return$m>1?$n>1?u(u($n-1,$m),$m-1):3:3**$n;}

পিএইচপি'র বাম সাহিত্যের জন্য টেরিনারিটির প্রথম বন্ধনী প্রয়োজন ... বা পরীক্ষার একটি নির্দিষ্ট ক্রম।
এটি প্রথম বন্ধনীযুক্ত প্রকাশে দুটি বাইট সংরক্ষণ করেছে।


সম্ভবত একটি পুনরাবৃত্তি পদ্ধতি রয়েছে, যা আরও গল্ফিংয়ের অনুমতি দিতে পারে ...
তবে আমি এখনই সময় নিতে পারি না।


যদি আমি সেসোসকে জানতাম বা এটি শিখতে এবং এই মুহূর্তে অনুবাদ করার সময় পেয়েছি
তিতাস

@ লিকি নুন: আমি এটিকে কেবল লুপ এবং সংযোজনে ভেঙে ফেলেছি। সেসোসে কি কোনও উপায় আছে যে কোনও একটি ঘরের মূল্য অন্য কক্ষে যুক্ত করতে পারে?
তিতাস

@ অ্যান্ডারস ক্যাসরগ: আপনি সম্ভবত ঠিকই আছেন ... সেই আলগোরিদমটি দেখে আমার চোখের ছোঁয়ায় ফোস্কা পড়েছিলাম। শীঘ্রই আবার এটি তাকান।
তিতাস
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.