निर्मित एक्स-रे के बिना पूर्णांक x को पावर x तक बढ़ाएं

Question

टास्क - शीर्षक बहुत अधिक है: यह एक पूर्णांक x को पावर x , जहां बढ़ाता है 0<x।

प्रतिबंध:

• घातांक का प्रयोग करें, exp(), ln(), और किसी भी अन्य शक्तियों से संबंधित भाषा में निर्मित इन, जैसे pow(), x^x, x**xमना किया है।
• आप यह मान सकते हैं कि दिया गया पूर्णांक आपकी पसंद की प्रोग्रामिंग भाषा की सीमाओं को फिट बैठता है।

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

Input | Output
---------------
2     | 4
3     | 27
5     | 3125
6     | 46656
10    | 10000000000

---

यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे छोटा कार्यक्रम जीत जाता है।

Comments

क्या हम इनपुट को एक स्ट्रिंग के रूप में स्वीकार कर सकते हैं?

— झबरा

मैंने इसे संपादित किया है, उम्मीद है कि इसे फिर से खोल दिया जाएगा। मैंने नियम 3 को नष्ट कर दिया और इसके बजाय कहा कि यह एक पूर्ण कार्यक्रम होना चाहिए, जैसा कि ओपी ने शायद इरादा किया था

— श्री एक्सकोडर

बहुत बेहतर, @ Mr.Xcoder लेकिन मैं दूसरे प्रतिबंध को हटाने (या फिर से रिकॉर्ड करने) का सुझाव देता हूं। क्या "एक फ़ंक्शन नहीं" जेएस को भाग लेने से बाहर करता है? मैं यह भी सुझाव देता हूं कि चुनौती के उद्देश्यों के लिए, कि हमें संभालना चाहिए 0और अपेक्षित आउटपुट निर्दिष्ट ( 0या 1या तो) होना चाहिए । अंत में, नकारात्मक पूर्णांक को संभालना चुनौती के लिए एक अच्छा अतिरिक्त होगा।

— झबरा

@Shaggy ने ऐप्पल कैलकुलेटर पर 0 ^ 0 की गणना में वापस js जोड़ा है और यह 1 लौटा है। हो सकता है कि 1 का चुना हुआ मान होना चाहिए, क्योंकि पायथन भी लौटता 1है 0^0। हालांकि, Foundation+ स्विफ्ट 0

— मिस्टर एक्सकोडर

@ Mr.Xcoder, मैंने "प्रतिबंध" को हटा दिया है जिसे हमें संभालने की आवश्यकता नहीं है 0और इसके बजाय 0<xलीड-इन में निर्दिष्ट किया गया है। मैंने यह प्रतिबंध भी हटा दिया कि कोड में त्रुटियां नहीं होनी चाहिए; बिना कहे चले जाना चाहिए। यदि आवश्यक हो तो वापस रोल करने के लिए स्वतंत्र महसूस करें।

— झबरा

Answer 1

एपीएल (डायलॉग) , 4 बाइट्स

के लिए एक्स ^एक्स , लेता है एक्स और बाईं तर्क के रूप में एक्स सही तर्क के रूप में।

×/⍴⍨

ऑनलाइन सभी मामलों की कोशिश करो!

×/ का उत्पाद

⍴⍨ arg प्रतियां arg

और यहां एक ऐसा है जो नकारात्मक पूर्णांक भी संभालता है:

×/|⍴|*×

सभी मामलों की कोशिश करो!

×/ के उत्पाद

| निरपेक्ष मूल्य

⍴ के एपीसैंट्स

| निरपेक्ष मूल्य

* की शक्ति को

× साइन इन करें

अंतर्निहित पावर आदिम है:

x*y

Answer 2

पायथन , 25 बाइट्स

lambda n:eval('1'+'*n'*n)

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

Answer 3

गणितज्ञ, 16 बाइट्स

मैं इस बाइट गिनती में दो समाधान मिल गया है:

1##&@@#~Table~#&

यहाँ, #~Table~#की nप्रतियों की एक सूची बनाता है n। फिर Listसिर को बदल दिया जाता है, 1##&जो इसके सभी तर्कों को एक साथ गुणा करता है।

Nest[n#&,1,n=#]&

यह केवल इनपुट को स्टोर करता है nऔर फिर गुणा 1करके n, nगुणा करता है।

Comments

#~Product~{#}&

— एलेफाल्फा

@alephalpha आह, अच्छी बात है। आप एक अलग उत्तर के रूप में पोस्ट कर सकते हैं।

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

Answer 4

जावास्क्रिप्ट (ईएस 6), 33 28 25 24 बाइट्स

n=>g=(x=n)=>--x?n*g(x):n

---

कोशिश करो

f=
n=>g=(x=n)=>--x?n*g(x):n
o.innerText=f(i.value=3)()
i.oninput=_=>o.innerText=f(+i.value)()

<input id=i min=1 type=number><pre id=o>

---

इतिहास

25 बाइट्स

f=(n,x=n)=>--x?n*f(n,x):n

28 बाइट्स

n=>eval(1+("*"+n).repeat(n))

33 बाइट्स

n=>eval(Array(n).fill(n).join`*`)

Answer 5

शुद्ध बैश, 43

echo $[$1<2?1:$[$1<2?2:$1]#`printf 1%0$1d`]

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

यह सुनिश्चित नहीं है कि अगर यह नियमों को बहुत अधिक झुका रहा है - मैं किसी भी सूचीबद्ध प्रतिबंधित बिल्ड का उपयोग नहीं कर रहा हूं, लेकिन मैं आधार रूपांतरण का उपयोग कर रहा हूं।

• printf 1%0$1d1इसके बाद n 0s आउटपुट करता है
• $[b#a]aआधार bसंख्या के रूप में इलाज करने के लिए एक अंकगणितीय विस्तार है , जो आवश्यक परिणाम देता है। दुर्भाग्य से आधार <2 काम नहीं करता है, इसलिए अतिरिक्त ?:बिट्स इनपुट n = 1 को संभालते हैं।

अधिकतम इनपुट 15 है, क्योंकि बैश हस्ताक्षरित 64-बिट पूर्णांक (2 ³¹ -1 तक) का उपयोग करता है।

Comments

एक ही समस्या जैसा कि मेरे पास था, यह x = 1 के लिए काम नहीं करता है। बहरहाल, बहुत दिलचस्प दृष्टिकोण।

— मैक्सिम मिखायलोव

@MaxLawnboy कि बाहर इशारा करने के लिए धन्यवाद - कि दुख की बात है मेरे जवाब फूला हुआ। शायद मैं एक और छोटे संस्करण का पता लगा सकता हूं ...

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

सुन्दर सामान। हमेशा बैश सीखने की कामना करते हैं, लेकिन हमेशा इसके लिए बहुत आलसी रहे हैं) =

Answer 6

ऐलिस , 13 बाइट्स

/o
\i@/.&.t&*

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

व्याख्या

/o
\i@/...

यह उन कार्यक्रमों के लिए एक रूपरेखा है जो दशमलव पूर्णांक को पढ़ते हैं और लिखते हैं और पूरी तरह से कार्डिनल मोड में काम करते हैं (इसलिए अधिकांश अंकगणितीय समस्याओं के लिए कार्यक्रम)।

.    Duplicate n.
&.   Make n copies of n.
t    Decrement the top copy to n-1.
&*   Multiply the top two values on the stack n-1 times, computing n^n.

Answer 7

मानक एमएल , 42 बाइट्स

fn x=>foldl op*1(List.tabulate(x,fn y=>x))

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

स्पष्टीकरण:

fn y => x                 (* An anonymous function that always returns the inputted value *)
List.tabulate(x, fn y=>x) (* Create a list of size x where each item is x *)
foldl op* 1               (* Compute the product of the entire list *)    

Comments

PPCG में आपका स्वागत है!

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

TIO के पास अब MLton है। tio.run/nexus/…

— डेनिस

ओह यह कमाल है! धन्यवाद!

— संगीतज्ञ ५२३

Answer 8

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

ẋ⁸P

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

कैसे?

ẋ⁸P - Main link: x             e.g. 4
 ⁸  - link's left argument, x       4
ẋ   - repeat left right times       [4,4,4,4]
  P - product                       256

Comments

डारन, मैं ऐसा करना चाहता था। : P

— HyperNeutrino

@ जोनाथन एलन यह 3 बाइट्स, या 3 चौड़े अक्षर हैं? हमें वास्तविक कोड बाइट्स पर सही निर्णय लेने के लिए कृपया सोर्स कोड हेक्स डंप देखें। ;-) और सुधार करें

@ xakepp35 जेली एक एसबीसीएस और बाइट्स लिंक का उपयोग हेडर में इंगित करता है। हेक्सडंप के साथ कार्यक्रम F7 88 50इरादा के रूप में काम करता है।

— डेनिस

@ जवाब के लिए धन्यवाद! मैं पहले कभी इस तरह की भाषा की कल्पना नहीं कर सका =)

Answer 9

क्यूबिक्स , 19 बाइट्स

..@OI:1*s;pu!vqW|($

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

क्रमशः

साइड की लंबाई 2 के साथ एक क्यूब पर फैलता है

    . .
    @ O
I : 1 * s ; p u
! v q W | ( $ .
    . .
    . .

• I:1 इनपुट लेता है, इसे डुप्लिकेट करता है और 1 धक्का देता है। यह एक काउंटर, गुणक और परिणाम के साथ स्टैक को सेट करता है।
• *s; टीओएस को गुणा करता है, परिणाम को पिछले के साथ स्वैप करता है और पिछले को हटा देता है।
• puकाउंटर आइटम को टीओएस पर लाओ। यू टर्न। यह एक लेन परिवर्तन होने के लिए उपयोग किया जाता है, लेकिन एक बाइट दाढ़ी बनाने के लिए आवश्यक है।
• |($यह एक बाइट को बचाने के लिए किया गया था। जब यह मारा जाता है तो गिरावट को रोक देता है। प्रतिबिंबित करता है, काउंटर को घटाता है और क्यूब के चारों ओर कोई ओप लपेटता है।
• !vqWकाउंटर का परीक्षण करें। यदि सत्य पुनर्निर्देशन को छोड़ देता है, तो काउंटर को बीओएस पर रखें, लेन को वापस गुणक पर बदलें। अन्यथा पुनर्निर्देशित।
• |sO@यह काउंटर टेस्ट से पुनर्निर्देशित अंतिम क्रम है। क्षैतिज परावर्तक के पार जाता है, टीओएस को नतीजे पर लाता है, जिससे टीओटी, ouput और हॉल्ट को परिणाम मिलता है।

Answer 10

आर, 22 बाइट्स

स्टड xसे पढ़ता है।

prod(rep(x<-scan(),x))

की xप्रतियों की एक सूची बनाता है x, फिर उस सूची के तत्वों के उत्पाद की गणना करता है। जब x=0, repरिटर्न numeric(0), जो लंबाई का एक संख्यात्मक वेक्टर है 0, लेकिनprod की संख्या 1 है, इसलिए 0^0=1इस विधि से, जो कि आर के बेसिन घातांक के अनुरूप है, इसलिए यह बहुत साफ है।

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

Answer 11

लिनक्स के लिए x86_64 मशीन भाषा, 14 11 10 बाइट्स

0:   6a 01                   pushq  $0x1
2:   58                      pop    %rax
3:   89 f9                   mov    %edi,%ecx
5:   f7 ef                   imul   %edi
7:   e2 fc                   loop   5
9:   c3                      retq

इसे ऑनलाइन करने की कोशिश करो! , संकलन और निम्नलिखित सी कार्यक्रम चलाएं।

const char h[]="\x6a\1\x58\x89\xf9\xf7\xef\xe2\xfc\xc3";

int main(){
  for( int i = 1; i < 4; i++ ) {
    printf( "%d %d\n", i, ((int(*)())h)(i) );
  }
}

Answer 12

रूबी, 20 18 बाइट्स

-2 बाइट्स क्योंकि कल्पना बदल गई है और मुझे अब एक्सपोनेंट तर्क की आवश्यकता नहीं है।

->x{eval [x]*x*?*}

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

Answer 13

स्टैक्ड , 10 बाइट्स

{!1[n*]n*}

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

एक ही आकार के लिए दो-तर्क प्रतिरूपण:

{%1[x*]y*}

दोनों कार्य हैं। एक समारोह है कि पलता को दोहराया जाएगा 1द्वारा n nबार।

Answer 14

स्काला , 32 26 बाइट्स

n=>List.fill(n)(n).product

इसे ऑनलाइन आज़माएं! (TIO में लंबे समय तक रूपांतरण जोड़ा गया है, इसलिए यह n = 10 पर अतिप्रवाह नहीं होगा।)

Answer 15

05AB1E , 3 बाइट्स

.DP

इसे ऑनलाइन आज़माएं! या सभी उदाहरणों का प्रयास करें

.D  # pop a,b    push b copies of a 
    # 05AB1E implicitly takes from input if there aren't enough values on the stack
    # For input 5, this gives us the array: [5,5,5,5,5]
  P # Take the product of that array
    # Implicit print

Comments

लगता है कि आपको मज़ा आया .D। पहली बार मैंने इसका उपयोग देखा है।

— मैजिक ऑक्टोपस Urn

आह, मुझे नहीं पता कि यहाँ क्या हो रहा है .. यह बहुत ही आकर्षक है और इस पर कोई स्पष्टीकरण नहीं है कि यह कैसे काम करता है। = (

@ xakepp35 क्या वह मदद करता है?

— रिले

Answer 16

हास्केल , 24 23 21 बाइट्स

f y=product$y<$[1..y]

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

• 1 बाइट बचाई , लाईकोनी के लिए धन्यवाद
• 2 बाइट्स सहेजे, धन्यवाद nimi के लिए

Comments

f y=foldr1(*)$y<$[1..y]एक बाइट छोटी है।

— लकोनी

product$y<$[1..y]

— नीमी

यकीन नहीं होता कि मैं उत्पाद के बारे में कैसे भूल गया, धन्यवाद! : डी

— सूदी १६'१

Answer 17

जाप , 4 बाइट्स

ÆUÃ×

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

व्याख्या

ÆUÃ×       // implicit: U = input integer
Uo{U} r*1  // ungolfed

Uo{ }      // create array [0, U) and map each value to...
   U       //   the input value
      r*1  // reduce with multiplication, starting at 1          
           // implicit output of result

Answer 18

x86 मशीन कोड (लिनक्स), 18 बाइट्स

31 c0 ff c0 31 db 39 df 74 07 0f af c7 ff c3 eb f5 c3

यह निम्नानुसार एक सी घोषणा की उम्मीद है extern int XpowX(int)।

disassembled

XpowX:
  # edi : input register
  # ebx : counter
  # eax : result register
  xor  %eax, %eax    # result  = 0
  inc  %eax          # result += 1
  xor  %ebx, %ebx    # counter = 0
  loop:
    cmp  %ebx, %edi  # if (counter == input)
    je   done        #   return result
    imul %edi, %eax  # result  *= input
    inc        %ebx  # counter += 1
    jmp   loop
  done:
    ret

Answer 19

ब्रेकीलॉग , 6 बाइट्स

g;?j₎×

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

व्याख्या

          Example input: 5
g         Group: [5]
 ;?       Pair with the Input: [[5], 5]
   j₎     Juxtapose [5] 5 times: [5, 5, 5, 5, 5]
     ×    Multiply

Answer 20

सीजाम , 7 बाइट्स

ri_a*:*

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

व्याख्या

ri       e# Read an int from input
  _      e# Duplicate it
   a*    e# Put the copy in the array and repeat it that many times
     :*  e# Take the product of the array

Answer 21

पर्ल 6 , 13 बाइट्स

{[*] $_ xx$_}

$_ xx $_( अनाम फ़ंक्शन का तर्क होने के नाते) की $_प्रतियों की सूची का मूल्यांकन करता है, और फिर गुणा के साथ उस सूची को कम कर देता है।$_$_[*]

Answer 22

सीजाम , 6 बाइट्स

ri_m*,

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

ri       e# Read integer
  _      e# Duplicate
   m*    e# Cartesian power. The first argument is interpreted as a range
     ,   e# Number of elements. Implicitly display

Answer 23

लौंग, २२

#(apply *(repeat % %))

:)

Answer 24

रोड़ा , 17 बाइट्स

{product([_]*_1)}

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

यह एक अनाम फ़ंक्शन है जो स्ट्रीम से इनपुट लेता है।

स्पष्टीकरण:

{product([_]*_1)}
{               } /* An anonymous function */
         [_]      /* An array containing the input value */
            *_1   /* repeated times the input value */
 product(      )  /* Product of all values in the array */

Answer 25

डीसी , २४ २३ २६ 22 बाइट्स

यह डीसी में एक पुनरावर्ती मैक्रो लिखने का मेरा पहला प्रयास है। मुझे यकीन है कि यह एक उप-इष्टतम समाधान है जिसे बहुत सुधार किया जा सकता है।

dsr1+[lrr1-d1<F*]dsFxp

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

संपादित करें: धन्यवाद eush77 ! -4 निवाले।

Comments

के लिए काम नहीं करता है x=1।

— eush77

आप शुरुआत में lrदो dएस के साथ अंत में दृश्यों को बदलकर दो बाइट्स से दाढ़ी बना सकते हैं ।

— eush77

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

— eush77

@ eush77 मैं यह कहने वाला था कि दूसरा हटाने से lrयहाँ काम नहीं होगा। यह स्टैक-आधारित भाषा में मेरा पहली बार गोल्फ है, इसलिए यह बहुत ही असामान्य लगता है। आपकी सहायताके लिए धन्यवाद!

— मैक्सिम मिखायलोव

Answer 26

बैच, 58 बाइट्स

@set n=1
@for /l %%i in (1,1,%1)do @set/an*=%1
@echo %n%

केवल 32-बिट अंकगणित के कारण एकल-अंक इनपुट के लिए काम करता है।

Answer 27

ब्रेनफ * ck , 148 बाइट्स

,[->+>+<<]>>[-<<+>>]++++++++[<------<------>>-]<[->>+>>+<<<<]>>[-<<+>>]>>-[-<<<<<[>[>+>+<<-]>>[<<+>>-]<<<-]>>[-<<+>>]>>>]<<<++++++++[-<<++++++>>]<<.

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

बिल्ट-इन नहीं;)

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

,                                       - get ascii input
[->+>+<<]                               - duplicate input
>>[-<<+>>]                              - shift inputs left to start
++++++++[<------<------>>-]             - convert ascii into input numbers
<[->>+>>+<<<<]                          - get loop intervals (same as input #)
>>[-<<+>>]                              - shift input back again
>>-[-<<<<<[>[>+>+<<-]>>[<<+>>-]<<<-]>>  - iterated addition (multiplication)
[-<<+>>]>>>                             - Shift output back into input
]<<<++++++++[-<<++++++>>]<<.            - convert final output to ascii

संक्षेप में, यह कई बार x(इनपुट) गुणा करके काम करता है x। (उर्फ पुनरावृति इसके अतिरिक्त)। शुद्ध परिणाम x ^ x है।

आई / ओ

कार्यक्रम एक एकल ASCII इनपुट लेता है, और इसे ASCII सूचकांक माइनस 48 के रूप में संसाधित करता है । शून्य से 48 वास्तविक संख्या का आदानों को सामान्य बनाने में है ( 4हो जाता है 52-> 52-48-> 4)। 9 से अधिक संख्या इनपुट करने के लिए, अगले संक्षारक ASCII वर्ण ( :-> 58-48-> 10) का उपयोग करें। कार्यक्रम एक समान फैशन में ouputs।

टेस्ट I / O

INPUT > PROCESSED INPUT >> OUTPUT > TRANSLATED OUTPUT
1 > 1 >> 1 > 1
2 > 2 >> 4 > 4
3 > 3 >> K > 27

चूंकि 3 के इनपुट के बाद कोई मुद्रण योग्य ASCII वर्ण नहीं हैं, यह केवल सिद्धांत में संख्याओं को प्रिंट कर सकता है । हालाँकि, आप विज़ुअलाइज़र पर इस तरह से वास्तव में काम करने वाले सभी इनपुट की जांच कर सकते हैं ।

Answer 28

MATLAB / ऑक्टेव, 23 बाइट्स

@(n)(prod(n*ones(n,1)))

Answer 29

पायथन, 32 बाइट्स

f=lambda g,z=1:z>g or g*f(g,z+1)

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

Comments

PPCG में आपका स्वागत है! आपको f=भाग की गणना करने की आवश्यकता नहीं है , इसलिए आप अपनी जमा को 30 बाइट्स तक छोटा कर सकते हैं ।

— स्टैडिओबॉक्स

@Steadybox f=भाग की गणना करने की आवश्यकता है, क्योंकि यह पुनरावर्ती है, इसलिए यह fठीक से काम करने के लिए फ़ंक्शन के नाम पर निर्भर करता है

— Musicman523

@ musicman523 हाँ, आप सही हैं।

— स्टेयडबॉक्स

Answer 30

आम लिस्प , 59 42 40 बाइट्स

(lambda(x)(apply'*(fill(make-list x)x)))

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