(X, y) লাগে এমন একটি ফাংশন লিখুন এবং লুপগুলি [বন্ধ] ব্যতিরেকে x এর শক্তিতে ফিরে আসুন

Question

এটি সত্যই ঝরঝরে একটি ছোট চ্যালেঞ্জ।

একটি ফাংশান বা একটা পদ্ধতি যে দুটি প্যারামিটার নেয়, লিখুন xএবং yএবং ফলাফল দেখায় লুপ ব্যবহার না করে, অথবা পাওয়ার ফাংশন সালে নির্মিত।xy

বিজয়ী সর্বাধিক সৃজনশীল সমাধান এবং 3 দিনের পরে সর্বাধিক সংখ্যক ভোটের ভিত্তিতে চয়ন করা হবে।

Comments

এটি কোন ধরণের চ্যালেঞ্জ?

— ভিজিওন

কীভাবে exp(log(x)*y)?

— r3mainer

পূর্ণসংখ্যার জন্য উত্তর কি কেবল গ্রহণযোগ্য? যেহেতু এটি প্রথম জবাব।

— মিম্বুবস

দেখে মনে হচ্ছে উত্তরগুলি এখন পর্যন্ত হয় পুনরাবৃত্তি বা পুনরাবৃত্ত 'এক্স'র তালিকা ব্যবহার করে। আমি আমার মস্তিষ্ককে অন্যভাবে ভাবার চেষ্টা করছি (বিশেষত এমন কিছু যা কোনও অ-পূর্ণসংখ্যার y এর মঞ্জুরি দেয়)।

— বেনম

দুর্ভাগ্যক্রমে লুপগুলিতে নিষেধাজ্ঞার ফলে মজার গাণিতিক সমাধানগুলি টেলর সম্প্রসারণের মতো নয়।

— শ্যাডট্যালকার

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

এইচএম .. এটি জেতে 5 টি অক্ষরে লেখা যেতে পারে, ঠিক একই পদ্ধতিতে। */@$~

— seequ

@ সিজিগ 4 এমনকি, আপনি যদি বাম দিকে ঘাঁটিঘাঁটি করতে অনুমতি দেন তবে ডানদিকে বেস করুন।

— 20uʎs

আমার ফ্লিপ এ্যাডভারব ছিল কারণ আমি ভেবেছিলাম এটি অনুমোদিত নয়।

— seequ

মধ্যে @Seeq 4 Dyalog APL :×/⍴⍨

— আদম

Answer 2

সি #: ফ্লোটিং পয়েন্ট এক্সপোজারগুলি

ঠিক আছে, এই সমাধানটি বেশ ভঙ্গুর। আপনি সহজেই 6 টির মতো হাস্যকর আকারে এটি নিক্ষেপ করতে পারেন break তবে এটি 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" আমি এটি উপভোগ করেছি।

— ডেভিডসি

অবশ্যই আনুমানিক ফাংশনগুলির ব্যবহার লুপিংয়ের উপর নির্ভর করছে যা প্রশ্নটিতে নিষিদ্ধ ছিল বা লুপটি কাঠামোর পদ্ধতির অভ্যন্তরে রয়েছে বলে এটি ঠিক আছে?

— ক্রিস

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

তবে এটি কোনও ফাংশন নয়, একটি সংকলন-সময় মান, তাই না? : ও

— পেপারবার্ডমাস্টার 6'14

ঠিক আছে, কনস্ট্রাক্টর একটি ফাংশন এবং টেমপ্লেট পরামিতিগুলি প্রায় ফাংশন আর্গুমেন্টের মতো ... তাই না? =)

— এরলক

@ পেপারবার্ডমাস্টার হ্যাঁ ... এ কারণেই আমি কিছু নিয়ম মোড়ানোর বিষয়টি স্বীকার করেছি। আমি ভেবেছিলাম আমি লেজ পুনরাবৃত্তি ছাড়াও কিছু জমা দিতে যাচ্ছি, তবে আমি কেবল সংকলন সময় লেজ পুনরাবৃত্তি জমা দিয়েছি, হাহা। যথেষ্ট যদিও বন্ধ, তাই না?

— অ্যাসিফেনস

@ অ্যাসেফেনস ৪ যথেষ্ট বন্ধ, আমি এটি পছন্দ করি: 3

— পেপারবার্ডমাস্টার

Answer 4

পাইথন

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

নন-টাইগার শক্তির পক্ষে কাজ করে না।

Comments

আমার এটা ভাল লেগেছে.

— কোডিবাগস্টাইন

আপনি কেন ব্যবহার না করে বিভাজক যুক্ত করছেন 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

use replicate y x instead of take y $ repeat x

— mniip

I was convinced that you could save characters by writing your second function pointfree. As it turns out f=(product.).flip replicate is exactly the same number of chars.

— Kaya

@mniip It doesn't matter, this isn't code golf.

— nyuszika7h

Answer 6

Python

If y is a positive integer

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

Answer 7

JavaScript (ES6), 31

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

Usage:

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

Explanation:

The above function builds an expression which multiply x y times then evaluates it.

Answer 8

I'm surprised to see that nobody wrote a solution with the Y Combinator, yet... thus:

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)))

No loops, No vector/list operations and No (explicit) recursion!

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

Comments

Uh, I've just seen right now KChaloux's Haskell solution that uses fix, upvoting him...

— berdario

Answer 9

C# : 45

Works for integers only:

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

Comments

Beat me to it :-) I think you could save a few bytes by writing return --y?x:x*P(x,y); instead

— r3mainer

But this isn't code-golf...

— Oberon

@oberon winning criteria was not clear when this was posted. Things have moved on.

— Level River St

@steveverrill Sorry.

— Oberon

Also in C# --y would be an int which is not the same as a bool like in other languages.

— Chris

Answer 10

bash & sed

No numbers, no loops, just an embarrasingly dangerous glob abuse. Preferably run in an empty directory to be safe. Shell script:

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

Comments

"Preferably run in an empty directory to be safe." :D

— Almo

Answer 11

Javascript

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

Uses regular expressions to create an array of size y+1 whose first element is 1. Then, reduce the array with multiplication to compute power. When y=0, the result is the first element of the array, which is 1.

Admittedly, my goal was i) not use recursion, ii) make it obscure.

Answer 12

Mathematica

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

Probably cheating to use the fact that x^(1/y) = y√x

Comments

Not cheating. Smart.

— Michael Stern

This is brilliant. Wish I'd thought of it for my R post.

— shadowtalker

Answer 13

JavaScript

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

Answer 14

Golfscript, 8 characters (including I/O)

~])*{*}*

Explanation:

TLDR: another "product of repeated array" solution.

The expected input is two numbers, e.g. 2 5. The stack starts with one item, the string "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

Golfscript is always the way to go.

— Nit

Answer 15

Ruby

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

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

Sample use:

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

This ultimately is the same as several previous answers: creates a y-length array every element of which is x, then takes the product. It's just gratuitously obfuscated to make it look like it's using the forbidden ** operator.

Answer 16

C, exponentiation by squaring

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);
}

golfed version in 46 bytes (thanks ugoren!)

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

should be faster than all the other recursive answers so far o.O

slightly slower version in 45 bytes

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

Comments

For odd b, ~-b/2 == b/2.

— ugoren

@ugoren oh sure, you're right

— izabera

This is a popular interview question :) "How can you write pow(n, x) better than O(n)?"

— Jordan Scales

Answer 17

Haskell - 55

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

There's already a shorter Haskell entry, but I thought it would be interesting to write one that takes advantage of the fix function, as defined in Data.Function. Used as follows (in the Repl for the sake of ease):

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

Q

9 chars. Generates array with y instances of x and takes the product.

{prd y#x}

Can explicitly cast to float for larger range given int/long x:

{prd y#9h$x}

Comments

Matching Golfscript in length is a feat to achieve.

— Nit

Answer 19

Similar logic as many others, in PHP:

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

Run it with php file.php 5 3 to get 5^3

Answer 20

I'm not sure how many upvotes I can expect for this, but I found it somewhat peculiar that I actually had to write that very function today. And I'm pretty sure this is the first time any .SE site sees this language (website doesn't seem very helpful atm).

ABS

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);
    };

Works for negative exponents and rational bases.

I highlighted it in Java syntax, because that's what I'm currently doing when I'm working with this language. Looks alright.

Answer 21

Pascal

The challenge did not specify the type or range of x and y, therefore I figure the following Pascal function follows all the given rules:

{ 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;

No loop, no built-in power or exponentiation function, not even recursion or arithmetics!

Answer 22

J - 5 or 4 bytes

Exactly the same as marinus' APL answer.

For x^y:

*/@$~

For y^x:

*/@$

For example:

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

x $~ y creates a list of x repeated y times (same as y $ x

*/ x is the product function, */ 1 2 3 -> 1 * 2 * 3

Answer 23

Python

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

** is built-in operator imo.

— Silviu Burcea

@SilviuBurcea True, editing.

— Oberon

@SilviuBurcea operator =/= function

— VisioN

@VisioN true, but the idea was about built-ins. I don't think the OP knows about all these built-in operators ...

— Silviu Burcea

Answer 24

Javascript

With tail recursion, works if y is a positive integer

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

Answer 25

Bash

Everyone knows bash can do whizzy map-reduce type stuff ;-)

#!/bin/bash

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

---

If thats too trolly for you then there's this:

#!/bin/bash

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

Answer 26

C

Yet another recursive exponentiation by squaring answer in C, but they do differ (this uses a shift instead of division, is slightly shorter and recurses one more time than the other):

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

Answer 27

Mathematica

This works for integers.

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

Example

f[5,3]

125

---

How it works

Table makes a list of y x's. Times takes the product of all of them.`

---

Another way to achieve the same end:

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

Example

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

125

Answer 28

Windows Batch

Like most of the other answers here, it uses recursion.

@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 is stored in the environment variable z.

Answer 29

perl

Here's a tail recursive perl entry. Usage is echo $X,$Y | foo.pl:

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

Or for a more functional-type approach, how about:

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

Comments

"a: stuff goto a if something" looks like a loop.

— Glenn Randers-Pehrson

Yep, the goto version is a loop, but isn't tail recursion also essentially a loop?

— skibrianski

Answer 30

Python

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

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

answer =125

I am not sure if this is against the requirements, but if not here is my attempt.

Comments

Welcome to PPCG! When you do your language header you can leave out the "language=" since by custom everyone puts the language in the header so that's understood. You may indeed have run afoul of the rules here, but we'll let the voters decide. Glad to have a new member at the country club.

— Jonathan Van Matre