संख्या त्रिकोण फ्लिप

30

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

         1                      1         
       2   3                  3   2       
     4   5   6    <--->     6   5   4     
   7   8   9  10         10   9   8   7   
11  12  13  14  15     15  14  13  12  11

यह A038722 का n'th तत्व है , जो एक-अनुक्रमित है:

1, 3, 2, 6, 5, 4, 10, 9, 8, 7, 15, 14, 13, 12, 11, ...

यह क्रम बढ़ती लंबाई के साथ धनात्मक पूर्णांक के सन्निहित विखंडन को उलट देता है:

 1, 3, 2, 6, 5, 4, 10, 9, 8, 7, 15, 14, 13, 12, 11, ...
<-><----><-------><-----------><------------------>

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

1 -> 1
2 -> 3
3 -> 2
4 -> 6
14 -> 12
990 -> 947
991 -> 1035
1000 -> 1026
1035 -> 991
1036 -> 1081
12345 -> 12305

लीडरबोर्ड:

कोड स्निपेट दिखाएं

code-golf  math  sequence 
— XNOR
स्रोत

जवाबों:

15

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

n=>((2*n)**.5+.5|0)**2-n+1

OEIS से निम्न सूत्र का कार्यान्वयन :

सूत्र

डेमो

कोड स्निपेट दिखाएं

— Arnauld
स्रोत
मुझे यह पसंद है कि इसे एक पूर्णांक में बदल दिया जाए! अच्छी नौकरी!
— क्रेग आर 8806
7

जेली , 8 7 बाइट्स

RṁR€UFi

1 बाइट बचाने के लिए @ErikTheOutgolfer का शुक्रिया!

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

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

RṁR€UFi  Main link. Argument: n

R        Range; yield [1, ..., n].
  R€     Range each; yield [[1], [1, 2], [1, 2, 3], ..., [1, ..., n]].
 ṁ       Mold the left argument like the right one, yielding
         [[1], [2, 3], [4, 5, 6], ...]. The elements of the left argument are 
         repeated cyclically to fill all n(n+1)/2 positions in the right argument.
    U    Upend; reverse each flat array, yielding [[1], [3, 2], [6, 5, 4], ...].
     F   Flatten, yielding [1, 3, 2, 6, 5, 4, ...].
      i  Index; find the first index of n in the result.
— डेनिस
स्रोत
6

ऐलिस , 27 बाइट्स

.Cविचार के लिए Sp3000 का धन्यवाद ।

/o
\i@/.2:e2,tE*Y~Z.H2*~.C+

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

व्याख्या

मुझे लगता है कि त्रिकोणीय संख्याओं का उपयोग करके इसे गणना करने का एक छोटा तरीका हो सकता है, लेकिन मुझे लगा कि यह बिल्ट-इन का एक दिलचस्प दुरुपयोग है, इसलिए यहां एक अलग समाधान है।

मूल विचार ऐलिस के "पैक" और "अनपैक" बिल्ट-इन का उपयोग करना है। "पैक", या Z, दो पूर्णांकों को मैप करता है जो उन्हें विशेष रूप से एक पूर्णांक के लिए बनाता है। "अनपैक", या Y, इस आक्षेप का विरोध करता है और एक पूर्णांक को दो में बदल देता है। आम तौर पर, इसका उपयोग किसी एकल (बड़े) पूर्णांक में पूर्णांकों की सूची या वृक्ष को संग्रहीत करने के लिए किया जा सकता है और बाद में व्यक्तिगत मूल्यों को पुनर्प्राप्त करने के लिए किया जा सकता है। हालांकि, इस मामले में हम विपरीत क्रम में कार्यों का उपयोग कर सकते हैं, ताकि हमारे लिए बायजेक्शन की प्रकृति को काम करने दिया जा सके।

दो पूर्णांकों में एक पूर्णांक को अनपैक करना मूल रूप से तीन चरणों में होता है:

  1. मानचित्र simple → ℤ (शून्य सहित) एक सरल "तह" के साथ। यही है, विषम एनजीलों के लिए नकारात्मक पूर्णांकों को मैप करें, और गैर-नकारात्मक पूर्णांकों को भी एनएक्चर्स को।

  2. मानचित्र ℕ → , 2 , कैंटर पेयरिंग फ़ंक्शन का उपयोग करते हुए । यह है कि, एक अनंत ग्रिड के विकर्णों के साथ-साथ नलिकाएं भी लिखी जाती हैं और हम सूचकांक लौटाते हैं:

       ...
3  9 ...
2  5 8 ...
1  2 4 7 ...
0  0 1 3 6 ...

   0 1 2 3

    जैसे 8जोड़ी को मैप किया जाएगा (1, 2)।

  3. मानचित्र ℕ 2 → ℤ 2 , व्यक्तिगत रूप से प्रत्येक पूर्णांक पर चरण 1 का उल्टा इस्तेमाल करते हैं। यही है, विषम नोडल्स को नकारात्मक पूर्णांक में मैप किया जाता है, और यहां तक ​​कि नोडल को गैर-नकारात्मक पूर्णांक में मैप किया जाता है।

दो पूर्णांकों को एक में पैक करने के लिए, हम बस उन चरणों में से प्रत्येक को उल्टा करते हैं।

अब, हम देख सकते हैं कि कैंटर पेयरिंग फंक्शन की संरचना हमारे द्वारा आवश्यक त्रिकोण को आसानी से एनकोड कर देती है (हालाँकि मान बंद-से-एक हैं)। उन विकर्णों को उलटने के लिए, हमें बस इतना करना है कि x और y को ग्रिड में समन्वयित करें।

दुर्भाग्य से, उपरोक्त सभी तीन चरण एक ही बिल्ट-इन Y(या Z) में संयुक्त हैं , हमें ℕ → ℤ या ℤ → ings मैपिंग को पूर्ववत करने की आवश्यकता है । हालांकि, जबकि इसलिए हम सीधे का उपयोग करके बाइट्स के एक जोड़े को बचा सकता है कर ℕ + → ℤ या ℤ → ℕ + मैपिंग, तालिका में बंद-एक करके त्रुटि का ख्याल रखना। तो यहाँ संपूर्ण एल्गोरिथ्म है:

  1. मानचित्र ℕ + → ℤ का उपयोग कर (एन / 2) * (-1) n-1 । इस मैपिंग को ऐसे चुना जाता है कि यह अनपैकिंग के दौरान निहित ℤ → un मैपिंग को रद्द कर देता है , सिवाय इसके कि यह मान को 1 से नीचे स्थानांतरित कर देता है ।
  2. परिणाम को दो पूर्णांकों में अनपैक करें।
  3. उन्हें स्वैप करें।
  4. स्वैप किए गए मानों को फिर से एक पूर्णांक में पैक करें।
  5. मानचित्र ℕ → ℤ + उपयोग | 2n | + (n )0) । फिर से, इस मैपिंग को इस तरह चुना जाता है कि यह पैकिंग के दौरान निहित ℤ → m मैपिंग को रद्द कर देता है , सिवाय इसके कि यह मान को 1 से ऊपर ले जाए।

उस रास्ते से, हम कार्यक्रम को देख सकते हैं:

/o
\i@/...

यह केवल पूर्णांक इनपुट और आउटपुट के साथ रैखिक अंकगणितीय कार्यक्रमों के लिए एक रूपरेखा है।

.    Duplicate the input.
2:   Halve it.
e    Push -1.
2,   Pull up the other copy of the input.
t    Decrement.
E    Raise -1 to this power.
*    Multiply. We've now computed (n/2) * (-1)^(n-1).
Y    Unpack.
~    Swap.
Z    Pack.
.H   Duplicate the result and take its absolute value.
2*   Double.
~    Swap with other copy.
.C   Compute k-choose-k. That's 1 for k ≥ 0 and 0 for k < 0.
+    Add. We've now computed |2n| + (n≥0).
— मार्टिन एंडर
स्रोत
4

ऑक्टेव , 71 68 बाइट्स

3 बाइट्स ने कॉनर ओ'ब्रायन को धन्यवाद दिया ।

x=triu(ones(n=input('')));x(~~x)=1:nnz(x);disp(nonzeros(flip(x))(n))

यह स्मृति सीमाओं के कारण बड़े इनपुट के लिए काम नहीं करता है।

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

व्याख्या

इनपुट पर विचार करें n = 4। कोड पहले मैट्रिक्स बनाता है

 1     1     1     1
 0     1     1     1
 0     0     1     1
 0     0     0     1

तो फिर यह स्तंभ-प्रमुख क्रम में अशून्य प्रविष्टियों को बदल देता है (नीचे है, तो भर में) द्वारा 1, 2, 3...:

 1     2     4     7
 0     3     5     8
 0     0     6     9
 0     0     0    10

फिर यह मैट्रिक्स को लंबवत रूप से फ़्लिप करता है:

 0     0     0    10
 0     0     6     9
 0     3     5     8
 1     2     4     7

अंत में, यह nकॉलम-मेजर ऑर्डर में -th नॉनजेरो वैल्यू लेता है , जो इस मामले में है 6।

— लुइस मेंडो
स्रोत
1
@ rahnema1 यही eप्रतिभा है! आपको निश्चित रूप से अपने अन्य बहुत अच्छे सुझावों के साथ, एक उत्तर के रूप में पोस्ट करना चाहिए। के रूप में ans =, मुझे यकीन नहीं है कि यह वैध है या नहीं
— लुइस मेंडो
4

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

r=round
f n=r(sqrt$2*n)^2-r n+1

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

यह उत्तर सिर्फ सूत्र का उपयोग करता है। यह यहां सबसे कम दिलचस्प जवाब है, लेकिन यह गोल्फ के लिए भी होता है।

हास्केल , 38 36 34 बाइट्स

x!y|x<=y=1-x|v<-y+1=v+(x-y)!v
(!0)

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

(!0) बिंदु मुक्त कार्य हम किससे संबंधित हैं।

व्याख्या

मुझे यह कहकर शुरू करने दें कि मैं इस जवाब से बहुत खुश हूं।

यहां मूल विचार यह है कि यदि हम अपने इनपुट से छोटी सबसे बड़ी त्रिकोणीय संख्या को हटा दें तो हम इसे उल्टा कर सकते हैं और त्रिकोणीय संख्या को वापस जोड़ सकते हैं। इसलिए हम एक ऑपरेटर को परिभाषित करते हैं !, !हमारे नियमित इनपुट को लेते हैं x, लेकिन यह एक अतिरिक्त संख्या भी लेता है y। yबढ़ते त्रिकोणीय संख्या के आकार का ट्रैक रखता है। अगर x>yहम recurse करना चाहते हैं, हम में कमी xसे yऔर वृद्धि yएक एक करके। इसलिए हम इसकी गणना करते हैं (x-y)!(y+1)और y+1इसे जोड़ते हैं। यदि x<=yहम अपने आधार मामले में पहुँच गए हैं, xतो हम जिस त्रिभुज पर लौटते हैं, उस पंक्ति में स्थान को उलटने के लिए 1-x।

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

f x|u<-div(x^2-x)2=[u+x,u+x-1..u+1]
(!!)$0:(>>=)[1..]f

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

(!!)$0:(>>=)[1..]f एक बिंदु मुक्त कार्य है

व्याख्या

पहली बात यह है कि हम है के साथ संबंध है f, fएक समारोह है कि लेता है xऔर रिटर्न xरिवर्स में वें त्रिकोण का वीं पंक्ति। यह पहले x-1nd त्रिकोणीय संख्या की गणना करके और इसे असाइन करता है u। u<-div(x^2-x)2। हम फिर सूची वापस करते हैं [u+x,u+x-1..u+1]। u+xहै xवें त्रिकोणीय संख्या और पंक्ति पर पहले नंबर, u+x-1कि एक से कम है और पंक्ति पर दूसरा नंबर u+1एक आखिरी त्रिकोणीय संख्या से अधिक है और इस तरह पंक्ति पर अंतिम संख्या है।

एक बार जब हम fएक सूची बनाते हैं (>>=)[1..]f, जो त्रिकोण का एक चपटा होता है। हम सामने के साथ शून्य जोड़ते हैं 0:ताकि हमारे उत्तर एक से ऑफसेट न हों, और इसे हमारे अनुक्रमण समारोह में आपूर्ति करें (!!)।

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

f 0=[0]
f x|u<-f(x-1)!!0=[u+x,u+x-1..u+1]
(!!)$[0..]>>=f

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

यह एक 2 बाइट्स लंबा है, लेकिन मेरी राय में थोड़ा अधिक सुरुचिपूर्ण है।

— गेहूं का जादूगर
स्रोत
3

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

k,j,l;f(n){for(k=j=0;k<n;)l=k,k+=++j;n=1+k-n+l;}

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

संभवत: सबॉप्टीमल, लेकिन मैं इससे बहुत खुश हूं। इस तथ्य का उपयोग करता है कि

NTF N = T N + A057944 ( N ) - N + 1

(यदि मैंने सूत्र को सही ढंग से लिखा है, वह है)

— कोनोर ओ ब्रायन
स्रोत
आप रिटर्न नहीं कह रहे हैं, लेकिन रिटर्न वैल्यू का उपयोग किया जाता है। यह अपरिभाषित व्यवहार है।
— 2501
@ 2501 जब तक कार्यक्रम काम करता है, इसकी अनुमति है। और, एक फ़ंक्शन के पहले तर्क को लिखना एक मूल्य वापस करने के बराबर है।
— कॉनर ओ'ब्रायन
और, एक फ़ंक्शन के पहले तर्क को लिखना एक मूल्य वापस करने के बराबर है। C भाषा में ऐसी कोई चीज मौजूद नहीं है। मानक यहां तक ​​कि स्पष्ट रूप से एक फ़ंक्शन से लौटे मूल्य का उपयोग करके कहता है जो वापस नहीं आता है अपरिभाषित व्यवहार।
— 2501
1
@ 2501 आप सी स्पेसिफिकेशन के लिए C वातावरण (gcc) को भ्रमित करने वाले प्रतीत होते हैं। हां, सी भाषा / युक्ति इसे अपरिभाषित कहती है, लेकिन इसे इस तरह लागू किया जाता है। इसलिए जब मैं "समतुल्य" कहता हूं, तो मैं निश्चित रूप से सीसीसी के gcc और अन्य अन्य संकलक के कार्यान्वयन का उल्लेख कर रहा हूं। PPCG पर, हम "परिपूर्ण" कोड नहीं लिखते हैं - बहुत कोड गोल्फिंग के लिए विनिर्देश के खिलाफ जाता है। जैसा कि मैंने कहा, जब तक यह काम करता है, यह एक मान्य उत्तर है।
— कॉनर ओ'ब्रायन
@ 2501 मैं आपको मेटा साइट पर कुछ लेखों को पढ़ने के लिए प्रोत्साहित करता हूँ, विशेष रूप से यह ।
— कॉनर ओ'ब्रायन
2

05AB1E , 30 बाइट्स

U1V[YLO>X›iYLOX-UY<LO>X+,q}Y>V

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

— एडुआर्डो होफेल
स्रोत
मैं "क्या कहने वाला था? कोई यूएबोड के साथ 05AB1E उत्तर?" लेकिन फिर एक गैर-एएससीआईआई चरित्र इसे बर्बाद कर देता है ... पी अच्छा पहला जवाब, हालांकि, प्रोग्रामिंग पहेलियाँ और कोड गोल्फ में आपका स्वागत है!
— clismique
@ Qwerp-Derp आपका बहुत-बहुत धन्यवाद! मैंने अभी इस भाषा को सीखना शुरू किया है, इसलिए मुझे आश्चर्य नहीं है कि मेरा उत्तर इतना बुरा था।
— एडुआर्डो होफेल
2

टिनिस्पिल , 78 बाइट्स

(d _(q((R N T)(i(l T N)(_(a R 1)N(a T R))(a 2(a T(s T(a N R
(d f(q((N)(_ 2 N 1

एक फ़ंक्शन को परिभाषित fकरता है जो मैपिंग करता है। इसे ऑनलाइन आज़माएं!

Ungolfed

हमें सबसे छोटी त्रिभुजाकार संख्या मिलती है जो इनपुट संख्या से अधिक या उसके बराबर होती है, साथ ही साथ यह संख्या किस त्रिभुज की संख्या होती है। इनमें से हम संख्या के फ़्लिप किए गए संस्करण की गणना कर सकते हैं।

  • यदि वर्तमान त्रिकोणीय संख्या एन से कम है, तो त्रिकोण की अगली पंक्ति में पुन: दर्ज करें। (हम गणित को सरल बनाने के लिए शीर्ष पंक्ति को पंक्ति 2 मानते हैं।)
  • अन्यथा, एन का फ़्लिप्ड संस्करण (TN) + (TR) +2 है।

मुख्य फ़ंक्शन flipबस _flipशीर्ष पंक्ति से शुरू होने वाले सहायक फ़ंक्शन को कॉल करता है ।

(load library)

(def _flip
 (lambda (Num Row Triangular)
  (if (less? Triangular Num)
   (_flip Num (inc Row) (+ Triangular Row))
   (+ 2
    (- Triangular Num)
    (- Triangular Row))))))

(def flip
 (lambda (Num) (_flip Num 2 1)))
— DLosc
स्रोत
1

05AB1E , 9 बाइट्स

·LD£í˜¹<è

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

व्याख्या

·L          # push range [1 ... 2n]
  D         # duplicate
   £        # split the first list into pieces with size dependent on the second list
    í       # reverse each sublist
     ˜      # flatten
      ¹<è   # get the element at index <input>-1

दुर्भाग्य से चपटे दुर्भाग्य से बड़ी सूची को बहुत अच्छी तरह से संभाल नहीं करता है।
1 बाइट की कीमत पर हम OEIS पर पाए गए गणितीय सूत्र का उपयोग करके t2z + ¹n >-> कर सकते हैं ।floor(sqrt(2*n)+1/2)^2 - n + 1

— Emigna
स्रोत
1

बैच, 70 बाइट्स

@set/ai=%2+1,j=%3+i
@if %j% lss %1 %0 %1 %i% %j%
@cmd/cset/ai*i+1-%1

त्रिकोणीय संख्या के सूचकांक को खोजने के लिए एक लूप का उपयोग करता है कम से कम जितना बड़ा n।

— नील
स्रोत
0

APL (Dyalog), 27 बाइट्स

मैं एक ही bytecount में दो समाधान मिल गया है।

एक रेल:

⊢⊃⊃∘(,/{⌽(+/⍳⍵-1)+⍳⍵}¨∘⍳)

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

और एक dfn:

{⍵⊃⊃((⍳⍵),.{1+⍵-⍳⍺}+\⍳⍵)}

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

ये दोनों समाधान पहले फ़्लिप किए गए त्रिभुज को बनाते हैं और फिर तर्क ( 1-based) द्वारा बताए गए सूचकांक में तत्व को निकालते हैं ।

— क्रिकटी लिथोस
स्रोत
0

जे, 25 बाइट्स

3 :'>:y-~*:>.-:<:%:>:8*y'

स्पष्टीकरण के रूप में, विचार करें f(n) = n(n+1)/2। f(r), पंक्ति दी, मिरर किए गए त्रिकोण rकी rवें पंक्ति की बाईं ओर की संख्या को लौटाता है । अब, विचार करें g(n) = ceiling[f⁻¹(n)]। g(i), सूचकांक दिया जाता है i, उस पंक्ति को लौटाता है जिस पर सूचकांक मुझे मिलता है। फिर, f(g(n))पंक्ति की बाईं ओर की संख्या जिस पर n n पाया जाता है। तो, h(n) = f(g(n)) - (n - f(g(n)-1)) + 1उपरोक्त समस्या का जवाब है।

सरलीकरण, हम प्राप्त करते हैं h(n) = [g(n)]² - n + 1 = ceiling[(-1 + sqrt(1 + 8n))/2]² - n + 1।

@ अरनौलड के फॉर्मूले से ऐसा प्रतीत होता है कि:

ceiling[(-1 + sqrt(1 + 8n))/2] = floor[1/2 + sqrt(2n)]।

— ljeabmreosn
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.