एक अंकित घन पर आउटपुट अंकित करें

Question

किसी भी तरह से क्यूब के 7 से 8 कोने तक संख्या 0 से असाइन करें। वास्तव में प्रत्येक वर्टेक्स को एक नंबर सौंपा जाना चाहिए।

उदाहरण के लिए, आपके शीर्षकों को इस तरह सौंपा जा सकता है:

  3-----1
 /|    /|
4-----2 |
| |   | |
| 5---|-0
|/    |/
6-----7

एक प्रोग्राम को 0 से 5 तक पूर्णांक में लिखें। इनमें से प्रत्येक 6 नंबर आपके क्यूब के बिल्कुल एक चेहरे के साथ जुड़ा हुआ है जिसे आप पसंद करते हैं। जब इन नंबरों में से एक इनपुट होता है, तो संबंधित चेहरे के 4 शीर्ष संख्याओं को अंकों के 2 × 2 वर्ग में स्टडआउट करने के लिए मुद्रित किया जाना चाहिए। चेहरे को क्यूब के बाहर से सीधा देखना है। सभी 4 फेस रोटेशन मान्य हैं।

उदाहरण के लिए, यदि 0 ऊपर के उदाहरण के घन के सामने वाले भाग से जुड़ा है, तो यह इनपुट के लिए एक मान्य आउटपुट होगा 0:

42
67

चेहरे को किसी भी 90 ° रोटेशन पर देखा जा सकता है, इसलिए ये भी मान्य हैं:

27
46

76
24

64
72

यह आउटपुट (और इसके घुमाव) मान्य नहीं हैं , क्योंकि वे चेहरे के गलत पक्ष से देखे जाते हैं:

24
76

एक ही विचार अन्य सभी चेहरों पर लागू होता है। उदाहरण के लिए यदि 1 बैक फेस से जुड़ा है, तो इनपुट 1आउटपुट उत्पन्न कर सकता है 13[newline]05(और 31[newline]50अमान्य होगा)।

तो असली चुनौती आपके वर्टेक्स नंबर और रोटेशन को चुन रही है जैसे कि इनपुट को उसके 4 वर्टेक्स नंबर में ट्रांसलेट करना आसान और छोटा है।

बाइट्स में सबसे छोटा कोड जीतता है। टाईब्रेकर पहले की पोस्ट है। ( आसान बाइट काउंटर। )

टिप्पणियाँ

• आप एक कार्यक्रम के बजाय एक समारोह लिख सकते हैं। इसे 0 से 5 तक पूर्णांक लेना चाहिए और 2 × 2 अंक ग्रिड स्ट्रिंग को प्रिंट या वापस करना चाहिए।
• स्टड, कमांड लाइन या फ़ंक्शन arg से इनपुट लें। आप मान सकते हैं कि इनपुट वैध है।
• आउटपुट में वैकल्पिक रूप से एक अनुगामी न्यूलाइन हो सकती है।
• अपने द्वारा चुने गए शीर्ष और चेहरे की संख्या हमें बताना सुनिश्चित करें।

Answer 1

सीजेएम, 23 16 बाइट्स

इस समस्या का एक सुंदर गणितीय समाधान है। लेकिन मुझे कोई सुराग नहीं है कि किसी को कैसे खोजना है, इसलिए सुपर संपीड़ित हार्ड कोडिंग है!

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

li_o1^_p_6|o3+6%

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

घन लेआउट

  4-----7          4-----7          3-----2
 /|    /|         /  0  /|         /  3  /|
1-----0 |        1-----0 |        6-----5 |
| |   | |        |     |2|        |     |4|
| 5---|-2        |  1  | 2        |  5  | 7
|/    |/         |     |/         |     |/ 
6-----3          6-----3          1-----4  

व्याख्या

मेरे पुराने जवाब ने पहले से ही क्यूब को बाहर रखा है, ताकि प्रत्येक चेहरे को चेहरे की संख्या के बराबर अपनी पहली (शीर्ष-बाईं ओर) शीर्ष संख्या के साथ वर्णित किया जा सके। लेकिन मैं चेहरे की संख्या का उपयोग करके अधिक शीर्ष संख्याओं की गणना करने में सक्षम होना चाहता था। कुछ बिंदु पर, मैं इस विचार के साथ आया कि मेरे पैर को दरवाजे में मिला, दूसरे नंबर (शीर्ष-बाएं) की शीर्ष संख्या की गणना चेहरे के नंबर XOR के रूप में 1. और परीक्षण और त्रुटि के थोड़ी देर बाद, मैं ऊपर आने में कामयाब रहा। ऊपर दिखाए गए लेआउट और नीचे दिए गए फ़ार्मुलों के साथ जो मुझे एक चेहरे के लिए हर शीर्ष संख्या की गणना करने की अनुमति देते हैं n:

• बाएं से बाएं: n
• दायां शीर्ष: n^1
• नीचे बाएँ: (n^1)|6
• नीचे दाएं: ((n^1)+3)%6

संदर्भ के लिए, मैं यहां वांछित लेआउट में प्रत्येक चेहरे के लिए आउटपुट पुन: पेश करूंगा:

Face:      0     1     2     3     4     5

Vertices:  01    10    23    32    45    54
           74    63    70    65    72    61

तो पूरा कार्यक्रम सिर्फ इनपुट फेस नंबर को पढ़ने और इन मूल्यों का उत्पादन करने के लिए नीचे आता है, भले ही अलग-अलग छोरों के लिए थोड़ा अलग प्रिंटिंग लॉजिक हो। ध्यान दें, क्योंकि पहले आधार के बाद शुरू होने वाले प्रत्येक शीर्ष को n^1मुझे केवल एक बार गणना करने की आवश्यकता होती है, जो तर्क को और भी अधिक संकुचित कर देता है।

---

पश्चाताप के लिए, और क्योंकि मुझे लगता है कि यह अभी भी एक अच्छा दृष्टिकोण था, यहाँ मेरा पुराना जवाब है।

सीजेएम, 23 बाइट्स

इस समस्या का एक सुंदर गणितीय समाधान है। लेकिन मुझे कोई सुराग नहीं है कि किसी को कैसे खोजना है, इसलिए सुपर संपीड़ित हार्ड कोडिंग है!

"pÜ×ñè¨"487b8b3/ri_o=~p

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

घन लेआउट

  0-----7          0-----7          3-----6
 /|    /|         /  0  /|         /  3  /|
1-----2 |        1-----2 |        4-----5 |
| |   | |        |     |2|        |     |5|
| 5---|-6        |  1  | 6        |  4  | 7
|/    |/         |     |/         |     |/ 
4-----3          4-----3          1-----0  

व्याख्या

नियोजित मूल दृष्टिकोण कठिन कोड को प्रत्येक चेहरे के लिए यथासंभव कम स्थान पर कोड करना है। ऑप्टिमाइज़र के आधार रूपांतरण समाधान के लिए इसी तरह, यह शीर्ष सूची को एक अष्टक संख्या के रूप में मानता है जिसे ASCII वर्ण डेटा के रूप में पैक किया गया है। लेकिन इसके बारे में जहां समानताएं आगे के अनुकूलन के लिए रास्ता बनाती हैं!

यहाँ तीन प्रमुख अनुकूलन हैं जो मैंने "भोली" समाधान के लिए किए हैं:

• क्यूब को ऐसे बिछाएं कि प्रत्येक चेहरे को उसके चेहरे की संख्या के साथ पहली शीर्ष संख्या के रूप में वर्णित किया जा सके। जैसा कि ऊपर प्रस्तुत किया गया है, मेरे घन लेआउट को देखते हुए, कोई यह देख सकता है कि प्रत्येक चेहरे की शीर्ष-बाईं ओर की शीर्ष संख्या चेहरे की संख्या के बराबर है। यह मुझे इनपुट बैक को प्रिंट करने की लागत पर छह कम आवृत्तियों को एनकोड करने की अनुमति देता है, जो एक बाइट को बचाने के लिए निकलता है।
• शीर्ष डेटा को एक स्ट्रिंग में पैक करें जिसके लिए प्रत्येक "वर्ण" में अधिकतम 256 से अधिक हो। जैसे ही यह अधिकतम पिछले 256 से बढ़ता है, स्ट्रिंग की लंबाई धीरे-धीरे कम हो जाती है, लेकिन यह संभावना बढ़ जाती है कि कोई भी "वर्ण" 256 से अधिक है और है इस प्रकार अब 1-बाइट ASCII वर्ण सेट का हिस्सा नहीं है। इसलिए मैंने एक ऐसा प्रोग्राम लिखा, जिसमें 256 से 1000 तक हर बेस में वर्टेक्स डेटा को एन्कोड करने की कोशिश की गई, जिसके साथ मुझे लगभग 10 ऐसे बेस मिले, जो बेस 256 की तुलना में कैरेक्टर डेटा के एक बाइट को बचाते हैं। मैंने 487 को चुना, क्योंकि इसमें भी अच्छी प्रॉपर्टी है परिणामी स्ट्रिंग में पूरी तरह से मुद्रण योग्य ASCII शामिल हैं।
• पहले अनुकूलन के साथ मिश्रित, आउटपुट को विषम रूप से उत्पन्न करता है। सीजेएम में सामान्य दृष्टिकोण 2-तत्व सूचियों की 2-तत्व सूची के रूप में शीर्ष डेटा को प्रारूपित करना होगा, बीच में एक नई रेखा डालें, और आउटपुट को स्पष्ट रूप से मुद्रित होने दें। लेकिन मैं इसके बजाय पहले वर्टेक्स (इनपुट फेस नंबर के बराबर) को एक ऑपरेटर के साथ प्रिंट करता हूं जो एक नई रेखा नहीं जोड़ता है, दूसरे वर्टीकल्स की 3-एलिमेंट लिस्ट को पुनः प्राप्त करता है, अगले वर्टेक्स को पकड़ता है और इसे जोड़ने वाले ऑपरेटर के साथ प्रिंट करता है एक newline, और अन्य दो कोने स्पष्ट रूप से मुद्रित होने दें। यह एक बाइट बचाता है।

Comments

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

— पीटर टेलर

आपका नवीनतम उत्तर शानदार है। मुझे लगता है कि आपको इसे एक अलग उत्तर के रूप में पोस्ट करना चाहिए क्योंकि यह पूरी तरह से अलग दृष्टिकोण है और किसी अन्य अपवोट के योग्य है। मूल रूप से आपके पास मेरे सी उत्तर के समान ही क्यूब है लेकिन पहले तीन के साथ भी कोने एक स्थान पर स्थानांतरित हो गए हैं। मुझे विश्वास नहीं हो रहा है कि मैं चूक गया 6+n%2 --> 6|n(मैंने पहले ही अपने रूबी के जवाब में इसे शामिल कर लिया है।) ध्यान दें कि n --> n^1चेहरों पर परिवर्तन करके आप अपने सूत्रों को सरल बना सकते हैं, हालांकि मैं अनुमान लगा रहा हूं कि जैसे-जैसे आप हारेंगे nऔर n^1जीतते जाएंगे। अपने स्कोर में मदद नहीं करेगा।

— लेवल रिवर सेंट

@steveverrill प्रशंसा के लिए धन्यवाद! मैंने चैट में पूछा कि क्या मुझे इसे पूरी तरह से नए उत्तर के रूप में पोस्ट करना चाहिए, लेकिन आम सहमति नहीं थी इसलिए मैंने ऐसा नहीं किया। मैं निश्चित रूप से खुद से प्रसन्न था जब मुझे एहसास हुआ कि सावधानी से nऔर n^1क्यूब के चारों ओर जोड़े मुझे बस के साथ एक और शीर्ष की गणना करने की अनुमति देंगे |6। और मैंने उस n --> n^1परिवर्तन को नहीं देखा , जो निश्चित रूप से समझ में आता है। लेकिन आपने सही ढंग से कहा कि यह वास्तव में मेरे स्कोर को प्रभावित नहीं करेगा, इसलिए मैं शायद इसे छोड़ दूंगा।

— रनर ११

मैंने आगे बढ़कर अपने XOR विचार को अपने रूबी के उत्तर में शामिल कर लिया है। यह 10 की बचत देता है (2 के अलावा के लिए 6+n%2 --> 6|n) मुझे आशा है कि आपको कोई आपत्ति नहीं है। मैंने n --> n^1चेहरों पर परिवर्तन का उपयोग किया , इसलिए मेरा नवीनतम संशोधन आपके जैसे ही आउटपुट देता है, लेकिन विभिन्न इनपुट के साथ। BTW, मुझे नहीं लगता कि बिट ऑपरेशन असंगत हैं, यह सब निर्भर करता है कि आप उनका उपयोग कैसे करते हैं!

— लेवल रिवर सेंट

1 गोल्फर में छोटा है:~.1^..n@6|@3+6%

— पीटर टेलर

Answer 2

सी, 69

f(c){int d=c++%2*2-1;printf("%d%d\n%d%d",(c-d)%6,c%6,c%2+6,(c+d)%6);}

परीक्षण कार्यक्रम में अपराजित

f(c){
 int d=c++%2*2-1;
 printf("%d%d\n%d%d",(c-d)%6,c%6,c%2+6,(c+d)%6);
}

int n;
main(){
  scanf("%d",&n);
  f(n);
}

व्याख्या

मेरा घन नंबरिंग, जब सामने आया, इस तरह दिखता है:

0---7
|   |
| 0 |
|   |
1---2---7 
|   |   |
| 1 | 2 |
|   |   |
6---3---4---7
    |   |   |
    | 3 | 4 |
    |   |   |
    6---5---0
        |   |
        | 5 |
        |   |
        6---1

शीर्ष बाएं कोने में चेहरे के समान संख्या है।

निचले दाएं कोने में नंबर है (n+2)%6

विषम के nलिए शीर्ष दायां कोना है (n+1)%6और नीचे बाईं ओर है6

यहां तक nकि शीर्ष दाएं कोने के लिए 7और नीचे बाईं ओर है(n+1)%6

कार्यक्रम विषम संख्याओं को प्रदर्शित करता है और समान संख्या में 180 डिग्री घुमाया जाता है। इसका मतलब यह है कि शीर्ष दायां कोना सदैव होता है (n+1)%6और नीचे का बायां भाग हमेशा होता है (n+1)%2+6। इन्वर्ट करना nऔर n+2आसान है (इसे जोड़ना या जोड़ना या घटाना या आवश्यक के रूप में c=n+1उपयोग करके dकिया जाता है।)1-1

उत्पादन

$ ./a
0
21
70

$ ./a
1
12
63

$ ./a
2
43
72

$ ./a
3
34
65

$ ./a
4
05
74

$ ./a
5
50
61

Comments

+1 यह एक प्रकार का सुरुचिपूर्ण गणितीय समाधान है जिसकी मैं कल्पना कर रहा था। दुर्भाग्य से, यह C ...

— Runer112

@ Runer112 धन्यवाद। दुर्भाग्य से, सी वह भाषा है जिसे मैं सबसे अच्छी तरह से जानता हूं। मैं रूबी सीख रहा हूं लेकिन मैं अभी भी एक शुरुआत हूं। रूबी को इस स्कोर को तोड़ने में सक्षम होना चाहिए, लेकिन शायद सीजम के साथ प्रतिस्पर्धा नहीं करनी चाहिए। शायद मैं रूबी में बाद में पोस्ट करूंगा, या बस मेरे सी उत्तर में कुछ मामूली सुधार पाएंगे (उदाहरण के लिए चेहरे c%6को बदलकर c%=6और घुमाकर ताकि यह पहले आ जाए, कुछ मापांक गणनाओं को समाप्त करना संभव हो।) प्रयोग करने के लिए एक और चीज। एक स्थान पर चेहरे के लेबलिंग को स्थानांतरित करना, इसलिए मुझे n-1,n,n+1इसके बजाय मिलता है n,n+1,n+2।

— लेवल रिवर सेंट

@steveverrill आप पहले से ही nवैश्विक घोषित कर रहे हैं , इसलिए आप इसे उच्चतर घोषित करके कुछ बाइट्स बचा सकते हैं, हस्ताक्षर बदल सकते हैं f()? या हम केवल fयहाँ फ़ंक्शन देख रहे हैं?

— dwcanillas

@dwcanillas "You may write a function instead of a program"तो मैं केवल फ़ंक्शन गिन रहा हूं। किसी भी मामले में, यह उस भाषा में अवधारणा का एक प्रमाण था जिससे मैं सबसे अधिक परिचित हूं। मैं अपने रूबी जवाब को छोटा करने में अधिक रुचि रखता हूं, जो शुरू से ही इससे बहुत कम था।

— लेवल रिवर सेंट

Answer 3

तत्व, १ 18

_4:2%6+``2+6%`-5+`

कई और अधिक उन्नत गोल्फिंग भाषाओं के विपरीत, एलिमेंट में एक कम्प्रेशन ऑपरेटर नहीं होता है, इसलिए समाधान की संक्षिप्तता उपयोग की गई सटीक नंबरिंग स्कीम के बजाय निकटता से बंधी होती है। कुछ प्रयोग के बाद, मैंने एक नई नंबरिंग योजना बनाई है जो केवल सरल अंकगणितीय परिचालनों का उपयोग करके वर्टिकल की गणना करने की अनुमति देती है।

  1-----0          1-----0          2-----5
 /|    /|         /  4  /|         /  3  /|
4-----6 |        4-----6 |        3-----7 |
| |   | |        |     |0|        |     |5|
| 7---|-5        |  2  | 5        |  1  | 0
|/    |/         |     |/         |     |/ 
3-----2          3-----2          4-----1  

शीर्ष-बाएँ कोने 6 है तो भी और यदि विषम हो तो 7। टॉप-राइट कॉर्नर फेस नंबर ही है। बॉटम-लेफ्ट फेस नंबर, प्लस 2, मॉड 6 है। बॉटम-राइट फेस नंबर 5 माइनस है।

यहाँ कोड का स्पष्टीकरण दिया गया है।

_4:2%6+``2+6%`-5+`
_4:                    take input and make several copies of it
   2%6+`               take face #, mod 2, add 6, and output
        `              output input, which already has the newline attached
         2+6%`         take face #, add 2, mod 6, and output
              -5+`     negate face #, add 5, and output

यहाँ प्रत्येक चेहरे के लिए आउटपुट दिए गए हैं:

0
60
25

1
71
34

2
62
43

3
73
52

4
64
01

5
75
10

Comments

+1: हालांकि मुझे आपका कोड अशोभनीय लगता है, लेकिन यह देखना अच्छा है कि गोल्फ की भाषा में यह स्कोर कैसा है। ऐसा लगता है कि आप वर्तमान में संयुक्त 3 वें स्थान पर हैं, 2 सीजेएम उत्तर के पीछे: पीटर टेलर और रनर 112।

— लेवल रिवर सेंट

अब यह एक ठोस दूसरे स्थान पर है, लेकिन मैं इसे सीजेएम की पिटाई करने से नहीं रोकता।

— PhiNotPi 13

Answer 4

ऑक्टेव, 108 100 68 50 बाइट्स

बेशक यह मेरे पिछले दृष्टिकोण, सादे हार्डकोडिंग की तुलना में अधिक सुरुचिपूर्ण तरीके से करने का एक तरीका है। मैं हैरान हूँ कि कैसे ऑक्टेव मैटलैब की तुलना में कोडगुल्फ़ के लिए अधिक उपयुक्त है)

f=@(n)['040201375767';'261345154623'](:,2*n+(1:2))

लेआउट:

(क्षमा करें, मैं इसे जोड़ना भूल गया।)

घन लेआउट

  1-----5          1-----5          6-----7
 /|    /|         /  2  /|         /  5  /|
0-----4 |        0-----4 |        2-----3 |
| |   | |        |     |4|        |     |3|
| 3---|-7        |  0  | 7        |  1  | 5
|/    |/         |     |/         |     |/ 
2-----6          2-----6          0-----1  

पुराने संस्करणों:

f=@(n)[0 4 0 2 0 1 3 7 5 7 6 7;2 6 1 3 4 5 1 5 4 6 2 3](:,2*n+(1:2))

यहां तक ​​कि पुराने संस्करण:

यह वास्तव में एक 2x2x2 सरणी बनाने वाला है और फिर एक 'स्लाइस' चुनना। हम एक 3D मैट्रिक्स क्रमपरिवर्तन करते हैं और हर बार शीर्ष या निचले स्लाइस का चयन करते हैं। (यह मैट्रिक्स के बजाय एक अभिव्यक्ति के अनुक्रमण के कारण matlab में काम नहीं करता है) मुझे यकीन है कि ऐसा करने के अधिक प्रत्यक्ष तरीके होंगे जो कम होंगे।

f=@(n)squeeze(permute(reshape(0:7,2,2,2),circshift((1:3)',n))(n=fix(n/3)+1,circshift((1:2)',n-1),:))

f=@(n)squeeze(permute(reshape(0:7,2,2,2),circshift((1:3)',n))(floor(n/3)+1,circshift((1:2)',floor(n/3)),:))

Answer 5

CJam, 31 28 (या 26) बाइट्स

8,2/W%_1m<]z[D75K46]2/+ri=N*

जो 26 बाइट्स संस्करण में आधार रूपांतरण का उपयोग करके भी संपीड़ित किया जा सकता है ।

क्यूब की तरह लगता है:

  7-----1
 /|    /|
5-----3 |
| |   | |
| 6---|-0
|/    |/
4-----2

जैसे चेहरों के साथ

  7-----1      .-----.      .-----.      .-----.
 /  4  /|     /  4  /|     /  4  /|     /  0  /|
5-----3 |    .-----. |    .-----. |    .-----. |
|     |2|    |     |1|    |     |0|    |     |5|
|  1  | 0    |  0  | .    |  3  | .    |  3  | .
|     |/     |     |/     |     |/     |     |/ 
4-----2      .-----.      .-----.      .-----.    

इसे यहाँ ऑनलाइन आज़माएँ

Answer 6

CJam (25 बाइट्स)

"ñRXµ  roM~"(ib65b2/q~=N*

इसमें एक गैर-मुद्रण योग्य वर्ण और एक टैब (जिसे StackExchange सॉफ़्टवेयर द्वारा मंगाई जाएगी) है, इसलिए xxd प्रारूप में:

0000000: 22f1 5258 1fb5 0972 6f4d 7e22 2869 6236  ".RX...roM~"(ib6
0000010: 3562 322f 717e 3d4e 2a                   5b2/q~=N*

ऑनलाइन डेमो

घन:

  1-----0        Faces:
 /|    /|        10 46
4-----6 |        14 37
| |   | |        20 31
| 3---|-2        23 57
|/    |/         56 20
7-----5          57 64

यह शुद्ध हार्ड-कोडिंग है, क्यूब वर्जन के साथ बेस कंप्रेस को अधिकतम करने के लिए चुना गया है। मैं 2-अंकीय संख्याओं को डिकोड करता हूं, इसलिए उनमें से कोई भी 0. के साथ शुरू नहीं हो सकता है। मैं नहीं चाहता कि कोई भी 7 के साथ शुरू हो, क्योंकि दूसरा आधार बहुत अधिक है। इसलिए 0 और 7 एक लंबे विकर्ण पर होना चाहिए। मैं एन्कोडिंग मान को कम करने के लिए पहले एक 10 बढ़त चाहता हूं। इसके अलावा, बाइट काउंट को बदले बिना लचीलेपन की एक उचित मात्रा है।

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

Answer 7

जावास्क्रिप्ट (ईएस 6), 53 62

टेम्पलेट स्ट्रिंग्स का उपयोग करके सहेजें 8 बाइट्स संपादित करें, thx @NinjaBearMonkey। खबरदार, उद्धरण के अंदर newlines महत्वपूर्ण हैं और ध्वस्त नहीं किया जा सकता है।

जावास्क्रिप्ट में चतुर नहीं हो सकता, यह बहुत क्रिया है।

f=n=>`01
23
45
67
01
31
5702
64`.substr(n-4?n*3:20,5)

उत्पादन for(i=0;i<6;i++)console.log(f(i),i)

०१
२३
०

२३
४५
१

४५
६
2 २

६।
०१
३

02
64
4

31
57
5

संख्या संघों को सत्यापित करने के लिए स्निपेट देखें ( यह मजेदार था)

function P3D(x,y,z) {
    this.x = x;this.y = y;this.z = z;
    this.rotateX = angle => {
        var rad = angle * Math.PI / 180,
        cosa = Math.cos(rad),sina = Math.sin(rad),
        y = this.y * cosa - this.z * sina,
        z = this.y * sina + this.z * cosa
        return new P3D(this.x, y, z)
    }
    this.rotateY = angle => {
        var rad = angle * Math.PI / 180,
        cosa = Math.cos(rad), sina = Math.sin(rad),
        z = this.z * cosa - this.x * sina,
        x = this.z * sina + this.x * cosa
        return new P3D(x,this.y, z)
    }
    this.rotateZ = angle => {
        var rad = angle * Math.PI / 180,
        cosa = Math.cos(rad), sina = Math.sin(rad),
        x = this.x * cosa - this.y * sina,
        y = this.x * sina + this.y * cosa
        return new P3D(x, y, this.z)
    }
    this.project = (viewWidth, viewHeight, fov, viewDistance) => {
        var factor = fov / (viewDistance + this.z),
        x = this.x * factor + viewWidth / 2,
        y = this.y * factor + viewHeight / 2
        return new P3D(x, y, this.z)
    }
}
 
var vx = [
    new P3D(-1,1,-1),
    new P3D(1,1,-1),
    new P3D(-1,-1,-1),
    new P3D(1,-1,-1),
    new P3D(-1,-1,1),
    new P3D(1,-1,1),
    new P3D(-1,1,1),
    new P3D(1,1,1),
];
// Define the vx that compose each of the 6 faces. These numbers are
// indices to the vertex list defined above.

var faces = [[0,1,3,2],[2,3,5,4],[4,5,7,6],[6,7,1,0],[0,2,4,6],[1,3,5,7]]

faces.map((f,i)=>{
    var mx=vx[f[0]].x+vx[f[1]].x+vx[f[2]].x+vx[f[3]].x,
    my=vx[f[0]].y+vx[f[1]].y+vx[f[2]].y+vx[f[3]].y,
    mz=vx[f[0]].z+vx[f[1]].z+vx[f[2]].z+vx[f[3]].z
    vx[i+10]=new P3D(mx/4, my/4, mz/4)
    f[4]=i
    f[5]=i+10
})

var angle = 0;

var ctx = CV.getContext("2d");

setInterval(loop,33)
 
function loop() {
    ctx.fillStyle = "#fff"
    ctx.fillRect(0,0,400,200);
    ctx.font = "20px Arial"
    angle += 2
    
    var t = vx.map(v=>
        v
        .rotateX(angle).rotateY(-angle).rotateZ(-angle)
        .project(400,200,128,3)
    )
    
  
    ctx.strokeStyle = "#f00"
    t.forEach((v,i)=>i<8?ctx.strokeText(i,v.x,v.y):0)

    ctx.strokeStyle = "#428"
    ctx.beginPath()
    faces.forEach(f=>(                         
        ctx.moveTo(t[f[0]].x,t[f[0]].y),
        ctx.lineTo(t[f[1]].x,t[f[1]].y),
        ctx.lineTo(t[f[2]].x,t[f[2]].y),
        ctx.lineTo(t[f[3]].x,t[f[3]].y),
        ctx.lineTo(t[f[0]].x,t[f[0]].y),
        ctx.strokeText(f[4],t[f[5]].x,t[f[5]].y)
    ))
    ctx.closePath(),
    ctx.stroke()
}

<canvas id=CV width=400 height=200></canvas>

Comments

यदि आप ES6 टेम्प्लेट स्ट्रिंग्स का उपयोग करते हैं , तो आप इसके बजाय एक्टीव न्यूलाइन वर्णों का उपयोग कर सकते हैं \n, जिससे 8 बाइट्स बचनी चाहिए।

— निन्जाबियरमॉन्की

आपको टेम्पलेट स्ट्रिंग्स के लिए उद्धरण चिह्नों के बजाय टिक मार्क का उपयोग करना होगा।

— निन्जाबियरमॉन्की

ठीक है, यह है कि मैं वास्तव में यह कैसे परीक्षण किया।

— edc65

Answer 8

रूबी रेव 1, 40 36

->(c){print(c^1,c,"\n",6|c,(c+3)%6)}

4 बाइट्स को बचाने के लिए एक लैम्ब्डा का उपयोग करने के सुझाव के लिए @rcrmn का धन्यवाद। मैं इसे गुमनाम छोड़ने के बारे में निश्चित नहीं था लेकिन ऐसा लगता है कि यहाँ मेटा पर चर्चा की गई थी और यह तय किया कि यह ठीक था।

यहाँ यह 40-बाइट फ़ंक्शन के रूप में है, मेरे रेव 0 रूबी उत्तर के साथ तुलना करने के लिए, नीचे भी (मूल सी उत्तर एक अलग पोस्ट में है।)

def f(c)print(c^1,c,"\n",6|c,(c+3)%6)end

Runer112 से आगे की प्रेरणा: यह उनके नवीनतम (16 बाइट!) उत्तर में प्रयुक्त नंबरिंग योजना के संशोधन पर निर्भर करता है। PhiNotPi की स्कीम का सीधा पोर्ट समान स्कोर देगा।

रेव 0 राउंड वन स्टेप से नंबरिंग को शिफ्ट करने और सब कुछ XOR 1 लेने से, हमें निम्नलिखित क्यूब मिलते हैं:

4---7
|   |
| 1 |
|   |
1---0---7
|   |   |
| 0 | 3 |
|   |   |
6---3---2---7
    |   |   |
    | 2 | 5 |
    |   |   |
    6---5---4
        |   |
        | 4 |
        |   |
        6---1

उत्पादन

0
10
63

1
01
74

2
32
65

3
23
70

4
54
61

5
45
72

रूबी रेव ०, ५६ ५२ ५०

अनावश्यक हटाने के द्वारा 4 बाइट सहेजा ()%6से c-dऔर एक अन्य 2 (runer112 से प्रेरित) द्वारा6+c%2 --> 6|c ।

फ़ंक्शन के लिए स्कोर है, जो सिर्फ पहली पंक्ति है। मैं रूबी के लिए नया हूं और मुझे आश्चर्य है कि मैं एक उपयोगकर्ता इनपुट नंबर प्राप्त करने के लिए 12 वर्णों (11 प्लस न्यूलाइन) से छोटा तरीका नहीं खोज सकता। नतीजतन, एक कार्यक्रम के बजाय एक कार्य करना 1 बाइट बचाता है।

def f(c)d=c%2*2-1;print((c+d)%6,c,"\n",c|6,c-d)end

n=gets.to_i
f(n)

यह मेरे C उत्तर का एक पोर्ट है। सी में, %ऑपरेटर नकारात्मक संख्या के साथ एक नकारात्मक मान लौटाता है। रूबी में यह हमेशा एक सकारात्मक मूल्य देता है, इसलिए 1 को जोड़ने की कोई आवश्यकता नहीं है c। परिणामस्वरूप, चेहरों की संख्या को 1 से नीचे स्थानांतरित करना लाभप्रद है:

0---7
|   |
| 1 |
|   |
1---2---7 
|   |   |
| 2 | 3 |
|   |   |
6---3---4---7
    |   |   |
    | 4 | 5 |
    |   |   |
    6---5---0
        |   |
        | 0 |
        |   |
        6---1

नए चेहरे की संख्या के साथ, कार्यक्रम ऊपर दिखाए गए अनुसार प्रिंट करता है और 180 डिग्री के माध्यम से घुमाया जाता है:

1
21
70

2
12
63

3
43
72

4
34
65

5
05
74

0
50
61

Comments

मेरा मानना ​​है कि आप लंबोदा का उपयोग करके फ़ंक्शन को छोटा कर सकते हैं: ->(x){...code...}जो आपके फ़ंक्शन की परिभाषा 4 वर्णों को छोटा करता है। फिर आपको इसे उपयोग करने के लिए एक चर पर असाइन करना होगा, और इसे #call

— rorlork

@ धन्यवाद, आप सही कह रहे हैं, f=->(c){print(c^1,c,"\n",6|c,(c+3)%6)}दौड़ते हैं और 2 अक्षर छोटे हैं (यदि मैं छोड़ता हूं तो 4 अक्षर छोटे हैं f=)। यकीन नहीं होता है कि अगर निष्पक्ष होना चाहिए, f=लेकिन सवाल यह नहीं कहता है कि फ़ंक्शन अनाम नहीं हो सकता है। जो मुझे अजीब लगता है वह यह है कि यह वाक्यविन्यास शुरुआती से दिखाए गए वाक्यविन्यास से पूरी तरह से अलग है, जिसमें ब्रेसिज़ के अंदर पारित पैरामीटर है:f=lambda{|c|print(c^1,c,"\n",6|c,(c+3)%6)}

— लेवल रिवर सेंट

इसे ही लैम्बडा शाब्दिक कहा जाता है। और वास्तव में मुझे हमेशा एक संदर्भ खोजने में मुश्किल होती है जब मुझे वाक्यविन्यास को याद करने की आवश्यकता होती है ...

— rorlork

Answer 9

अजगर, ३०

धन्यवाद @ जेकब 2 बाइट्स के लिए।

Jc2jkfx>Q2!.&T^2%Q3U8jb?_J%Q2J

इसे यहाँ आज़माएँ।

अजगर विशेषज्ञों की सलाह को गंभीरता से स्वीकार किया जाएगा। विशेष रूप से मुझे लगता है कि आउटपुट सेक्शन में कुछ सुधार हो सकता है।

निम्नलिखित अजगर का बंदरगाह: ...

अजगर, 109

Q=input()
s=''.join(map(str,filter(lambda v:(Q<3)^(v&(1<<Q%3)>0),range(8))))
print s[1-Q%2::2],'\n',s[Q%2::2]

... जो एक बंदरगाह है

शुद्ध बैश, 130

स्पष्टीकरण के प्रयोजनों के लिए:

for v in {0..7};{
if(($1/3));then((v&(1<<$1%3)))&&a+=$v
else((v&(1<<$1%3)))||a+=$v
fi
}
i=$[$1%2*2]
echo "${a:i:2+i}
${a:2-i:4-i}"

घन कोने इस प्रकार गिने जाते हैं:

  4-----5
 /|    /|
0-----1 |
| |   | |
| 6---|-7
|/    |/
2-----3

और चेहरे इस प्रकार गिने जाते हैं:

Face  Vertices  Swap
   0  0,2,4,6
   1  0,1,4,5   x
   2  0,1,2,3
   3  1,3,5,7   x
   4  2,3,6,7
   5  4,5,6,7   x

Swapकॉलम यह दर्शाता है कोने के आदेश उत्पादन में बंद कर दिया जाना चाहिए।

एल्गोरिथ्म सभी कोने {0..7} से शुरू होता है। वर्टेक्स नंबरों में सेट बिट्स के अनुसार कार्यक्षेत्र समाप्त हो जाते हैं:

• 0,1 और 2 चेहरों के लिए, क्रमशः 1,2 या 3 बिट्स वाले कोने रखे गए हैं
• 3,4 और 5 चेहरों के लिए, क्रमशः 1,2 या 3 सेट के बिट्स रखे जाते हैं

"रखे गए" सिरों को एक तार से जोड़ा जाता है। स्ट्रिंग आउटपुट वर्ण 0,1 तब 2,3 या इसके विपरीत है, जो इस बात पर निर्भर करता है कि स्वैप फ्लैग (फेस नंबर मॉड 2) सेट है या नहीं।

Answer 10

जे - 26 बाइट्स

तर्क के रूप में चेहरे की संख्या लेना और अंकों का ग्रिड वापस करना।

0{.@":"0@{0&(|:|.)&(i.3#2)

हम निम्नलिखित घन का उपयोग कर रहे हैं:

  4-----5    Face numbers:
 /|    /|     0 - front
0-----1 |     1 - top
| |   | |     2 - left
| 6---|-7     3 - back
|/    |/      4 - bottom
2-----3       5 - right

उदाहरण ( tryj.tk पर स्वयं देखें ):

   0{.@":"0@{0&(|:|.)&(i.3#2) 3         NB. inline
76
54
   f =: 0{.@":"0@{0&(|:|.)&(i.3#2)      NB. named
   f each 0 1 2 3 4 5                   NB. all results
+--+--+--+--+--+--+
|01|40|64|76|37|13|
|23|51|20|54|26|57|
+--+--+--+--+--+--+

रोटी और मक्खन है 0&(|:|.)। यह एक क्रिया है जो उलट जाती है और क्यूब को इस तरह से घुमाती है जैसे कि हर चेहरे पर जाने के लिए जब इसे लागू किया जाता है, जो कि हम इनपुट तर्क का उपयोग करते हैं। क्यूब के वर्टिकल से उत्पन्न होते हैं i.3#2, इसलिए हम इसे शुरुआती बिंदु के रूप में उपयोग करते हैं, और 0...{जब हम काम करते हैं तो सामने वाले को लेते हैं।

एक स्ट्रिंग के रूप में अंकों को प्रिंट करना 8 वर्णों का खर्च होता है: {.@":"0@अगर हमें केवल एक सरणी वापस करने की अनुमति दी गई थी, तो यह 8 पूरे वर्णों की बचत है। [मुट्ठी हिलाना और अंधाधुंध पकड़ना]

Comments

1, 4 और 5 के परिणाम उलटे प्रतीत होते हैं

— डिजिटल ट्रॉमा

Answer 11

> <> (मछली) , 38 बाइट्स

'/ =/2= 28"H5'a@i-!
noan~\;
~>:?!^1-@~

प्रत्येक आउटपुट को दो 2-अंकीय पंक्तियों के रूप में संग्रहीत किया जाता है। पंक्तियों को स्ट्रिंग में चारकोड के रूप में संग्रहीत किया जाता है '/ =/2= 28"H'(पंक्ति को छोड़कर 10जो स्ट्रिंग के बाद जोड़ा जाता है a)। पहले चरित्र ( / = 47) का उपयोग दूसरी बातचीत पर कार्यक्रम के प्रवाह को पुनर्निर्देशित करने के लिए किया जाता है।

शीर्ष 2*(53-n)तत्वों को छोड़ दिया जाता है (जहां n इनपुट संख्या के चारकोड है) और अगले दो कोड एक नई रेखा के बीच मुद्रित होते हैं।

लेआउट:

  3-----2
 /|    /|
4-----7 |
| |   | |
| 5---|-0
|/    |/
6-----1      0 1 2 3 4 5 sides are top front bottom back left right respectively.