यह चुनौती एक प्रोग्रामिंग ब्लॉग मैं अक्सर से प्रेरित थी। कृपया यहां मूल पोस्ट देखें: एक प्रोग्रामिंग पहेली

चुनौती

एक फ़ंक्शन को परिभाषित करें f:Q->Qजैसे कि f(f(n)) = -nसभी गैर-शून्य पूर्णांक n, और जहां Qतर्कसंगत संख्याओं का सेट है।

विवरण

जो कुछ भी आपकी पसंदीदा भाषा में, परिभाषित कृपया एक समारोह या कार्यक्रम fकि पैरामीटर के रूप में स्वीकार करता है एक नंबर nऔर रिटर्न या आउटपुट एक नंबर f(n)।

जो भी तंत्र आपकी भाषा के लिए सबसे स्वाभाविक है, इनपुट प्रदान किया जा सकता है: फ़ंक्शन तर्क, STDIN, कमांड लाइन तर्क, स्टैक स्थिति, वॉइस इनपुट, गिरोह के संकेत, आदि से पढ़ें।

आउटपुट किसी फ़ंक्शन / प्रोग्राम से रिटर्न वैल्यू होना चाहिए या STDOUT में प्रिंट होना चाहिए।

मैं उन कार्यों के उत्तरों को प्रतिबंधित करना चाहूंगा जो प्रोग्राम स्टेट या वैश्विक मेमोरी / डेटा का लाभ नहीं लेते हैं जो फ़ंक्शन के बाहर से दिखाई देते हैं f। उदाहरण के लिए, उस काउंटर के बाहर एक काउंटर रखना fकितनी बार fकॉल किया गया था और सिर्फ इस गिनती के आधार पर एक नेगेटिव करना किसी के लिए बहुत चुनौतीपूर्ण या दिलचस्प नहीं है। निर्णय fकेवल fलेशिकल स्कोप के भीतर डेटा पर निर्भर होना चाहिए ।

हालांकि, यह प्रतिबंध कुछ स्टैक-ओरिएंटेड भाषाओं या अन्य प्रकार की भाषाओं के लिए संभवतः अनुचित है जो इस प्रकार के डेटा या स्कोप को अलग नहीं करते हैं। कृपया इस चुनौती की भावना के साथ अपने सर्वोत्तम निर्णय का उपयोग करें।

स्कोरिंग

सामान्य कोड गोल्फ नियम लागू होते हैं- आपका स्कोर आपके स्रोत कोड में बाइट्स की संख्या है ।

न्यूनतम उत्तर के लिए डोमेन और कोडोमैन की आवश्यकता होती fहै जो तर्कसंगत के एक सबसेट के रूप में होता है Q। यदि आप अपने डोमेन और कोडन fको पूर्णांकों तक सीमित रखते हैं Z, तो आपका स्कोर आपके स्रोत कोड में 90% बाइट्स की संख्या की सीमा है ।

बराबर का अवसर

एक टाई की स्थिति में, निम्नलिखित का उपयोग क्रम में किया जाएगा:

आपके स्रोत कोड में मुद्रण योग्य गैर-व्हाट्सएप प्रतीकों की सबसे कम संख्या
उत्तर प्रस्तुत करने की प्रारंभिक तिथि और समय

संपादित करें

आपको मनमाने ढंग से संख्याओं का समर्थन करने की आवश्यकता नहीं है। कृपया अपनी चुनी हुई भाषा (आमतौर पर पूर्णांक और फ्लोटिंग पॉइंट, क्रमशः) में सेट Zऔर Qडेटाटाइप्स के रूप में व्याख्या करें ।

यदि आपका समाधान पूरी तरह से डेटा संरचना के अंतर्निहित ढांचे या बिट पैटर्न पर निर्भर करता है, तो कृपया इसकी सीमाओं और इसका उपयोग कैसे किया जा रहा है, इसका वर्णन करें।

— ardnew
स्रोत

20

f (n) = i * n - शुद्ध गणित: P

— जोहान्स कुह्न

8

@JohannesKuhn यही कारण है कि डोमेन और

— कोडोमैन

क्या आप f:Q->Qइसका मतलब बता सकते हैं ?

— beary605

@ beary605 इसका मतलब fहै कि Qअन्य सदस्यों (संभवतः उसी के) के लिए (तर्कसंगत संख्या) के सदस्यों की एक मैपिंग है Q। देख en.wikipedia.org/wiki/Function_(mathematics)#Notation

— ardnew

7

मुझे पता था कि मैंने इसे हाल ही में देखा था, लेकिन यह याद रखने में थोड़ा समय लगा। StackOverflow पर एक कम कसकर निर्दिष्ट संस्करण हाल ही में बंद हुआ था। 100 से अधिक उत्तर।

— पीटर टेलर

12

जे, 9 अंक (10 वर्ण)

Stackoverflow के आधार पर जवाब :

   (*-[*_1&^)

पहला विचार (13 वर्ण):

   ((-*)-2&|*+:)

   ((-*)-2&|*+:) _10 _9 _8 _7 _6 _5 _4 _3 _2 _1 0 1 2 3 4 5 6 7 8 9 10
_9 10 _7 8 _5 6 _3 4 _1 2 0 _2 1 _4 3 _6 5 _8 7 _10 9

   ((-*)-2&|*+:) _9 10 _7 8 _5 6 _3 4 _1 2 0 _2 1 _4 3 _6 5 _8 7 _10 9
10 9 8 7 6 5 4 3 2 1 0 _1 _2 _3 _4 _5 _6 _7 _8 _9 _10

— randomra
स्रोत

यह पूर्णांक इनपुट के लिए काम करता है, लेकिन यह फ्लोटिंग पॉइंट वैल्यू के लिए काल्पनिक आउटपुट का उत्पादन करता है (फ़ंक्शन को युक्ति के अनुसार तर्कसंगत इनपुट के लिए तर्कसंगत आउटपुट का उत्पादन करना चाहिए)

— अस्थिरता

5

@Volatility, युक्ति शब्द भ्रमित कर रहा है, लेकिन जैसा कि मैंने पढ़ा है यह डोमेन और कोडन को पूर्णांक तक सीमित करने की अनुमति देता है।

— पीटर टेलर

क्या आपको कोष्ठक की आवश्यकता है?

— सायोस

14

पायथन: 61 34 30 29 27 अंक

एफ: क्यू -> क्यू

गणित में:

       | 0.5-x   if x is in Q \ Z
f(x) = |
       | x+0.5   if x is in Z

पायथन में:

f=lambda x:.5+[x,-x][x%1>0]

के साथ परीक्षण किया गया

filter(lambda n: n[0] != -n[1], map(lambda n:(n,f(f(n))),range(0,50)))

इसके पीछे तर्क:

जब आप एक पूर्णांक लेते हैं nऔर इसे डालते हैं तो fआपको मिल जाएगा x+0.5। यह किसी भी अधिक पूर्णांक नहीं है, इसलिए अगला एप्लिकेशन वह होगा 0.5-(x+0.5)जो है -x।

क्रेडिट

करने के लिए धन्यवाद

बकरियू ने इसे 61 वर्णों से 34 वर्णों तक के लिए स्ट्रिप किया।
30 वर्णों के कोड आकार को और कम करने के लिए अस्थिरता ।
कॉपी 29 वर्णों के लिए कोड आकार को कम करने (और एक संभावित चल बिन्दु समस्या को ठीक करने के लिए)।
उपरोक्त परिवर्तनों के साथ आई एक विसंगति का उल्लेख करने के लिए aditsu ।

नहीं, इसका मतलब यह नहीं है। यदि वह इसका उल्लेख करता है, तो उसे "सभी तर्कसंगत संख्याएं" लिखनी चाहिए। f:Q->Qइसका मतलब केवल यह है कि f तर्कसंगत संख्या से परिमेय संख्याओं का मानचित्र बनाता है। च की मेरी परिभाषा क्या है।

— मार्टिन थोमा

11

सी, 41 अंक (41 या 45 वर्ण)

32- और 64-बिट दोनों का उपयोग करके काम करता है।

f : Z -> Z(सिवाय INT_MAX)

f(n){return (abs(n)%2*2-1)*n+n?(-n<n)*2-1:0;}

यदि हमें शामिल नहीं करना है तो 0हम कुछ वर्णों (41 वर्णों) को काट सकते हैं:

f : Z -> Z(सिवाय 0और INT_MAX):

f(n){return (abs(n)%2*2-1)*n+(-n<n)*2-1;}

यह फ़ंक्शन सभी पूर्णांकों को उनके संकेत और समता के आधार पर 4 समूहों में विभाजित करके काम करता है।

तो हमारे पास 4 अलग-अलग संयोजन हैं:

+ even, + odd, - even, - odd

जैसा कि हमें संख्या के संकेत को स्विच करने की आवश्यकता है, लेकिन दो पास होने के बाद समता नहीं, हमें दो अलग-अलग अनुक्रम मिलते हैं:

  + even -> - odd -> - even -> + odd -\
^-------------------------------------/

  + even -> + odd -> - even -> - odd -\
^-------------------------------------/

इस उदाहरण में मैंने पहला चुना है।

पहले हमें सभी ऋणात्मक पूर्णांकों को विषम ऋणात्मक पूर्णांकों के लिए मैप करना होगा। हम यह संकेत बदलकर और संख्या में वृद्धि करके करते हैं (आप इसके स्थान पर संख्या में कमी भी चुन सकते हैं):

f1(n) = -n + 1

फिर हमें सभी विषम ऋणात्मक पूर्णांकों को ऋणात्मक पूर्णांकों तक मैप करने की आवश्यकता है। हमें यह सुनिश्चित करने की आवश्यकता है कि f2(f1(n)) = -n:

f2(f1(n)) = -n
f2(-n + 1) = -n
f2(-n) = -n - 1
f2(n) = n - 1

उसी विधियों का उपयोग करना जो हम पाते हैं f3और f4:

f3(n) = -n - 1
f4(n) =  n + 1

इन फ़ंक्शन को एक एकल फ़ंक्शन में संयोजित करने के लिए, हम देखते हैं कि हर बार जब nहम साइन इन करते हैं nऔर हर बार nसकारात्मक होता है तो हम एक से बढ़ाते हैं और अन्यथा हम एक से घटते हैं:

f1(n) = -n + 1 (+ even)
f2(n) =  n - 1 (- odd)
f2(n) = -n - 1 (- even)
f4(n) =  n + 1 (+ odd)

इस प्रकार इसे फिर से लिखा जा सकता है:

f(n) = odd(n) * n + sign(n)

जहां विषम संख्याओं के लिए और यहां तक कि संख्याओं के लिए भी odd(n)लौटता है ।1-1

कुल 4 समाधान हैं:

f(n) = odd(n) * n + sign(n)  (edge cases: f(f(0))  -> -2, f(f(INT_MAX))   -> -8)
f(n) = even(n) * n - sign(n) (edge cases: f(f(0))  -> -2, f(f(INT_MIN+1)) -> -6)
f(n) = odd(n) * n - sign(n)  (edge cases: f(f(1))  -> -3, f(f(INT_MIN))   -> -5)
f(n) = even(n) * n + sign(n) (edge cases: f(f(-1)) -> -1, f(f(INT_MIN))   -> -5)

INT_MINहमेशा -INT_MIN == INT_MIN=> के रूप में सभी 4 कार्यों में एक किनारे का मामला माना जा सकता है f(f(INT_MIN)) = INT_MIN।

— Tyilo
स्रोत

यह अनिवार्य रूप से मेरे गोल्फस्क्रिप्ट उत्तर के समान है (बेहतर तरीके से समझाया गया है)। क्या यह 0 के लिए काम करता है?

— बेन रीच

@BenReich जवाब में कहा गया है कि यह 03 और अन्य नंबरों के लिए काम नहीं करता है ।

— टिलो

1

@ टायलियो अब मैं देख रहा हूं। समझ में आता है। ऐसा लगता है कि आपको केवल Zबोनस लेना चाहिए यदि आप 0 को कवर करते हैं, तो कम से कम।

— बेन रीच

@BenReich ने बोनस तब तक निकाला जब तक मैं इसे ठीक नहीं कर लेता।

— टिलो

9

यहाँ मेरा यह जाना है।

long f(int i){return i;}
int f(long i){return -i;}

लाइव उदाहरण :

int main()
{
  for(int i=-10; i<10; i=i+3)
    std::cout << f(f(i)) << "\n";
}

इनपुट प्रकार cn आपकी आवश्यकताओं के अनुरूप मनमाने ढंग से किया जाना चाहिए। यह संस्करण पूर्णांक शाब्दिक के लिए काम करता है जो 2 ^ 32-1 की तुलना में परिमाण में छोटा होता है।

— rubenvb
स्रोत

2

समस्या ने कहा f:Q->Q, नहीं f:Z->Z।

— AJMansfield

@AJMansfield कल्पना का स्कोर खंड परिभाषित कार्यों के लिए बोनस अंक प्रदान करने के f:Z->Zलिए था, भ्रामक

— शब्दांकन के

6

इस जवाब के साथ समस्या यह है कि यह दो अलग-अलग कार्यों को परिभाषित करता है, जबकि कल्पना की आवश्यकता है कि आप केवल एक को परिभाषित करें। लेकिन मैं एक शब्दार्थ बहस शुरू करने का मतलब नहीं है, यह अभी भी एक बहुत ही विचारशील समाधान है

— ardnew

@ardnew, ओह यू आर राइट। मुझे SO चैट पर लाउंज <C ++> के साथ साझा करने से कुछ सेकंड पहले ही इस वैध आपत्ति की ओर इशारा किया गया था। मुझे आश्चर्य है कि कंपाइलर इसका क्या बनाता है (यदि यह कॉल को इनलाइन नहीं करता है), लेकिन मेरी असेंबली बेकार है।

— rubenvb

1

मुझे लगता है कि आप अंतरिक्ष मेंreturn -i

— Cyoce

6

जावास्क्रिप्ट, 18

f=n=>n%1?.5-n:n+.5

नए वसा तीर संकेतन (फ़ायरफ़ॉक्स 22) का उपयोग करना।

अन्य संस्करण (18):

f=n=>n%1?-.5/n:.5/n

पिछला संस्करण (20):

f=n=>n-~~n?.5-n:n+.5

उदाहरण:

> [-3,-2,-1,1,2,3].map(f).map(f)
[3, 2, 1, -1, -2, -3]

— प्रतिलिपि
स्रोत

10

लगता है कि जावास्क्रिप्ट कॉफीस्क्रिप्ट में विकसित हो रहा है।

— पीटर टेलर

4

गणितज्ञ १ 18

f=#+1/2-4#(#-⌊#⌋)&

यहाँ ⌊...⌋फर्श समारोह है। यह केवल तर्कसंगत संख्याओं का उपयोग करता है (सूचियों, जटिल संख्याओं आदि का नहीं)

f[10]
f[f[10]]

21/2

-10

f[-5]
f[f[-5]]

-9/2

5

— ybeltukov
स्रोत

3

x86 असेंबली लैंग्वेज (FASM)। तर्क और परिणाम बाज रजिस्टर में हैं।

यह ठीक से -2 ^ 30 <N <+ 2 ^ 30-1 के लिए काम करता है

16 बाइट्स निष्पादन योग्य कोड।

        use32

f_n:
        lea     edx, [2*eax]
        xor     edx, eax
        btc     eax, 30
        shl     edx, 1
        jnc     .end
        neg     eax
.end:
        retn

— johnfound
स्रोत

अपने नंबरों को साफ़ करना; 2E30 2 * 10 ^ 30 नहीं, 2 ^ 30 होगा जैसा कि मुझे लगता है कि आप चाहते हैं।

— Nick T

@ मेरी गलती नहीं। फिक्स्ड।

— जॉन्फाउंड

मुझे पूरा यकीन है कि आप स्रोत कोड में बाइट्स की गणना करने वाले हैं।

— nyuszika7h

3

आम लिस्प: 35 बाइट्स

(defun f(x)(/(if(> 1 x)-1/2 1/2)x))

योजना (और रैकेट): 36 बाइट्स

(define(f x)(/(if(> 1 x)-1/2 1/2)x))

टिप्पणियों और स्पष्टीकरण के साथ अधूरा:

(define (f x)
  (/             ;; divide
     (if (> 1 x) ;; if x is below 1 
         -1/2    ;; then -1/2 (the fraction)
         1/2)    ;; else 1/2 (the fraction)
      x))        ;; gets divided with x

के लिए किसी भी संख्या xमें अंश में बदल जाएगा जो दोनों भाषाओं में एक असली सही संख्या है।[1,->]if1/2

विभाजन का हिस्सा तब बन जाएगा (/ 1/2 x)इसलिए अंश बन जाएगा 1/(x*2)जो हमेशा नीचे होता है 1। के लिए 1यह हो जाएगा 1/2, के लिए 2यह है 1/4, आदि

1 से नीचे की किसी भी संख्या के ifलिए अंश में बदल जाएगा -1/2, जो फ़ंक्शन करता है, (/ -1/2 x)जो है, -1/(2*x)लेकिन चूंकि हम पिछले रन के परिणाम के मूल्य की उम्मीद कर सकते हैं, हम x को 1 / (x * 2) के लिए दोहरा आवेदन कर सकते हैं।-1/((1/(x*2))*2) = -x

जैसे कि दूसरा आवेदन 1में बदल जाता 1/2है(/ -1/2 1/2) ==> -1

— Sylwester
स्रोत

यह कैसे काम करता है?

— AJMansfield

@AJMansfield ने कुछ जानकारी जोड़ी। बस पूछें कि क्या कुछ अस्पष्ट है। अगर आपने इसे नहीं सीखा है तो LISP सिंटैक्स पढ़ना हनी की तरह है और इसे इस्तेमाल करने में कुछ सप्ताह लगते हैं।

— सिल्वेस्टर

3

सी, 60 (66 । 9⌉)

int f(int x){if(!x&1||!~x)return ~x;if(x<0)return x-1;return x+1;}

यहाँ एक बिना शर्त संस्करण है:

int f(int x){
    if(!x&1 || !~x) return ~x;
    if(x<0) return x-1;
    return x+1;
}

यह विधि केवल पूर्णांक का उपयोग करके काम करती है, इसलिए इसे 90% स्कोर बोनस मिलता है। मैं इसे मूल रूप से जावा में लिख रहा था, लेकिन यह महसूस किया कि इस कार्यक्रम से विशेष रूप से सी-स्टाइल तार्किक ऑपरेटरों को फायदा हो सकता है।

जैसा कि इसके विपरीत कोई पूर्णांक नहीं है -INT_MIN, इसके बजाय f(f(INT_MIN))रिटर्न देता है INT_MIN।

अंतर्निहित मानचित्रण बीजगणितीय रूप से सरल होता है। कथन x=f(x)को निष्पादित करने के साथ x बदलता है:

x+1, अगर xसकारात्मक और विषम है
-x+1, अगर xसकारात्मक है और यहां तक कि
x-1, अगर xनकारात्मक और विषम है
-x-1, अगर xनकारात्मक है और यहां तक कि

अगली बार फ़ंक्शन x पर लागू होने पर प्रत्येक मामले का परिणाम अगले मामले के अंतर्गत आएगा।

जैसा कि आप देख सकते हैं, यह पैदावार के बाद मामले के साथ एक मामले की रचना करता है -x।

कोड दो के तारीफ पूर्णांक की बिट संरचना का लाभ उठाने के लिए फ़ंक्शन के कुछ चतुर सरलीकरण का एक परिणाम है।

— AJMansfield
स्रोत

3

> <> , 21 + 3 = 24 बाइट्स, 22 अंक

:0)$:0($:1$2%2*-*+-n;

का प्रयोग करें आधिकारिक अजगर दुभाषिया , और प्रयोग -vआदेश पंक्ति विकल्प इनपुट दर्ज करने के लिए, 3 बाइट्स की लागत से।

मुझे लगता है कि यह बेहतर हो सकता है - मैं इसे देखता रहूंगा और इसे नीचे गिराने की कोशिश करूंगा।

इनपुट को देखते हुए n, कार्यक्रम आउटपुट

(n>0) - ((n<0) + n * (1 - 2*(n%2)))

कहाँ (n>0)और (n<0)बुलियन हैं। यह जिलेटिन के पायथन उत्तर के बराबर है

(n>0) - (n<0) - n * (-1)**n

लेकिन हमारे ><>पास एक अंतर्निर्मित प्रतिक्षेपक ऑपरेटर नहीं है, इसलिए हम (1 - 2*(n%2))इसके स्थान पर उपयोग करते हैं (-1)**n।

गणितीय सिद्धांत निम्नानुसार है - यदि (और केवल यदि आप रुचि रखते हैं) पढ़ें:

किसी भी फंक्शन को देखते हुए f: Z -> Zकि f(f(n)) = -nसभी nमें Z, हम तुरंत देखते हैं f(f(f(f(n)))) = n, या दूसरे शब्दों में, f^4पहचान समारोह है। विशेष रूप से, fउलटा है, और इसका उलटा कार्य है f^3। इस प्रकार fका क्रमपरिवर्तन है Z, और के बाद से f^4 = Id, यह इस प्रकार के हर कक्षा (या चक्र) है कि fआकार या तो है 1, 2या 4।

इसके बाद, हम देखते हैं कि f(0) = 0। प्रमाण: f(0) = f(-0) = f(f(f(0))) = -f(0)तो f(0) = 0, इच्छानुसार। इसके विपरीत, मान लीजिए कि xलंबाई का एक चक्र है 1या 2, इसलिए f(f(x)) = x। फिर -x = xतो x = 0।

इस प्रकार fनिश्चित बिंदु (1-चक्र) को छोड़कर, पूरी तरह से 4-चक्रों से बना होता है 0।

इसके अलावा, हर 4-चक्र में फॉर्म होना चाहिए (x, y, -x, -y), और चक्र को चारों ओर घुमाकर हम यह मान सकते हैं कि xऔर yदोनों सकारात्मक हैं। इसके विपरीत, नॉनजेरो पूर्णांकों को विभाजित करने वाले 4-चक्रों का ऐसा प्रत्येक उत्पाद एक विकल्प निर्धारित करता है f।

इस प्रकार प्रत्येक विकल्प fएक निर्देशित ग्राफ से विशिष्ट रूप से मेल खाता है, जिसके कोने सकारात्मक पूर्णांक हैं, जैसे कि प्रत्येक शीर्ष बिल्कुल एक तीर की घटना है, या तो प्रवेश या बाहर निकल रहा है। अधिक सटीक रूप से, अंतर्निहित अप्रत्यक्ष ग्राफ में, प्रत्येक शीर्ष पर सटीक रूप से डिग्री है 1। (प्रत्येक 4-चक्र के (x y -x -y)साथ xऔर yसकारात्मक तीर के साथ मेल खाता है x --> y।)

इस जवाब (और यहाँ कई अन्य उत्तर) में समारोह ग्राफ जहां से मेल खाती है 1 --> 2, 3 --> 4और सामान्य रूप से 2k-1 --> 2k।

इस तरह के रेखांकन का आदेश दिया जोड़े के अनंत दृश्यों के साथ द्विभाजन में हैं (a_n, p_n), जहां प्रत्येक a_nएक सकारात्मक पूर्णांक है और प्रत्येक p_nया तो है 0या 1एक दृश्य दिया: (a_1, p_1), (a_2, p_2), (a_3, p_3), ..., हम पहली जोड़ी 1के साथ 1 + a_1, और फिर हम या तो तीर के रूप में 1 --> 1 + a_1या तीर 1 + a_1 --> 1जो इस पर निर्भर p_1है 0या 1। मूल रूप से, तीर या तो एक <संकेत या >संकेत है, जो की समता पर निर्भर करता है p_1।

इसके बाद, सबसे छोटे अनपेक्षित पॉजिटिव पूर्णांक को लें k, और किसी भी संख्या को पहले से ही किसी भी संख्या के साथ जोड़कर k, बिल्कुल a_2कदमों से गिनती करें। kपरिणाम के साथ जोड़ी , और p_2ऊपर के आधार पर तीर की दिशा निर्धारित करें । फिर (a_3, p_3), आदि के साथ दोहराएं ।

प्रत्येक तीर अंततः इस तरह से निर्धारित किया जाएगा, इसलिए प्रक्रिया अच्छी तरह से परिभाषित है। इस उत्तर में फ़ंक्शन अनुक्रम से मेल खाती है (1,0), (1,0), (1,0), ..., चूंकि चरण nमें सबसे छोटा अनपेक्षित पूर्णांक है 2n-1और किसी भी पूर्णांक से बड़ा कोई पूर्णांक 2n-1नहीं है, इसलिए हम 2n-1 --> 2nप्रत्येक के लिए प्राप्त करते हैं n(तीर इस तरह उन्मुख होते हैं क्योंकि प्रत्येक p_nबराबर होता है 0)।

इस सेट की कार्डिनैलिटी है (N*2)^N = N^N, जो इस उत्तर के अंतिम पैराग्राफ के बराबर है 2^N, वास्तविक संख्याओं की कार्डिनैलिटी।

— mathmandan
स्रोत

कमांड लाइन विकल्प आमतौर पर प्रत्येक बाइट होते हैं।

— बिल्ली

@ मेटा इस मेटा पोस्ट में "विशेष इनवोकेशन" अनुभाग देखें ।

— मैथमंडन

2

पहले वाले J उत्तर को ठीक करने के लिए (मूल पर टिप्पणी करने के लिए मेरे पास पर्याप्त प्रतिष्ठा नहीं है):

(*+[*1-~2*2|])

यह बस के _1&^साथ बदल 1-~2*2|]देता है, जो विपरीत संकेत देता है। तो मैं बदल -एक करने के लिए +(जो केवल के इनपुट पर मायने रखती है 1और _1)।

यहाँ परीक्षण हैं:

   (*+[*1-~2*2|])6 3 _9 _8 1r2 _4.6 0 1 _1
7 _2 8 _9 1 7.28 0 2 _2
   (*+[*1-~2*2|])7 _2 8 _9 1 7.28 0 2 _2
_6 _3 9 8 0 _10.3568 0 _1 1

   NB. f^:2 = f@:f
   (*+[*1-~2*2|])^:(2)6 3 _9 _8 1r2 _4.6 0 1 _1
_6 _3 9 8 2 _5.0832 0 _1 1

जैसा कि आप देख सकते हैं, डोमेन और रेंज सभी वास्तविक संख्याओं के हैं, लेकिन यह केवल पूर्णांकों (0 सहित) के लिए काम करता है।

स्पष्टीकरण:

(   *     + [ *  1-~    2*     2|]    )
 signum n + n * pred (twice (n mod 2))

— जेम्स वुड
स्रोत

2

GolfScript `ceiling(26*.9)=24`

गोल्फस्क्रिप्ट केवल पूर्णांक संभालता है, इसलिए Zकुल 24 अंकों के लिए बोनस लागू करें :

.{..0>2*(\)2%!2*(@*+}{ }if

8 वर्णों के लिए 0 का विशेष मामला। 0 को अनदेखा करना, हमारे पास 17 बिंदुओं का उत्तर हो सकता है:

..0>2*(\)2%!2*(@*+

यह कोड xस्टैक के शीर्ष पर एक पूर्णांक के लिए निम्न कार्य करता है :

यदि x0 है, 0तो स्टैक पर छोड़ दें और कोई और नियम लागू न करें।
अगर xहै भी तो नकारात्मक x।
यदि xसकारात्मक है, तो जोड़ें 1।
यदि xनकारात्मक है, घटाना 1।

यह तार्किक रूप से एक चक्र में 4 नंबरों के सेट को जोड़ता है, जहां चक्र के fतत्व ट्रेस होते हैं, और चक्र के विपरीत कोने एक दूसरे के नकारात्मक होते हैं। प्रत्येक पूर्णांक ठीक 1 ऐसे चक्र का हिस्सा है, सिवाय 0 जो विशेष आवरण है। उदाहरण के लिए, इसके लिए {-8, -7, 7, 8}:

7 f -> 8
8 f -> -7
-7 f -> -8
-8 f -> 7

केवल प्रासंगिक परीक्षण के मामले मैं सोच सकता था कि एक नकारात्मक विषम, नकारात्मक, यहां तक कि, सकारात्मक विषम, सकारात्मक भी 0, और फिर मैंने फेंक दिया -1और 1चूंकि उनकी निकटता से 0समस्या हो सकती है:

[-10 -5 -1 0 1 5 10]
{.{..0>2*(\)2%!2*(@*+}{ }if}:f;
{f f}%
-> [10,5,1,0,-1,-5,-10]

मुझे यकीन है कि वास्तविक गोल्फस्क्रिप्ट में कुछ हद तक सुधार किया जा सकता है। ऐसा महसूस नहीं होता कि इसमें 26 अक्षर होने चाहिए! कुछ सुझाव सुनना पसंद करेंगे।

— बेन रीच
स्रोत

2

जावा, सिर्फ मनोरंजन के लिए

यहाँ एक कार्यान्वयन है जो implementation और an के बीच एक वास्तविक आक्षेप करता है, जो एक ही समय में एक विषम कार्य है (g -x) == -g (x))। यह संबंधित as तत्व को एक जटिल संख्या के रूप में मानता है और इसे "i" से गुणा करता है, फिर वापस ℤ में परिवर्तित करता है।

f (x) = g⁻¹ (ig (x))
f (f (x)) = g⁻¹ (-g (x)) = - x

फ़ंक्शन O (1) में चलता है।

public class Ffn {
    public static int f(int n) {
        if (n == 0) {
            return 0;
        }
        // adjust sign
        int s = n > 0 ? 1 : -1;
        int m = n * s;
        // calculate square "radius"
        int r = (int) (Math.sqrt(2 * m - 1) + 1) / 2;
        int q = r * 2;
        // starting point
        int x = r, y = r;
        int k = q * (r - 1) + 1;

        if (m - k < q) {
            // go left
            x -= m - k;
        }
        else {
            // go left
            x -= q;
            // go down
            y -= m - k - q;
        }

        // multiply by i
        int x2 = -y * s, y2 = x * s;
        // adjust sign
        s = y2 < x2 || y2 == x2 && x2 < 0 ? -1 : 1;
        x2 *= s;
        y2 *= s;

        if (y2 == r) {
            // go left
            k += r - x2;
        }
        else {
            // go left and down
            k += q + r - y2;
        }
        return k * s;
    }

    public static void main(final String... args) {
        for (int i = 0; i < 1000000; ++i) {
            if (f(f(i)) != -i || f(f(-i)) != i) {
                System.out.println(i);
            }
        }
    }
}

PS नया साल मुबारक!

— aditsu
स्रोत

मेरा मानना है कि व्हाट्सएप अनावश्यक है।

— पीपीपी

2

अजगर 3 - 38

करने के लिए इसी तरह के @ मूस का जवाब है, लेकिन, f(n) == n। सभी पूर्णांक मानों के लिए कार्य करता है।

f=lambda x:x*(isinstance(x,int)*2.0-1)

— cjfaure
स्रोत

2

पर्ल, 33 (गैर-व्हाट्सएप)

sub f{($=)=@_;$=-$_[0]?-$=:"$=.1"}

संपादित करें:

$=.".1"छोटा किया गया "$=.1"(धन्यवाद ardnew)।

गणित:

गणित

Ungolfed:

# script.pl
sub f {
  ($=) = @_;   # short for $= = int($_[0]); 
               # "int" is implicit in assignments to $=;
               # ($=) can be prepended by "local" to get
               # the function free of side effects.

  $= - $_[0] ? # short for $= != $_[0], check if input is integer
    -$=        # input is not an integer  
  : $= . ".1"  # input is integer
}  

# Testing
chomp;
$_ = sprintf "f(f($_)) = f(%s) = %s\n", f($_), f(f($_));

उदाहरण:

perl -p script.pl
7
f(f(7)) = f(7.1) = -7
2
f(f(2)) = f(2.1) = -2
0
f(f(0)) = f(0.1) = 0
-1
f(f(-1)) = f(-1.1) = 1
-10
f(f(-10)) = f(-10.1) = 10
-1.23
f(f(-1.23)) = f(1) = 1.1
3.4
f(f(3.4)) = f(-3) = -3.1
1.0
f(f(1.0)) = f(1.1) = -1

— हेइको ओबर्डिएक
स्रोत

मजबूत समाधान- फ़्लोटिंग पॉइंट टेस्ट के मामले जो आपने डेमो किए हैं उन्हें प्रति युक्ति की आवश्यकता नहीं है (इसके लिए बोनस अंक की पेशकश करनी चाहिए!)। यहाँ कुछ ही क्लीनअप 22 sub f{yzxzzc?-$_:x.$_}

— चर

1

@ कर्णदेव: धन्यवाद। लेकिन मैं असहमत हूं कि आपका समाधान एक ही एल्गोरिदम का उपयोग करता है। एल्गोरिथ्म sub f{yzxzzc?-$_:x.$_}है नहीं यह चर के माध्यम से एक राज्य का उपयोग करता है, राज्य मुक्त $_। इस वजह से, fयह अब एक फ़ंक्शन (गणितीय अर्थ में) नहीं है, क्योंकि राज्य के आधार पर एक ही इनपुट मूल्य के लिए विभिन्न मूल्य संभव हैं (मौसम $_में एक xया नहीं होता है)। मेरा एल्गोरिथ्म एक राज्य का उपयोग नहीं करता है, जानकारी आउटपुट मूल्य में एन्कोडेड है। पूर्णांक जोड़कर वास्तविक संख्याओं में परिवर्तित कर दिया जाता है .1। और असली संख्याओं को वापस स्विच किए गए साइन के साथ पूर्णांक में बदल दिया जाता है।

— हेइको ओबर्डिएक

रुचिकर लगती कोई राज्य डेटा अपने कार्यान्वयन में प्रयोग किया जाता है , क्योंकि प्रारंभिक असाइनमेंट की और नहीं के कुछ विशेष गुण की वजह से $=?

— arnnew

मुझे नहीं पता था कि मैं उस चार्ट के साथ अपनी आवश्यकता (कि fपरिभाषित किया गया Q->Q) भी विफल रहा x। यह भी $=.".1"छोटा किया जा सकता है"$=.1"

— ardnew

@ardnew: विशेष गुण $=यह है कि यह केवल पूर्णांक संख्याएँ लेता है। एक साधारण चर का उपयोग करके इसे प्राप्त किया जा सकता है $a=int$_[0]:। लेकिन फ़ंक्शन के कारण तीन अतिरिक्त बाइट्स खर्च होते हैं int।

— हेइको ओबर्डिएक

2

जूलिया, २६

julia> f(n::Int)=n//1
f (generic function with 1 method)
julia> f(n)=int(-n)
f (generic function with 2 methods)
julia> f(f(4))
-4

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

— gggg
स्रोत

यह नहीं है कि एक गणितज्ञ एक समारोह को क्या कहेगा: जूलिया 3==3//1रिटर्न में trueलेकिन f(3//1)==f(3)रिटर्न false।

— ओमर

2

कैंडी , 20 18 बाइट्स

3 -> 4 -> -3 -> -4 -> 3 चाल का उपयोग करता है।

~A2%{|m}1A0>{+|-}.

इसे लागू करने के लिए दुभाषिया पर -i स्विच का उपयोग करें

दोहरे-आक्रमण का उदाहरण:

$ candy -i 7 -e '~A2%{|m}1A0>{+|-}.'
program length: 18
>>> 8
$ candy -i 8 -e '~A2%{|m}1A0>{+|-}.'
program length: 18
>>> -7
$ candy -i -7 -e '~A2%{|m}1A0>{+|-}.'
program length: 18
>>> -8
$ candy -i -8 -e '~A2%{|m}1A0>{+|-}.'
program length: 18
>>> 7

लंबा फार्म:

peekA
pushA
digit2
mod          # even/odd
if
else
  negate     # negate even numbers
endif
digit1
pushA
digit0
greater      # positive/negative
if
  add        # add two numbers from stack (original stack value, and delta)
else
  sub        # diff two numbers from stack (original stack value, and delta)
endif
retSub

— डेल जॉनसन
स्रोत

2

डायलॉग एपीएल, 9 अंक

×-⍨⊢×¯1*⊢

स्रोत 9 बाइट्स लंबा है और बोनस के लिए अर्हता प्राप्त करता है (जो बिल्कुल भी मदद नहीं करता है)। यह शीर्ष SO उत्तर से सूत्र का उपयोग भी करता है।

— lirtosiast
स्रोत

1

पायथन: 32 बाइट्स (29 अंक)

f: Z -> Z

f=lambda n:(n>0)-(n<0)-n*(-1)**n

बेन रीच की विधि का उपयोग करना।

— जेलाटीन
स्रोत

पायथन 2 में, आप कुछ बाइट्स को बचाने के लिए, के (n>0)-(n<0)साथ बदल सकते हैं cmp(n,0)। (लेकिन पायथन 3 में नहीं: docs.python.org/3/whatsnew/3.0.html#ordering-comparison )

— मैथमैडैन

1

जीटीबी , 22

@S;N,"--$x?N)→N~N#~-N&

— Timtech
स्रोत

1

जावा, 113 बाइट्स

दृष्टिकोण बहुत सरल है। यह अनुमान से अधिक बाइट्स समाप्त हो गया, लेकिन शायद थोड़ा नीचे गोल्फ हो सकता है।

public class F{public static int f(int x){if(x<0)x+=-2147483647-++x;x+=1073741824;return x<0?-2147483647-++x:x;}

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

-2147483648 के अलावा सभी एक्स के लिए काम करता है।

— FIQ
स्रोत

1

संख्याओं का समान अनुक्रम (3, 4, -3, -4, 3 ...) गोल्फस्क्रिप्ट उत्तर के रूप में, लेकिन पर्ल में लागू किया गया (व्हॉट्सएप छीनने के बाद 42 वर्ण)

sub f{($_[0]%2?1:-1)*$_[0]+($_[0]<0?-1:1)}

अधिक कानूनी रूप से:

sub f { ($_[0] % 2 ? $_[0] : -$_[0] ) + ( $_[0] < 0 ? -1 : 1 ) }

या इससे भी अधिक कानूनी रूप से:

sub f {
  my $n = shift;
  my $sign = $n >= 0 ? 1 : -1;
  # note that in perl $n % 2 is the same as int($n) % 2
  if( $n % 2 ) {
    # odd: add one to magnitude
    return $n + $sign
  } else {
    # even: subtract one from magnitude then invert
    return -($n - $sign)
  }
}

आउटपुट:

ski@anito:~/mysrc/.../acme$ echo 3 | perl -e 'sub f{($_[0]%2?1:-1)*$_[0] + ($_[0]<0?-1:1)}; my $x = <>; for(0..10) { print "$_: $x\n"; $x = f($x); }'
0: 3
1: 4
2: -3
3: -4
4: 3
5: 4
6: -3
7: -4
8: 3
9: 4
10: -3

— skibrianski
स्रोत

ऊपर भी गैर-पूर्णांक के लिए काम करता है: स्की @ aito: ~ / mysrc /.../ acme $ echo 1.1234 | perl -e 'sub f {($ _ [0]% 2; 1: -1) * $ _ [0] + ($ _ [0] <0? -1: 1)}; मेरा $ x = <>; के लिए (0..4) {प्रिंट "$ _: $ x \ n"; $ x = f ($ x); } '0: 1.1234 1: 2.1234 2: -1.1234 3: -2.1234 4: 1.1234

— स्कीब्रीन्स्की

1

सैड, 25 बाइट्स।

|sed s/0+/0-/|sed s/^/0+/

उपयोग:

$ echo 1.23 |sed s/0+/0-/|sed s/^/0+/
0+1.23
$ echo 0+1.23 |sed s/0+/0-/|sed s/^/0+/
0+0-1.23

— केन ए
स्रोत

1

मतलाब, 26 वर्ण

f=@(n) (n<0)-(n<0)-n*(-1)^n

— bla
स्रोत

2

यह एक मान्य उत्तर नहीं है, क्योंकि फ़ंक्शन का डोमेन और कोडोमन जटिल नहीं होना चाहिए।

— Wrzlprmft

ओह, मुझे क्षमा करें ... मैंने केवल शीर्षक पढ़ा और यह सावधानी नहीं थी ... चलो देखते हैं कि क्या मैं इसे कुछ हद तक संपादित कर सकता हूं

— bla

1

सी ++ - 63 55.8

इस तरह कोड दिखता है:

int f(int n){return (n&45056?n^45056:n|45056)*(n&45056?-1:1);}

यह पूर्णांक पर काम नहीं करता है जिसका चौथा बाइट 0xB के बराबर है क्योंकि यह पास के ट्रैक को रखने के लिए उस मान का उपयोग करता है। अन्यथा शून्य सहित Z के किसी भी सदस्य पर काम करता है।

— Darkgamma
स्रोत

क्या आप इसे समझा सकते हैं? पहले निरीक्षण में ऐसा लगता है कि आप fएक स्थिर वैरिएबल के साथ कॉल का एक काउंटर रख रहे हैं । लेकिन फिर किस बात का sqrt?

— arnnew

मुझे लगता है कि इस प्रश्न को गलत समझा गया है; सोचा कि C ++ एक स्थिर-उन्मुख भाषा है, लेकिन एक स्थिर चर ठीक था, लेकिन मैं कोड ठीक कर दूंगा। अन्यथा मुझे नहीं पता कि मुझे इसकी आवश्यकता क्यों है sqrtक्योंकि यह टाइप कास्टिंग के साथ वैसे भी गोल हो जाता है। मैं इसे फिर से तैयार करूँगा ताकि यह स्थिर चर के बिना काम करे।

— डार्कगामा

मुझे नहीं पता कि आपको कहां 55.8से मिला है, लेकिन आपका वर्तमान कोड 62 बाइट्स लंबा है। संपादित करें: कोई बात नहीं, मैंने सवाल ठीक से नहीं पढ़ा।

— nyuszika7h

प्रतिबंध कि चौथी बाइट 0xB के बराबर नहीं हो सकती दुर्भाग्य से यह चुनौती का एक वैध जवाब नहीं देता है, जिसके लिए सभी पूर्णांकों पर (कम से कम) काम करने की आवश्यकता होती है।

— पिपरी

1

सिंटेटिका द्वारा आपूर्ति किए गए फ़ंक्शन के साथ अपडेट किया गया (जाहिर है कि जिसे अब इसके लिए क्रेडिट मिलना चाहिए)

भाषा: अजगर

वर्णों की संख्या: 41 व्हॉट्सएप सहित

f=lambda x:-float(x) if str(x)==x else`x`

— HolySquirrel
स्रोत

कृपया उस भाषा का नाम भी बताएं जो आपने प्रदान की थी चरित्र वर्ण भी।

— प्रोग्रामफॉक्स

मुझे पसंद है कि यह गैर-पूर्णांक के साथ भी कैसे काम करता है। बहुत बढ़िया। :)

— cjfaure

f=lambda x:-float(x) if str(x)==x else`x`काफी छोटा है: 41

— व्हाट्सएप

धन्यवाद सिंथेटिका, मैं भी backticks चाल के बारे में पता नहीं था! : D

— HolySquirrel

पूर्णांक पर fएक स्ट्रिंग लौटाता है; विनिर्देश का कहना है कि इसे एक तर्कसंगत संख्या वापस करनी होगी।

— उमर

1

प्रोलॉग, 36 बाइट्स

कोड:

X*Y:-X//1=:=X,Y is 0.5+X;Y is 0.5-X.

व्याख्या की:

Dyadic predicate which converts integers to floats and floats back to negated integers.

उदाहरण:

10*X.
X = 10.5

10*Y,Y*X.
X = -10,
Y = 10.5

— Emigna
स्रोत

1

जावास्क्रिप्ट ईएस 6, 27 26 बाइट्स

a=>a%1?-Math.floor(a):a+.2

— SuperJedi224
स्रोत

1

माउस-2002 , 21 19 12 बाइट्स

$A1%[1%_|1%]

एक फ़ंक्शन को परिभाषित करता है A; इसे कॉल करें #A,#A,?;;( जैसे कि उपयोगकर्ता किसी भी नंबर को दर्ज करने के लिए प्रतीक्षा करेगा)। वैकल्पिक रूप से, इसे कॉल करें #A,#A,n;;जहां nकोई भी संख्या है।

— बिल्ली
स्रोत

1

जूलिया, २१

f(x)=(1-2(1>x>-1))/2x

फिर

julia> f(f(12//1))
-12//1

p // q तर्कसंगत संख्याओं की जूलिया का शाब्दिक अंकन है।

— mschauer
स्रोत

एक फ़ंक्शन च को ऐसे परिभाषित करें कि सभी गैर-शून्य पूर्णांक n के लिए f (f (n)) = -n

चुनौती

विवरण

स्कोरिंग

बराबर का अवसर

संपादित करें

जे, 9 अंक (10 वर्ण)

पायथन: 61 34 30 29 27 अंक

क्रेडिट

टिप्पणियाँ

सी, 41 अंक (41 या 45 वर्ण)

जावास्क्रिप्ट, 18

गणितज्ञ १ 18

आम लिस्प: 35 बाइट्स

योजना (और रैकेट): 36 बाइट्स

सी, 60 (66 । 9⌉)

> <> , 21 + 3 = 24 बाइट्स, 22 अंक

गणितीय सिद्धांत निम्नानुसार है - यदि (और केवल यदि आप रुचि रखते हैं) पढ़ें:

GolfScript `ceiling(26*.9)=24`

जावा, सिर्फ मनोरंजन के लिए

अजगर 3 - 38

पर्ल, 33 (गैर-व्हाट्सएप)

जूलिया, २६

कैंडी , 20 18 बाइट्स

डायलॉग एपीएल, 9 अंक

पायथन: 32 बाइट्स (29 अंक)

जीटीबी , 22

जावा, 113 बाइट्स

सैड, 25 बाइट्स।

मतलाब, 26 वर्ण

सी ++ - 63 55.8

प्रोलॉग, 36 बाइट्स

जावास्क्रिप्ट ईएस 6, 27 26 बाइट्स

माउस-2002 , 21 19 12 बाइट्स

जूलिया, २१

एक फ़ंक्शन च को ऐसे परिभाषित करें कि सभी गैर-शून्य पूर्णांक n के लिए f (f (n)) = -n

चुनौती

विवरण

स्कोरिंग

बराबर का अवसर

संपादित करें

जे, 9 अंक (10 वर्ण)

पायथन: 61 34 30 29 27 अंक

क्रेडिट

टिप्पणियाँ

सी, 41 अंक (41 या 45 वर्ण)

जावास्क्रिप्ट, 18

गणितज्ञ १ 18

आम लिस्प: 35 बाइट्स

योजना (और रैकेट): 36 बाइट्स

सी, 60 (*66 *। 9⌉)

> <> , 21 + 3 = 24 बाइट्स, 22 अंक

गणितीय सिद्धांत निम्नानुसार है - यदि (और केवल यदि आप रुचि रखते हैं) पढ़ें:

GolfScript ceiling(26*.9)=24

जावा, सिर्फ मनोरंजन के लिए

अजगर 3 - 38

पर्ल, 33 (गैर-व्हाट्सएप)

जूलिया, २६

कैंडी , 20 18 बाइट्स

डायलॉग एपीएल, 9 अंक

पायथन: 32 बाइट्स (29 अंक)

जीटीबी , 22

जावा, 113 बाइट्स

सैड, 25 बाइट्स।

मतलाब, 26 वर्ण

सी ++ - 63 55.8

प्रोलॉग, 36 बाइट्स

जावास्क्रिप्ट ईएस 6, 27 26 बाइट्स

माउस-2002 , 21 19 12 बाइट्स

जूलिया, २१

सी, 60 (66 । 9⌉)

GolfScript `ceiling(26*.9)=24`