17

सूत्र

उदाहरण के लिए नंबर 300 को लीजिए

300 के प्रमुख कारक हैं [2, 3, 5](विशिष्ट संख्याएँ जो कि 300 और अभाज्य के कारक हैं)
उन संख्याओं में से प्रत्येक को चुकाना आपको देगा [4, 9, 25]
उस सूची को सारांशित करना आपको देगा 4 + 9 + 25 = 38
अंत में अपने मूल संख्या से उस राशि (38) को घटाएं 300-38 = 262(यह परिणाम है)

इनपुट

आपका इनपुट 2 से अधिक धनात्मक पूर्णांक होगा। आपको 2 से इनपुट मूल्य (समावेशी) तक की सभी संख्याओं की जाँच करनी चाहिए और वह संख्या ज्ञात करें जो उपरोक्त सूत्र के साथ सबसे बड़ा परिणाम उत्पन्न करती है।

उत्पादन

आपका आउटपुट एक स्पेस, कॉमा, न्यूलाइन या आप जो भी भाषा की अनुमति देता है, उससे अलग दो नंबर होंगे (दो नंबर को अलग करने के लिए अलगाव आवश्यक है)। ये किसी फ़ाइल, stdout, या आपकी भाषा का उपयोग करने के लिए आउटपुट हो सकते हैं। आपका लक्ष्य उस सीमा में संख्या को खोजना है जो ऊपर दिए गए सूत्र के माध्यम से चलने पर अधिकतम आउटपुट का उत्पादन करता है। प्रदर्शित पहली संख्या प्रारंभिक संख्या (जैसे 300) होनी चाहिए और दूसरी संख्या उस आउटपुट की होनी चाहिए जो कि उत्पादित सूत्र (जैसे 262) है

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

Input: 3       Output: 2, -2
Input: 10      Output: 8, 4
Input: 50      Output: 48, 35
Input: 1000    Output: 1000, 971
Input: 9999    Output: 9984, 9802

उदाहरण के माध्यम से काम किया

10 के इनपुट पर विचार करें, हमें 2-10 से सभी नंबरों के लिए फॉर्मूला चलाना चाहिए (समावेशी)

Num PrimeFacs PrimeFacs^2 SumPrimeFacs^2 Result
2   [2]       [4]         4              -2
3   [3]       [9]         9              -6
4   [2]       [4]         4               0
5   [5]       [25]        25             -20
6   [2, 3]    [4, 9]      13             -7
7   [7]       [49]        49             -42
8   [2]       [4]         4               4
9   [3]       [9]         9               0
10  [2, 5]    [4, 25]     29             -19

जैसा कि आप देख सकते हैं सबसे बड़ा परिणाम है 4, जो 8सूत्र में मूल्य को इनपुट करने का एक परिणाम था । इसका मतलब है कि इनपुट के लिए आउटपुट 10होना चाहिए8, 4

स्कोरिंग और नियम

इनपुट और आउटपुट के लिए डिफ़ॉल्ट नियम लागू होते हैं: कोड गोल्फ के लिए डिफ़ॉल्ट: इनपुट / आउटपुट विधियां
मानक कमियां निषिद्ध हैं: डिफ़ॉल्ट रूप से मना किए गए Loopholes
फ़ंक्शन या पूर्ण कार्यक्रम हो सकते हैं

बाइट्स में सबसे छोटा कोड जीतता है

— Keatinge
स्रोत

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

— मेगो

2

यदि अधिकतम परिणाम के लिए कई संख्याओं को बांधा जाता है तो क्या होना चाहिए?

— डेनिस

1

@ डेनिस मेरे लिए यह स्वीकार्य है कि वह अधिकतम संख्या उत्पन्न करने वाली किसी भी संख्या को अनुमति दे सकता है? मैं एक नया नियम लागू नहीं करना चाहता जो सभी मौजूदा समाधानों को तोड़ दे।

— कीटिंग

2

हाँ, यह शायद सबसे अच्छा विकल्प है। 950 एक उदाहरण हो सकता है, जहां दोनों [900, 862] और [945, 862] दोनों मान्य उत्तर होंगे।

— डेनिस

1

Can मैं उत्पादन उलटे क्रम में संख्या, जैसे इनपुट के लिए 50: 35, 48?

— nimi

5

पायथ, 17 15 बाइट्स

_eSttm,-ds^R2{P

परीक्षण सूट।

— लीक नन
स्रोत

4

जावा 8 लैम्ब्डा, 247 239 233 225 224 219 198 161 अक्षर

मैंने सोचा था कि 300 वर्णों से कम में संभव होना चाहिए क्योंकि ... आप जानते हैं ... जावा!

और यह वास्तव में 200 वर्णों में भी संभव है!

m->{int n=1,u,f,F[],g,G=g=1<<31;for(;++n<=m;){u=n;F=new int[m+1];for(f=1;++f<=u;)u/=u%f<1?(F[f]=f--):1;f=0;for(int p:F)f+=p*p;g=n-f>g?(G=n)-f:g;}return G+","+g;}

मुझे नहीं पता कि आयात का यह उपयोग वैध है या नहीं, लेकिन मेरा मानना है कि यह ठीक होना चाहिए। यहाँ एक वर्ग में भेड़ का बच्चा ungolfed है:

public class Q80507 {
    static String greatestAfterReduction(int maxNumber) {
        int number = 1, upper, factor, primeFactors[], greatestResult, greatestNumber = greatestResult = 1 << 31; // <-- Integer.MIN_VALUE;
        for (;++number <= maxNumber;) {
            // get unique primefactors
            upper = number;
            primeFactors = new int[maxNumber + 1];
            for (factor = 1; ++factor <= upper;)
                upper /= upper % factor < 1 ? (primeFactors[factor] = factor--) : 1;

            factor = 0;
            for (int prime : primeFactors)
                factor += prime * prime;

            greatestResult = number - factor > greatestResult ? (greatestNumber = number) - factor : greatestResult;
        }
        return greatestNumber + "," + greatestResult;
    }
}

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

अपडेट

आउटपुट से नई लाइन को हटा दिया।

Integer.MIN_VALUE को 1 << 31 पर गोल्फ के लिए @ogregoire के लिए धन्यवाद!

कोड को फिर से देखने के बाद मुझे कुछ और जगहें मिलीं, जहाँ चीज़ें गोल्फ हो सकती थीं।

@Blue = = 0 से <1 चाल के लिए धन्यवाद!

कुछ बचे हुए व्हाट्सएप को हटा दिया। इसके अलावा अलगाव के लिए केवल एक चर की जरूरत होती है ताकि किसी एक चरबी को बर्बाद करने की जरूरत न पड़े।

@Ogregoire को फिर से इंगित करने के लिए धन्यवाद कि मैं इसे छापने और घोषणाओं को एक साथ रखने के बजाय मूल्य वापस कर सकता हूं! इससे बहुत कुछ बचा!

मुझे पता चला कि अगर मैं एक और चार को बचाने के लिए दूसरे के बजाय एक टर्नरी का उपयोग कर सकता हूं।

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

— Frozn
स्रोत

1

Integer.MIN_VALUEके रूप में छोटा किया जा सकता है 1<<31।

— ओलिवियर ग्रेजायर

1

अगर (u% f <1) इसके बजाय 1 बाइट्स बचाएं

— ब्लू

1

कई बार intदोहराए जाने से बचने के लिए एक ही स्थान पर अपने सभी एस की घोषणा करें int, और यदि संभव हो तो उन्हें उनके मूल्य प्रदान करें।

— ओलिवियर ग्रेजायर

1

इसके अलावा, इससे छुटकारा पाएं System.out.println(...)और इसे प्रिंट करने के बजाय एक मूल्य लौटाएं: जैसा कि ओपी उल्लेख करता है, मानक I / O विधि उपयोग में है।

— ओलिवियर ग्रेजायर

1

आप उस हैश ट्रिक का भी उपयोग कर सकते हैं जिसका उपयोग मैंने C # में हैशटैट को एक इंट सरणी में बदलने के लिए किया था। यह संभवतः आपको कई बाइट्स को बचाने वाले आयात को छोड़ने देगा।

— एस्ट्रोडन

3

दरअसल, 21 बाइट्स

u2x;`;y;*@-`M;M;)@í@E

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

स्पष्टीकरण:

u2x;`;y;*@-`M;M;)@í@E
u2x;                   push two copies of range(2, n+1) ([2, n])
    `      `M          map:
     ;                   duplicate
      y;                 push two copies of prime divisors
        *                dot product of prime divisors lists (equivalent to sum of squares)
         @-              subtract from n
             ;M;)      duplicate, two copies of max, move one copy to bottom of stack
                 @í    get index of max element
                   @E  get corresponding element from range

— मै जाऊं
स्रोत

क्या आप इस भाषा से जुड़ सकते हैं?

— ऐसा नहीं है कि चार्ल्स

1

@NotthatCharles आप ऑनलाइन दुभाषिया में भाषा के नाम पर क्लिक कर सकते हैं।

— डेनिस

ठीक है, मैंने Actually Programming LanguageGoogle परिणामों के 5 वें पृष्ठ को ब्राउज़ करने के बाद भी कुछ नहीं पाया। यह भाषा कौन सी है?

— तेजस काले

2

@Tejas आप उस भाषा के नाम पर क्लिक कर सकते हैं जो आपको इसके स्रोत पर

— भेजेगी

3

MATL , 18 बाइट्स

:"@tYfu2^s-]v2#X>w

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

अंतिम मामला ऑनलाइन कंपाइलर के लिए बहुत लंबा होता है, लेकिन यह सही परिणाम देता है (यह मेरे कंप्यूटर में लगभग 11 सेकंड का समय लेता है, मैटलैब पर चल रहा है):

व्याख्या

वर्णित प्रक्रिया का सीधा आवेदन।

:         % Implicit input n. Range [1 2 ... n]
"         % For each
  @       %   Push that number
  tYfu    %   Duplicate. Prime factors. Unique values
  2^s-    %   Square. Sum of array values. Subtract
]         % End for each
v         % Concatenate stack contents into vertical vector
2#X>      % Max and arg max
w         % Swap. Implicit display

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

3

सी #, 194 बाइट्स

मेरा पहला कोड गोल्फ :)। अपनी वाचालता के बावजूद मैंने अपनी पसंदीदा भाषा का इस्तेमाल किया। मैंने इसे @ फ्रोज़न के जावा के C # फ़ंक्शन पोर्ट के रूप में शुरू किया, लेकिन कोड को अनुकूलन के साथ आगे सिकोड़ने के कई तरीके मिले।

string R(int a){int u,f,g,N=g=1<<31;for(int n=1;++n<=a;){u=n;int[]P=new int[a+1];for(f=1;++f<=u;){if(u%f<1){u/=f;P[f]=f--;}}f=0;foreach(var p in P){f+=p*p;}if(n-f>g){g=(N=n)-f;}}return N+","+g;}

यह प्रमुख कारकों को संग्रहीत करने के लिए एक सरणी का उपयोग करता है। क्योंकि यह कारक द्वारा अनुक्रमित है यह कारक की प्रतियों के साथ दोहराया कारकों को प्रतिस्थापित करेगा। यह फ़ंक्शन को कोई आयात नहीं करने देता है। इसके लिए सिस्टम की भी आवश्यकता नहीं है।

— AstroDan
स्रोत

यह वास्तव में एक अच्छी चाल है! मेरे संस्करण में इसका उपयोग करने की कोशिश करेंगे

— फ्रोज़न

3

बैश + जीएनयू उपयोगिताओं, 74

seq 2 $1|factor|sed -r 's/:?( \w+)\1*/-\1*\1/g'|bc|nl -v2|sort -nrk2|sed q

seq सभी पूर्णांक 2 से n उत्पन्न करता है
factorएक बृहदान्त्र के बाद नंबर देता है, फिर एक डुप्लिकेट सहित सभी प्रमुख कारकों की सूची को अलग करता है। उदाहरण के लिए 12 का परिणाम है12: 2 2 3
sedबृहदान्त्र और डुप्लिकेट कारकों को हटाता है, फिर आवश्यक अंकगणितीय अभिव्यक्ति उत्पन्न करता है। 12 के लिए उदा:12- 2* 2- 3* 3
bc इसका मूल्यांकन करता है
nl उपसर्ग n वापस (2 पर शुरू)
sort दूसरे कॉलम के अनुसार, संख्यात्मक रूप से, अवरोही क्रम में
seq पहली लाइन को प्रिंट करता है और क्विट करता है।

Ideone।

— डिजिटल आघात
स्रोत

2

Brachylog , 48 बाइट्स

:2:{eI$pd:{:2^.}a+:I--:I.}fF$\hor:0m:Ir.r~m[F:J]

व्याख्या

Main predicate:

:2:{}fF                     Unify F with the list of all binding for which predicate 1 is
                            true, given [Input, 2] as input.
       $\hor:0m             Retrieve the max of F by diagonalizing it, taking the
                            first row, sorting that row and reversing the sorted row.
               :Ir.         Unify the Output with [I, Max],
                   r~m[F:J] [I, Max] is in F at index J (the index is unimportant)


Predicate 1:

eI                          I is an integer in the range given in Input
  $pd                       Get the list of prime factors of I, with no duplicates
     :{:2^.}a               Apply squaring to each element of that list
             +              Sum the list
              :I-           Subtract I from the sum
                 -          Multiply by -1 (let's call it Result)
                  :I.       Unify the Output with [Result, I]

— Fatalize
स्रोत

2

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

ÆfQ²S_@,µ€ḊṀṚ

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

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

ÆfQ²S_@,µ€ḊṀṚ  Main link. Argument: n

        µ      Combine the chain to the left into a link.
         €     Apply it to each k in [1, ..., n].
Æf               Yield k's prime factors as a list.
  Q              Unique; deduplicate the prime factors.
   ²             Square each unique prime factor.
    S            Compute their sum.
     _@          Subtract the result from k.
       ,         Pair with k, yielding [result(k), k].
          Ḋ    Dequeue; discard the first pair which corresponds to k = 1.
           Ṁ   Get the maximum (lexicographical order).
            Ṛ  Reverse the pair.

— डेनिस
स्रोत

2

05AB1E, 19 17 16 बाइट्स

कोड:

L©f€n€O®-®)ø¦{¤R

स्पष्टीकरण:

L                    # make a list of 1..input [1,2,3,4,5,6]
 ©                   # save the list for reuse
  f                  # get primefactors of numbers in list [[],[2],[3],[2],[5],[2,3]]
   €n                # square each factor [[],[4],[9],[4],[25],[4,9]]
     €O              # sum the factors [0,4,9,4,25,13]
       ®-            # subtract from saved list [1,-2,-6,0,-20,-7]
         ®)ø         # zip with saved list [[1,1],[-2,2],[-6,3],[0,4],[-20,5],[-7,6]]
            ¦        # drop the first item (n=1) [[-2,2],[-6,3],[0,4],[-20,5],[-7,6]]
             {       # sort [[-20,5],[-7,6],[-6,3],[-2,2],[0,4]]
              ¤      # get last item [0,4]
               R     # reverse [4,0]

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

— Emigna
स्रोत

2

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

!n=maximum(k->(k-sumabs2(k|>factor|>keys),k),2:n)[[2,1]]

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

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

एक इनपुट n को देखते हुए , प्रत्येक पूर्णांक k के लिए जैसे कि 2 ≤ k we n , हम tuple (f (k), k) उत्पन्न करते हैं , जहां f (k) k और उसके प्रमुख कारकों के वर्गों के योग के बीच का अंतर है। ।

च (के) के साथ ही गणना की जाती है k-sumabs2(k|>factor|>keys), जो कारक कश्मीर प्रधानमंत्री कुंजी और प्रतिपादक मूल्यों की एक Dict में, सभी कुंजियों (प्रधानमंत्री कारकों) के अर्क उनके वर्गों और घटाता जिसके परिणामस्वरूप पूर्णांक से की राशि लेता है k ।

अंत में, हम उत्पन्न टुपल्स का लेक्सोग्राफिक अधिकतम लेते हैं और इसे सूचक 2 और 1 पर आरोपित करके उल्टा करते हैं ।

— डेनिस
स्रोत

1

क्लोजर, 215 बाइट्स

(fn j[x](apply max-key second(map(fn[w][w(- w(let[y(reduce +(map #(* % %)(set(flatten((fn f[q](let[c(filter(fn[r](=(mod q r)0))(range 2 q))](if(empty? c)q(map f c))))w)))))](if(= y 0)(* w w)y)))])(range 2(inc x)))))

बस नियमों का पालन करता है। प्रत्येक संख्या के प्रमुख कारकों की गणना करता है, उन्हें वर्ग में रखता है और उन्हें योग देता है। उसके बाद 2 तत्वों के वैक्टर की एक सूची तैयार करें: प्रारंभिक संख्या और उसका परिणाम और दूसरे तत्व के अधिकतम मूल्य वाले तत्व को ढूंढें।

आप इसे यहां ऑनलाइन देख सकते हैं: https://ideone.com/1J9i0y

— cliffroot
स्रोत

1

आर 109 बाइट्स

y=sapply(x<-2:scan(),FUN=function(x)x-sum(unique(as.numeric(gmp::factorize(x))^2)));c(x[which.max(y)],max(y))

मैंने धोखा दिया और एक पैकेज का इस्तेमाल किया gmp।

— उछलने वाली गेंद
स्रोत

1

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

ri({))_mf_|2f#:+-}/]_:e>_@#))\]p

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

— एक सीमन्स
स्रोत

1

पाइके, 17 बाइट्स

FODP}mXs-)DSei@Oi

यहाँ यह कोशिश करो!

— नीला
स्रोत

1

PowerShell v2 +, 124 120 117 बाइट्स

2..$args[0]|%{$y=$z=$_;2..$_|%{$y-=$_*$_*!($z%$_)*('1'*$_-match'^(?!(..+)\1+$)..')};if($y-gt$o){$o=$y;$p=$_}}
"$p $o"

पहली पंक्ति मूल्यों की गणना करती है, दूसरी सिर्फ आउटपुट है।

हम 2अपने कमांड-लाइन तर्क $args[0]और लूप तक एक सीमा बनाने से शुरू करते हैं |%{...}। प्रत्येक लूप में हम अपने वर्तमान मूल्य के बराबर सहायक चर सेट करते हैं $y=$z=$_। फिर हम 2अपने वर्तमान नंबर तक हर संख्या के माध्यम से लूप करते हैं । प्रत्येक आंतरिक लूप हम जांचते हैं कि क्या यह संख्या एक भाजक है !($z%$_)और क्या यह प्रमुख है ('1'*$_-match'^(?!(..+)\1+$)..') , और यदि यह दोनों है तो हम वर्ग को घटाते हैं $y(चेक बूलियन गुणन का उपयोग करके किया जाता है)।

एक बार जब हम सभी प्राइम डिविजर्स के माध्यम से चले गए और वर्गों को घटा दिया, यदि शेष संख्या सबसे बड़ी है जिसे हमने अब तक देखा है $y-gt$o, तो हम अपने आउटपुट चर सेट करते हैं $o=$y;$p=$_। जब हम पूरी सीमा से गुजर रहे होते हैं, तब हम केवल बीच के स्थान के साथ आउटपुट करते हैं।

— AdmBorkBork
स्रोत

1

हास्केल, 91 बाइट्स

f m=reverse$maximum[[n-sum[p^2|p<-[2..n],mod n p<1,mod(product[1..p-1]^2)p>0],n]|n<-[2..m]]

उपयोग का उदाहरण: f 50->[48,35]।

प्राइम फैक्टर फ़ंक्शंस उपलब्ध हैं, import Data.Numbers.Primesजिसके माध्यम से बहुत सारे बाइट्स खर्च होते हैं, इसलिए मैं @ लिन के प्राइम चेकर का उपयोग कर रहा हूं । बाकी सीधे आगे है: इनपुट mलूप के nमाध्यम से[2..m] और अंदर के लूप के pमाध्यम से [2..n]। सभी pको प्रधान रखें और विभाजित करें n, वर्ग और योग।

— nimi
स्रोत

1

अजगर 2, 108 105 100 बाइट्स

f=lambda n,m=2,p=1:m>n or-~f(n,m+1,p*m*m)-(n%m<p%m)*m*m
r=max(range(2,input()+1),key=f)
print r,f(r)

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

— डेनिस
स्रोत

1

जावास्क्रिप्ट (ईएस 6), 111 105 बाइट्स

f=n=>{r=n<2?[]:f(n-1);for(s=[],j=n,i=2;j>1;k%i?i++:j/s[i]=i);s.map(i=>j-=i*i,j=n);return j<r[1]?r:[n,j]}

पता नहीं क्यों मैंने इससे पहले इसे पुनरावृत्ति करने के लिए नहीं सोचा था।

— नील
स्रोत

1

जे, 44 बाइट्स

[:((],.~2+I.@e.)>./)@:}.1(-[:+/*:@~.@q:)@+i.

सीधे-सीधे दृष्टिकोण। के सभी मूल्यों को भी लौटाता हैn उस परिणाम के अधिकतम मूल्य में ।

प्रयोग

   f =: [:((],.~2+I.@e.)>./)@:}.1(-[:+/*:@~.@q:)@+i.
   f 3
2 _2
   f 10
8 4
   f 50
48 35
   f 1000
1000 971
   f 9999
9984 9802
   f 950
900 862
945 862

— मील की दूरी पर
स्रोत

एक सीमा में सबसे बड़ी संख्या जब इसके प्रमुख कारकों के वर्गों का योग घटाया जाता है

पायथ, 17 15 बाइट्स

जावा 8 लैम्ब्डा, 247 239 233 225 224 219 198 161 अक्षर

अपडेट

दरअसल, 21 बाइट्स

MATL , 18 बाइट्स

व्याख्या

सी #, 194 बाइट्स

बैश + जीएनयू उपयोगिताओं, 74

Brachylog , 48 बाइट्स

व्याख्या

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

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

05AB1E, 19 17 16 बाइट्स

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

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

क्लोजर, 215 बाइट्स

आर 109 बाइट्स

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

पाइके, 17 बाइट्स

PowerShell v2 +, 124 120 117 बाइट्स

हास्केल, 91 बाइट्स

अजगर 2, 108 105 100 बाइट्स

जावास्क्रिप्ट (ईएस 6), 111 105 बाइट्स

जे, 44 बाइट्स

प्रयोग