एक फ़ंक्शन लिखें जो (x, y) लेता है और x को Loops के बिना y की शक्ति में लौटाता है [बंद]

Question

यह वास्तव में एक छोटी चुनौती है।

एक फ़ंक्शन या एक प्रक्रिया लिखें जो दो मापदंडों को लेती है, xऔर छोरों का उपयोग किए बिना yपरिणाम देता है , या बिजली कार्यों में निर्मित होता है।xy

विजेता सबसे रचनात्मक समाधान है, और 3 दिनों के बाद सबसे अधिक वोटों के आधार पर चुना जाएगा।

Comments

यह किस तरह की चुनौती है?

— VisioN

कैसे के बारे में exp(log(x)*y)?

— r3mainer

क्या पूर्णांकों के लिए एक उत्तर केवल स्वीकार्य है? चूंकि ये पहले उत्तर हैं।

— mmumboss

अब तक के जवाबों की तरह लगता है कि या तो पुनरावृत्ति का उपयोग करें या बार-बार के एक्स की सूची। मैं अपने दिमाग को दूसरे तरीके से सोचने की कोशिश कर रहा हूं (विशेषकर कुछ ऐसा जो गैर-पूर्णांक वाई की अनुमति देता है)।

— BenM

दुर्भाग्य से लूप पर निषेध टेलर विस्तार जैसे मजेदार गणितीय समाधानों को नियंत्रित करता है।

— छायाकार

Answer 1

एपीएल (7)

{×/⍵/⍺}

वाम तर्क आधार है, सही तर्क प्रतिपादक है, जैसे:

     5 {×/⍵/⍺} 6
15625

स्पष्टीकरण:

• ⍵/⍺⍺ ⍵बार-बार दोहराता है, जैसे 5 {⍵/⍺} 6->5 5 5 5 5 5
• ×/उत्पाद लेता है, जैसे ×/5 5 5 5 5 5-> 5×5×5×5×5×5->15625

Comments

हम्म .. यह J में 5 वर्णों में लिखा जा सकता है, बिल्कुल वही विधि। */@$~

— देखिए

@ Sieg 4 यहां तक ​​कि अगर आप बाईं ओर घातांक की अनुमति देते हैं, तो दाईं ओर आधार।

— atı

मेरे पास फ्लिप क्रिया विशेषण था क्योंकि मुझे लगा कि इसकी अनुमति नहीं है।

— देखिए

@ सियाल 4 इन द्यलोग एपीएल :×/⍴⍨

— आदम

Answer 2

C #: फ्लोटिंग पॉइंट एक्सपोर्टर

ठीक है, यह समाधान काफी नाजुक है। आप इस पर 6 जैसी हास्यास्पद बड़ी संख्याओं को फेंककर आसानी से इसे तोड़ सकते हैं। लेकिन यह जैसी चीजों के लिए खूबसूरती से काम करता है DoublePower(1.5, 3.4), और पुनरावृत्ति का उपयोग नहीं करता है!

    static double IntPower(double x, int y)
    {
        return Enumerable.Repeat(x, y).Aggregate((product, next) => product * next);
    }

    static double Factorial(int x)
    {
        return Enumerable.Range(1, x).Aggregate<int, double>(1.0, (factorial, next) => factorial * next);
    }

    static double Exp(double x)
    {
        return Enumerable.Range(1, 100).
            Aggregate<int, double>(1.0, (sum, next) => sum + IntPower(x, next) / Factorial(next));
    }

    static double Log(double x)
    {
        if (x > -1.0 && x < 1.0)
        {
            return Enumerable.Range(1, 100).
                Aggregate<int, double>(0.0, (sum, next) =>
                    sum + ((next % 2 == 0 ? -1.0 : 1.0) / next * IntPower(x - 1.0, next)));
        }
        else
        {
            return Enumerable.Range(1, 100).
                Aggregate<int, double>(0.0, (sum, next) =>
                    sum + 1.0 / next * IntPower((x - 1) / x, next));
        }
    } 

    static double DoublePower(double x, double y)
    {
        return Exp(y * Log(x));
    } 

Comments

"6 की तरह हास्यास्पद रूप से बड़ी संख्या में" मुझे बहुत मज़ा आया।

— डेविड मार्क

निश्चित रूप से Enumerable फ़ंक्शन का उपयोग लूपिंग पर निर्भर है जो प्रश्न में निषिद्ध था या क्या यह ठीक है क्योंकि लूप फ्रेमवर्क विधियों के अंदर है?

— क्रिस

Answer 3

सी ++

कुछ टेम्प्लेट मेटा प्रोग्रामिंग के बारे में कैसे? यह झुकता है कि क्या छोटे नियम थे, लेकिन यह एक शॉट के लायक है:

#include <iostream>


template <int pow>
class tmp_pow {
public:
    constexpr tmp_pow(float base) :
        value(base * tmp_pow<pow-1>(base).value)
    {
    }
    const float value;
};

template <>
class tmp_pow<0> {
public:
    constexpr tmp_pow(float base) :
        value(1)
    {
    }
    const float value;
};

int main(void)
{
    tmp_pow<5> power_thirst(2.0f);
    std::cout << power_thirst.value << std::endl;
    return 0;
}

Comments

लेकिन यह एक फ़ंक्शन नहीं है, एक संकलन-समय मान है, है ना? : ओ

— पेपरबर्डमास्टर

ठीक है, एक निर्माता एक फ़ंक्शन है, और टेम्पलेट पैरामीटर फ़ंक्शन तर्क के समान हैं ... सही? =)

— erlc

@PaperBirdMaster हाँ ... यही कारण है कि मैंने झुकने वाले कुछ नियम को स्वीकार किया है। मुझे लगा कि मैं पूंछ-पुनरावृत्ति के अलावा कुछ प्रस्तुत करने जा रहा हूं, लेकिन मैंने सिर्फ संकलन समय पूंछ पुनरावृत्ति, हाहा प्रस्तुत किया। बंद पर्याप्त हालांकि, है ना?

— astephens4

@ astephens4 काफी करीब है, मुझे यह पसंद है: 3

— पेपरबर्डमास्टर

Answer 4

अजगर

def power(x,y):
    return eval(((str(x)+"*")*y)[:-1])

Noninteger शक्तियों के लिए काम नहीं करता है।

Comments

मैं यह पसंद है।

— CodyBugstein

आप उपयोग किए बिना विभाजक क्यों जोड़ रहे हैं join? eval('*'.join([str(x)] * y))।

— बकुरीउ

क्या यह कोड-ट्रोलिंग था?

— गेरिट

यह भी नोट करना चाहेंगे कि अजगर के पास **ऑपरेटर है, इसलिए आप इसे विकसित कर सकते हैं ()।

— Riking

@ बाइकिंग: यह एक इनबिल्ट होगा, हालांकि।

— होवरकच

Answer 5

हास्केल - 25 वर्ण

f _ 0=1
f x y=x*f x (y-1)

मारिनस के एपीएल संस्करण के बाद:

f x y = product $ take y $ repeat x

मनिप की टिप्पणी और व्हाट्सएप को हटाने के साथ, 27 वर्ण:

f x y=product$replicate y x

Comments

के replicate y xबजाय का उपयोग करेंtake y $ repeat x

— mniip

मुझे विश्वास था कि आप अपने दूसरे फंक्शन पॉइंटफ्री को लिखकर पात्रों को बचा सकते हैं। जैसा कि यह पता चला f=(product.).flip replicateहै कि वर्णों की संख्या समान है।

— काया

@mniip इससे कोई फर्क नहीं पड़ता, यह कोड गोल्फ नहीं है।

— nyuszika7h

Answer 6

अजगर

यदि yएक सकारात्मक पूर्णांक है

def P(x,y):
    return reduce(lambda a,b:a*b,[x]*y)

Answer 7

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

// Testable in Firefox 28
f=(x,y)=>eval('x*'.repeat(y)+1)

उपयोग:

> f(2, 0)
1
> f(2, 16)
65536

स्पष्टीकरण:

उपरोक्त फ़ंक्शन एक अभिव्यक्ति बनाता है जो कई x yबार गुणा करता है और फिर उसका मूल्यांकन करता है।

Answer 8

मुझे यह देखकर आश्चर्य हुआ कि किसी ने वाई कॉम्बिनेटर के साथ एक समाधान नहीं लिखा, फिर भी ... इस प्रकार:

को Python2

Y = lambda f: (lambda x: x(x))(lambda y: f(lambda v: y(y)(v)))
pow = Y(lambda r: lambda (n,c): 1 if not c else n*r((n, c-1)))

कोई लूप, कोई वेक्टर / सूची संचालन और नहीं (स्पष्ट) पुनरावर्तन!

>>> pow((2,0))
1
>>> pow((2,3))
8
>>> pow((3,3))
27

Comments

उह, मैंने अभी देखा है KChaloux का Haskell समाधान जो fixउसका उपयोग करता है , उसे

— उभारता है

Answer 9

C #: 45

केवल पूर्णांकों के लिए काम करता है:

int P(int x,int y){return y==1?x:x*P(x,y-1);}

Comments

इसे मुझे मारो :-) मुझे लगता है कि आप return --y?x:x*P(x,y);इसके बजाय कुछ बाइट्स बचा सकते हैं

— r3mainer

लेकिन यह कोड-गोल्फ नहीं है ...

— ओबेरॉन

@ रॉबर्टन जीतने के मापदंड स्पष्ट नहीं थे जब यह पोस्ट किया गया था। चीजें आगे बढ़ी हैं।

— स्तर नदी सेंट

@steveverrill क्षमा करें।

— ओबेरॉन

इसके अलावा C # --y में एक इंट ऐसा होगा जो अन्य भाषाओं की तरह बूल के समान नहीं है।

— क्रिस

Answer 10

बैश और सेड

कोई संख्या नहीं, कोई छोर नहीं, बस एक खतरनाक खतरनाक ग्लोब दुरुपयोग। अधिमानतः सुरक्षित होने के लिए खाली निर्देशिका में चलाएँ। शैल स्क्रिप्ट:

#!/bin/bash
rm -f xxxxx*
eval touch $(printf xxxxx%$2s | sed "s/ /{1..$1}/g")
ls xxxxx* | wc -l
rm -f xxxxx*

Comments

"अधिमानतः सुरक्षित होने के लिए खाली निर्देशिका में चलाएं।" : डी

— अल्मो

Answer 11

जावास्क्रिप्ट

function f(x,y){return ("1"+Array(y+1)).match(/[\,1]/g).reduce(function(l,c){return l*x;});}

आकार की एक सरणी बनाने के लिए नियमित अभिव्यक्तियों का उपयोग करता है y + 1 जिसका पहला तत्व 1 है। फिर, शक्ति की गणना करने के लिए गुणा के साथ सरणी को कम करें। जब y = 0, परिणाम सरणी का पहला तत्व है, जो 1 है।

निस्संदेह, मेरा लक्ष्य था) मैं पुनरावृत्ति का उपयोग नहीं करता, ii) इसे अस्पष्ट बनाते हैं।

Answer 12

मेथेमेटिका

f[x_, y_] := Root[x, 1/y]

शायद इस तथ्य का उपयोग करने के लिए धोखा दे रहा है कि x ^ (1 / y) = y .x

Comments

धोखा नहीं। होशियार।

— माइकल स्टर्न

ये जबरदस्त है। काश मैं अपने आर पोस्ट के लिए इसके बारे में सोचता।

— शैटॉल्कर

Answer 13

जावास्क्रिप्ट

function f(x,y){return y--?x*f(x,y):1;}

Answer 14

गोल्फस्क्रिप्ट, 8 अक्षर (I / O सहित)

~])*{*}*

स्पष्टीकरण:

TLDR: एक और "दोहराया सरणी का उत्पाद" समाधान।

अपेक्षित इनपुट दो नंबर है, उदाहरण के लिए 2 5। स्टैक एक आइटम, स्ट्रिंग से शुरू होता है "2 5"।

Code     - Explanation                                             - stack
                                                                   - "2 5"
~        - pop "2 5" and eval into the integers 2 5                - 2 5        
]        - put all elements on stack into an array                 - [2 5]
)        - uncons from the right                                   - [2] 5
*        - repeat array                                            - [2 2 2 2 2]
{*}      - create a block that multiplies two elements             - [2 2 2 2 2] {*}
*        - fold the array using the block                          - 32

Comments

गोल्‍सस्क्रिप्ट हमेशा जाने का मार्ग है।

— नित

Answer 15

माणिक

class Symbol
  define_method(:**) {|x| eval x }
end

p(:****[$*[0]].*(:****$*[1]).*('*'))

नमूना उपयोग:

$ ruby exp.rb 5 3
125
$ ruby exp.rb 0.5 3
0.125

यह अंततः कई पिछले उत्तरों के समान है: प्रत्येक तत्व का एक y-लंबाई सरणी बनाता है जो x है, फिर उत्पाद लेता है। यह सिर्फ आभारी रूप से निषिद्ध है यह देखने के लिए कि यह निषिद्ध **ऑपरेटर का उपयोग कर रहा है ।

Answer 16

सी, घातांक द्वारा घातांक

int power(int a, int b){
    if (b==0) return 1;
    if (b==1) return a;
    if (b%2==0) return power (a*a,b/2);
    return a*power(a*a,(b-1)/2);
}

46 बाइट्स में गोल्फ संस्करण (धन्यवाद बदसूरत!)

p(a,b){return b<2?b?a:1:p(a*a,b/2)*(b&1?a:1);}

अब तक के अन्य सभी पुनरावर्ती उत्तरों की तुलना में तेज़ होना चाहिए

45 बाइट्स में थोड़ा धीमा संस्करण

p(a,b){return b<2?b?a:1:p(a*a,b/2)*p(a,b&1);}

Comments

अजीब के लिए b, ~-b/2 == b/2।

— बदसूरत

@ यूगोरेन ओह यकीन है, आप सही हैं

— izabera

यह एक लोकप्रिय साक्षात्कार प्रश्न है :) "आप pow(n, x)ओ (एन) से बेहतर कैसे लिख सकते हैं ?"

— जॉर्डन स्केल

Answer 17

हास्केल - 55

pow x y=fix(\r a i->if i>=y then a else r(a*x)(i+1))1 0

पहले से ही एक छोटी हास्केल प्रविष्टि है, लेकिन मुझे लगा कि इसे लिखने के लिए दिलचस्प होगा जो fixफ़ंक्शन का लाभ उठाता है , जैसा कि परिभाषित किया गया है Data.Function। निम्नानुसार उपयोग किया जाता है (आसानी के लिए प्रतिकृति में):

ghci> let pow x y=fix(\r a i->if i>=y then a else r(a*x)(i+1))1 0
ghci> pow 5 3
125

Answer 18

क्यू

9 चरस। के yउदाहरणों के साथ सरणी उत्पन्न करता है xऔर उत्पाद लेता है।

{prd y#x}

इंट / लॉन्ग x दी गई बड़ी रेंज के लिए स्पष्ट रूप से तैरने के लिए डाली जा सकती है:

{prd y#9h$x}

Comments

लंबाई में गोल्‍सस्क्रिप्ट का मिलान करना एक उपलब्धि है।

— नित

Answer 19

PHP में कई अन्य लोगों के समान तर्क:

<?=array_product(array_fill(0,$argv[2],$argv[1]));

php file.php 5 35 ^ 3 प्राप्त करने के लिए इसे चलाएं

Answer 20

मुझे यकीन नहीं है कि मैं इसके लिए कितने उत्थान की उम्मीद कर सकता हूं, लेकिन मुझे यह कुछ अजीब लग रहा था कि मुझे वास्तव में आज उस कार्य को लिखना था। और मुझे पूरा यकीन है कि यह पहली बार है। कोई भी साइट इस भाषा को देखती है (वेबसाइट बहुत उपयोगी नहीं लगती है)।

एबीएस

def Rat pow(Rat x, Int y) =
    if y < 0 then
        1 / pow(x, -y)
    else case y {
        0 => 1;
        _ => x * pow(x, y-1);
    };

नकारात्मक घातांक और तर्कसंगत ठिकानों के लिए काम करता है।

मैंने इसे जावा सिंटैक्स में हाइलाइट किया, क्योंकि इस समय मैं इस भाषा के साथ काम कर रहा था। ठीक लग रहा है।

Answer 21

पास्कल

चुनौती में एक्स और वाई के प्रकार या सीमा को निर्दिष्ट नहीं किया गया था, इसलिए मुझे लगता है कि निम्नलिखित पास्कल फ़ंक्शन सभी दिए गए नियमों का पालन करता है:

{ data type for a single bit: can only be 0 or 1 }
type
  bit = 0..1;

{ calculate the power of two bits, using the convention that 0^0 = 1 }
function bitpower(bit x, bit y): bit;
  begin
    if y = 0
      then bitpower := 1
      else bitpower := x
  end;

कोई लूप, कोई बिल्ट-इन पॉवर या एक्सपेंशन फंक्शन, रिक्रिएशन या अंकगणित भी नहीं!

Answer 22

जे - 5 या 4 बाइट्स

बिल्कुल वैसा ही जैसा कि marinus 'APL उत्तर ।

के लिए x^y:

*/@$~

के लिए y^x:

*/@$

उदाहरण के लिए:

   5 */@$~ 6
15625
   6 */@$ 5
15625

x $~ yxबार- yबार (समान के रूप में) की एक सूची बनाता हैy $ x

*/ xउत्पाद कार्य है, */ 1 2 3->1 * 2 * 3

Answer 23

अजगर

from math import sqrt

def pow(x, y):
    if y == 0:
        return 1
    elif y >= 1:
        return x * pow(x, y - 1)
    elif y > 0:
        y *= 2
        if y >= 1:
            return sqrt(x) * sqrt(pow(x, y % 1))
        else:
            return sqrt(pow(x, y % 1))
    else:
        return 1.0 / pow(x, -y)

Comments

** बिल्ट-इन ऑपरेटर इमो है।

— सिल्वियू बर्किया

@SilviuBurcea सच, संपादन।

— ओबेरॉन

@SilviuBurcea ऑपरेटर =/=फंक्शन

— VisioN

@VisioN सच है, लेकिन यह विचार बिल्ट-इन के बारे में था। मुझे नहीं लगता कि ओपी को इन सभी अंतर्निर्मित ऑपरेटरों के बारे में पता है ...

— सिल्वियू बर्किया

Answer 24

जावास्क्रिप्ट

पूंछ पुनरावृत्ति के साथ, काम करता है अगर yएक सकारात्मक पूर्णांक है

function P(x,y,z){z=z||1;return y?P(x,y-1,x*z):z}

Answer 25

दे घुमा के

हर कोई जानता है bashकि व्हिस्की के नक्शे-प्रकार को कम कर सकते हैं ;-)

#!/bin/bash

x=$1
reduce () {
    ((a*=$x))
}
a=1
mapfile -n$2 -c1 -Creduce < <(yes)
echo $a

---

अगर आपके लिए भी बहुत टोलियाँ हैं तो यह है:

#!/bin/bash

echo $(( $( yes $1 | head -n$2 | paste -s -d'*' ) ))

Answer 26

सी

अभी तक सी में जवाब देने से एक और पुनरावर्ती प्रतिपादक है, लेकिन वे अलग-अलग होते हैं (यह विभाजन के बजाय एक बदलाव का उपयोग करता है, थोड़ा कम होता है और दूसरे की तुलना में एक बार अधिक पुनरावृत्ति करता है):

e(x,y){return y?(y&1?x:1)*e(x*x,y>>1):1;}

Answer 27

मेथेमेटिका

यह पूर्णांकों के लिए काम करता है।

f[x_, y_] := Times@@Table[x, {y}]

उदाहरण

f[5,3]

125

---

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

Tableकी सूची बनाता है y x। Timesउन सभी के उत्पाद लेता है। `

---

उसी अंत को प्राप्त करने का दूसरा तरीका :

#~Product~{i,1,#2}&

उदाहरण

#~Product~{i, 1, #2} & @@ {5, 3}

125

Answer 28

विंडोज बैच

यहां अन्य अधिकांश उत्तरों की तरह, यह पुनरावृत्ति का उपयोग करता है।

@echo off
set y=%2
:p
if %y%==1 (
set z=%1
goto :eof
) else (
    set/a"y-=1"
    call :p %1
    set/a"z*=%1"
    goto :eof
)

x ^ y को पर्यावरण चर में संग्रहीत किया जाता है z।

Answer 29

पर्ल

यहाँ एक पूंछ पुनरावर्ती पर्ल प्रविष्टि है। उपयोग प्रतिध्वनि है $ X, $ Y | foo.pl:

($x,$y) = split/,/, <>;
sub a{$_*=$x;--$y?a():$_}
$_=1;
print a

या अधिक कार्यात्मक प्रकार के दृष्टिकोण के बारे में, कैसे:

($x,$y) = split/,/, <>;
$t=1; map { $t *= $x } (1..$y);
print $t

Comments

"ए: सामान गोटो एक अगर कुछ" लूप की तरह दिखता है।

— ग्लेन रेंडर्स-पीरसन

हां, गोटो संस्करण एक लूप है, लेकिन क्या पूंछ की पुनरावृत्ति भी अनिवार्य रूप से लूप नहीं है?

— skibrianski

Answer 30

अजगर

def getRootOfY(x,y):
   return x**y 

def printAnswer():
   print "answer is ",getRootOfY(5,3)
printAnswer()

answer =125

मुझे यकीन नहीं है कि यह आवश्यकताओं के खिलाफ है, लेकिन अगर यहां नहीं है तो मेरा प्रयास है।

Comments

PPCG में आपका स्वागत है! जब आप अपना भाषा हेडर करते हैं तो आप "भाषा =" को छोड़ सकते हैं क्योंकि कस्टम द्वारा सभी भाषा को हेडर में रखा जाता है ताकि वह समझ में आए। आप वास्तव में नियमों का पालन कर सकते हैं, लेकिन हम मतदाताओं को निर्णय लेने देंगे। खुशी है कि देश क्लब में एक नया सदस्य है।

— जोनाथन वान मैट्रे