यह 8 वें ग्रेडर गणित की परीक्षा से प्रेरित है

पहचान

हमारे पास निम्नलिखित कोनों के साथ एक क्यूब है

A(0, 0, 0)
B(1, 0, 0)
C(1, 1, 0)
D(0, 1, 0)
E(0, 0, 1)
F(1, 0, 1)
G(1, 1, 1)
H(0, 1, 1)

इस घन में स्पष्ट रूप से 8 कोने, 12 किनारे और 6 चेहरे हैं। यदि हम अब कोने G को काटते हैं, तो ऐसा है कि हमारा कटा हुआ विमान प्रत्येक निकटवर्ती मूल किनारे के बीच से होकर जाता है, हम 2 नए कोने, 3 नए किनारे और एक नया चेहरा जोड़ते हैं। बेहतर स्पष्टीकरण के लिए कृपया हाथ से खींची गई इस कला का आनंद लें

इनपुट

कोनों की एक सूची को देखते हुए (एएच द्वारा पहचाने गए इस उदाहरण में), जो काट दिया जाएगा, कोनों, किनारों और चेहरे की नई संख्या की गणना करें।

आप इनपुट को किसी भी रूप में पसंद करते हैं, ~~जब तक कि यह एक ही कोनों पर प्रतिक्रिया करता है~~ (जैसे कि एएच के बजाय आप 1-8 या 4-7 का उपयोग कर सकते हैं, आप इसे एक सूची, सीएसवी, जो भी हो) मान सकते हैं

आप सूची को अलग-अलग मान सकते हैं (हर कोने में एक बार दिखाई देगा), लेकिन यह खाली हो सकता है। सूची में कभी भी गैर मौजूदा कोने नहीं होंगे।

उत्पादन

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

उदाहरण

{}        ->  8, 12,  6 (empty list)  
{A}       -> 10, 15,  7  
{A,C}     -> 12, 18,  8   
{A,C,F}   -> 14, 21,  9  
{A,B,C}   -> 12, 19,  9  
{A,B,C,D} -> 12, 20, 10

अंत में, यह कोडगॉल्फ है, इस प्रकार बाइट्स जीत में सबसे छोटा जवाब है। कृपया मानक खामियों से बचना चाहिए।

code-golf

— infinitezero
स्रोत

2

दिलचस्प ... तो आसन्न कोनों को काटने का मतलब होगा कि वे एक कोने को साझा करेंगे, और एक किनारे को खत्म करेंगे? यह पहले की तुलना में अधिक जटिल है

— जो किंग

चूंकि तुर्की में इमगुर अवरुद्ध है, इसलिए मैं छवि नहीं देख सकता। क्या आप कृपया एक वैकल्पिक छवि लिंक भेज सकते हैं

— विंडमिल कुकीज़

@ जोकिंग सही है।

— अनंत

@WindmillCookies मुझे क्षमा करें, मुझे यह नहीं पता था। मैंने अब एक अलग होस्ट का उपयोग किया है।

— अनंत

2

उदाहरण के लिए, क्या मैं ए के लिए 0, सी के लिए 1, बी के लिए 2, डी के लिए 3, ई के लिए 4, जी के लिए 5, एफ के लिए 6, एच के लिए 7 का उपयोग कर सकता हूं? या मुझे ABCDEFGH का आदेश रखना चाहिए?

— tsh

2

जेली , 23 बाइट्स

3R×L+“©®€‘ɓŒcn/€§ċ1;`Żạ

एक मोनडिक लिंक। इनपुट क्यूब के कोनों की एक सूची है जैसे कार्टेशियन को-ऑर्डिनेट्स (घन को-ऑर्डिनेट सिस्टम के साथ संरेखित)। आउटपुट पूर्णांकों की एक सूची है [faces, corners, edges],।

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

कैसे?

3R×L+“©®€‘ɓŒcn/€§ċ1;`Żạ - Link: list of lists, C          e.g. [[0,1,1],[1,1,0],[1,1,1],[0,0,0]] -- this could represent "FHGA"
3R                      - range of 3                           [1,2,3]
   L                    - length of C                          4
  ×                     - multiply                             [4,8,12]
     “©®€‘              - list of code-page indices            [6,8,12]
    +                   - add                                  [10,16,24]
          ɓ             - start a new dyadic chain, f(C,X) where X is the above result
           Œc           - pairs of C                           [[[0,1,1],[1,1,0]],[[0,1,1],[1,1,1]],[[0,1,1],[0,0,0]],[[1,1,0],[1,1,1]],[[1,1,0],[0,0,0]],[[1,1,1],[0,0,0]]]
              /€        - reduce €ach with:
             n          -   (vectorising) not equal?           [[1,0,1],[1,0,0],[0,1,1],[0,0,1],[1,1,0],[1,1,1]]
                §       - sum each                             [2,1,2,1,2,3]
                 ċ1     - count ones                           2
                   ;`   - concatenate with itself              [2,2]
                     Ż  - prepend a zero                       [0,2,2]
                      ạ - absolute difference with X           [10,14,22]

यदि कोनों को "ऑर्डर" किया जाना चाहिए क्योंकि वे प्रश्न में हैं, तो यह पूर्णांक 0-4 के साथ 25 बाइट्स के लिए एएच के रूप में काम करता है: 3R×L+“©®€‘ɓŒc^/€ḟ2<5S;`Żạ(एक्सओआर का उपयोग करना कम करता है, ट्वीस को फ़िल्टर करता है, फिर पांच से कम की गणना करता है)।

— जोनाथन एलन
स्रोत

1

चारकोल , 48 45 बाइट्स

≔Ｅθ↨℅ι²η≔⊘№⭆η⭆ηΣＥι↔⁻§λξν1ηＩＥ⟦⁶⁻⁸η⁻¹²η⟧⁺ι×⊕κＬθ

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। आरेख में 0-7अक्षरों का प्रतिनिधित्व करने के लिए अंकों का उपयोग करता है ABDCEFHG। आदेश चेहरे, कोनों, किनारों में आउटपुट। स्पष्टीकरण:

≔Ｅθ↨℅ι²η

प्रत्येक वर्ण का ASCII कोड लें और इसे आधार 2 में बदलें।

≔⊘№⭆η⭆η

आधार 2 नंबरों की सूची के कार्टेशियन उत्पाद को अपने साथ रखें।

ΣＥι↔⁻§λξν1η

आधार 2 की जोड़ियों को एक साथ XOR करें और 1 बिट की संख्या का योग करें। गणना करें कि कितने जोड़े में 1 का योग है और 2 से विभाजित करें। यह संयोग कोनों की संख्या देता है।

ＩＥ⟦⁶⁻⁸η⁻¹²η⟧⁺ι×⊕κＬθ

चेहरे, कोनों और किनारों की संख्या की गणना और प्रिंट करें।

— नील
स्रोत

1

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

a=>[a.map(u=>a.map(v=>j-=!!'ABCDAEFGHEFBCGHD'.match(u+v),n++,j+=2),n=j=6)|2+j,n+j,n]

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

— TSH
स्रोत

1

पर्ल 6 , 59 58 बाइट्स

{6+@_,|((2,3 X*4+@_)X-(@_ X~@_)∩~<<ords "% 286
>C/")}