हाइपरप्रोग्रामिंग: एन + एन, एन × एन, एन ^ एन सभी एक में

Question

एक प्रोग्राम लिखें जो 1 से 9 तक की संख्या में शामिल हो। अपने मूल रूप में, आपके प्रोग्राम को N + NEg आउटपुट आउटपुट करना चाहिए 2यदि N है 1, 4यदि N है 2, 6यदि N है 3, और इसी तरह।

जब आपके प्रोग्राम के प्रत्येक वर्ण को जगह में डुप्लिकेट किया जाता है, तो यह एक ऐसा प्रोग्राम होना चाहिए जो N (अभी भी 1 से 9 तक) में हो और N × NEG आउटपुट को आउटपुट करता है 1यदि N है 1, 4यदि N है 2, 9यदि N है 3, और इसी तरह।

जब आपके प्रोग्राम का हर कैरेक्टर जगह-जगह पर ट्रिपलेटेड हो जाता है, तो यह एक ऐसा प्रोग्राम होना चाहिए जो N (अभी भी 1 से 9 तक) में हो और N ^ एनईजी आउटपुट आउटपुट करता है 1यदि N है 1, 4यदि N है 2, 27यदि N है 3, 387420489यदि N है 9, तो आदि।

9 से ऊपर की संख्या की आवश्यकता नहीं है क्योंकि 10 ^ 10 कई भाषा की सामान्य पूर्णांक सीमा के बाहर है।

उदाहरण

यदि आपका प्रारंभिक कार्यक्रम था

My_Program!
Exit();

फिर यह एन में लेने में सक्षम होना चाहिए और एन + एन को आउटपुट करना चाहिए।

इसके अतिरिक्त, कार्यक्रम

MMyy__PPrrooggrraamm!!

EExxiitt(());;

N और आउटपुट N × N में लेना चाहिए।

अंत में, कार्यक्रम

MMMyyy___PPPrrrooogggrrraaammm!!!


EEExxxiiittt((()));;;

एन में लेना चाहिए और आउटपुट एन ^ एन।

चौगुनी-चरित्र कार्यक्रम और उससे आगे की आवश्यकता नहीं है।

नियम

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

• विंडोज यूजर्स \r\nएक चरित्र के रूप में व्यवहार कर सकते हैं क्योंकि चीजों से \r\r\n\nकोई मतलब नहीं होगा या शायद काम भी करेगा।

• बाइट्स जीत में सबसे छोटा मूल कार्यक्रम (एन + एन एक)।

Comments

क्या यह भी संभव है?

— सर्ज बॉर्श

यह हमेशा असंभव लगता है जब तक कि यह नहीं हो जाता है - नेल्सन मंडेला

— अदनान

@ सर्जबॉर्श हाँ।

— डेनिस

दुर्भाग्य से यह केवल सीमित मात्रा में भाषाओं में संभव है।

— मत्तीरॉक

@ R.Kap नहीं, बहुत भ्रामक लगता है।

— केल्विन के शौक 1

Answer 1

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

एन एन

“(ẹ+)‘FQṖṪỌv

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

एन × एन

““((ẹẹ++))‘‘FFQQṖṖṪṪỌỌvv

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

एन ^ N

“““(((ẹẹẹ+++)))‘‘‘FFFQQQṖṖṖṪṪṪỌỌỌvvv

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

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

जेली में कई अलग-अलग प्रकार के स्ट्रिंग शाब्दिक हैं; उन सभी की शुरुआत ए से होती है “। यदि शाब्दिक में एक से अधिक होते हैं “, तो एक स्ट्रिंग सरणी वापस आ जाती है, और “एक दूसरे से स्ट्रिंग को अलग करती है।

उदाहरण के लिए, “abc“def”पैदावार ['abc', 'def']।

शाब्दिक के अंतिम चरित्र (किसी भी ”«»‘’, जहां «वर्तमान में कार्यान्वित नहीं किया गया है) के आधार पर, व्यक्ति विभिन्न प्रकार के शाब्दिकों के बीच चयन कर सकता है। इसके लिए ‘, हम संबंधित यूनिकोड वर्णों के बजाय जेली के कोड पृष्ठ में कोड अंक प्राप्त करते हैं ।

उदाहरण के लिए, “abc“def‘पैदावार [[97, 98, 99], [100, 101, 102]]।

कार्यक्रमों में तीन शाब्दिक निम्नलिखित कोड बिंदु सरणियों के अनुरूप हैं।

“(ẹ+)‘           -> [40, 214, 43, 41]
““((ẹẹ++))‘      -> [[], [40, 40, 214, 214, 43, 43, 41, 41]]
“““(((ẹẹẹ+++)))‘ -> [[], [], [40, 40, 40, 214, 214, 214, 43, 43, 43, 41, 41, 41]]

एन एन

“(ẹ+)‘FQṖṪỌv                          Main link. Argument: n

“(ẹ+)‘                                As before.
      F                               Flatten the array. Yields an integer array.
       Q                              Unique; deduplicate the integers.
                                      This yields [40, 214, 43, 41].
        Ṗ                             Pop; remove the last element.
         Ṫ                            Tail; extract the last element. 
                                      This yields 43, the Unicode code point of +.
          Ọ                           Unordinal; cast to character.
           v                          Eval; execute the character as a Jelly
                                      program with argument n.

एन × एन

““((ẹẹ++))‘‘FFQQṖṖṪṪỌỌvv              Main link. Argument: n

““((ẹẹ++))‘                           As before.
           ‘                          Increment all integers.
            FF                        Flatten the array. Yields an integer array.
              QQ                      Unique; deduplicate the integers.
                                      This yields [41, 215, 44, 42].
                ṖṖ                    Pop twice; remove the last two elements.
                  ṪṪ                  Tail; extract the last element.
                                      This yields 215, the Unicode code point of ×.
                    ỌỌ                Unordinal; cast to character.
                      v               Eval; execute the character as a Jelly
                                      program with argument n.
                       v              Eval; convert the return value (n×n) to a
                                      string and execute that string as a Jelly
                                      program with argument n. Since the string
                                      consists of a single integer literal, that
                                      integer is returned, ignoring the argument.

ध्यान दें कि F, Q, Ṫ, और Ọ1 डी सरणियों, सरणियों डुप्लिकेट, पूर्णांकों, और वर्ण (क्रमशः) के बिना परिवर्तित न करें।

एन ^ N

“““(((ẹẹẹ+++)))‘‘‘FFFQQQṖṖṖṪṪṪỌỌỌvvv  Main link. Argument: n

“““(((ẹẹẹ+++)))‘                      As before.
                ‘‘                    Increment all integers twice.
                  FFF                 Flatten the array. Yields an integer array.
                     QQQ              Unique; deduplicate the integers.
                                      This yields [42, 216, 45, 43].
                        ṖṖṖ           Pop thrice; remove the last three elements.
                           ṪṪṪ        Tail; extract the last element.
                                      This yields 42, the Unicode code point of *.
                              ỌỌỌ     Unordinal; cast to character.
                                 v    Eval; execute the character as a Jelly
                                      program with argument n.
                                  vv  Eval twice. See N×N.

Comments

मुझे एक उत्तर की उम्मीद थी, क्योंकि आप लोग यहां कुछ भी हल कर सकते हैं, लेकिन यह सिर्फ कुछ वास्तव में पागल सामान है। आप एक गुरु हैं और मैं आपकी भव्यता के कारण विस्मय में हूँ।

— नोवा

मुझे नहीं लगता कि मैंने इससे पहले डेनिस से कोई जवाब देखा है, जिसके परिणामस्वरूप मुझे "कोई रास्ता नहीं" सोचना शुरू हो गया है, फिर धीरे-धीरे आश्वस्त हो रहा है कि वह स्पष्टीकरण पढ़कर किसी तरह का भगवान है।

— मैजिक ऑक्टोपस उर्फ़

उत्थान में शामिल हुए। वाह।

— डैनियल आर

कोई रास्ता नहीं ... आप गोल्फ में कितने घंटे बिताते हैं?!?

— tfrascaroli

@ फाल्को मुझे यकीन है कि डेनिस बस सो रहा था जब वह तैनात था। ;)

— मार्टिन एंडर

Answer 2

> <> , 41 बाइट्स

\<
1:: :
&&* +
i*n n
c&
%:
4l
0(
.i
n}
&?

इसे ऑनलाइन आज़माएं: एन + एन , एन * एन , एन ^ एन । मान लेता है कि एसटीडीआईएन इनपुट बिल्कुल चार है।

> <> एक 2 डी भाषा है, इसलिए हम इस तथ्य का उपयोग कर सकते हैं कि कोड अर्थार्थक ज्यादातर अपरिवर्तित हैं यदि हम निर्देशों को नीचे की ओर निष्पादित करते हैं - अतिरिक्त खाली लाइनें जो सुनिश्चित करती हैं कि सिर्फ नो-ऑप हैं। इसका अपवाद सशर्त ट्रैम्पोलिन है, ?जो एक मूल्य को पॉप करता है और अगले निर्देश को छोड़ देता है यदि मूल्य नॉनजरो था - अतिरिक्त न्यूलाइन्स ?सम्मिलित किए गए नो-ऑप्स के कारण गड़बड़ कर देगा , लेकिन हम इसे ?अंत में डालकर प्राप्त कर सकते हैं एक कॉलम और रैपिंग का लाभ लेना।

यह तय करने के लिए कि किस ऑपरेशन को निष्पादित करना है, कुंजी वह है 40., जो आईपी को स्थिति में भेजती है (4, 0)। कोड के विस्तार के कारण, x = 4कॉलम +बेस प्रोग्राम के *लिए, डबल प्रोग्राम के ^लिए और ट्रिपल्ड प्रोग्राम के लिए मेल खाता है । दुर्भाग्य से> <> में निर्मित घातांक नहीं है, जो कि कार्यक्रम के थोक बनाता है।

[Setup]
\         Mirror: reflect IP direction to downwards
1&        Put 1 into the register
ic%       Push a code point of input, then take it mod 12. This maps the char '1' to the
          number 1, and so forth for '2' to '9'.
40.       Jump to (4, 0), still heading downwards

[N+N version]
:+        Duplicate then add
n         Output as number
          (Stack is now empty, so the program errors out trying to do the above again)

[N*N version]
:*        Duplicate then multiply
n         Output as number
          (Stack is now empty, so the program errors out trying to do the above again)

[N^N version]
:&*&      Multiply register by N
:l(       Push (N < length of stack + 1)
i         Push input, but since we're now at EOF this pushes -1 (stack length += 1)
}         Move -1 to the back
?<        If (N < length + 1) was 1, execute the < to move leftward. Otherwise, skip it.
          (Continue loop)

\         Mirror: reflect IP direction upwards
&n        Output register
.         Jump to (-1, N), which is invalid so the program errors out

Answer 3

TovTovTov ( चिकन का एक उत्परिवर्तन): 810147050 बाइट्स

नीचे दिए गए दो सुझाए गए समाधान हैं: एक प्रश्न का पूर्ण समाधान जिसमें बहुत सारे बाइट्स की आवश्यकता होती है, और एक दूसरा आंशिक समाधान (केवल एन + एन और एन * एन भागों को हल करने के लिए , केवल 484 बाइट्स की आवश्यकता होती है), प्रत्येक एक अलग दृष्टिकोण और अपना स्वयं का समाधान करता है। शांत चाल का सेट! :)

1. पूर्ण समाधान (810147050 बाइट्स)

का उपयोग करते हुए TovTovTov(TOV='hi',SEP=','), TOVतत्वों जगह में डुप्लिकेट करने पात्रों के लिए प्रतिरक्षा हैं (दोनों "hihihi"और "hhiihhiihhii"तीन है "hi"उन में है, और सभी TovTovTovका ध्यान रखता है कई कैसे है TOVरों के बीच दिखाई देते हैं SEPरों)।

यदि हम उपयोग करते हैं SEP=', ', तो पूरा कार्यक्रम चरित्र दोहराव के लिए प्रतिरक्षा होगा (जो शांत है, लेकिन सवाल हल नहीं करेगा)। इसलिए हम उपयोग करते हैं SEP=','।

इसलिए, कार्यक्रम "hihihi,hi", उदाहरण के लिए [3,1], जबकि और करने के "hhiihhiihhii,,hhii"लिए संकलन करता है , जबकि चींटियों की सरणी के लिए संकलन करता है । इसका मतलब यह है कि आदेश स्वयं दोहराव के बाद अपना अर्थ नहीं बदलते हैं, लेकिन समग्र दोहराव चरित्र दोहराव के साथ बदलता है। नीचे दिए गए समाधान कार्यक्रम की लंबाई पर सवाल उठाते हैं और इसका उपयोग यह तय करने के लिए करते हैं कि क्या प्रिंट करना है , या ।[3,0,1]"hhiihhiihhii,,hhii"[3,0,0,1]N+NN*NN^N

इन्टस सरणी के रूप में सुझाया गया पूर्ण समाधान है: [6, 12, 9, 18, 9, 142, 11, 38, 8, 9, 260, 11, 73, 8, 22, 75, 7, 10, 14, 3, 1, 22, 24, 18, 15, 8, 10, 16, 3, 1, 22, 24, 18, 15, 8, 10, 45, 16, 7, 22, 3, 1, 22, 24, 18, 15, 8, 22, 3, 1, 22, 24, 18, 15, 8, 25, 3, 1, 22, 24, 18, 15, 8, 48, 3, 1, 22, 24, 18, 15, 8, 277, 3, 1, 22, 24, 18, 15, 8, 3146, 3, 1, 22, 24, 18, 15, 8, 46677, 3, 1, 22, 24, 18, 15, 8, 823564, 3, 1, 22, 24, 18, 15, 8, 16777237, 3, 1, 22, 24, 18, 15, 8, 387420510, 3, 1, 22, 24, 18, 15, 8]

एक स्ट्रिंग के रूप में, यह एक बहुत लंबा कार्यक्रम है, जिसमें 810147050 अक्षर हैं, जिनके साथ शुरू होता है: hihihihihihi,hihihihihihihihihihihihi,hihihihihihihihihi,hihihihihihihihihihihihihihihihihihi,hihihihihihihihihi,hihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihih...

2. प्रश्न के केवल N + N और N * N भागों को हल करना (484 बाइट्स)

TovTovTov(TOV='1',SEP=', ')इस समय का उपयोग , SEPदोहराव के लिए प्रतिरक्षा हैं ( ",, "अभी भी इसमें सिर्फ एक ", "है), इसलिए निम्न सुझाए गए समाधान में हमेशा 33 कमांड होंगे, भले ही चरित्र दोहराव के बाद:

1111, 111111111111111111111111111111111111111111111111, 1111111111, 1111111111, 1111111111, 111111, 111111111111, 111111111, 11111111111111, 111, 1, 1111111111111111111111, 111111111111111111111111, 111111111111111111, 111111111111111, 11111111, 111111111111, 1111111111111111, 111111111111111, 1111111111111111111111, 111111111111111111111111111111111111, 11, 1111111111111111111111111111, 111111, 111, 111111, 11111111111, 111111111111111111111111111, 1111, 1, 11111111, 1, 11111111

उपरोक्त इन्टस सरणी ( उपरोक्त 33 कमांड में से प्रत्येक में TOVs की संख्या 1) निम्नानुसार है:[4,48,10,10,10,6,12,9,14,3,1,22,24,18,15,8,12,16,15,22,36,2,28,6,3,6,11,27,4,1,8,1,8]

33 पूरी तरह से अलग-अलग आदेशों की एक सूची में वर्णों को दोहराते हुए : [8,96,20,20,20,12,24,18,28,6,2,44,48,36,30,16,24,32,30,44,72,4,56,12,6,12,22,54,8,2,16,2,16]

मूल इन्ट्स सरणी (जो एन + एन की गणना करता है ) को सावधानीपूर्वक डिज़ाइन किया गया था ताकि कमांड के अर्थ बदलने के बाद, प्रोग्राम अभी भी समझ में आता है, लेकिन एन * एन की गणना करता है । उदाहरण के लिए, पहला 4(जो TovTovTov"चरित्र को बदलने के लिए एक एएससीआई कोड के रूप में अगले ऑप का इलाज करता है" को समझता है) चरित्र दोहराव के बाद बदलता है 8, जो कि एक पूरी तरह से अलग कमांड है ("प्रोग्राम काउंटर को पहले पॉप्ड किए गए मान से बदल दें) स्टैक, यदि मान सही होने के तुरंत बाद पॉप हुआ ")।

Answer 4

Befunge-98 , 38 बाइट्स

vx:k:2-k*.@
20@
j3.
>^*
>:^
>:+.@

इसे ऑनलाइन आज़माएं: एन + एन , एन * एन , एन ^ एन

यह प्रोग्राम आउट-ऑफ-द-बॉक्स काम नहीं करेगा क्योंकि इसे निष्पादन की शुरुआत में स्टैक पर इनपुट की आवश्यकता होती है। निम्नलिखित कोड के साथ पहली पंक्ति को प्रतिस्थापित करके (तीन बाइट्स जोड़कर) यह स्टड से इनपुट लेगा (हालांकि यह tryitonline.net पर काम नहीं करता है, दुख की बात है):

v
&x:k:2-

---

व्याख्या

सेट अप

v       Redirect motion downward
02j     Jump over two instructions/spaces, executing the third
        If N=1, it will skip to the 6th line
        If N=2, it will skip to the 5th line
        If N=3, it will skip to the 4th line

एन = 1

>       Move right
:+.@    Duplicate, add, print and exit

एन = 2

>>::^^  Move right, duplicate twice, move up
*.@     Multiply, print and exit

एन = 3

>>>^^^  Redirect motion
30x     Set instruction pointer delta to (3, 0), causing it to
        move right, executing every third instruction
:k:     Duplicate the number (we'll call it M) M+1 times
        The stack is now [M]*(M+2)
2-k*    Multiply things M-1 times (`k' is a quirky instruction)
.@      Print and exit