एक हाइपरक्यूब घुमाएँ

Question

परिचय

हाइपरक्यूब / टेसरेक्ट एक सामान्य क्यूब के 4 आयामी समकक्ष है। यह एक क्यूब नेट लेकर, इसे 3 डी आयाम तक बढ़ाकर बनाया गया है, फिर - 4 वें आयाम का उपयोग करके - इसे हाइपरक्यूब में मोड़ना। यह मूल रूप से एक घन है, जहां प्रत्येक पक्ष एक घन है।

हाइपरक्यूब बनाने के लिए, आपको 16 4 डी वैक्टर (एक वेक्टर एक x, एक y, एक zऔर एक wघटक) की आवश्यकता होती है। ये वैक्टर निम्नलिखित हैं:

A(0, 0, 0, 0); B(1, 0, 0, 0); C(1, 0, 1, 0); D(0, 0, 1, 0); E(0, 1, 0, 0); F(1, 1, 0, 0); G(1, 1, 1, 0); H(0, 1, 1, 0); 
I(0, 0, 0, 1); J(1, 0, 0, 1); K(1, 0, 1, 1); L(0, 0, 1, 1); M(0, 1, 0, 1); N(1, 1, 0, 1); O(1, 1, 1, 1); P(0, 1, 1, 1);

हाइपरक्यूब के 24 चेहरे हैं। निम्नलिखित सूची में उन सभी को शामिल किया गया है (प्रत्येक समूह एक क्वाड को चिह्नित करता है):

ABFE, CDHG, BCGF, DAEH, DCBA, FEHG
IJNM, KLPO, JKON, LIMP, LKJI, PMNO
ABJI, DCKL, BCKJ, DAIL, FEMN, GHPO, FGON, EHPM, EAIM, BFNJ, CGOK, HDLP

इस सारी जानकारी के साथ, आपके पास तकनीकी रूप से कोड में एक हाइपरक्यूब है। इसे घुमाने के लिए, आपको प्रत्येक घूर्णी विमान के लिए 6 अलग-अलग मैट्रिस चाहिए, एक YZ, XZ, XY, XW, YW और ZW विमानों के लिए। आपके पास हर मैट्रिक्स होने के बाद, आपको उनके साथ क्यूब के कोने को गुणा करना होगा।

निम्नलिखित छवियां प्रत्येक मैट्रिक्स की संरचना दिखाती हैं:

YZ विमान पर रोटेशन के लिए:

XZ विमान पर रोटेशन के लिए:

एक्सवाई विमान पर रोटेशन के लिए:

XW विमान पर रोटेशन के लिए:

YW विमान पर रोटेशन के लिए:

जेडडब्ल्यू विमान पर रोटेशन के लिए:

इस क्रम में घुमाव मिलते हैं।

इस सब के बाद, आपके पास एक घुमा हुआ हाइपरक्यूब है। अब आपको इसे आकर्षित करने की आवश्यकता है। आपको एक ऑर्थोगोनल प्रोजेक्शन का उपयोग करना चाहिए जिसे भेजने के (x, y, z, w)लिए एक परिप्रेक्ष्य प्रक्षेपण के साथ जोड़ा गया है (2x/(2+z), 2y/(2+z))।

इनपुट

आपका इनपुट 0 (समावेशी) और 360 (विशेष रूप से) के बीच 6 पूर्णांक है। ये हाइपरक्यूब के विभिन्न घूर्णी विमानों पर डिग्री में रोटेशन का प्रतिनिधित्व करते हैं।

उत्पादन

आपका आउटपुट हाइपरक्यूब वाली एकल छवि होना चाहिए। प्रदर्शन एक रेखापुंज छवि, एक वेक्टर छवि या एक ASCII कला हो सकता है। आउटपुट छवि कम से कम 100 * 100 पिक्सेल होनी चाहिए, और क्यूब को कम से कम 50% स्क्रीन लेने की आवश्यकता होती है। किसी भी डिफ़ॉल्ट छवि आउटपुट प्रारूप की अनुमति है।

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

0 0 0 0 0 0

0 0 0 0 0 30

30 0 0 0 0 30

0 0 0 30 30 30

45 45 45 0 0 0

45 45 45 45 45 45

छवियों को एक नए टैब में खोलें, उन्हें पूर्ण आकार में देखने के लिए।

नियम

• डिफ़ॉल्ट नियम लागू होते हैं
• मानक खामियों को मना किया जाता है
• बाइट्स में सबसे छोटा कोड जीतता है

Comments

आपने दूसरी पोस्ट क्यों की?

— R

@ E @s forIʀᴋ मैंने इसे आखिरी समीक्षा के लिए चैट में पोस्ट किया

— Bálint

जैसा कि मैंने सैंडबॉक्स में दो अलग-अलग अवसरों पर बताया है, प्रदर्शन के लिए प्रक्षेपण का वर्णन अधूरा है क्योंकि यह मानता है कि अनुमानित की जाने वाली वस्तु 3-आयामी है, जबकि यह वास्तव में, 4-आयामी है।

— पीटर टेलर

@luserdroog मुझे लगता है कि 'U' को 'N' होना चाहिए।

— बीकर

@ Bálint चुनौती के लिए धन्यवाद, मैंने इसका आनंद लिया। उम्मीद है कि हम अधिक जवाब और विभिन्न दृष्टिकोण प्राप्त करेंगे। : D

— बीकर

Answer 1

ऑक्टेव, 474 433 429 बाइट्स

function H(a,b,c,d,e,f) C=@cosd;S=@sind;R=[1,0,0,0;0,C(e),0,-S(e);0,-S(e)*S(f),C(f),-C(e)*S(f);0,S(e)*C(f),S(f),C(e)*C(f)]*[C(c)*C(d),-S(c)*C(d),0,S(d);S(c),C(c),0,0;0,0,1,0;-C(c)*S(d),S(c)*S(d),0,C(d)]*[C(b),S(a)*S(b),C(a)*S(b),0;0,C(a),-S(a),0;-S(b),S(a)*C(b),C(a)*C(b),0;0,0,0,1]*(dec2bin(0:15)'-48.5);Z=R(3,:)+2;R=2*R./Z;Q=[1,2,10,12,11,9,10,14,16,12,4,8,16,15,11,3,7,15,13,9,1,5,13,14,6,8,7,5,6,2,4,3,1];plot(R(1,Q),R(2,Q));

घुमाया गया:

function H(a,b,c,d,e,f) 
C=@cosd;S=@sind;
R=[1,0,0,0;0,C(e),0,-S(e);0,-S(e)*S(f),C(f),-C(e)*S(f);0,S(e)*C(f),S(f),C(e)*C(f)]*
  [C(c)*C(d),-S(c)*C(d),0,S(d);S(c),C(c),0,0;0,0,1,0;-C(c)*S(d),S(c)*S(d),0,C(d)]*
  [C(b),S(a)*S(b),C(a)*S(b),0;0,C(a),-S(a),0;-S(b),S(a)*C(b),C(a)*C(b),0;0,0,0,1]*
  (dec2bin(0:15)'-48.5);
Z=R(3,:)+2;
R=2*R./Z;
Q=[1,2,10,12,11,9,10,14,16,12,4,8,16,15,11,3,7,15,13,9,1,5,13,14,6,8,7,5,6,2,4,3,1];
plot(R(1,Q),R(2,Q));

रोटेशन मेट्रिक्स अभी भी बहुत सारे बाइट्स का उपभोग करते हैं, लेकिन एयुलरियन चक्र ने काफी अच्छी तरह से काम किया, जिससे 96 120 से नीचे 33 तक का दौरा किया ।

Msb को [0:15]x- कोऑर्डिनेट करने और lsb को w- कोऑर्डिनेट करने पर विचार करते हुए 4-बिट बाइनरी प्रतिनिधित्व लेने से वर्टिकल उत्पन्न होते हैं ।

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

---

आउटपुट:

H(0,0,0,0,0,0)

H(0,0,0,0,0,30)

H(30,0,0,0,0,30)

H(0,0,0,30,30,30)

H(45,45,45,0,0,0)

H(45,45,45,45,45,45)

Comments

संपादित करें: मैं बेवकूफ हूं। हर जगह एक ही चर से मूर्ख ... [क्या आप सुनिश्चित हैं कि आप पूर्ण पूर्व-गुणा मैट्रिक्स नहीं चाहते हैं? :) i.imgur.com/nkM6y6g.png]

— अल्गमीर जुएल

@algmyr हाँ, पूरी तरह से गुणा मैट्रिक्स के बारे में दो बार के रूप में लंबे समय से आया था, अगर मुझे सही ढंग से याद है।

— बीकर

इसे अधिक पसंद करना चाहिए, मैक्सिमा की बेवकूफी "सरलीकरण" का आनंद लें: i.imgur.com/klkXLPf.png

— algmyr

: गणित में दुखी नाकाम रहने के लिए अप करने के लिए यहां अपने कोड का एक और अधिक golfed संस्करण, 330 बाइट्स paste.ee/p/2GRyJ

— algmyr

Answer 2

परिशिष्ट भाग 1075 732 683 640 631 601 590 545 542 526 514 478 470

Mat.ps और G का उपयोग करता है ।

संपादित करें: -343 वैक्टर और ईयूलियन सर्किट के बाइनरी एन्कोडिंग पीढ़ी को लागू कियाचोरी हो गयाअन्य उत्तरों से उधार लिया गया। और जी लाइब्रेरी से बाइनरी-टोकन-स्ट्रिंग्स लागू किया।
संपादित करें: -49 पुनर्परिभाषित sin cosऔर negछोटे नामों के लिए।
संपादित करें: -43 अनुक्रमों के लिए संक्षिप्त नाम 0 0 0 1 1 0।
संपादित करें: -9 al (यानी। aload) से छोटा है (")@। कुछ नहीं की कीमत पर idi(यानी। idiv) के लिए 3 कॉल फैक्टर 1 idiv।
संपादित करें: -30 जी से लागू निहित परिभाषा ब्लॉक ।
संपादित करें: -10 कुछ अधिक उपयोग किए गए अनुक्रम।
संपादित करें: -45i j k l m n कोणों के लिए चर निकालें और हमेशा वर्तमान कोण को परिभाषित करें tऔर कोणों के कार्य (वैश्विक) मान का उपयोग करेंtचर। रोटेशन मैट्रिक्स के कोड-विवरण को तब तक क्रियान्वित करें जब तक उसका tमूल्य तैयार न हो जाए।
संपादित करें: -3 निकालें <16>$अर्थात। closepath। और एक जगह।
संपादित करें: -16 फैक्टर-आउट सरणी ब्रैकेट यूनिट वैक्टर से रोटेशन मेट्रिसेस ( J K Lऔर M) में। फिर से लागू गिरा moके लिए modऔर suके लिए sub।
संपादित करें: -12 प्रोजेक्ट-एंड-ड्रा फ़ंक्शन को इन-लाइन करें और शब्दकोश को हटा दें (अब खाली)।
संपादित करें: -36 एक स्ट्रिंग में सर्किट (यानी चेहरे ) को एन्कोड किया गया।
संपादित करें: -8 कोने सरणी की परिभाषा निकालें V। इसके बजाय, ढेर पर छोड़ दें औरdupआवश्यकतानुसार काम की प्रतियां (एक बार, पहले और फिर से लूप के अंत में)। साथ ही, बाइनरी-टोकन-स्ट्रिंग्स के कुछ ऑपरेटरों को संक्षिप्त नामों में अनुवाद किया जहां बीटीएस ने कोई बचत नहीं दी, इसलिए (I)$अब fora(यानी forall) है। if duहो सकता है (T8)$, लेकिन if duस्पष्ट रूप से एक बेहतर विकल्प है (यह गोल्फ है , प्रति सेशन नहीं )। इसके अलावा, प्रदर्शन scale से पहले translate , इसलिए अनुवाद निर्देशांक हो सकता है 3और 4बजाय 300और 400।

(mat.ps)run 3(G)run $
t sin
A neg
t cos
0 0
0 1
1 0
2 mu Z 2(!V)@
idi 2 mo .5 su
(>8)$
[F D]
[D E]
[E D]
[D F]

3 4 100(&>88)$(,)# div(<N)#[E 15{[I 1 H I 2 H I 4 H ex 8 H]}fo]E
5{ARGUMENTS 1(XK/)$/t ex d{{J[0 C B 0][0 A C 0]K}{[C 0 A 0]L[B 0
C 0]K}{[C B D][A C D]M K}{[C D A]L M[B D C]}{J[0 C 0 B]M[0 A 0
C]}{J L[D C B][D A C]}}(>K)$[(>?)$]transpose matmul}fo
du(019;:89=?;37?>:26><804<=576451320){48 su get al po{W
Z Y X}{(>3)$}fora X G Y G{li}(D)#{mov}if du}fora(HB)#

3 4और 100दूसरे खंड की पहली पंक्ति में प्रतिनिधित्व करने वाले केंद्र-एक्स, केंद्र-y और पैमाने पैरामीटर, क्रमशः, पृष्ठ पर ड्राइंग के (बीच में निर्देशांक द्वारा कर दिया जाता है scale)। (300,400) पीएस इकाइयों में लगभग अमेरिकी पत्र-आकार के कागज (612,792) का केंद्र है।

यदि आप मोटे तौर पर पोस्टस्क्रिप्ट का पालन कर सकते हैं, तो महत्वपूर्ण विचित्र चीजें निहित प्रक्रिया ब्लॉक और एन्कोडेड ऑपरेटर स्ट्रिंग्स हैं। जैसा कि नीचे दिए गए वर्कफ़िले में टिप्पणियों द्वारा दिखाया गया है, पहले ब्लॉक की प्रत्येक पंक्ति को ए, बी, सी, आदि द्वारा नाम दिया गया है। F E Dउत्पादन होगा 1 0 0 1 0 0। एन्कोडेड ऑपरेटर स्ट्रिंग्स के लिए, कुछ भी जो एक तर्क है $ #या @ऑपरेटर कॉल का एक क्रम है, सिस्टम नेम टेबल, PLRM 3ed परिशिष्ट F से ऑपरेटरों का चयन करने के लिए बाइट्स का उपयोग करके। ये सुविधाएँ और अधिक जी लाइब्रेरी के साथ पोस्टस्क्रिप्ट के लिए उपलब्ध हैं। अब mat.ps फ़ंक्शन भी शामिल है)।

Workfile:

(mat.ps)run 3(G)run $
t sin %/A
A neg %/B
t cos %/C
0 0 %/D
0 1 %/E
1 0 %/F
2 mu Z 2(!V)@ %/G  %ad div %add div %108 1 54
idi 2 mo .5 su %idiv mod sub %/H %106 169 51
(>8)$ %/I %exch dup
[F D] %/J
[D E] %/K
[E D] %/L
[D F] %/M


3 4
100(&>88)$ %currentlinewidth exch dup dup %38
(,)#  %scale %139-95=44
div(<N)# %div setlinewidth %54 155-95=60 %translate %173-95=78
%/V
[E 15{[ I
    1 H I
    2 H I
    4 H ex
    8 H]}fo]

E 5{ARGUMENTS 1(XK/)$ %index get cvr %88 75 47
    /t ex d %exch def %62 51
    {{J[0 C B 0][0 A C 0]K} 
     {[C 0 A 0]L[B 0 C 0]K} 
     {[C B D][A C D]M K} 
     {[C D A]L M[B D C]}
     {J[0 C 0 B]M[0 A 0 C]}
     {J L[D C B][D A C]}}
    (>K)$ %exch get %62 75
    [
        (>?)$ %exch exec %62 63
    ]
    transpose matmul
}fo %for
du %dup
%d %def
%{transpose matmul}fora d

%[E 9 11 10 8 9 13 15 11 3 7 15 14 10 2 6 14 12 8 0 4 12 13 5 7 6 4 5 1 3 2 0]
%<0001090b0a08090d0f0b03070f0e0a02060e0c0800040c0d050706040501030200>
%          abcdef
%0123456789:;<=>?
(019;:89=?;37?>:26><804<=576451320)
{48 su get % 169 75 %V (>K)$ %sub %exch get

    al po %aload pop %2 117
    {W Z Y X}{(>3)$ %exch def
    }fora %forall %2 117  62 51 73
    X G
    Y G
    {li}(D)# %stopped
    {mov}
    if du%(T8)$ %if %84 du %dup 56
}
%<49a7a1>$ %forall stroke showpage %73 167-95=72 161-95=66
fora(HB)#

अपुष्ट और हल्की टिप्पणी:

300 400 translate   %roughly center of letter paper
currentlinewidth
100 dup dup scale
div setlinewidth    %scale x100, reduce line-width/100
(mat.ps)run         %load matrix library
ARGUMENTS aload pop{f e d c b a}{exch cvr def}forall  %define args as 
                                 % a,b,etc and convert to real numbers
/m{2 mod .5 sub}def
/P{aload pop{w z y x}{exch def}forall   %P: [x y z w]  project-and-draw  -
    x 2 mul z 2 add div 
    y 2 mul z 2 add div 
    {lineto}stopped{moveto}if %catch(&handle!) nocurrentpoint error in lineto
}bind def
/V[0 1 15{    % generate vectors with a for-loop
    [ exch
        dup m
        1 index 2 idiv m
        2 index 4 idiv m
        4 3 roll 8 idiv m
    ]
}for]
[[[1 0 0 0][0 a cos a sin neg 0][0 a sin a cos 0][0 0 0 1]] 
     [[b cos 0 b sin 0][0 1 0 0][b sin neg 0 b cos 0][0 0 0 1]] 
     [[c cos c sin neg 0 0][c sin c cos 0 0][0 0 1 0][0 0 0 1]] 
     [[d cos 0 0 d sin][0 1 0 0][0 0 1 0][d sin neg 0 0 d cos]]
     [[1 0 0 0][0 e cos 0 e sin neg][0 0 1 0][0 e sin 0 e cos]]
     [[1 0 0 0][0 1 0 0][0 0 f cos f sin neg][0 0 f sin f cos]]]
{transpose matmul} forall def   % apply array of rotations and define

%Eulerian circuit (borrowed and adjusted for 0-based indexing)
[0 1 9 11 10 8 9 13 15 11 3 7 15 14 10 2 6 14 12 8 0 4 12 13 5 7 6 4 5 1 3 2 0]

% the main program!
% on the stack is the Eulerian circuit array
{
    V exch get  %lookup index in (sextuply-transformed) vertex array
    P           %call project-and-draw
} forall
closepath stroke %draw it, don't just think about it

showpage % gs's cmd-line-args option automatically sets -dBATCH,
    % so without a showpage, gs will immediately exit before you
    % can look at the picture :(

मेरे कुछ आउटपुट प्रश्न के उदाहरणों के दर्पण चित्र हैं।

के लिए gs -- hc.ps 0 0 0 0 0 0, मुझे मिलता है:

gs -- hc.ps 0 0 0 0 0 30

gs -- hc.ps 30 0 0 0 0 30

gs -- hc.ps 0 0 0 30 30 30

gs -- hc.ps 45 45 45 0 0 0

gs -- hc.ps 45 45 45 45 45 45

बोनस एनीमेशन मैं सिर्फ इस कार्यक्रम के साथ बनाया। यह छवि रोटेशन अनुक्रम 0 30 60 0 i i से मेल खाती है , जहां मैं 0 से 360 तक 2 तक होता है।

Comments

वाह। गणितीय समस्या के लिए पोस्टस्क्रिप्ट उत्तर।

— TuxCrafting

@ T @xCräftîñg जब तक आप आसानी से मैट्रिक्स गुणा कर सकते हैं तब तक वास्तव में इस प्रश्न में उतना गणित नहीं है। और मैं एके डेवडनी के द आर्मचेयर यूनिवर्स को पढ़ने के बाद से इस कार्यक्रम को लिखना चाहता हूं ।

— लूजर ने

जी लाइब्रेरी में नए कार्य जोड़े गए। यहां उपयोग नहीं किया जा सकता है, लेकिन यह इस 307 बाइट संस्करण की अनुमति देता है ।

— लूसर ने 21

Answer 3

सी # + एकता, 1060 845 835 बाइट्स

C # ≈ जावा

मान लेता है कि यह फ़ंक्शन एक स्क्रिप्ट में रखा गया है MainCamera।

संपादित करें:
Eulerian चक्र का उपयोग करके 19 बाइट्स सहेजे गए ~ 200 बाइट को बचाने के सुझावों के लिए @TuukkaX का धन्यवाद।

golfed:

void d(float[]r){transform.position=Vector3.back*2;GetComponent<Camera>().backgroundColor=Color.black;Vector4[]p=new Vector4[16];Matrix4x4[]m=new Matrix4x4[6];int i=0;for(;i<16;i++)p[i]=new Vector4(i%2,i/2%2,i/4%2,i/8%2)-new Vector4(.5f,.5f,.5f,.5f);int[,]X={{6,8,1,12,7,11},{5,0,0,0,5,10},{10,10,5,15,15,15}};for(i=0;i<6;i++){m[i]=Matrix4x4.identity;r[i]=Mathf.Deg2Rad*r[i];float c=Mathf.Cos(r[i]),s=Mathf.Sin(r[i]);m[i][X[1,i]]=c;m[i][X[2,i]]=c;m[i][X[0,i]]=s;m[i][X[0,i]%4*4+X[0,i]/4]=-s;}for(i=0;i<16;i++)foreach(Matrix4x4 x in m)p[i]=x*p[i];int[]F={0,1,9,11,10,8,9,13,15,11,3,7,15,14,10,2,6,14,12,8,0,4,12,13,5,7,6,4,5,1,3,2,0};LineRenderer l=new GameObject().AddComponent<LineRenderer>();l.SetVertexCount(33);l.material=new Material(Shader.Find("Sprites/Default"));l.SetWidth(.03f,.03f);for(i=0;i<33;i++)l.SetPosition(i,p[F[i]]);

न्यूलाइन्स + इंडेंटेशन + पूर्ण शेल:

using UnityEngine;
using System.Collections;

public class h : MonoBehaviour {

    void d(float[]r)
    {
        transform.position=Vector3.back*2.5f;
        GetComponent<Camera>().backgroundColor=Color.black;
        Vector4[]p=new Vector4[16];
        Matrix4x4[]m=new Matrix4x4[6];
        int i=0;
        for(;i<16;i++)p[i]=new Vector4(i%2,i/2%2,i/4%2,i/8%2)-new Vector4(.5f,.5f,.5f,.5f);
        int[,]X={{6,8,1,12,7,11},{5,0,0,0,5,10},{10,10,5,15,15,15}};
        for (i=0;i<6;i++){
            m[i]=Matrix4x4.identity;
            r[i]=Mathf.Deg2Rad*r[i];
            float c=Mathf.Cos(r[i]);
            float s=Mathf.Sin(r[i]);
            m[i][X[1,i]]=c;
            m[i][X[2,i]]=c;
            m[i][X[0,i]]=s;
            m[i][X[0,i]%4*4+X[0,i]/4]=-s;
        }
        for (i=0;i<16;i++)foreach(Matrix4x4 x in m)p[i]=x*p[i];
        int[]F={0,1,9,11,10,8,9,13,15,11,3,7,15,14,10,2,6,14,12,8,0,4,12,13,5,7,6,4,5,1,3,2,0};
        LineRenderer l=new GameObject().AddComponent<LineRenderer>();
        l.SetVertexCount(33);
        l.material=new Material(Shader.Find("Sprites/Default"));
        l.SetWidth(.03f,.03f);
        for (i=0;i<33;i++)
            l.SetPosition(i,p[F[i]]);
        l.gameObject.tag = "Player";
    }
    public float[] input;
    void Start()
    {
        d(input);
    }
}

मैं रोटेशन के मेट्रिक्स के निर्माण के लिए एक सरल फॉर्मूला नहीं बना सका और न ही "चेहरे" जो आकर्षित करने के लिए, ताकि हार्ड-कोड के लिए बहुत सारे बाइट्स का खर्च हो। मैंने @beaker से Eulerian चक्र उधार लिया। इसके अलावा, एकता बिल्ट-इन बेहद क्रियात्मक हैं।

आप सभी परीक्षण मामलों को ऑनलाइन सत्यापित कर सकते हैं ।

Comments

यह पहली बार है जब मैंने यहाँ पर C # + यूनिटी उत्तर देखा है। +1

— DanTheMan

मैं हर लगता है 0.5fकम किया जा सकता .5fहै और 0.01fकरने के लिए .01f। मुझे यह भी लगता है कि पूर्णांक सरणियों को int[]कई बार कहने के बजाय अल्पविराम से अलग किया जा सकता है ।

— यति

@ ओह, तुम सही हो! कुछ समय से C # का उपयोग नहीं किया गया था इसलिए अंतिम टिप के बारे में निश्चित नहीं था।

— यतीस

@TuukkaX मेरी पिछली टिप्पणी पर ध्यान न दें, मैं उपयोग कर सकता हूं int[,]। फिर भी, धन्यवाद।

— ब्लू

आपके पास अभी भी ऐसा है Vector4(0.5f,0.5f,0.5f,0.5f)जिसे कम किया जा सकता है Vector4(.5f,.5f,.5f,.5f)।

— यति

Answer 4

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

f=(...R)=>(P=s=>[...s].map(i=>parseInt(i,16)),C=document.createElement`canvas`,X=C.getContext`2d`,X.translate((C.width=300)/2,(C.height=300)/2),X.lineWidth=0.01,X.scale(100,100),X.beginPath(),P("0267fd9804c8ab915dcefb37546ea2310").map((e,i)=>{[x,y,z]=P("084c2a6e195d3b7f").map(i=>[...(1e3+i.toString(2)).slice(-4)].map(i=>i-0.5)).map(e=>(R.map((R,i,_,M=Math,C=M.cos(r=R*M.PI/180),S=M.sin(r))=>((a,b,s=1)=>[e[a],e[b]]=[C*e[a]-s*S*e[b],s*S*e[a]+C*e[b]])(...[[1,2],[0,2,-1],[0,1],[0,3,-1],[1,3],[2,3]][i])),e))[e];[x,y]=[2*x/(2+z),2*y/(2+z)];i?X.lineTo(x,y):X.moveTo(x,y)}),X.stroke(),C)

"Ungolfed":

f=(...R)=>(                                                              // function that accepts rotations in the following form: f(a,b,c,d,e,f)
    P=s=>[...s].map(i=>parseInt(i,16)),                                  // function to convert strings to hex-arrays
    V=P("084c2a6e195d3b7f")                                              // vertices encoded as hex values ( [0,1,1,0] -> 6 )
        .map(i=>[...(1e3+i.toString(2)).slice(-4)].map(i=>i-0.5))        // convert hex values to vertices, center the hypercube
        .map(e=>(R.map((R,i,_,M=Math,C=M.cos(r=R*M.PI/180),S=M.sin(r))=> // convert angles to degrees, precalculate sin and cos values
        ((a,b,s=1)=>[e[a],e[b]]=[C*e[a]-s*S*e[b],s*S*e[a]+C*e[b]])       // apply matrix transforms to all vertices
        (...[[1,2],[0,2,-1],[0,1],[0,3,-1],[1,3],[2,3]][i])),e)),        // list of encoded matrix transforms
    C=document.createElement`canvas`,X=C.getContext`2d`,                 // create image to draw on
    X.translate((C.width=300)/2,(C.height=300)/2),                       // setup image dimensions, center transform
    X.lineWidth=0.01,X.scale(100,100),X.beginPath(),                     // setup line, scale the transform and begin drawing
    P("0267fd9804c8ab915dcefb37546ea2310").map((e,i)=>{                  // hypercube edge path indices encoded as hex values
        [x,y,z]=V[e];[x,y]=[2*x/(2+z),2*y/(2+z)];                        // project vertex
        i?X.lineTo(x,y):X.moveTo(x,y)}),X.stroke(),                      // draw vertex
    C)                                                                   // return image

इसे कार्रवाई में देखें (लगातार घुमाए जाने के लिए संशोधित):

with(document)with(Math)with(document.getElementById`canvas`)with(getContext`2d`){render=()=>{requestAnimationFrame(render);clearRect(0,0,width,height);save();K=performance.now();R=[K*0.01,K*0.02,K*0.03,K*0.04,K*0.05,K*0.06];X=s=>[...s].map(i=>parseInt(i,16));V=X("084c2a6e195d3b7f").map(i=>[...(1e3+i.toString(2)).slice(-4)].map(i=>i-0.5)).map(e=>(R.map((R,i,_,C=cos(r=R*PI/180),S=sin(r))=>((a,b,s=1)=>[e[a],e[b]]=[C*e[a]-s*S*e[b],s*S*e[a]+C*e[b]])(...[[1,2],[0,2,-1],[0,1],[0,3,-1],[1,3],[2,3]][i])),e));translate((width=300)/2,(height=300)/2);lineWidth=0.01;scale(100,100);beginPath();X("0267fd9804c8ab915dcefb37546ea2310").map((e,i)=>{[x,y,z]=V[e];[x,y]=[2*x/(2+z),2*y/(2+z)];i?lineTo(x,y):moveTo(x,y)});stroke();restore();};render();}

<html><body><canvas id="canvas"></canvas></body></html>

फ़ंक्शन HTML5 कैनवस ऑब्जेक्ट लौटाता है, आपको document.body.appendChild(f(0,0,0,0,0,0))उदाहरण के लिए इसे पेज पर जोड़ना होगा ।

वर्तमान में, घुमाव क्रम से लागू होते हैं, मैं पुन: व्यवस्थित करने पर काम कर रहा हूं, लेकिन जैसा कि है, यह हाइपरक्यूब को सही ढंग से घुमाता है।

Comments

चालाक, मुझे यह समझने में थोड़ा समय लगा कि आप मैट्रिक्स के साथ क्या कर रहे हैं। : D इसके अलावा, मैं काम करने के लिए आपका कोड स्निपेट प्राप्त नहीं कर सकता ... यह मुझे एक अनचाही "स्क्रिप्ट त्रुटि" दे रहा है। लाइन में 0.

— बीकर

@ बीकर आप किस ब्राउज़र का उपयोग कर रहे हैं? मैंने इसे नवीनतम फ़ायरफ़ॉक्स पर परीक्षण किया है।

— डेंड्रोबियम

मैं सफारी 9.1.1 पर हूं। मुझे एक अलग कोशिश करते हैं।

— बीकर

हां, क्रोम ठीक काम करता है।

— बीकर

सफारी बकवास है। अगर कुछ काम करता है यह जाँच करने के लिए इसका उपयोग न करें।

— पैट्रिक रॉबर्ट्स

Answer 5

गणितज्ञ, ४५३ ४१५ बाइट्स *

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

Graphics[Line[Table[{2#/(2+#3),2#2/(2+#3)}&@@Map[Dot@@Table[Table[If[n==m==#2||n==m==#,Cos[#3],If[n==#2&&m==#,If[#2==1&&(#==3||#==4),1,-1]Sin[#3],If[n==#&&m==#2,If[#2==1&&(#==3||#==4),-1,1]Sin[#3],If[n==m,1,0]]]],{n,4},{m,4}]&[k[[1]],k[[2]],a[[k[[3]]]]°],{k,{{4,3,6},{4,2,5},{4,1,4},{2,1,3},{3,1,2},{3,2,1}}}].#&,Tuples[{0,1},4]-.5,{1}][[i]],{i,{1,2,10,12,11,9,10,14,16,12,4,8,16,15,11,3,7,15,13,9,1,5,13,14,6,8,7,5,6,2,4,3,1}}]]]

* मैं गिनती कर रहा हूं °और ==प्रत्येक के रूप में एकल बाइट्स के रूप में वे Mathematica में एक एकल चरित्र के रूप में प्रतिनिधित्व कर रहे हैं। मुझे लगता है कि यह उचित है क्योंकि बहुत सी भाषाएं अजीब चरित्र एन्कोडिंग का उपयोग करती हैं।

टिप्पणियों के साथ अपुष्ट। इनपुट के रूप में शीर्ष पर हार्ड कोडित है a={30,0,0,0,0,30};। मैंने अपने स्कोर की ओर नहीं गिना।

a = {45, 45, 45, 45, 45, 45};



(* #2,#-th rotation matrix as a funciton of #3 *)
(* Using the \
#-notation saved 6 bytes over the more common function definition \
notation*)
r = 
  Table[If[n == m == #2 || n == m == #, Cos[#3], 
     If[n == #2 && m == #, 
      If[#2 == 1 && (# == 3 || # == 4), 1, -1] Sin[#3], 
      If[n == # && m == #2, 
       If[#2 == 1 && (# == 3 || # == 4), -1, 1] Sin[#3], 
       If[n == m, 1, 0]]]], {n, 4}, {m, 4}] &;

(* Total rotation matrix. Need six of them. Function of the six \
angles to rotate.*)

u = Dot @@ 
     Table[r[k[[1]], 
       k[[2]], \[Degree]*
        a[[k[[3]]]]], {k, {{4, 3, 6}, {4, 2, 5}, {4, 1, 4}, {2, 1, 
         3}, {3, 1, 2}, {3, 2, 1}}}].# &;



(* List of all vertices of the hypercube *)
t = Tuples[{0, 1}, 4];
t -= .5;
v = Map[u, t, {1}];

(*projection*)
p = {2 #/(2 + #3), 2 #2/(2 + #3)} &;

(*Eulerian tour*)

l = Table[
   p @@ v[[i]], {i, {1, 2, 10, 12, 11, 9, 10, 14, 16, 12, 4, 8, 16, 
     15, 11, 3, 7, 15, 13, 9, 1, 5, 13, 14, 6, 8, 7, 5, 6, 2, 4, 3, 
     1}}];
Graphics[Line[l]]

0 0 0 0 0 30

0 0 0 30 30 30

405 10 -14 -8 -9 205