23

इस बार की चुनौती n वें Fibohexaprime को खोजने की है । एक Fibohexaprime की परिभाषा इस प्रकार है:

हम पहले फाइबोनैचि संख्याओं के साथ एक सूची का निरीक्षण करते हैं:

N  | Fibonacci number
1  | 1 
2  | 1 
3  | 2 
4  | 3 
5  | 5 
6  | 8 
7  | 13 
8  | 21 
9  | 34 
10 | 55 
11 | 89 
12 | 144 
13 | 233 
14 | 377 
15 | 610
16 | 987 
17 | 1597

उसके बाद, हम संख्याओं को हेक्साडेसिमल में बदलते हैं:

N  | Fib  | Hex 
1  | 1    | 1
2  | 1    | 1
3  | 2    | 2
4  | 3    | 3
5  | 5    | 5
6  | 8    | 8
7  | 13   | D
8  | 21   | 15
9  | 34   | 22
10 | 55   | 37
11 | 89   | 59
12 | 144  | 90
13 | 233  | E9
14 | 377  | 179
15 | 610  | 262
16 | 987  | 3DB
17 | 1597 | 63D

हेक्साडेसिमल संख्याओं से, हम अक्षरों को छानते हैं। हम सभी संख्या के साथ बचे हैं। हमें जांचने की आवश्यकता है कि क्या ये संख्याएँ प्रधान हैं:

hex |  filtered |  is prime? |  N =
1   >  1        >  false
1   >  1        >  false
2   >  2        >  true         1
3   >  3        >  true         2
5   >  5        >  true         3
8   >  8        >  false
D   >  0        >  false
15  >  15       >  false
22  >  22       >  false
37  >  37       >  true         4
59  >  59       >  true         5
90  >  90       >  false
E9  >  9        >  false
179 >  179      >  true         6
262 >  262      >  false
3DB >  3        >  true         7
63D >  63       >  false

यदि फ़िल्टर किया गया नंबर एक प्राइम है, तो हम इसे Fibohexaprime कहते हैं । आप देख सकते हैं कि N = 7, संबंधित रिटेल नंबर 987 है।

कार्य सरल है, जब एसटीडीआईएन या स्वीकार्य विकल्प का उपयोग करके एक इनपुट दिया जाता है, एक प्रोग्राम या एक फ़ंक्शन लिखें जो STDOUT या स्वीकार्य विकल्प का उपयोग करके nth Fibohexaprime का आउटपुट देता है।

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

Input - Output
1     - 2
2     - 3
3     - 5
4     - 55
5     - 89
6     - 377
7     - 987
8     - 28657
9     - 75025
10    - 121393
11    - 317811
12    - 5702887
13    - 9227465
14    - 39088169
15    - 102334155
16    - 32951280099
17    - 4052739537881
18    - 806515533049393
19    - 7540113804746346429

नियम:

के बीच एक पूर्णांक ( 1और एक 64-बिट हस्ताक्षरित पूर्णांक के लिए अधिकतम मूल्य 19से 20अधिक मूल्य) को देखते हुए, संबंधित मूल्य को आउटपुट करता है।
आप एक समारोह या एक कार्यक्रम लिख सकते हैं।
यह कोड-गोल्फ है , इसलिए कम से कम बाइट्स जीत के साथ जमा करना!

— अदनान
स्रोत

जिस तरह से इसे शब्दबद्ध किया गया है, ऐसा लगता है कि फ़ंक्शन को STDIN से भी पढ़ना चाहिए और STDOUT पर लिखना होगा। क्या वो सही है? आमतौर पर हम कार्यों को तर्कों को स्वीकार करने और मूल्यों को सुविधाजनक बनाने की अनुमति देते हैं।

— एलेक्स ए।

2

@AlexA। दोनों स्वीकार्य विकल्प हैं। STDIN से पढ़ना और STDOUT का उपयोग करना अनिवार्य नहीं है।

— अदनान

4

पायथ, 27 बाइट्स

Leu,eGsGbU2ye.fq1lPs-.HyZGQ

प्रदर्शन

ynth फाइबोनैचि संख्या की गणना करता है। एक .fलूप में इनपुट के अनुसार फाइबोहेक्सप्राइम पाया जाता है।

— isaacg
स्रोत

12

MATL , 28 बाइट्स

यह MATL संस्करण 1.0.0 का उपयोग करता है , जो इस चुनौती से पहले 12 दिसंबर को Esolangs में प्रकाशित हुआ था ।

1Hi:"`tb+t16YAt58<)YtZp~]]1$

उदाहरण

>> matl 1Hi:"`tb+t16YAt58<)YtZp~]]1$
> 10
121393

व्याख्या

कोड मार्टिन बंटनर के उत्तर के समान है ।

1           % number literal
H           % paste from clipboard H. Initial contents: 2
i:          % vector of equally spaced values from 1 to input value           
"           % for                      
  `         % do...while         
    t       % duplicate                           
    b       % bubble up element in stack          
    +       % addition 
    t       % duplicate                   
    16YA    % convert integer to string representation in base 16
    t       % duplicate             
    58      % number literal: first ASCII code after '9'           
    <       % is less than? (element-wise)    
    )       % reference () indexing with logical index from previous comparison
    Yt      % convert string to number 
    Zp      % true for prime numbers                                
    ~       % logical 'not'
  ]         % end                                                   
]           % end                                                   
1$          % input specification for final implicit display function

— लुइस मेंडो
स्रोत

4

दुनिया का पहला MATL जवाब! अच्छी नौकरी, लुइस!

— बीकर

1

MATL के लिए हुर्रे! कोड गोल्फिंग की दुनिया में आपका स्वागत है!

— रायरेंग - मोनिका

8

सीजेएम, 28 बाइट्स

TXri{{_@+_Gb{A<},Abmp!}g}*p;

इसका परीक्षण यहां करें।

व्याख्या

TX        e# Push 0 and 1 to initialise Fibonacci computation.
ri        e# Read input and convert to integer N.
{         e# Run this block N times...
  {       e#   While the condition on top of the stack is truthy...
    _@+   e#     Compute next Fibonacci number (dropping the second-to-last one).
    _Gb   e#     Duplicate and convert to base 16.
    {A<}, e#     Keep only digits less than 10.
    Ab    e#     Convert from base 10.
    mp!   e#     Check that it's not a prime.
  }g
}*
p;        e# Print the last number we found and discard the one before.

— मार्टिन एंडर
स्रोत

7

पर्ल 6 , 62 बाइट्स

काम करने के लिए मेरा पहला पास था:

{(grep *[1].is-prime,map {$_,+[~] .base(16)~~m:g/\d/},(1,1,*+*...*))[$_-1;0]} # 77

grepऔर को मिलाकर map, मैं 10 बाइट निकाल सकता हूं

{(map {$_ if is-prime [~] .base(16)~~m:g/\d/},(1,1,*+*...*))[$_-1]} # 67

अगर मैं grepइसके बजाय का उपयोग करता हूं map, तो मैं 5 और बाइट्स बचाता हूं:

{(grep {is-prime [~] .base(16)~~m:g/\d/},(1,1,*+*...*))[$_-1]} # 62

उपयोग:

# give it a name
my &code = {...}

say code $_ for 1..^20;

2
3
5
55
89
377
987
28657
75025
121393
317811
5702887
9227465
39088169
102334155
32951280099
4052739537881
806515533049393
7540113804746346429

— ब्रैड गिल्बर्ट b2gills
स्रोत

3

गणितज्ञ 111 बाइट्स

अतिरिक्त गोल्फिंग के लिए अभी भी जगह हो सकती है।

t=Table[Fibonacci@k,{k,1600}];f@n_:=PrimeQ@FromDigits[Select[n~IntegerDigits~16,#<10&]];
g@k_:=Select[t,f][[k]]

g[7]

987

g[19]

7540113804746346429

— DavidC
स्रोत

3

जूलिया, 123 बाइट्स

n->(a=[];i=1;while endof(a)<n b=([1 1;1 0]^i)[1];(s=filter(isdigit,hex(b)))>""&&isprime(parse(s))&&push!(a,b);i+=1end;a[n])

यह एक अनाम फ़ंक्शन है जो पूर्णांक को स्वीकार करता है और पूर्णांक देता है। इसे कॉल करने के लिए, इसे एक नाम दें, जैसे f=n->...।

Ungolfed:

function f(n::Integer)
    # Initialize an array and an index
    a = []
    i = 1

    # Loop while we've generated fewer than n fibohexaprimes
    while endof(a) < n
        # Get the ith Fibonacci number
        b = ([1 1; 1 0]^i)[1]

        # Filter the hexadecimal representation to digits only
        s = filter(isdigit, hex(b))

        # If there are digits to parse, parse them into an
        # integer, check primality, and push the Fibonacci
        # number if prime
        s > "" && isprime(parse(s)) && push!(a, b)

        # Next
        i += 1
    end

    # Return the last generated
    return a[n]
end

— एलेक्स ए।
स्रोत

3

जीएपी , 204 बाइट्स

यह उत्तर बहुत ही अचूक है, सिवाय इसके कि जीएपी काफी ठंडा है ताकि अगले युगल फाइबोहेक्सप्राइम (और अभी भी ठंडा हो सके, यह दी गई कोड के साथ मिलीसेकंड में पाया जाता है)।

gap>f(20);                                                                    
31940434634990099905
gap> f(21);
12776523572924732586037033894655031898659556447352249
gap> f(22);
971183874599339129547649988289594072811608739584170445
gap> f(23);
1324695516964754142521850507284930515811378128425638237225
gap> f(24);
187341518601536966291015050946540312701895836604078191803255601777

ध्यान दें कि f (24) 2 ^ 216 और 2 ^ 217 के बीच है।

यहाँ कोड है:

f:=function(n)local c,i,x;c:=1;i:=0;while c<=n do x:=HexStringInt(Fibonacci(i));RemoveCharacters(x,"ABCDEFGHIJKLMNOPQRSTUVWXYZ");x:=Int(x);if IsPrime(x) then c:=c+1;fi;i:=i+1;od;Print(Fibonacci(i-1));end;

वहाँ शायद अभी भी कुछ गोल्फ है कि किया जा सकता है। मुझे लगता है कि कार्यान्वयन बहुत सीधा है।

Ungolfed:

f:=function(n)
    local counter,i,x;
    counter:=1;i:=0;
    while counter<=n do
        x:=HexStringInt(Fibonacci(i));
        RemoveCharacters(x,"ABCDEFGHIJKLMNOPQRSTUVWXYZ");
        x:=Int(x);
        if IsPrime(x) then
            counter:=counter+1;
        fi;
        i:=i+1;
    od;
    Print(Fibonacci(i-1));
end;

— लियाम
स्रोत

3

सी, 186 183 बाइट्स

#include<stddef.h>
size_t a,b,c,d,m,x;size_t F(n){a=0,b=1;while(n){x=b;b+=a;a=x;c=0,m=1;while(x)d=x%16,m*=d<10?c+=m*d,10:1,x/=16;d=c>1;x=2;while(x<c)if(c%x++==0)d=0;d&&--n;}return a;}

प्राइमलिटी टेस्ट बहुत ही अकुशल होता है, इसलिए कंपीटिशन के लिए थोड़ा संघर्ष करना पड़ेगा n > 16और लंबे समय तक दर्द बना रहेगा n = 19। फिर भी यह काम करता है और अपेक्षित परिणाम देता है।

कोड मानता है कि size_t64 बिट प्रकार है, जो 64 बिट लिनक्स और विंडोज दोनों के लिए सही है।

बोनस: दुर्भाग्य से हमें 64 बिट प्रकारों का उपयोग करना आवश्यक है, जिससे 33 बाइट्स का ओवरहेड हो जाता है। निम्नलिखित संस्करण n <= 15का उपयोग करने के लिए काम करता है intऔर 150 बाइट लंबा है:

a,b,c,d,m,x;F(n){a=0,b=1;while(n){x=b;b+=a;a=x;c=0,m=1;while(x)d=x%16,m*=d<10?c+=m*d,10:1,x/=16;d=c>1;x=2;while(x<c)if(c%x++==0)d=0;d&&--n;}return a;}

टेस्ट मुख्य:

#include <stdio.h>

int main() {
  printf("Input - Output\n");
  for (int i = 1; i < 20; ++i) {
    printf("%2d    - %ld\n", i, F(i));
  }
}

— स्टेफानो सैनफिलिपो
स्रोत

क्या आप size_tशामिल का उपयोग करके और ड्रॉप करके थोड़ा बचा सकते हैं? यह कार्यान्वयन-विशिष्ट है, लेकिन 64-बिट लिनक्स और विंडोज जीसीसी दोनों में 64-बिट प्रतीत होता है (और जब से हमने कोडगॉल्फ में पोर्टेबिलिटी के बारे में परवाह की थी?)। (साइड नोट: %ld64-बिट विंडोज में 64-बिट नहीं है; ज़रूरतें %lld)

— बॉब

@ याकूब मैंने इसके बारे में सोचा, लेकिन size_tयह एक बायिन नहीं है, यह इसमें परिभाषित किया गया है stddef.h(जो बदले में प्रत्यक्ष या अप्रत्यक्ष रूप से लगभग किसी अन्य हेडर द्वारा शामिल किया गया है)। एक तरह से या दूसरे, मैं एक की जरूरत है #include। मैं अभी भी 2 बाइट्स बचा सकता हूं , हालांकि size_tइसके बजाय uint64_t:) :)

— स्टेफानो सैनफिलिपो

lldबिट के लिए भी धन्यवाद , मुझे इसे विंडोज पर परीक्षण करने का मौका नहीं मिला (लेकिन पोर्टेबिलिटी कोई फर्क नहीं पड़ता, ठीक है?)

— स्टेफानो सैनफिलिपो

हम्म, stdio.hजब मैं परीक्षण कर रहा था तो यह आया होगा । किसी भी मामले में - आप math.hइसके बजाय शामिल करके एक जोड़े को बचा सकते हैं stddef.h।

— बॉब

math.hमेरे लिए चाल नहीं करता (GNCC 4.9 के साथ GNU libc)

— स्टेफानो सैनफिलिपो

2

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

N=input();a,b=0,1
while N:a,b=b,a+b;t=int(''.join(c for c in hex(b)if ord(c)<65));N-=(t>1)*all(t%x for x in range(2,t))
print b

एल्गोरिथ्म बहुत अधिक कुशल हो सकता है। विशेष रूप से, मौलिकता (t>1)*all(t%x for x in range(2,t))संभावित कारकों की जांच सभी तरह से करती है t-1, जब वास्तव में इसे केवल वर्गमूल के तल तक जांचना होगा । के बाद से rangeअजगर 2 में स्मृति में भंडार एक पूरी सूची है, एक को यह सुराग MemoryErrorपर N=17(मेरी मशीन पर डिफ़ॉल्ट सेटिंग का उपयोग)।

— mathmandan
स्रोत

2

रूबी, 160 बाइट्स

->i{t,o,k=[],[],0;f=->n{t[n]||=n<3?1:f[n-2]+f[n-1]};(r=('%x'%f[k]).scan(/\d/).join.to_i;(r>1&&(r==2||(2...r).none?{|j|r%j==0}))&&o<<r;k+=1)while !o[i-1];t[k-1]}

Ungolfed:

-> i {
  t, o, k = [], [], 0
  f = -> n {
    t[n] ||= n < 3 ? 1 : f[n-2] + f[n-1]
  }
  while !o[i-1] do
    r=('%x'%f[k]).scan(/\d/).join.to_i
    o << r if (r > 1 && (r == 2 || (2...r).none?{|j| r%j == 0 }))
    k+=1
  end
  t[k-1]
}

उपयोग:

# Assign the anonymous function to a variable
m = ->i{t,o,k=[],[],0;f=->n{t[n]||=n<3?1:f[n-2]+f[n-1]};(r=('%x'%f[k]).scan(/\d/).join.to_i;(r>1&&(r==2||(2...r).none?{|j|r%j==0}))&&o<<r;k+=1)while !o[i-1];t[k-1]}

m[2]
=> 3
m[19]
=> 7540113804746346429

— वासु अडारी
स्रोत

2

आर, 164 बाइट्स

g=function(n){f=function(m)ifelse(m<3,1,f(m-1)+f(m-2));p=0;while(n){p=p+1;x=gsub("\\D","",sprintf("%x",f(p)));x[x==""]=1;y=1:x;if(sum(!tail(y,1)%%y)==2)n=n-1};f(p)}

नई लाइनों के साथ प्रस्तुत:

g=function(n){
    f = function(m)ifelse(m<3,1,f(m-1)+f(m-2)) #Fibonacci function
    p = 0
    while(n){
        p = p+1
        x = gsub("\\D","",sprintf("%x",f(p))) #To Hex, and get rid of non-digits
        x[x==""] = 1 #If x is empty string
        y = 1:x #Converts to integer(!) and save the 1-to-x sequence to a variable
        if(sum(!tail(y,1)%%y)==2) n = n-1 #If prime, decrements counter
        }
    f(p)
    }

उदाहरण:

> g(1)
[1] 2
> g(5)
[1] 89
> g(10)
[1] 121393
> g(12)
[1] 5702887

— plannapus
स्रोत

Nth Fibohexaprime का पता लगाएं

पायथ, 27 बाइट्स

MATL , 28 बाइट्स

उदाहरण

व्याख्या

सीजेएम, 28 बाइट्स

व्याख्या

पर्ल 6 , 62 बाइट्स

गणितज्ञ 111 बाइट्स

जूलिया, 123 बाइट्स

जीएपी , 204 बाइट्स

सी, 186 183 बाइट्स

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

रूबी, 160 बाइट्स

आर, 164 बाइट्स