একটি রোকো নম্বর খুঁজুন


12

আমাকে একটি সাক্ষাত্কারে এই প্রশ্ন জিজ্ঞাসা করা হয়েছিল তবে আমি কোনও সমাধান বের করতে পারিনি। প্রশ্নটি ঠিক ছিল কি না জানি না। আমি অনেক চেষ্টা করেছি কিন্তু কোন সমাধানে পৌঁছতে পারিনি। সত্যি কথা বলতে কি কিছুই মনে আসে নি।

রোকো সংখ্যা

ধনাত্মক পূর্ণসংখ্যা হল একটি রোকো সংখ্যা, যদি এটি বা , যেখানে একটি মৌলিক সংখ্যা।এনএন=পি(পি+ +14)এন=পি(পি-14)পি

প্রথম 10 রোক্কো নম্বর হ'ল:

32,51,95,147,207,275,351,435,527,627

কার্য

আপনার কোডটি অবশ্যই ইনপুট হিসাবে ইতিবাচক পূর্ণসংখ্যাকে গ্রহণ করতে হবে এবং এটি কোনও রোকো নম্বর কিনা তা নির্ধারণ করতে হবে।

ব্রাউন পয়েন্টস

  • এমন একটি ফাংশন লিখুন যা রোককো সংখ্যাগুলির সংখ্যা 10 মিলিয়ন বা তার চেয়ে কম সমান গণনা করে এবং মুদ্রণ করে।
  • এমন একটি ফাংশন লিখুন যা বোনাস প্রশ্ন থেকে রোকো সংখ্যা গণনা এবং মুদ্রণযোগ্য যা মুখ্য (

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

3
আউটপুটটি একটি পূর্ণসংখ্যা হবে : ইনপুটটি রোকো নম্বর ছিল কিনা তার জন্য আপনি কি বুলিয়ান বোঝাতে চাইছেন না?
অ্যাডাম

5
বোনাস 2: print 0। সমস্ত রোকো সংখ্যা সংমিশ্রিত (n*..), সুতরাং কোনও ব্যাপ্তিতে প্রাইম নেই।
TFeld

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

5
আমি প্রশ্ন এবং ট্যাগগুলি সম্পাদনা করেছি। আপনি যদি রাজি না হন তবে নির্দ্বিধায় রোলব্যাক করুন বা আরও সম্পাদনা করুন। @ এরিকথ আউটগল্ফার যেমন বলেছিলেন, আমি মনে করি বোনাসগুলি অপসারণ করা উচিত।
আর্নৌল্ড

উত্তর:


10

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

রিটার্নস 1 যদি এন একটি রোকো নম্বর, বা হয় 0 অন্যথায়।

fDŠ/α14å

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

কিভাবে?

প্রদত্ত একটি ধনাত্মক পূর্ণসংখ্যা এন , আমরা পরীক্ষা কোন মৌলিক উত্পাদককে অস্তিত্ব আছে কিনা পি এর এন যেমন যে:

|পি-এনপি|=14

মন্তব্য

fDŠ/α14å  # expects a positive integer n as input       e.g. 2655
f         # push the list of unique prime factors of n  -->  2655, [ 3, 5, 59 ]
 D        # duplicate it                                -->  2655, [ 3, 5, 59 ], [ 3, 5, 59 ]
  Š       # moves the input n between the two lists     -->  [ 3, 5, 59 ], 2655, [ 3, 5, 59 ]
   /      # divide n by each prime factor               -->  [ 3, 5, 59 ], [ 885, 531, 45 ]
    α     # compute the absolute differences
          # between both remaining lists                -->  [ 882, 526, 14 ]
     14å  # does 14 appear in there?                    -->  1

11

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

n=>(g=k=>k>0&&n%--k?g(k):k==1)(n=(49+n)**.5-7)|g(n+=14)

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

কিভাবে?

একটি ধনাত্মক পূর্ণসংখ্যা এন , আমরা একটি প্রাইম এক্স সন্ধান করছি যেমন এক্স(এক্স+ +14)=এন বা এক্স(এক্স-14)=এন

সুতরাং নিম্নলিখিত চতুষ্কোণ সমীকরণ:

(1)এক্স2+ +14এক্স-এন=0
(2)এক্স2-14এক্স-এন=0

(1) এর ইতিবাচক মূলটি হ'ল:

এক্স0=49+ +এন-7

এবং (2) এর ইতিবাচক মূলটি হ'ল:

এক্স1=49+ +এন+ +7

সুতরাং, এক্স0 বা এক্স1 হয় প্রধান কিনা তা পরীক্ষার সমতুল্য ।

এটি করার জন্য, আমরা ক্লাসিক পুনরাবৃত্তিমূলক প্রাথমিকতা পরীক্ষা ফাংশনটি ব্যবহার করি, এটির জন্য একটি অতিরিক্ত পরীক্ষা দিয়ে নিশ্চিত করা হয় যে এটি চিরতরে লুপ না করে যদি এটি ইনপুট হিসাবে অযৌক্তিক সংখ্যা দেওয়া হয়।

g = k =>    // k = explicit input; this is the divisor
            // we assume that the implicit input n is equal to k on the initial call
  k > 0 &&  // abort if k is negative, which may happen if n is irrational
  n % --k ? // decrement k; if k is not a divisor of n:
    g(k)    //   do a recursive call
  :         // else:
    k == 1  //   returns true if k is equal to 1 (n is prime)
            //   or false otherwise (n is either irrational or a composite integer)

প্রধান মোড়ক ফাংশন:

n => g(n = (49 + n) ** .5 - 7) | g(n += 14)


6

Regex (ECMAScript), 64 62 বাইট

একটিএকটি+ +14এন=একটি(একটি+ +14)একটিএকটি+ +14

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

গুণটি অ্যালগরিদমটি এখানে আলাদাভাবে প্রয়োগ করা হয়েছে কারণ আমরা দৃ are় প্রতিজ্ঞাবদ্ধ হচ্ছি যে দুটি জ্ঞাত মান একসাথে আরও একটি জ্ঞানের মানের সমান হয় (একই সাথে একটি সংখ্যার জন্য নিখুঁত বর্গ হিসাবে পরীক্ষা করার জন্য, এই পোস্টে রেজেক্সের বিকল্প সংস্করণেও করা হয় )। এখনও অবধি আমার পোস্ট হওয়া অন্যান্য বেশিরভাগ উত্তরগুলিতে, গুণকে গণনা হিসাবে প্রয়োগ করা হয় (দৃ an়ভাবে বলা হয় না, ধারণাভাবে বলা হয়) যেখানে লক্ষ্য হল দুটি পরিচিত সংখ্যার গুণফল খুঁজে পাওয়া। উভয় পদ্ধতি উভয় পরিস্থিতিতেই কাজ করে তবে গল্ফ বুদ্ধিমান একে অপরের কাজ করতে খারাপ হয়।

^(?=(x((x{14})(x+)))(?=(\1*)\4\2*$)(\1*$\5))\6\3?(?!(xx+)\7+$)

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


 # For the purposes of these comments, the input number = N.
 ^
 # Find two numbers A and A+14 such that A*(A+14)==N.
 (?=
     (x((x{14})(x+)))   # \1 = A+14; \2 = \1-1; \3 = 14; \4 = A-1; tail -= \1
     (?=                # Assert that \1 * (\4+1) == N.
         (\1*)\4\2*$    # We are asserting that N is the smallest number satisfying
                        # two moduli, thus proving it is the product of A and A+14
                        # via the Chinese Remainder Theorem. The (\1*) has the effect
                        # of testing every value that satisfies the "≡0 mod \1"
                        # modulus, starting with the smallest (zero), against "\4\2*$",
                        # to see if it also satisfies the "≡\4 mod \2" modulus; if any
                        # smaller number satisfied both moduli, (\1*) would capture a
                        # nonzero value in \5. Note that this actually finds the
                        # product of \4*\1, not (\4+1)*\1 which what we actually want,
                        # but this is fine, because we already subtracted \1 and thus
                        # \4*\1 is the value of tail at the start of this lookahead.
                        # This implementation of multiplication is very efficient
                        # golf-wise, but slow, because if the number being tested is
                        # not even divisible by \1, the entire test done inside this
                        # lookahead is invalid, and the "\1*$" test below will only
                        # fail after this useless test has finished.
     )
     (\1*$\5)           # Assert that the above test proved \1*(\4+1)==N, by
                        # asserting that tail is divisible by \1 and that \5==0;
                        # \6 = tool to make tail = \1
 )
 # Assert that either A or A+14 is prime.
 \6                     # tail = \1 == A+14
 \3?                    # optionally make tail = A
 (?!(xx+)\7+$)          # Assert tail is prime. We don't need to exclude treating
                        # 1 as prime, because the potential false positive of N==15
                        # is already excluded by requiring \4 >= 1.
 


3

ব্র্যাচল্যাগ , 13 12 বাইট

ṗ;14{+|-};?×

কমান্ড-লাইন আর্গুমেন্ট হিসাবে প্রার্থী নম্বর লিখুন। আউটপুট trueবা falseএটি অনলাইন চেষ্টা করুন!

ব্যাখ্যা

কোডটি এমন একটি শিকারী যাঁর ইনপুট নিয়ন্ত্রণহীন এবং যার আউটপুট সেই নম্বরটি আমরা পরীক্ষা করছি।

ṗ             Let the input ? be a prime number
 ;14          Pair it with 14, yielding the list [?, 14]
    {+|-}     Either add or subtract, yielding ?+14 or ?-14
         ;?   Pair the result with the input, yielding [?+14, ?] or [?-14, ?]
           ×  Multiply; the result must match the candidate number

(টিপস স্বাগত জানাই। এটি {+|-}এখনও বিশৃঙ্খল বোধ করে।)


3

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

বিভিন্ন পদ্ধতির পরে DLosc এর উত্তর

Ċ-14&∋ṗ&×

N কে আউটপুট হিসাবে নিয়ে যায়, [P, P-14] বা [P + 14, P] ইনপুট দিয়ে ফিরে আসে (প্রথম বৃহত্তম সংখ্যা)

ব্যাখ্যা

Ċ              # The 'input' is a pair of numbers
 -14           #   where the 2nd is 14 smaller then the first
    &∋ṗ        #   and the pair contains a prime
       &×      #   and the numbers multiplied give the output (N)

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


2

পাইথ, 22 20 বাইট

}Qsm*Ld+Ld_B14fP_TSh

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

}Qsm*Ld+Ld_B14fP_TShQ   Implicit: Q=eval(input())
                        Trailing Q inferred
                  ShQ   Range [1-(Q+1)]
              fP_T      Filter the above to keep primes
   m                    Map the elements of the above, as d, using:
          _B14            [14, -14]
       +Ld                Add d to each
    *Ld                   Multiply each by d
  s                     Flatten result of map
}Q                      Is Q in the above? Implicit print

সম্পাদনা: ইনপুট হিসাবে 3 বাইট সংরক্ষণ করা সর্বদা ইতিবাচক হবে, সুতরাং তালিকা থেকে নেতিবাচক মানগুলি ফিল্টার করার দরকার নেই। ইনপুটগুলির জন্য একটি বাগও স্থির করে 1এবং 21 বাইটের মূল্য। পূর্ববর্তী সংস্করণ:}Qsm*Ld>#0+Ld_B14fP_TU


2

05 এ বি 1 , 16 15 14 বাইট

এর পরিবর্তে 14 গণনা করে 1 বাইট সংরক্ষণ করা হয়েছে žvÍ(আমি বিশ্বাস করি না যে আমি এটি প্রথম স্থানে ভাবিনি)।

এমিগিনার প্রতি 1 বাইট সংরক্ষণ করা হয়েছে

ÅPε7·D(‚+y*Q}Z

এটি অনলাইন চেষ্টা করুন! বা সমস্ত ইনপুট পরীক্ষা করুন

ব্যাখ্যা

                 # Implicit input n
ÅP               # Push a list of primes up to n
  ε         }    # For each prime in the list...
   7·            # Push 14 (by doubling 7)
     D(‚         # Push -14 and pair them together to get [14,-14]
        +        # Add [14,-14] to the prime
         y*      # Multiply the prime to compute p(p-14) and p(p+14)
           Q     # Check if the (implicit) input is equal to each element
             Z   # Take the maximum

1
আপনি পরিবর্তন করে একটি বাইট সংরক্ষণ করতে পারবেন }˜såকরার Q}Zঅন্তর্নিহিত ইনপুট ব্যবহার। আপনার টেস্ট-স্যুটটি তখন এটির কাজ করার জন্য এই জাতীয় কিছুতে কিছুটা পরিবর্তন করতে হবে । এছাড়াও, লেখার আরও সুস্পষ্ট উপায় žvÍবা হবে 14;)
এমিগিনা

ধন্যবাদ! যখন আপনি সবচেয়ে জটিল উপায়ে / ফেসপালমে 14 টি চাপতে পারেন তখন কেন এটি সহজ করবেন :)
উইসোয়া


2

রেটিনা 0.8.2 , 61 বাইট

.+
$*
^((1{14})1(1)+)(?<=(?<!^\4+(..+))\2?)(?<-3>\1)+$(?(3)1)

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

.+
$*

অ্যানারিতে রূপান্তর করুন।

^((1{14})1(1)+)

\1দুটি কারণের বৃহত্তর ধারন করে। \2একটি বাইট সংরক্ষণ করে ধ্রুবক 14 টি ক্যাপচার করে। \3বিয়োগ 1 টি দুটি কারণের চেয়ে ছোটটিকে ক্যাপচার করে This এটিও নিশ্চিত করে যে উভয় উপাদান কমপক্ষে 2।

(?<=(?<!^\4+(..+))\2?)

এর মধ্যে কমপক্ষে একটি প্রধান বিষয় নিশ্চিত করার জন্য দুটি কারণ পরীক্ষা করে দেখুন Check \2?@ ডেডকোডের উত্তরটি ব্যবহারের ধারণাটি নির্লজ্জভাবে চুরি হয়েছিল।

(?<-3>\1)+

দুটি কারণের চেয়ে বড়টির পুনরাবৃত্তি করুন দুটি কারণের চেয়ে ছোটটির চেয়ে এক বারের সমান। যেহেতু আমরা ইতিমধ্যে একবারে বৃহত্তর ফ্যাক্টরটি ক্যাপচার করেছি তারপরে শেষ হয় দুটি কারণের পণ্য ক্যাপচার করার জন্য।

$(?(3)1)

নিশ্চিত করুন যে পণ্যটি প্রদত্ত সংখ্যার সমান।

এর $*সাথে প্রতিস্থাপন করে রেটিনা 1 এর সরাসরি অনুবাদে *1একই বাইট গণনা থাকবে তবে সমস্ত বকে 1এস দ্বারা প্রতিস্থাপন করে একটি বাইট সংরক্ষণ করা যায় _এবং তার *1পরিবর্তে এর *পরিবর্তে প্রতিস্থাপন করা যেতে পারে *_। আগের রেটিনা 1 উত্তর 68 বাইটের জন্য:

.+
*
Lw$`^(__+)(?=(\1)+$)
$1 _$#2*
Am` (__+)\1+$
(_+) \1

0m`^_{14}$

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

.+
*

অ্যানারিতে রূপান্তর করুন।

Lw$`^(__+)(?=(\1)+$)
$1 _$#2*

সমস্ত সংখ্যক কারণের সন্ধান করুন।

Am` (__+)\1+$

নিশ্চিত করুন যে একটি প্রধান।

(_+) \1

নিখুঁত পার্থক্য নিন।

0m`^_{14}$

কোনও 14 আছে কিনা তা পরীক্ষা করে দেখুন।


1

জাভাস্ক্রিপ্ট (ব্যাবেল নোড) , 69 বাইট

অভিশাপ, আমি যদিও আর্নল্ডসের জবাব দিতে যাচ্ছিলাম কিন্তু না .....: সি

x=>[...Array(x)].some((a,b)=>x/(a=(p=n=>--b-1?n%b&&p(n):n)(b))-a==14)

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

আমি x=>[...Array(x)].some(পুনরাবৃত্তি ব্যবহার করে অংশটি থেকে মুক্তি পেতে চাই যাতে এটি সময়ের সাথে সংক্ষিপ্ত হতে পারে

ব্যাখ্যা

x=>[...Array(x)]                                                              Creates a range from 0 to x-1 and map:

                .some((a,b)=>                                                 Returns True if any of the following values is true
                             x/                                              Input number divided by
                                (a=(p=n=>--b-1?n%b&&p(n):n)(b))               recursive helper function. Receives a number (mapped value) as parameters and returns 
                                                                              the same number if it is prime, otherwise returns 1. Take this value
                                                                              and assign to variable a
                                                               -a            Subtract a from the result  
                                                                     ==14    Compare result equal to 14

এটি সূত্র ব্যবহার করে

এন/পি-পি==14




1

এপিএল (এনএআরএস) 16 টি চর, 32 বাইট

{14=∣r-⍵÷r←↑⌽π⍵}

argument π⍵} তার যুক্তির কার্যকারিতা আবিষ্কার করবে এবং আমরা অনুমান করি যে এর ফলাফলের শেষ উপাদানটি (n এর বিভাজকের তালিকা) n এর সর্বোচ্চ প্রধান বিভাজক; এখানে আমরা ধরে নিই যে রোকো সংখ্যার সমতুল্য সংজ্ঞাটি হ'ল: এন হ'ল একটি রোকো সংখ্যা <=> এন এর সর্বোচ্চ ফ্যাক্টর প্রাইম: r এর মতো এটি সত্য 14 = ∣rn÷ r [সি সিউডোকোডের জন্য 14 == অ্যাবস (আরএন) / r) রোকো সংখ্যার এই সংজ্ঞাটি 1..1000000 এর মধ্যে পরিশেষে ঠিক আছে বলে মনে হচ্ছে]; ওকে মানটির পরিসীমা হবে 1..ম্যাক্স ইন্ট; পরীক্ষা:

 f←{14=∣r-⍵÷r←↑⌽π⍵}
 {⍞←{1=f ⍵:' ',⍵⋄⍬}⍵⋄⍬}¨1..10000
32  51  95  147  207  275  351  435  527  627  851  1107  1247  1395  1551  1887  2067  2255  2451  2655  2867  3551  4047  4307  4575  5135  5427  5727  6035  6351  6675  7347  8051  8787  9167  9951   

1

সি # (ভিজ্যুয়াল সি # ইন্টারেক্টিভ সংকলক) , 99 বাইট

n=>Enumerable.Range(2,n).Any(p=>Enumerable.Range(2,p).All(y=>y>=p|p%y>0)&(n==p*(p+14)|n==p*(p-14)))

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

Enumerable.Range আবার স্ট্রাইক করেছে :) উন্মাদ সংকলক পতাকা ব্যবহার করে আপনি জিনিসগুলিকে কিছুটা হ্রাস করতে পারবেন, যদিও আমি ভ্যানিলা দ্রবণটির এক অনুরাগী।

সি # (ভিজ্যুয়াল সি # ইন্টারেক্টিভ সংকলক ) + / আপনি: সিস্টেম.লিনক.অনুন্যযোগ্য, 77 বাইট

n=>Range(2,n).Any(p=>Range(2,p).All(y=>y>=p|p%y>0)&(n==p*(p+14)|n==p*(p-14)))

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

নীচে আরনাউল্ডের সমাধানের একটি বন্দর রয়েছে যা দেখতে দুর্দান্ত লাগছিল। এটি বর্তমানে দীর্ঘতম, তবে এটি সম্ভবত কিছু গল্ফ করা যেতে পারে।

সি # (ভিজ্যুয়াল সি # ইন্টারেক্টিভ সংকলক) , 101 বাইট

n=>{bool g(int k)=>--k<2?n>1:n%k>0&g(k);var d=Math.Sqrt(n+49)-7;return(n=(int)d)==d&(g(n)|g(n+=14));}

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


0

এপিএল (এনএআরএস) 30 টি চর, 60 বাইট

{∨/{0=1∣⍵:0π⍵⋄0}¨(7,¯7)+√49+⍵}

এখানে 0π হ'ল ফাংশনটি হ'ল যদি একটি সংখ্যা প্রধান হয়, তবে পরীক্ষা করুন:

 f←{∨/{0=1∣⍵:0π⍵⋄0}¨(7,¯7)+√49+⍵}
 {⍞←{1=f ⍵:' ',⍵⋄⍬}⍵⋄⍬}¨0..700
32  51  95  147  207  275  351  435  527  627

0

F #, 2 টি উত্তর (নন-কেপটেটিং)

আমি @ আরনাউল্ডের উত্তরগুলি সত্যিই পছন্দ করেছি, তাই আমি তাদের অনুবাদ করেছি।

জাভাস্ক্রিপ্ট উত্তরের উপর ভিত্তি করে 123 বাইট

fun n->let t=int<|sqrt(float n+49.)in Seq.map(fun n->Seq.filter(fun i->n%i=0)[1..n]|>Seq.length=2)[t-7;t+7]|>Seq.reduce(||)

ব্যাখ্যা:

fun n->let t=int<|sqrt(float n+49.)in Seq.map(fun n->Seq.filter(fun i->n%i=0)[1..n]|>Seq.length=2)[t-7;t+7]|>Seq.reduce(||) //Lambda which takes an integer, n
       let t=int<|sqrt(float n+49.)                                                                                         //let t be n, converted to float, add 49 and get square root, converted back to int (F# type restrictions)
                                   in                                                                                       //in the following...
                                                                                                  [t-7;t+7]                 //Subtract and add 7 to t in a list of 2 results (Lists and Seqs can be interchanged various places)
                                      Seq.map(fun n->Seq.filter(fun i->n%i=0)[1..n]|>Seq.length=2)                          //See if either are prime (here, if either result has 2 and only 2 divisors)
                                                                                                           |>Seq.reduce(||) //And logically OR the resulting sequence

05AB1E উত্তরের উপর ভিত্তি করে 125 বাইট

fun n->let l=Seq.filter(fun i->n%i=0)[2..n-1]in let m=Seq.map(fun i->n/i)l in Seq.map2(fun a b->abs(a-b))l m|>Seq.contains 14

ব্যাখ্যা:

fun n->let l=Seq.filter(fun i->n%i=0)[2..n-1]in let m=Seq.map(fun i->n/i)l in Seq.map2(fun a b->abs(a-b))l m|>Seq.contains 14  //Lambda which takes an integer, n
       let l=Seq.filter(fun i->n%i=0)[2..n-1]                                                                                  //let l be the list of n's primes 
                                             in                                                                                //in...
                                                let m=Seq.map(fun i->n/i)l                                                     //m, which is n divided by each of l's contents
                                                                           in                                                  //and then...
                                                                              Seq.map2(fun a b->abs(a-b))l m                   //take the absolute difference between each pair of items in the two sequences to make a new sequence
                                                                                                            |>Seq.contains 14  //and does the resulting sequence contain the number 14?

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