इस पिरामिड का निर्माण करें

Question

आपका पिरामिड

जिस पिरामिड को मैं बनाना चाहता हूं, वह पूरी तरह से क्यूब्स से बना है। इसमें 24 परतें हैं, और ऊपर से एन ^वें परत में एन ² क्यूब्स हैं जो एन स्क्वायर द्वारा एन में व्यवस्थित है। पिरामिड इस तरह दिखता है:

पिरामिड का निर्माण करने के लिए, आपको क्यूब्स की आपूर्ति की आवश्यकता होगी। आपको ४ ९ ०० क्यूब्स दिए गए हैं जो given० बाय 70 वर्ग में व्यवस्थित हैं जो इस तरह दिखता है:

(ठीक है, मैं मानता हूं कि वर्ग की तस्वीर पूरी तरह से अनावश्यक है।)

1 ² + 2 ² + 3 ² + ... + 24 ² = 70 ^{2 के बाद से} , पिरामिड बनाने के लिए आपके पास बिल्कुल सही संख्या में क्यूब्स हैं। आपको बस इतना बताना है कि प्रत्येक घन कहाँ जाना चाहिए।

आपका कार्य

आपको वर्ग में क्यूब्स और पिरामिड में क्यूब्स के बीच एक मनमाना आक्षेप करना चाहिए। (यह अच्छा होगा यदि आपका उत्तर 4900 में से अलग-अलग जीवों का उपयोग कर रहा है।)

फिर, एक फ़ंक्शन या प्रोग्राम लिखें जो निम्न कार्य करता है:

• 70 में 70 वर्ग (निर्देशांक की एक जोड़ी के रूप में (X,Y)) एक घन के स्थान को देखते हुए ,
• पिरामिड में इसके स्थान को आउटपुट करें (निर्देशांक के एक ट्रिपल के रूप में (A,B,C))।

इनपुट और आउटपुट निर्देशांक सभी 0-अनुक्रमित या 1-अनुक्रमित हो सकते हैं। 1-अनुक्रमित माना जाता है, आपका इनपुट (X,Y)1 और 70 के बीच पूर्णांकों की एक जोड़ी (A,B,C)होगी। आपका आउटपुट पूर्णांकों का ट्रिपल होगा; Aशीर्ष (1 और 24 के बीच) से लेयर काउंटिंग (B,C)होनी चाहिए और उस लेयर (1 और A) के बीच उस क्यूब के निर्देशांक होने चाहिए ।

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

• पिरामिड के शीर्ष घन में निर्देशांक है (1,1,1)।
• पिरामिड के आधार के चारों कोनों है निर्देशांक (24,1,1), (24,1,24), (24,24,1), और (24,24,24)।
• यदि आप पिरामिड के कोनों पर वर्ग के कोनों को रखने का निर्णय लेते हैं, तो इनपुट पर (70,1)आप आउटपुट दे सकते हैं (24,24,1)।

आप मान सकते हैं कि आपको केवल (X,Y)इनपुट के रूप में मान्य निर्देश दिए जाएंगे । सुधार पूरी तरह से निम्नलिखित नियम द्वारा निर्धारित किया जाता है: दो अलग-अलग वैध इनपुट हमेशा दो अलग-अलग वैध विवाद देना चाहिए।

यह कोड-गोल्फ है : सबसे छोटा कोड जीतता है।

Answer 1

जेली , 15 14 बाइट्स

24p;€$€Ẏ
ḅ70ị¢

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

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

यह सबमिशन या तो एक पूर्ण प्रोग्राम के रूप में काम करता है ( [x, y]पहले कमांड लाइन तर्क और मानक आउटपुट पर आउटपुट के माध्यम से निर्देशांक ले रहा है ), या एक फ़ंक्शन के रूप में, संक्षेप में नाम दिया गया है 2Ŀ।

व्याख्या

सूची का निर्माण

हम संख्या के साथ शुरू करते हैं 24, जिसे 1 से 24 तक की सीमा के रूप में व्याख्या किया जाता है (क्योंकि हम इसका उपयोग करने की कोशिश कर रहे हैं जैसे कि यह एक सूची थी)। फिर हम उस पर पुनरावृति करते हैं; €इस कार्यक्रम में आखिरी क्या है। सूची के प्रत्येक तत्व n के लिए:

• हम जोड़े की सूची का निर्माण करते हैं x , y जहां प्रत्येक तत्व 1 से आता है .. n ; pतत्वों के दो सेट दिए गए जोड़े की एक सूची का निर्माण करता है, और क्योंकि केवल एक ही मूल्य यहाँ उपलब्ध है ( n ), इसका उपयोग दोनों सेटों के लिए किया जाता है, जो दोनों इसलिए 1 .. n से एक सूची बन जाते हैं ।
• हम सूची के प्रत्येक तत्व के लिए n (फिर, एकमात्र मूल्य जो हमारे पास उपलब्ध है) को जोड़ते हैं ;€।
• दूसरे €इन दोनों ऑपरेशनों को प्रत्येक n पर लागू करने के लिए (यानी दो निर्देशों वाले लूप बनाने के लिए), हम $दो निर्देशों को एक में समूहित करने के लिए उपयोग करते हैं।

अंत में, हम Ẏसूची को एक चरण में समतल करने के लिए उपयोग करते हैं, ताकि एक सूची प्राप्त हो सके जिसमें बस सभी निर्देशांक शामिल हों। यह इस तरह शुरू होता है:

[१, १, १], [१, १, २], [१, २, २], [२, १, २], [२, २, २], [१, १, ३], [१ , 2, 3], [1, 3, 3], [2, 1, 3], [2, 2, 3], [2, 3, 3], [3, 1, 3], [3, 2 , 3], [3, 3, 3], [1, 1, 4], [1, 2, 4], [1, 3, 4], [1, 4, 4], [2, 1, 4] ], [२, २, ४,], २, ३, ४], [२, ४, ४], [३, १, ४], [३, २, ४], [३, ३, ४] [३, ४, ४], [४, १, ४], [४, २, ४], [४, ३, ४], [४, ४, ४], ...

और [24, 24, 24] के साथ समाप्त होता है।

सूची को अनुक्रमित करना

हम इनपुट निर्देशांक को एक आधार 70 पूर्णांक: them70 के रूप में व्याख्या करके संख्या में परिवर्तित करके शुरू करते हैं: the70। यह हमें 71 से 4970 की रेंज में एक मूल्य देता है; ये सभी मान अद्वितीय मॉड 4900 ịहैं। सूची में सूची की लंबाई modulo में अनुक्रमित होती है, इसलिए [1, 1]हमें 71 [1, 2]वां तत्व, 72 वां तत्व, सभी तरह से मिलेगा [70, 70]जो हमें 70 वां तत्व देता है (अर्थात उत्तर के लिए तत्व से पहले) [1, 1])। अंत में, हमें केवल ¢यह बताने की जरूरत है कि कौन सी सूची को सूचीबद्ध करें (इस मामले में, यह पिछली पंक्ति द्वारा निर्दिष्ट सूची है; यही वह ¢है, पिछली पंक्ति को बिना किसी तर्क के चलाएं)।

Comments

14 बाइट्स

— caird coinheringaahing

Answer 2

PHP, 75 82 78 बाइट्स

0-अनुक्रमित :

सेट पी = एक्स * 70 + वाई फिर पी को ए ^{2 से} कम करें जबकि सही परत तक नीचे जाएं। A-1; पी / ए; पी% ए - किया।

(उलट: ए को सही परत पर बढ़ाते समय: पी = पी + ए ² फिर पी = पी + ए * बी + सी -> एक्स = पी / inc०, वाई = पी% inc०)

for($p=$argv[1]*70+$argv[2];$p>=++$a**2;$p-=$a**2);echo$a-1,_,$p/$a|0,_,$p%$a;

के साथ भागो php -nr '<code>' <X> <Y>; प्रिंट A_B_C

1-अनुक्रमित, 82 बाइट्स :

for($p=$argv[1]*70+$argv[2]-71;$p>++$a**2;$p-=$a**2);echo$a,_,$p/$a+1|0,_,$p%$a+1;

Comments

क्या आपको इसके बजाय P को X * 70 + Y पर सेट नहीं करना चाहिए?

— मिशा लावरोव

Answer 3

पायथन, 80 73 72 बाइट्स

पहला सबमिशन, बहुत कठोर न बनें:

0 अनुक्रमित

lambda x,y:[(a-1,b//a,b%a)for a in range(25)for b in range(a*a)][70*x+y]

सभी पिरामिडों के साथ 4900 लंबाई की सूची बनाता है और प्रत्येक इनपुट के लिए एक अलग सूची प्रविष्टि देता है।

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

Comments

साइट पर आपका स्वागत है और अच्छी पहली पोस्ट! बहुत सारे पायथन गोल्फर हैं जो आपके समाधान के लिए यहां से नीचे जाने की कोशिश करने को तैयार हैं, और मुझे उम्मीद है कि आप पीपीसीजी का आनंद लेंगे!

— 1

आप एक बाइट को बचाने के a**2लिए छोटा कर सकते हैं a*a।

— ल्यूक

वाह, एक सरल एक है। धन्यवाद।

— पट्टुएक्स

Answer 4

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

x,y=input()
n=-70*x-y
i=1
while n<0:i+=1;n+=i*i
print~-i,n/i,n%i

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

Comments

इसने C,

— थैंक्स के

Answer 5

सी 89 , 87 , 82 , 71 बाइट्स

Xnor के पायथन समाधान को लिया, और लाइनब्रेक को हटा दिया

p(x,y){for(x=-70*y-x,y=1;x<0;x+=++y*y);printf("%d %d %d",~-y,x/y,x%y);}

0 अनुक्रमित

z;p(x,y){for(x+=y*70+1,y=z=0;z<x;z+=++y*y);z-=x;printf("%d %d %d\n",y-1,z/y,z%y);}

1 अनुक्रमित

z;p(x,y){for(x+=~-y*70,y=z=1;z<x;z+=++y*y);z-=x-y;printf("%d %d %d\n",y,z/y,z%y+1);}

Comments

मुझे लगता है कि यह 1-अनुक्रमित संस्करण में z / y + 1 होना चाहिए।

— टाइटस

@ मैं यह नहीं देखता कि यह ओपी के प्रश्न का अनुपालन क्यों करता है

— प्रिंसपोलका

Answer 6

बैच, 103 बाइट्स

@set/an=%1*70+%2,i=0
:l
@set/an-=i*i,j=i,i+=1,k=n%%i,l=n/i
@if %l% geq %i% goto l
@echo %j% %k% %l%

0 अनुक्रमित। ऊपर से शुरू होने वाली प्रत्येक परत के माध्यम से काम करता है।

Answer 7

जे, 37 बाइट्स

-4 बाइट्स FrownyFrog के लिए धन्यवाद

(a:-.~,(<:,&.>{@;~&i.)"0 i.25){~70&#.

जेली विधि में जेली विधि का बहुत सीधा अनुवाद 0 अनुक्रमण करता है। शीर्ष पिरामिड वर्ग सबसे पहले है। आधार का निचला दायां कोना अंतिम है।

कोड के बहुमत एक निरंतर के रूप में ट्रिपल अनुक्रमित सूची का उत्पादन करने के लिए बॉयलरप्लेट है। 2 तत्व इनपुट के आधार पर उस सूची के भीतर सही तत्व का पता लगाना केवल आधार 70 से अनुवाद की बात है70&#.

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

Comments

(#~~:&a:)->a:-.~

— FrownyFrog

@FrownyFrog धन्यवाद जैसा कि अक्सर जे में मेरे साथ होता है, मैंने उस चाल का उपयोग पहले किया है और इस मामले में इसके बारे में भूल गया हूं। Btw, आप इस सवाल में रुचि हो सकती है , जो इस समस्या से प्रेरित था।

— जोनाह

Answer 8

भूसी , 13 बाइट्स

!foEG▲π3Π4B70

इसे ऑनलाइन आज़माएं! संकेत 1 से शुरू होते हैं।

व्याख्या

कुछ अन्य उत्तरों की तरह, मैं पिरामिड निर्देशांक की पूरी सूची का निर्माण करता हूं और बस इसमें अनुक्रमित करता हूं। मैं यह उन सभी त्रिभुजों को सूचीबद्ध करके करता हूँ [A,B,C]जहाँ संख्याएँ 1 और 24 के बीच होती हैं (जिन्हें बाइट बचाने के लिए 4 के रूप में व्यक्त किया जाता है) और जिनके लिए उन्हें रखा जाता है A >= max(B,C)।

!foEG▲π3Π4B70  Implicit input: a list of two numbers.
          B70  Interpret in base 70.
!              Modular index into the following list:
        Π4      Factorial of 4: 24
      π3        Take range and 3-fold Cartesian power: [[1,1,1],[1,1,2],..,[24,24,24]]
 f              Filter by
  oE            all values are equal
    G▲          in cumulative reduce by maximum.