_{इस नंबरफाइल प्रविष्टि से प्रेरित}

पृष्ठभूमि

किसी पूर्णांक n की घन दूरी की संख्या यहाँ पूर्णांक के सेट के रूप में परिभाषित की गई है जो किसी दिए गए x के लिए x distance की दूरी पर है । एक साधारण उदाहरण के लिए, के साथ और , घन दूरी संख्या हैं ।n=100x=2{92,108}

यह अलग-अलग एक्स द्वारा अलग-अलग सेट में बढ़ाया जा सकता है । साथ x ∈ {1,2,3,4}और एक ही n=100है, हम उसके एवज में सेट है {36,73,92,99,101,108,127,164}।

आइए CD (n, x) को सभी पूर्णांकों के सेट के रूप में परिभाषित n ± z³करें z ∈ {1,2,3,...,x}।

अब हम इन घन दूरी संख्याओं के कुछ विशेष गुणों पर ध्यान केंद्रित कर सकते हैं । कई विशेष गुणों में से जो संख्याएँ हो सकती हैं, उनमें से जिन दो गुणों में हम रुचि रखते हैं, वे हैं प्राइमलिटी और प्राइम डिविज़र्स ।

उपरोक्त उदाहरण के लिए सीडी (100,4) , ध्यान दें कि 73, 101, 127सभी प्रमुख हैं। यदि हम उन्हें सेट से हटा देते हैं, तो हम साथ रह जाते हैं {36,92,99,108,164}। इन संख्याओं के सभी प्रधान भाजक (क्रम में) हैं {2,2,3,3,2,2,23,3,3,11,2,2,3,3,3,2,2,41}, जिसका अर्थ है कि हमारे पास 5 अलग-अलग प्रधान भाजक हैं {2,3,23,11,41}। इसलिए हम यह परिभाषित कर सकते हैं कि सीडी (100,4) में ¹ की उग्रता है ।5

यहाँ चुनौती सबसे कम बाइट्स में एक फ़ंक्शन या प्रोग्राम लिखने की है, जो किसी दिए गए इनपुट की उग्रता को उत्पन्न करता है।

इनपुट

दो सकारात्मक पूर्णांक, nऔर x, किसी भी सुविधाजनक प्रारूप में।

उत्पादन

CD (n, x) के साथ परिकलित होने पर एक एकल पूर्णांक दो इनपुट नंबरों की उग्रता का वर्णन करता है ।

नियम

इनपुट / आउटपुट किसी भी उपयुक्त विधि से हो सकता है ।
मानक ढील प्रतिबंध लागू होते हैं।
गणना में आसानी के लिए, आप मान सकते हैं कि इनपुट डेटा ऐसा होगा कि सीडी (n, x) के सेट में केवल सकारात्मक संख्याएं होंगी (यानी, कोई सीडी (n, x) कभी नकारात्मक संख्या या शून्य नहीं होगी)।
फ़ंक्शन या प्रोग्राम इनपुट संख्याओं को संभालने में सक्षम होना चाहिए ताकि n + x³आपकी भाषा के मूल पूर्णांक डेटा प्रकार में फिट हो। उदाहरण के लिए, 32-बिट हस्ताक्षरित पूर्णांक प्रकार के लिए, सभी इनपुट नंबर n + x³ < 2147483648संभव हैं।

उदाहरण

n,x   - output
2,1   - 0   (since CD(2,1)={1,3}, distinct prime divisors={}, ravenity=0)
5,1   - 2
100,4 - 5
720,6 - 11

फुटनोट

1 - इसलिए नाम दिया गया क्योंकि हम सेट के कार्डिनल इट में रुचि नहीं रखते हैं , लेकिन एक अलग प्रकार का पक्षी है। चूंकि हम "सामान्य" विभाजकों के साथ काम कर रहे हैं, इसलिए मैंने सामान्य रैवेन का उपयोग करना चुना ।

— AdmBorkBork
स्रोत

100,4उपज 5 कैसे होती है? उस सेट की घन दूरी संख्याएँ हैं 36,164, और उस सेट के मुख्य कारक हैं 2,3,41(क्योंकि उस सेट के कारक क्रमशः {2, 3, 4, 6, 9, 12, 18, 36}और {2, 4, 41, 82, 164}हैं)। इसलिए, आउटपुट 3 होना चाहिए, न कि 5.

— आर। काप

2

@ R.Kap 100,4उदाहरण है जिसे ओपी पृष्ठभूमि अनुभाग में बताता है। आपका ग़लती के रूप में है कि आप सभी पर विचार करना चाहिए लगता है 1..xतो, [1,2,3,4]इस मामले के लिए।

— FryAmTheEggman

@FryAmTheEggman ओह। ठीक है। मुझे ये अब मिला।

— आर। काप

क्या इसका उच्चारण [ruh-VEE-nuh-tee] (या / r pronviːn thoseti / आपमें से जो IPA पढ़ते हैं) के लिए किया जाएगा?

— लीक नून

1

@ केनीलाऊ मेरे सिर में, मैंने इसे "राह-

— विन

4

जेली, 16 बाइट्स

ŒRḟ0*3+µÆfFœ-µQL

उस क्रम में x और n को कमांड-लाइन तर्क के रूप में लेता है । इसे ऑनलाइन आज़माएं!

यह काम किस प्रकार करता है

ŒRḟ0*3+µÆfFœ-µQL  Main link. Arguments, x, n

ŒR                Range; yield [-x, ..., x].
  ḟ0              Filter out 0.
    *3            Cube each remaining integer.
      +           Add n to all cubes.
       µ          Begin a new, monadic link. Argument: A (list of sums)
        Æf        Factorize each k in A.
          F       Flatten the resulting, nested list.
           œ-     Perform multiset difference with A.
                  If k in A is prime, Æf returns [k], adding on k too many to the
                  flat list. Multiset difference with A removes exactly one k from
                  the results, thus getting rid of primes.
                  If k is composite (or 1), it cannot appear in the primes in the
                  flat list, so subtracting it does nothing.
             µ    Begin a new, monadic link. Argument: D (list of prime divisors)
              Q   Unique; deduplicate D.
               L  Compute the length of the result.

— डेनिस
स्रोत

4

पायथ - 21 19 18 बाइट्स

मुझे आश्चर्य है कि अगर कोई चाल है।

l{st#mP+Q^d3s_BMSE

टेस्ट सूट ।

l                   Length
 {                  Uniquify
  s                 Combine divisor lists
   t#               Filter by if more than one element
     PM             Take prime factorization of each number
       +RQ          Add each num in list to input
          s_BM      Each num in list and its negative (with bifurcate)
              ^R3   Cube each num in list
                 SE Inclusive unary range - [1, 2, 3,... n] to input

— Maltysen
स्रोत

3

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

f(n,x)=endof(∪(foldl(vcat,map(k->[keys(factor(k))...],filter(i->!isprime(i),[n+z^3for z=[-x:-1;1:x]])))))

यह एक फ़ंक्शन है जो दो पूर्णांकों को स्वीकार करता है और एक पूर्णांक लौटाता है।

Ungolfed:

function f(n, x)
    # Get all cube distance numbers
    cubedist = [n + z^3 for z = [-x:-1; 1:x]]

    # Filter out the primes and zeros
    noprimes = filter(i -> !isprime(i) && i > 0, cubedist)

    # Factor each remaining number
    factors = map(k -> [keys(factor(k))...], noprimes)

    # Flatten the list of factors
    flat = foldl(vcat, factors)

    # Return the number of unique elements
    return endof(∪(flat))
end

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

युक्ति को अद्यतन किया गया है; आपको अब 0 के बारे में चिंता करने की ज़रूरत नहीं है।

— डेनिस

@ डेनिस नाइस, सिर ऊपर करने के लिए धन्यवाद।

— एलेक्स ए।

2

05AB1E , 20 19 बाइट्स

कोड:

L3mD(«-Dp_Ïvyf`})Úg

के रूप में इनपुट x, n। CP-1252 एन्कोडिंग का उपयोग करता है ।

इसे ऑनलाइन आज़माएं!

— अदनान
स्रोत

2

MATL , 21 बाइट्स

:3^t_h+tZp~)"@Yf!]vun

इनपुट x, nएक नई लाइन द्वारा अलग किया गया है।

इसे ऑनलाइन आज़माएं!

व्याख्या

:       % take n implicitly. Generate [1,2,...,n]
3^      % raise to 3, element-wise
t_h     % duplicate, negate, concatenate horizontally: [1,2,...,n,-1,2,...-n]
+       % take x implicitly. Add to that array
t       % duplicate
Zp      % array that contains true for primes
~       % logical negate
)       % apply index to keep only non-primes
"       % for each number in that array
  @     %   push that number
  Yf!   %   prime factors, as a column array
]       % end for each
v       % concatenate vertically all factors
u       % remove repeated factors
n       % number of elements of that array. Implicitly display

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

2

जे, 30 बाइट्स

#@~.@(,@:q:-.0&,)@:+(|#^&3)@i:

यह एक डाईडिक क्रिया है, जिसका उपयोग इस प्रकार है:

   f =: #@~.@(,@:q:-.0&,)@:+(|#^&3)@i:
   100 f 4
5

इसे यहाँ आज़माएँ।

व्याख्या

#@~.@(,@:q:-.0&,)@:+(|#^&3)@i:
                            i:  Range from -x to x
                    (     )@    Apply this verb to the range:
                       ^&3        a) every item cubed
                     |            b) absolute value of every item
                      #           c) every item in a) repeated b) times; this removes 0
                                     and produces some harmless duplication
                   +            Add n to every element of the resulting list
     (          )@:             Apply this verb to the resulting vector:
             0&,                  a) the vector with 0 appended
      ,@:q:                       b) flat list of prime divisors in the vector
                                     (and some extra 0s since we flatten an un-even matrix)
           -.                     c) list b) with elements of a) removed; this gets rid of
                                     the extra 0s and all primes that were in the list
#@~.@                           Remove duplicates and take length

— Zgarb
स्रोत

2

@:+(इतना उदास, भयानक-बाल-लड़का क्यों?

— AdmBorkBork

कृपया जवाब में TIO से लिंक करें?

— R

@EasterlyIrk TIO में J. नहीं है। मैं tryj.tk का लिंक जोड़ूंगा।

— जर्गर्ब

@ ज़र्ब ओकाई .___

— Rgar

2

पायथन 3.5, 218 198 बाइट्स:

( मुझे 20 बाइट बचाने के लिए @ धन्यवाद पर धन्यवाद।)

lambda r,n:len({z for z in{v for f in{t for u in[[r-q**3,r+q**3]for q in range(1,n+1)]for t in u if any(t%g<1 for g in range(2,t))}for v in range(2,f)if f%v<1}if all(z%g>0 for g in range(2,z))})

एक अच्छा एक-पंक्तिवाला लैम्ब्डा फ़ंक्शन, हालांकि यह थोड़ा लंबा हो सकता है। चूंकि मैं पायथन का उपयोग कर रहा था, इसलिए मुझे पहले चरण के लिए कंपोजिट खोजने का अपना तरीका अपनाना पड़ा, और फिर अंतिम चरण के लिए प्राइम डिविजर्स, इसलिए यह बहुत आसान नहीं था, और यह सबसे छोटा मैं था, खुद के द्वारा । को मिल सकता है। बहरहाल, यह वही करता है जिसकी उसे आवश्यकता है, और मुझे इस पर गर्व है। :) हालाँकि, इसे थोड़ा और नीचे गिराने के किसी भी सुझाव का स्वागत है।

— आर। कप
स्रोत

युगल चीजें: == 0 का उपयोग न करें, <1 का उपयोग करें, और! = 0,> 0 के लिए। इसके अलावा, अंत में z% 1 और z% z क्यों है? ऐसा लगता है कि वे हमेशा सच होंगे।

— ब्लू '

@ मुझे बताओ, तुम सही हो। वे हमेशा सच होंगे, इसलिए उस हिस्से की भी जरूरत नहीं है। इसलिए, मैं इसे हटा दूंगा। और भी, उन अन्य सुझावों के लिए धन्यवाद! :)

— आर। कप

1

PARI / GP , 79 बाइट्स

(n,x)->omega(factorback(select(k->!isprime(k),vector(2*x,i,n+(i-(i<=x)-x)^3))))

यहाँ मेरा मूल सीधा कार्यान्वयन है। ऊपर दिया गया अनुकूलित संस्करण दो वैक्टरों को एक एकल, थोड़ा अधिक जटिल वेक्टर में जोड़ता है।

(n,x)->omega(factorback(select(k->!isprime(k),concat(vector(x,i,n-i^3),vector(x,i,n+i^3)))))

— चार्ल्स
स्रोत

यह वाकई दिलचस्प है। मुझे लगता है कि कोड को आज़माने के लिए एक इन-ब्राउज़र लिंक है, लेकिन मुझे यकीन नहीं है कि वास्तव में इनपुट कैसे जमा किया जाए। क्या आप एक स्पष्टीकरण प्रदान कर सकते हैं?

— AdmBorkBork

@ टिमिमड: यदि आप उपरोक्त में से कोई भी f(जैसे f=(n,x)->...) असाइन करते हैं तो आप इसके साथ परीक्षण कर सकते हैं f(100,4)। वैकल्पिक रूप से, आप इसे एक पंक्ति में लागू कर सकते हैं ((n,x)->...)(100,4)।

— चार्ल्स

1

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

->(n,x){require'prime'
v=((-x..x).to_a-[0]).map{|i|n+i**3}.reject{|e|Prime.prime?(e)}
Prime.each(v[-1]).select{|i|v.any?{|e|e%i==0}}.size}

यह एक दंड की चुनौती थी। :-)

— jose_castro_arnaud
स्रोत

वे गंभीरता से रूबी में primes खोजने के लिए एक तरह से बनाया गया है? वाह ... मुझे विश्वास नहीं हो रहा है कि पायथन के पास ऐसा नहीं है।

— आर। काप

हाँ। रूबी-doc.org/stdlib-2.3.0/libdoc/prime/rdoc/Prime.html देखें - संस्करण 1.9.3 में भी काम करना चाहिए।

— jose_castro_arnaud

1

रूबी, 132 120 114 बाइट्स

मुझे अच्छी तरह पता है कि इस समाधान के लिए अभी भी बहुत से गोल्फिंग की आवश्यकता है। किसी भी गोल्फ टिप्स का स्वागत है।

require'prime'
->n,x{(-x..x).map{|i|j=n+i**3;j.prime?||(j==n)?[]:j.prime_division.map{|z|z[0]}}.flatten.uniq.size}

Ungolfing:

require 'prime'

def ravenity(n, x)
  z = []
  (-x..x).each do |i|
    j = n + i**3
    m = j.prime_division
    if j.prime? || j == n
      z << []
    else
      z << m.map{|q| q[0]}
    end
  return z.flatten.uniq.size
end

— Sherlock9
स्रोत

1

पायथन 3.5 - 177 175 159 बाइट्स

किसी भी गोल्फ युक्तियाँ का स्वागत करते हैं :)

a=range
p=lambda n:any(n%x<1for x in a(2,n))
r=lambda n,x:len(set(sum([[x for x in a(2,z+1)if z%x<1&1>p(x)]for z in filter(p,[n+z**3for z in a(-x,x+1)])],[])))

Ungolfed:

def is_composite(n):
    return any(n % x == 0 for x in range(2, n))

def prime_factors(n):
    return {x for x in range(2, n+1) if n % x == 0 and not is_composite(x)}

def ravenity(n, x):
    nums = [n + z**3 for z in range(-x, x+1)]
    nums = filter(is_composite, nums)
    factors = map(prime_factors, nums)
    factors = sum(factors, [])
    #remove duplicates
    factors = set(factors)
    return len(factors)

— टूमस लाककोनेन
स्रोत

0

वोल्फ्राम लैंग्वेज (गणितज्ञ) , 90 बाइट्स

Tr[1^Union[First/@Join@@FactorInteger/@Select[z=Range@#2^3;Join@@{#-z,#+z},Not@*PrimeQ]]]&

इसे ऑनलाइन आज़माएं!

un-golfed: कोड ज्यादातर दाईं से बाईं ओर पढ़ा जाता है,

F[n_, x_] := 
  Length[Union[                                        (* number of unique elements   *)
    First /@                                           (* drop multiplicities         *)
      Join @@                                          (* join all prime factor lists *)
        FactorInteger /@                               (* compute prime factors       *)
          Select[                                      (* select those...             *)
            Join @@ {n - Range[x]^3, n + Range[x]^3},  (* ...candidates...            *)
            Not@*PrimeQ]]]                             (* ...that are not prime       *)

— रोमन
स्रोत

क्यूब डिस्टेंस नंबरों की रेवेनिटी

पृष्ठभूमि

इनपुट

उत्पादन

नियम

उदाहरण

फुटनोट

जेली, 16 बाइट्स

यह काम किस प्रकार करता है

पायथ - 21 19 18 बाइट्स

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

05AB1E , 20 19 बाइट्स

MATL , 21 बाइट्स

व्याख्या

जे, 30 बाइट्स

व्याख्या

पायथन 3.5, 218 198 बाइट्स:

PARI / GP , 79 बाइट्स

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

रूबी, 132 120 114 बाइट्स

पायथन 3.5 - 177 175 159 बाइट्स

Ungolfed:

वोल्फ्राम लैंग्वेज (गणितज्ञ) , 90 बाइट्स