26

1 से 24 के लिए एक नंबर को देखते हुए उत्पादन वर्तमान जानकारी के अनुसार चुंबन संख्या (कुछ संख्या एक से अधिक स्वीकार्य उत्पादन होगा)। ज्यामिति का ज्ञान आवश्यक नहीं है क्योंकि आउटपुट सभी नीचे सूचीबद्ध हैं।

से चुम्बन संख्या समस्या पर विकिपीडिया पृष्ठ :

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

यही है, एक इकाई क्षेत्र को देखते हुए, कितने अधिक इकाई क्षेत्र उनमें से किसी को भी ओवरलैप किए बिना इसे छू सकते हैं? प्रश्न को N आयामी अंतरिक्ष में पूछा जाएगा, जहां एक क्षेत्र को N-1 आयामी क्षेत्र समझा जाता है।

उदाहरण के लिए:

2 आयामी अंतरिक्ष में, एक यूनिट सर्कल 6 अन्य यूनिट सर्कल को छू सकता है।
3 आयामी अंतरिक्ष में, एक इकाई क्षेत्र 12 अन्य इकाई क्षेत्रों को छू सकता है।

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

सीमा की तालिका

Dimension   Lower bound     Upper bound
1           2               2
2           6               6
3           12              12
4           24              24
5           40              44
6           72              78
7           126             134
8           240             240
9           306             364
10          500             554
11          582             870
12          840             1357
13          1154            2069
14          1606            3183
15          2564            4866
16          4320            7355
17          5346            11072
18          7398            16572
19          10668           24812
20          17400           36764
21          27720           54584
22          49896           82340
23          93150           124416
24          196560          196560

इनपुट

आयाम: एक पूर्णांक 1 से 24 (समावेशी)।

यहां "पूर्णांक" इंगित करता है कि इनपुट में कोई आंशिक हिस्सा नहीं होगा - यह हो सकता है 2या 3कभी नहीं 2.5। उदाहरण के लिए, एक समाधान अभी भी फ्लोट या स्ट्रिंग के रूप में इनपुट ले सकता है।

उत्पादन

प्रासंगिक सीमा में एक संख्या, उस इनपुट के लिए निचली सीमा से ऊपरी सीमा तक (समावेशी)।

आउटपुट निर्धारक होना चाहिए (हमेशा एक ही इनपुट के लिए समान)।

आउटपुट पूर्णांक होना चाहिए। उदाहरण के लिए, निवेश के लिए 5संभव मान्य outputs हैं 40, 41, 42, 43, 44। ध्यान दें कि यह मूल्य पर प्रतिबंध है, न कि प्रकार पर। यह एक फ्लोट को वापस करने के लिए स्वीकार्य है, बशर्ते इसमें शून्य आंशिक भाग हो। उदाहरण के लिए, 41.5मान्य नहीं होगा, लेकिन 41.0मान्य होगा।

स्कोरिंग

यह कोड-गोल्फ है । आपका स्कोर आपके कोड में बाइट्स की संख्या है। प्रत्येक भाषा के लिए, विजेता सबसे कम अंक वाला हल है।

code-golf geometry approximation

— trichoplax
स्रोत

6

वास्तव में शांत सन्निकटन समस्या।

— क्यूर

11

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

n->ceil(n<8?3.7exp(.51n)-5.1:n<24?9exp(.41n):196560)

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

कैसे?

मशीन लर्निंग! (किंदा। हो सकता है। वास्तव में नहीं। )

सबसे पहले, एन के खिलाफ निचली और ऊपरी सीमा डेटा और कुछ मैनुअल परीक्षण और त्रुटि की साजिश रचने से ऐसा लगता था कि एक घातीय फ़ंक्शन एन> = 8 के लिए अच्छी तरह से फिट हो सकता है। मैन्युअल रूप से इस फ़ंक्शन को खोजने के कुछ प्रयासों के बाद, मैंने एक पैरामीटर का उपयोग करने का सहारा लिया ट्यूनिंग फंक्शन ट्यून करने के लिए (जहाँ K = 8 से 24) a, b, और c को खोजने के लिए जैसे कि अभिव्यक्ति ने ऐसे मान दिए जो प्रत्येक K के लिए सही सीमा के भीतर झूठ बोलते हैं (क्रमिक रूप से छोटी सीमा के साथ) समारोह के विभिन्न रनों में संभावित मानों और इसके बाद के उच्चतर पूर्ववर्ती संस्करणों के लिए, बी, सी। कुछ ऐसे मान थे, हालांकि उनमें से कोई भी एन = 24 मामले को ठीक से फिट नहीं कर सकता था, इसलिए मैं एक के साथ गया था जिसमें 0 था और एन = 24 के लिए मूल्य को हार्डकोड किया था । $a * e^{b K} + c$ c

लोअर एन के लिए, 1 से 7 तक, मैं कुछ सरल अभिव्यक्ति या बहुपद खोजने की उम्मीद कर रहा था, लेकिन कोई भी ऐसा नहीं पा सका। इसलिए वापस फिटिंग करने के लिए , इस बार K = 1 से 7 के लिए (हालांकि मैंने वास्तव में नहीं सोचा था कि एक घातीय इस मामले में एक सही फिट होगा, दृश्य कथानक के रुझान के आधार पर)। शुक्र है, वहाँ पैरामीटर थे a, b, c जो कि पूरे रेंज में सही मान दे सकते हैं (कम से कम कॉल के भीतर )। $a * e^{b K} + c$ ceil

— sundar - मोनिका को बहाल करना
स्रोत

6

मैं मशीन सीखने की एक ग्रिडसर्च पर विचार नहीं करूंगा। कुछ भी हो तो यह क्रूर बल है।

— qwr

5

लेकिन यह अंदर है MLBase!!! जम्मू / कश्मीर, एमएल के आसपास लाइनों हमेशा की तरह धुँधली हैं, लेकिन यह शायद है लेबल मशीन सीखने लायक भी बुनियादी। तो फिर, यह हमेशा एक चर्चा प्राप्त करने के लिए उपयोगी है!

— सूंदर -

जब हम मशीन लर्निंग कहते हैं, हम मुख्य रूप से n = 2 या regexps के साथ बहुपद के बारे में सोचते हैं

— आआआआ कहते हैं कि मोनिका

2

जब मैं कहता हूँ मशीन लर्निंग, मुझे लगता है कि तंत्रिका जाल, निर्णय पेड़, HMMs,

— परसेप्ट्रान

@qwr मुझे बहुत देर हो चुकी है, लेकिन उन सभी चीजों के अलावा, प्रतिगमन को वास्तव में मशीन लर्निंग का एक हिस्सा माना जाता है। (और अधिक! एसवीएम, आदि)

— क्विंटेक

7

x86, 62 59 53 50 बाइट्स

मेरा समाधान एक बाइट लुकअप टेबल और 2 (कोई एफपी संगणना) द्वारा स्थानांतरण का उपयोग करता है। 23 के माध्यम से आयाम 9 शिफ्टिंग के लिए पर्याप्त लेवे प्रदान करते हैं। में इनपुट eaxऔर आउटपुट में ecx।

-3 अदला eax- बदली करके और ecxचूंकि cmp $imm, %alकम है cmp $imm, %cl।

-4 एन = 24 मामले को अलग से इलाज नहीं करके लेकिन सभी 1024 मामलों में समायोजन लागू करना।

-2 जल्दी नहीं लौटने से (बेवकूफ)

-3 को ऑफ़सेट के रूप में और movzblइसके साथ शून्य करने के बजाय तालिका का उपयोग करकेxor

start:
        dec     %eax                # 1-indexed table

        movzbl  table(%eax), %ecx   # return byte directly
        cmp     $8, %al
        jl      exit

        sal     $6, %ecx            # * 64 
        cmp     $19, %al
        jl      exit

        sal     $4, %ecx            # * 16
        sub     $48, %ecx

exit:   
        ret

#.data
table:  .byte   2, 6, 12, 24, 40, 72, 126, 240              # * 1
        .byte   5, 8, 10, 14, 19, 26, 41, 68, 84, 116, 167  # * 64  
        .byte   18, 28, 49, 92, 192                         # * 1024 - 48

Hexdump ( .textइसके बजाय तालिका .data)

00000502  48 0f b6 88 1c 05 00 00  3c 08 7c 0d c1 e1 06 3c  |H.......<.|....<|
00000512  13 7c 06 c1 e1 04 83 e9  30 c3 02 06 0c 18 28 48  |.|......0.....(H|
00000522  7e f0 05 08 0a 0e 13 1a  29 44 54 74 a7 12 1c 31  |~.......)DTt...1|
00000532  5c c0                                             |\.|

— qwr
स्रोत

1

तालिका केवल पढ़ने के लिए है, इसलिए आम तौर पर आप इसे अंदर डालेंगे .rodata, .dataवैसे भी नहीं । (या विंडोज पर, जाहिरा तौर पर .rdata)। यह .rodataखंड पाठ खंड के भाग के रूप में जुड़ा हुआ है।

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

1

और BTW, सामान्य लोग लिखते हैं shl, खासकर जब आपका नंबर अहस्ताक्षरित होता है (आप movzblइसे लोड करते थे, नहीं movsbl)। बेशक salएक ही opcode के लिए सिर्फ एक और नाम है। gcc का उत्सर्जन होता है sal, लेकिन यह हाथ से लिखे हुए कोड में देखने के लिए बहुत दुर्लभ है।

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

7

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

f=(n,k=2)=>n<24?--n?f(n,k*24/(17+~'_8443223'[n])):~~k:196560

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

कैसे?

अंतिम शब्द हार्ड-कोडेड है। $a_{24}=196560$

अन्य सभी शब्दों का उपयोग करके पुनरावर्ती रूप से गणना की जाती है:

{\begin{cases} a_{1} = 2 \\ a_{n + 1} = a_{n} \times \frac{24}{q_{n}} \end{cases}

$\begin{cases}a_1=2\\a_{n+1}=a_n\times\dfrac{24}{q_n}\end{cases}$

जहाँ को निम्न के रूप में परिभाषित किया गया है: $q_n$

{\begin{cases} q_{1} = 8 \\ q_{2} = 12 \\ q_{3} = 12 \\ q_{4} = 13 \\ q_{5} = 14 \\ q_{6} = 14 \\ q_{7} = 13 \\ q_{n} = 16, & for n > 7 \end{cases}

$\begin{cases}q_1=8\\q_2=12\\q_3=12\\q_4=13\\q_5=14\\q_6=14\\q_7=13\\q_n=16,&\text{for }n>7\end{cases}$

निम्नलिखित अनुपात के लिए अग्रणी:

3, 2, 2, \frac{24}{13}, \frac{12}{7}, \frac{12}{7}, \frac{24}{13}, \frac{3}{2}, \frac{3}{2}, \dots, \frac{3}{2}

$3,2,2,\frac{24}{13},\frac{12}{7},\frac{12}{7},\frac{24}{13},\frac{3}{2},\frac{3}{2},\ldots,\frac{3}{2}$

अंतिम परिणाम अंततः फ्लोर्ड और वापस आ गया है।

परिणाम सारांश

2 दशमलव स्थानों के साथ अनुमानित परिणाम दिए गए हैं।

  n |   a(n-1) | multiplier |      a(n) | output |          expected
----+----------+------------+-----------+--------+-------------------
  1 |      n/a |        n/a |         2 |      2 |                2
----+----------+------------+-----------+--------+-------------------
  2 |        2 |          3 |         6 |      6 |                6
  3 |        6 |          2 |        12 |     12 |               12
  4 |       12 |          2 |        24 |     24 |               24
  5 |       24 |      24/13 |     44.31 |     44 |        [40,..,44]
  6 |    44.31 |       12/7 |     75.96 |     75 |        [72,..,78]
  7 |    75.96 |       12/7 |    130.21 |    130 |      [126,..,134]
  8 |   130.21 |      24/13 |    240.39 |    240 |              240
  9 |   240.39 |        3/2 |    360.58 |    360 |      [306,..,364]
 10 |   360.58 |        3/2 |    540.87 |    540 |      [500,..,554]
 11 |   540.87 |        3/2 |    811.31 |    811 |      [582,..,870]
 12 |   811.31 |        3/2 |   1216.97 |   1216 |     [840,..,1357]
 13 |  1216.97 |        3/2 |   1825.45 |   1825 |    [1154,..,2069]
 14 |  1825.45 |        3/2 |   2738.17 |   2738 |    [1606,..,3183]
 15 |  2738.17 |        3/2 |   4107.26 |   4107 |    [2564,..,4866]
 16 |  4107.26 |        3/2 |   6160.89 |   6160 |    [4320,..,7355]
 17 |  6160.89 |        3/2 |   9241.34 |   9241 |   [5346,..,11072]
 18 |  9241.34 |        3/2 |  13862.00 |  13862 |   [7398,..,16572]
 19 | 13862.00 |        3/2 |  20793.01 |  20793 |  [10668,..,24812]
 20 | 20793.01 |        3/2 |  31189.51 |  31189 |  [17400,..,36764]
 21 | 31189.51 |        3/2 |  46784.26 |  46784 |  [27720,..,54584]
 22 | 46784.26 |        3/2 |  70176.40 |  70176 |  [49896,..,82340]
 23 | 70176.40 |        3/2 | 105264.59 | 105264 | [93150,..,124416]
----+----------+------------+-----------+--------+-------------------
 24 |           (hard-coded)            | 196560 |           196560

— Arnauld
स्रोत

1

पहली चीज़ जो मैंने देखी थी वह एक पुनरावर्ती जावास्क्रिप्ट फ़ंक्शन के अंदर बिटवाइज़ ऑपरेटरों की थी; पहली बात मैंने सोचा था कि "

— अरनॉल्ड

वास्तव में अच्छी तालिका। क्या आपने इसे मैन्युअल रूप से बनाया था?

— qwr

1

@qwr हाँ, यह ज्यादातर कुछ नोटपैड ++ संपादन है। मैंने पहले 4 कॉलम में मान उत्पन्न करने के लिए सिर्फ एक स्क्रिप्ट का उपयोग किया था।

— अरनुलद

4

जेली , 29 26 बाइट्स

“~D=ⱮziEc+y’Dḣ+⁵÷7PĊ«“£#;’

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

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

“~D=ⱮziEc+y’Dḣ+⁵÷7PĊ«“£#;’  Main link. Argument: n

“~D=ⱮziEc+y’                Set the return value to 485523230101001100011122.
            D               Decimal; convert the return value to base 10.
             ḣ              Head; take the first n elements of the digit list.
              +⁵            Add 10 to each element.
                ÷7          Divide the sums by 7.
                  P         Take the product.
                   Ċ        Ceil; round up to the nearest integer.
                     “£#;’  Yield 196560.
                    «       Take the minimum.

— डेनिस
स्रोत

1

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

21 बाइट गिरा। ऐश की शुरुआत में एक छेद जोड़ने के लिए टीश के सुझाव के लिए बड़ी कमी धन्यवाद (दो बाइट्स को बचाने के n-1लिए n, और निचले और ऊपरी सीमा के भीतर गोल संख्या के लिए लक्ष्य करना, इस प्रकार उन्हें निश्चित-बिंदु संकेतन से सिकोड़ना जैसे 1154घातीय अंकन। पसंद है 2e3।

फिर से, मेरा मूल लक्ष्य यह दिखाना था कि "गूंगा" रास्ता कितना हल्का होगा (जैसे कि किसी भी वास्तविक गणित का उपयोग नहीं करना, जैसे कि अरनल्ड का जवाब। यह प्रभावशाली है कि अभी भी इसे बिना किसी परिवर्तन या गणना के सिकोड़ने के लिए जगह थी।

n=>[,2,6,12,24,40,72,126,240,306,500,582,840,2e3,2e3,3e3,5e3,6e3,8e3,2e4,2e4,3e4,5e4,1e6,196560][n]

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

दो बार अरनुल्द के जवाब की लंबाई, जटिलता की 0 राशि।

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

(बिटशफ्टिंग का उपयोग करने के सुझाव के लिए -1 बाइट धन्यवाद)

f=(n)=>[2,6,12,24,40,72,126,240].concat([5,8,10,14,19,26,41,68,84,116,167].map(x=>x<<6),[17,28,49,91].map(x=>x<<10),196560)[n-1]

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

दिलचस्प होने की मांगों को पूरा करने के लिए, मैंने x86 उत्तर से तर्क चुरा लिया, और उससे सरणी बनाई। इसे 9 बाइट्स लंबा करना। लेकिन थोड़ा और दिलचस्प।

— एंथोनी
स्रोत

yawns कम से कम कुछ दिलचस्प कोशिश करें

— qwr

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

— एंथनी

1

बाइट लुकअप टेबल की बात शायद एक बायस्ट्रिंग या "02060c1828487ef0" जैसी किसी चीज़ का उपयोग करना है जहाँ प्रत्येक प्रविष्टि एक बाइट या 2 वर्ण हेक्स में है यदि आप चाहें। दशमलव में सीधे संख्याओं को संग्रहीत करना 3 वर्णों तक होता है।

— बिटशफ्टिंग

2

आप कम से कम निकालने पर करना चाहिए f=, परिवर्तन (x)करने के लिए x, एक छेद और परिवर्तन को जोड़ने x-1के लिए x। TIO ; और शायद उन्हें टायो 99 बाइट्स

— टीश

5

PPCG में आपका स्वागत है! :)

— झबरा

1

रूनिक, 173 बाइट्स

>i:8(?D5X1+1C,*212,+16,+1c2*,+1cX,+Sp3X7+a,*5X1+a,-1+kn$;
      R:c2*(?D4X1+1C,*212,+16,+1c2*,+Sp9*1+:4XY(?Dkn$;
             R`196560`r@;              ;$*C1nk,C1L

(ध्यान दें कि निचले दाएं कोने को बाइट्स के लिए गिना जाना चाहिए: वे स्पष्ट रूप से रिक्त स्थान से भरे हुए हैं।)

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

0-9,a-f  ->  1-15
2Xn+     ->  20+n

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

कार्यात्मक रूप से यह sundar के जूलिया उत्तर का एक पोर्ट है (लेकिन रूनिक eमें स्टैक को पुश करने के लिए कोई कमांड नहीं है (या वास्तव में, किसी भी दशमलव मान), इसलिए एक सन्निकटन की आवश्यकता थी)। e8 से कम के इनपुट के लिए अनुमान अधिक सटीक है, क्योंकि परिशुद्धता के नुकसान से आउटपुट की स्वीकार्य सीमा से बाहर के मूल्यों का परिणाम 7होता है (जैसे कि 125 का उत्पादन होगा)। Ceil()एक चरित्र में परिवर्तित करके पूरा किया गया था और फिर एक नंबर पर वापस आ गया (यह असाधारण बड़े मूल्यों के लिए विफल रहा, इसलिए 40k पर मैंने इसे 100 से विभाजित किया, रूपांतरण को वापस और पीछे करें, फिर 100 से गुणा करें)।

वहाँ शायद कुछ कमरे व्यवस्था को आसान बनाने के (जैसे खड़ी नीचे दिए गए प्रवेश बिंदु चल रहा है, या के लिए अनुमानों को संपीड़ित करने के लिए एक रास्ता खोजने है e), लेकिन मैं तो बस करने में सक्षम होने के साथ खुश हूँ कर गणना।

/?D5X1+1C,*212,+16,+1c2*,+1cX,+Sp3X7+a,*5X1+a,-1+kn$;
  R:c2*(?D4X1+1C,*212,+16,+1c2*,+Sp9*1+:4XY(?Dkn$;
\(8:i<   R`196560`r@;              ;$*C1nk,C1L

161 बाइट्स।

दुभाषिया अपडेट:

साथ धक्का फिक्सिंग इनपुट पढ़ने , रुनिक अब कई गणित कार्यों और युगल के रूप में पार्स तार करने की क्षमता है। यह इस उत्तर को सरलता से सरल कर देगा, लेकिन मैं इसे छोड़ दूंगा जैसा कि मैंने इसमें डाला गया प्रयास दिखाने के लिए किया है (मैंने एकल-तर्क मैथ फ़ंक्शंस और स्ट्रिंग पार्सिंग को पोस्ट करने के तुरंत बाद जोड़ा: मैं पहले से ही पाप / कॉस / टैन था मेरी टू-डू लिस्ट, लेकिन एक्सप, एब्स, लॉग, इत्यादि पर विचार नहीं किया गया था और पात्रों से बाहर चल रहा था)। TIO को अगले 24-48 घंटों में अपडेट करना चाहिए, यह इस बात पर निर्भर करता है कि डेनिस कब देखता है।

212,+16,+1c2*,+1cX,+1'eAइस दुभाषिया अपडेट के साथ -> कम हो जाएगा । Aकिसी वर्ण और मान को पॉप करता है और वर्ण के आधार पर उस मान पर एक मैथ का संचालन करता है ( eइस मामले में Exp()और Exp(1)रिटर्न ई है )।

— Draco18s
स्रोत

दो दर्जन से अधिक चुंबन संख्या अनुमान

सीमा की तालिका

इनपुट

उत्पादन

स्कोरिंग

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

कैसे?

x86, 62 59 53 50 बाइट्स

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

कैसे?

परिणाम सारांश

जेली , 29 26 बाइट्स

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

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

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

रूनिक, 173 बाइट्स

दुभाषिया अपडेट: