छोटे रामसे नंबर

Question

पृष्ठभूमि: रैमसे संख्या $R(r,s)$ कोने की न्यूनतम संख्या देता $v$ पूरा ग्राफ में $K_v$ ऐसी है कि एक लाल / नीले किनारे का रंग $K_v$ है कम से कम एक लाल $K_r$ या एक नीले $K_s$ । बड़े लिए सीमाएं $r, s$स्थापित करना बहुत मुश्किल है।

आपका काम संख्या उत्पादन के लिए है $R(r,s)$ के लिए $1 \le r,s \le 5$ ।

इनपुट

दो पूर्णांकों $r, s$ के साथ $1 \le r \le 5$ और $1 \le s \le 5$ ।

उत्पादन

$R(r,s)$ जैसा कि इस तालिका में दिया गया है:

  s   1    2    3    4      5
r +--------------------------
1 |   1    1    1    1      1
2 |   1    2    3    4      5
3 |   1    3    6    9     14
4 |   1    4    9   18     25
5 |   1    5   14   25  43-48

ध्यान दें कि $r$ और $s$ विनिमेय हैं: $R(r,s) = R(s,r)$ ।

के लिए आप कर सकते हैं उत्पादन के बीच किसी भी पूर्णांक 43 और 48 , समावेशी। इस सवाल के पोस्ट के समय ये सबसे अच्छे ज्ञात सीमाएं हैं।$R(5,5)$$43$$48$

Comments

मुझे लगता है कि (इसके लिए रेंज के साथ भी 5,5) कि यह कोल्मोगोरोव-जटिलता के तहत फिट हो सकता है (या केवल एक गैर-इनपुट, निश्चित आउटपुट फिट?)

— जोनाथन एलन

49 को R (5,5) के लिए कब रखा गया था? (मैं चुनौती नहीं दे रहा हूं; मुझे लगता है कि एक्सू और मैकके और रेडज़िज़ोव्स्की के बाद एक पेपर छूट गया है।)

— एरिक टॉवर्स

@EricTowers arxiv.org/abs/1703.08768

— qwr

@qwr: धन्यवाद! मैं अब तक इसका आनंद ले रहा हूं।

— एरिक टावर्स

Answer 1

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

करी सिंटैक्स में इनपुट लेता है (r)(s)।

r=>s=>--r*--s+[9,1,,13,2,,3,27,6][r<2|s<2||r*s%9]

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

कैसे?

पहले सन्निकटन के रूप में, हम सूत्र का उपयोग करते हैं:

$$(r-1)(s-1)$$

 0  0  0  0  0
 0  1  2  3  4
 0  2  4  6  8
 0  3  6  9 12
 0  4  8 12 16

$\min(r,s)<3$$1$

 1  1  1  1  1
 1  2  3  4  5
 1  3  -  -  -
 1  4  -  -  -
 1  5  -  -  -

अन्यथा, हम एक लुकअप टेबल से उठाया गया मान जोड़ते हैं जिसकी कुंजी द्वारा परिभाषित की जाती है:$k$

$$k=(r-1)(s-1)\bmod9$$

 k:                    table[k]:           (r-1)(s-1):         output:
 -  -  -  -  -         -  -  -  -  -       -  -  -  -  -       -  -  -  -  -
 -  -  -  -  -         -  -  -  -  -       -  -  -  -  -       -  -  -  -  -
 -  -  4  6  8   -->   -  -  2  3  6   +   -  -  4  6  8   =   -  -  6  9 14
 -  -  6  0  3         -  -  3  9 13       -  -  6  9 12       -  -  9 18 25
 -  -  8  3  7         -  -  6 13 27       -  -  8 12 16       -  - 14 25 43

Comments

अच्छा, पहली दो पंक्तियाँ एक स्वच्छ अभिव्यक्ति है।

— क्यूर

Answer 2

जावास्क्रिप्ट (Node.js) , 56 55 बाइट्स

f=(x,y)=>x<2|y<2||f(x,y-1)+f(x-1,y)-(x*y==12)-7*(x+y>8)

इसे ऑनलाइन आज़माएं! मैंने देखा कि टेबल पास्कल के त्रिकोण जैसा दिखता है लेकिन सुधार कारकों के साथ। संपादित करें: @ बन्दर के लिए 1 बाइट का धन्यवाद सहेजा गया।

Comments

हां, पास्कल की त्रिकोण पहचान

— रैम्सी

आप 1 बाइट की जगह बचा सकता है x*y>19के साथ x+y>8।

— सूंदर -

@ सूंदर धन्यवाद, मेरा मूल समाधान 50 बाइट्स था इससे पहले कि मुझे एहसास हुआ कि मेरी अनुक्रमण गलत था और मैंने इसे ठीक करने के बाद इसे फिर से गोल्फ के लिए प्रयास करना भूल गया।

— नील

Answer 3

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

’ScḢƊ_:¥9“ ı?0‘y

इसे ऑनलाइन आज़माएं! या एक परीक्षण-सूट देखें ।

बदलें 0के साथ +, ,, -, ., या /सेट करने के लिए के बराबर , , , , या क्रमशः (बजाय यहाँ)।43 44 45 46 47 $R(5,5)$$43$$44$$45$$46$$47$$48$

कैसे?

चूंकि हमें मिल सकता है:$R(r,s)\leq R(r-1,s)+R(r,s-1)$

$$R(r,s)\leq \binom{r+s-2}{r-1}$$

यह है ’ScḢƊऔर उत्पादन होगा:

 1  1  1  1  1
 1  2  3  4  5
 1  3  6 10 15
 1  4 10 20 35
 1  5 15 35 70

यदि हम हर बार नौ को घटाते हैं, तो परिणाम में हम अपने लक्ष्य के साथ तीन और संरेखित करते हैं (यह प्राप्त होता है _:¥9):

 1  1  1  1  1
 1  2  3  4  5
 1  3  6  9 14
 1  4  9 18 32
 1  5 14 32 63

शेष दो गलत मान, और तब जेली के परमाणु और कोड-पेज इंडेक्स के साथ अनुवाद किए जा सकते हैं ।$32$$63$y“ ı?0‘y

’ScḢƊ_:¥9“ ı?0‘y - Link: list of integers [r, s]
’                - decrement              [r-1, s-1]
    Ɗ            - last 3 links as a monad i.e. f([r-1, s-1]):
 S               -   sum                  r-1+s-1 = r+s-2
   Ḣ             -   head                 r-1
  c              -   binomial             r+s-2 choose r-1
        9        - literal nine
       ¥         - last 2 links as a dyad i.e. f(r+s-2 choose r-1, 9):
      :          -   integer division     (r+s-2 choose r-1)//9
     _           -   subtract             (r+s-2 choose r-1)-((r+s-2 choose r-1)//9)
         “ ı?0‘  - code-page index list   [32,25,63,48]
               y - translate              change 32->25 and 63->48

Comments

); आप किसी भी नंबर पर सेट कर सकते हैं अगर मैं के रूप में मैके, Radziszowski और Exoo द्वारा अनुमान लगाया 43 की सलाह देते हैं

— qwr

Answer 4

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

def f(c):M=max(c);u=M<5;print[48,25-u*7,3*M+~u-u,M,1][-min(c)]

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

---

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

def f(c):M=max(c);print[48,M%2*7+18,3*~-M+2*(M>4),M,1][-min(c)]

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

यह हास्यास्पद है, मुझे जल्द ही यह पोस्ट करने का पछतावा होगा ... लेकिन एह, ツ \ _ (ツ) _ /,। 1 तरह की शेव की हुई शेव हमारी जोनाथन एलन :) को दी गई। शायद जल्द ही लगभग 20 बाइट्स द्वारा outgolfed किया जाएगा ...

Comments

पोर्टिंग अरनल्ड का जेएस उत्तर अभी भी 62 बाइट्स है ।

— श्री एक्सकोडर

Answer 5

जूलिया 0.6 , 71 61 59 57 बाइट्स

A->((r,s)=sort(A);r<3?s^~-r:3r+(s^2-4s+3)*((r==s)+r-2)-3)

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

Ungolfed (अच्छी तरह से, थोड़ा अधिक पठनीय):

function f_(A)
  (r, s) = sort(A)

  if r < 3
    result = s^(r-1)
  else
    result = 3*r + 
               (s^2 - 4*s + 3) * ((r == s) + r - 2) -
               3
  end

  return result
end

यह क्या करता है?

Aआर और एस युक्त सरणी के रूप में इनपुट लेता है । आर का उपयोग करके आर को छोटी संख्या के साथ आर और एस में अनपैक करें (r,s)=sort(A)।

यदि r 1 है, तो आउटपुट 1. होना चाहिए। यदि r 2 है, तो आउटपुट जो भी है वह होना चाहिए। हो जाएगा r = 1 के लिए, और आर = 2 के लिए तो, , कम या
$s^{r - 1}$$s^0 = 1$$s^1 = s$
r<3?s^(r-1)r<3?s^~-r

दूसरों के लिए, मैंने ध्यान दिया कि आउटपुट है:

• r = 3, (क्रमशः s = 3, 4, 5 के लिए)। $2\times3 + [0, 3, 8]$
• r = 4 के लिए, (क्रमशः s = 4, 5 के लिए)$2\times4 + \ \ [10, 17]$
• r = 5 के लिए, 5 (s = 5 के लिए)$2\times5 + \ \ \ \ \ [35]$

(मैंने शुरू में सुविधा के लिए f (5,5) = 45 के साथ काम किया।)

यह एक संभावित प्रयोग करने योग्य पैटर्न की तरह दिखता है - इन सभी 2rमें समान है, 17 8 * 2 + 1 है, 35 17 * 2 + 1 है, 10 3 * 3 + 1 है। मैंने आधार मान को [0, 3, 8] से निकालने के साथ शुरू किया, जैसा कि [0 3 8][s-2](यह बाद में छोटा हो गया (s^2-4s+3))।

R = 3, 4, और 5 के लिए सही मान प्राप्त करने का प्रयास इसके साथ कई चरणों से गुजरा

2r+[0 3 8][s-2]*(r>3?3-s+r:1)+(r-3)^3+(r>4?1:0)

तथा

2r+(v=[0 3 8][s-2])+(r-3)*(v+1)+(r==s)v

उत्तरार्द्ध का विस्तार करना और इसे सरल बनाना पोस्ट कोड के लिए नेतृत्व किया।

Answer 6

x86, 49 37 बाइट्स

बहुत अनुकूलित नहीं है, बस तालिका की पहली तीन पंक्तियों के गुणों का शोषण कर रहा है। जब मैं यह लिख रहा था तो मुझे महसूस हुआ कि कोड मूल रूप से एक जंप टेबल है ताकि एक जंप टेबल कई बाइट्स को बचा सके। में इनपुट, eaxऔर ebx, आउटपुट में eax।

-12 के मामलों के संयोजन के द्वारा r >= 3एक लुकअप तालिका में (मूल रूप से बस r >= 4) और पीटर Cordes के सुझाव का उपयोग करते हुए cmp/ jae/ jneझंडे के साथ अभी भी सेट ताकि r1,r2,r3पहचाना जाता है केवल एक से cmp! एक निरंतर ऑफसेट का उपयोग करके चालाकी से तालिका में अनुक्रमित करना।

start:
        cmp     %ebx, %eax
        jbe     r1
        xchg    %eax, %ebx              # ensure r <= s

r1:
        cmp     $2, %al             
        jae     r2                      # if r == 1: ret r
        ret

r2:     
        jne     r3                      # if r == 2: ret s 
        mov     %ebx, %eax
        ret

r3:
        mov     table-6(%ebx,%eax),%al  # use r+s-6 as index
        sub     %al, %bl                # temp = s - table_val
        cmp     $-10, %bl               # equal if s == 4, table_val == 14
        jne     exit
        add     $4, %al                 # ret 18 instead of 14 

exit:
        ret                        

table:
        .byte   6, 9, 14, 25, 43

Hexdump

00000507  39 d8 76 01 93 3c 02 73  01 c3 75 03 89 d8 c3 8a  |9.v..<.s..u.....|
00000517  84 03 21 05 00 00 28 c3  80 fb f6 75 02 04 04 c3  |..!...(....u....|
00000527  06 09 0e 19 2b                                    |....+|

Comments

इतना सुनिश्चित न करें कि एक जंप टेबल इष्टतम होगी। r1: cmp $2, %al/ jae r2झंडे सेट करेंगे जैसे कि आप r2: jne r3दूसरे के बिना उपयोग कर सकते हैं cmp। में कूद लक्ष्य कहीं और r1हो सकता है ret, और के माध्यम से गिर सकता है r2। (हालत उलट)। BTW, यह पहला कोड-गोल्फ प्रश्न है जिसे मैंने SO पर अपने शॉर्ट जंप ऑफसेट टेबल उपयोग प्रश्न का उत्तर देने के बाद देखा । मुझे लगता है कि मैंने HNQ से सही एक को चुना :)

— पीटर कॉर्ड्स

r4एक निर्देश हो सकता है mov table-8(%ebx,%eax), %al:। IDK आपने एक रजिस्टर में टेबल एड्रेस को अलग करने के लिए एक अलग निर्देश का उपयोग क्यों किया। लेकिन प्रमुख चीजों में से एक यह है कि प्रतीकों से निरंतर ऑफसेट अतिरिक्त कुछ भी खर्च नहीं करता है क्योंकि यह पहले से ही 32-बिट निरपेक्ष पते पर इकट्ठा होता है। ऑब्जेक्ट फ़ाइल प्रारूप प्रतीक के रूप में एक ऑफसेट के साथ प्रतिनिधित्व कर सकते हैं, जब लिंकर अंतिम पते में भरता है इसलिए कंपाइलरों को एक संरचना के प्रत्येक क्षेत्र, या हर सरणी तत्व पर अलग-अलग लेबल नहीं लगाने

— पड़ते हैं

@PeterCordes मुझे यह एहसास भी नहीं हुआ कि यह HNQ बना है। और हाँ किसी कारण से मुझे लगा कि मुझे पता है कि वाक्य रचना गलत होने से पहले टेबल का पता एक रजिस्टर में होना चाहिए था। मैंने इसे यहां कोडगॉल्फ.स्टैकएक्सचेंज . com/a/168503/17360 पर फिक्स किया जो कि सिर्फ लुकअप टेबल है। लेकिन मैं निरंतर ऑफसेट के बारे में नहीं जानता था जो कि आसान है। मुझे लगता है कि मैं गुणन के बजाय अंतिम 3 पंक्तियों के लिए एक तालिका की कोशिश करूँगा।

— क्यूर

स्वयं पर ध्यान दें: retr1 और r2 के लिए एक का उपयोग करके 1 बाइट बचाना अभी भी संभव है ।

— qwr

अच्छा अद्यतन, अच्छा लग रहा है। यदि आप किस ओर जाते mov %ebx, %eaxहैं exit, तो यह हमेशा r3 के बाद चलता है, और r2 वहां कूदता है या r3 में होकर गिरता है? तब R3 बीएल अपने परिणाम पैदा करता है साथ sub %bl, %al/ cmp $10, %al/ jne exit/ add $4, %bl(तटस्थ आकार परिवर्तन: सीएमपी बनाम ऐड का उपयोग कर सकते अल, imm8 संक्षिप्त रूप)। लाभ यह है कि यह retr2 से भी निकालता है । हम्म नहीं है कि काम नहीं करता है, अच्छी तरह से हो सकता है अगर आप तालिका प्रविष्टियों या कुछ और नकारात्मक? और वह शायद आपको किसी चीज़ की ज़रूरत है। मैंने इस बारे में नहीं सोचा है और दुर्भाग्य से ऐसा करने का समय नहीं है: /

— पीटर कॉर्ड्स

Answer 7

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

f=lambda R,S:R<=S and[1,S,[6,9,14][S-3],[18,25][S&1],45][R-1]or f(S,R)

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

Answer 8

MATL, 25 21 बाइट्स

+2-lGqXnt8/k-t20/k6*-

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

MATL को जोनाथन एलन के जेली पोर्ट को पोर्ट करने का प्रयास ।

+2-lGqXn- उसी उत्तर के रूप में: कंप्यूट$\binom{r+s-2}{r-1}$

t8/k - डुप्लिकेट कि, 8 और फर्श से विभाजित करें

- - पिछले परिणाम से घटाएँ (हम जेली उत्तर में 9 के बजाय 8 बार संख्या में कितनी बार जाते हैं। परिणाम सभी के लिए समान है, लेकिन 35 और 70, जो यहाँ 31 और 62 देते हैं।)

t20/k - उस परिणाम को भी डुप्लिकेट करें, उसे 20 और फर्श से विभाजित करें (पहले से ही सही परिणामों के लिए 0 देता है, 31 के लिए 1, 62 के लिए 3)

6* - 6 से गुणा करें

- - परिणाम से घटाएँ (31 - 6 = 25, 62 - 18 = 44)

---

पुराने:

+t2-lGqXntb9<Q3w^/k-t20>+

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

Answer 9

पायथन 3 , 74 बाइट्स

lambda *a:[[1]*5,[2,3,4,5],[6,9,14],[18,25],[43]][min(a)-1][max(a)-min(a)]

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

Answer 10

प्रोटॉन , 52 बाइट्स

मेरे पायथन उत्तर के पास-पोर्ट ।

c=>[48,(M=max(c))%2*7+18,3*M-(M>4?1:3),M,1][-min(c)]

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

Answer 11

जावा 8, 62 बाइट्स

(r,s)->--r*--s+new int[]{9,1,0,13,2,0,3,27,6}[r<2|s<2?1:r*s%9]

लैम्ब्डा फंक्शन, पोर्ट ऑफ़ अरनाउल्ड का जावास्क्रिप्ट उत्तर । इसे यहाँ ऑनलाइन आज़माएँ ।

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

int f(int x,int y){return x<2|y<2?1:f(x,y-1)+f(x-1,y)-(x*y==12?1:0)-7*(x+y>8?1:0);}

पुनरावर्ती कार्य, नील के जावास्क्रिप्ट उत्तर का बंदरगाह । इसे यहाँ ऑनलाइन आज़माएँ ।

Answer 12

सी (जीसीसी), 57 बाइट्स

f(x,y){x=x<2|y<2?:f(x,y-1)+f(x-1,y)-(x*y==12)-7*(x+y>8);}

पुनरावर्ती कार्य, नील के जावास्क्रिप्ट उत्तर का बंदरगाह । इसे यहाँ ऑनलाइन आज़माएँ ।

सी (जीसीसी), 63 बाइट्स

f(r,s){r=--r*--s+(int[]){9,1,0,13,2,0,3,27,6}[r<2|s<2?:r*s%9];}

पोर्ट ऑफ अरनल्ड के जावास्क्रिप्ट उत्तर । इसे यहाँ ऑनलाइन आज़माएँ ।

Comments

49 बाइट्स

— सीलिंगकैट