Задача - Название в значительной степени подводит итог: возведите целое число x в степень x , где 0<x.

Ограничения:

• Использование в экспоненциации, exp(), ln(), а также любые иные полномочия , связанные с языком встроенные модули, как pow(), x^x, x**xзапрещено.
• Вы можете предположить, что данное целое число соответствует ограничениям языка программирования по вашему выбору.

Тестовые случаи:

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

Это код-гольф , поэтому выигрывает самая короткая программа в байтах.

APL (Дьялог) , 4 байта

Для x ^x принимает x в качестве левого аргумента и x в качестве правого аргумента.

×/⍴⍨

Попробуйте все случаи онлайн!

×/ продукт

⍴⍨ arg копирует arg

А вот еще один, который обрабатывает и отрицательные целые числа:

×/|⍴|*×

Попробуйте все случаи!

×/ продукт

| абсолютная величина

⍴ г эпетенции

| абсолютное значение

* в силу

× знак

Встроенный примитив Power:

x*y

Python , 25 байт

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

Попробуйте онлайн!

Mathematica, 16 байт

У меня есть два решения на этот счет байтов:

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

Здесь #~Table~#создается список nкопий n. Затем Listзаменяется глава, 1##&которая умножает все свои аргументы вместе.

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

Это просто хранит входные данные в nи затем умножает 1от n, nвремени.

JavaScript (ES6), 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`*`)

Чистая Баш, 43

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

Попробуйте онлайн .

Не уверен, что это слишком сильно нарушает правила - я не использую перечисленные запрещенные встроенные функции, но использую базовое преобразование.

• printf 1%0$1dвыводит 1затем н 0ы
• $[b#a]является арифметическим расширением, которое рассматривается aкак базовое bчисло, которое дает требуемый результат. К сожалению, base <2 не работает, поэтому дополнительные ?:биты обрабатывают ввод n = 1.

Максимальный ввод - 15, потому что bash использует 64-битные целые числа со знаком (до 2 ³¹ -1).

Алиса , 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.

Стандартный ML , 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 *)    

Желе , 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

Cubix , 19 байт

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

Попробуйте онлайн!

Шаг за шагом

Расширяется на куб с длиной стороны 2

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

• I:1 Принимает ввод, дублирует его и нажимает 1. Это устанавливает стек со счетчиком, множителем и результатом.
• *s; Умножает TOS, меняет результат на предыдущий и удаляет предыдущий.
• puПринесите встречный предмет в ТОС. Разворот. Это использование для смены полосы движения, но нужно побрить байт.
• |($Это было сделано, чтобы сохранить байт. При попадании пропускает декремент. отражает, уменьшает счетчик и пропускает обертывание без операции вокруг куба.
• !vqWПроверьте счетчик. Если правдиво пропустите переадресацию, поставьте счетчик на ЛС, измените полосу на множитель. В противном случае перенаправить.
• |sO@это конечная последовательность, перенаправленная с контр-теста. Проходит горизонтальное отражение, меняет TOS, принося результат в TOS, вывод и остановку.

R, 22 байта

читает xсо стандартного ввода.

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

генерирует список xкопий x, а затем вычисляет произведение элементов этого списка. Когда x=0, repвозвращает numeric(0), который представляет собой числовой вектор длины 0, но значение prodкоторого равно 1, так что с 0^0=1помощью этого метода, который согласуется со встроенным возведением в степень R, так что это довольно аккуратно.

Попробуйте онлайн!

машинный язык x86_64 для Linux, 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

Для того, чтобы попробовать его в Интернете! , скомпилируйте и запустите следующую C-программу.

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

Рубин, 20 18 байт

-2 байта, потому что спецификация изменилась, и мне больше не нужен аргумент экспоненты.

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

Попробуйте онлайн!

С накоплением , 10 байтов

{!1[n*]n*}

Попробуйте онлайн!

Возведение в степень с двумя аргументами для того же самого размера:

{%1[x*]y*}

Оба являются функциями. Повторяет функцию, которая умножается 1в n nразы.

Scala, 32 26 bytes

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

Try it online! (Added conversion to long in the TIO so it wouldn't overflow on n=10.)

05AB1E, 3 bytes

.DP

Try it online! or Try all examples

.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

Haskell, 24 23 21 bytes

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

Try it online!

• Saved 1 byte, thanks to Laikoni
• Saved 2 bytes, thanks to nimi

Japt, 4 bytes

ÆUÃ×

Try it online!

объяснение

Æ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

машинный код x86 (Linux), 18 байт

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

Ожидается объявление C следующим образом extern int XpowX(int).

разобранный

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

Брахилог , 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

CJam , 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

Perl 6 , 13 байт

{[*] $_ xx$_}

$_ xx $_оценивает список $_копий $_( $_являющийся аргументом анонимной функции), а затем [*]уменьшает этот список с умножением.

CJam , 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

Clojure, 22

#(apply *(repeat % %))

:)

Рёда , 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 */

постоянный ток , 24 23 26 22 байта

Это моя первая попытка написания рекурсивного макроса в dc. Я уверен, что это неоптимальное решение, которое можно значительно улучшить.

dsr1+[lrr1-d1<F*]dsFxp

Попробуйте онлайн!

Редактировать: Спасибо eush77 ! -4 байта.

Пакет, 58 байт

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

Работает только для однозначных входов благодаря 32-битной арифметике.

brainf * 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время. (иначе итеративное добавление). Чистый результат х ^ х.

I / O

Программа принимает один вход ASCII и обрабатывает его как индекс ASCII минус 48 . Минус 48 является нормализация входов действительных чисел ( 4становится 52-> 52-48-> 4). Чтобы ввести число больше 9, используйте следующий соответствующий символ ASCII ( :-> 58-48->10 ). Программа выводит аналогичным образом.

Тестовый ввод / вывод

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

Since there are no printable ASCII characters after an input of 3, it can only print numbers in theory. Though, you can check all inputs do in fact work on visualizers such as this.

MATLAB/Octave, 23 bytes

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

Python, 32 bytes

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

Try it online!

Common Lisp, 59 42 40 bytes

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

Try it online!