16

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

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

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

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

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

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

code-golf math arithmetic

— мохнатый
источник

Можем ли мы принять ввод как строку?

— Лохматый

Я внес изменения в это, надеясь, что он будет вновь открыт. Я удалил правило 3 и вместо этого заявил, что это должна быть полная программа, как, вероятно, предполагал ФП

— г-н Xcoder

Гораздо лучше, @ Mr.Xcoder, но я предлагаю снять (или переписать) второе ограничение. Разве «не функция» исключает участие JS? Я также предложил бы, для целей задачи, что мы должны обработать 0и указать ожидаемый результат ( 0или 1или либо). Наконец, обработка отрицательных целых чисел была бы хорошим дополнением к задаче.

— Лохматый

@Shaggy добавил js обратно в ... вычислил 0 ^ 0 на яблочном калькуляторе и вернул 1. Возможно, 1 должно быть выбранным значением, потому что Python также возвращает 1для 0^0. Тем не менее, Foundation+ Swift возвращает 0

— Mr. Xcoder

1

@ Mr.Xcoder, я снял «ограничение», которое нам не нужно обрабатывать, 0и вместо этого указал это 0<xв начале . Я также снял ограничение, что код не должен выдавать ошибки; это должно быть само собой разумеется. Не стесняйтесь откатиться при необходимости.

— Лохматый

15

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

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

×/⍴⍨

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

×/ продукт

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

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

×/|⍴|*×

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

×/ продукт

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

⍴ г эпетенции

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

* в силу

× знак

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

x*y

— Адам
источник

13

Python , 25 байт

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

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

— XNOR
источник

9

Mathematica, 16 байт

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

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

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

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

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

— Мартин Эндер
источник

1

#~Product~{#}&

— алефальфа

1

@alephalpha ах, хорошая мысль. Вы можете опубликовать это как отдельный ответ.

— Мартин Эндер

5

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

— мохнатый
источник

4

Чистая Баш, 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).

— Цифровая травма
источник

Та же проблема, что и у меня, это не работает для х = 1. Тем не менее, очень интересный подход.

— Максим Михайлов

@MaxLawnboy Спасибо за указание на это - это печально раздутый мой ответ. Возможно, я смогу найти другую более короткую версию ...

— Цифровая травма

Классная вещь. Всегда хотел выучить bash, но всегда был слишком ленив для этого =)

4

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

— Мартин Эндер
источник

4

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

— musicman523
источник

1

Добро пожаловать в PPCG!

— Мартин Эндер

1

У TIO сейчас есть MLton. tio.run/nexus/…

— Деннис

О, это круто! Благодарность!

— musicman523

3

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

— Джонатан Аллан
источник

Черт, я хотел сделать это. : P

— HyperNeutrino

@ Джонатан Аллан, это 3 байта или 3 широких символа? давайте посмотрим на исходный код шестнадцатеричного дампа, чтобы принять правильное решение по фактическому размеру байта кода. ;-) и внесите исправления

1

@ xakepp35 Jelly использует SBCS, и ссылка на байты в заголовке указывает на него. Программа с hexdump F7 88 50работает как задумано.

— Деннис

@Dennis спасибо за ответ! я никогда не мог представить себе такой язык раньше =)

3

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, вывод и остановку.

— MickyT
источник

3

R, 22 байта

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

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

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

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

— Giuseppe
источник

3

машинный язык 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) );
  }
}

— ceilingcat
источник

2

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

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

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

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

— Значение чернил
источник

2

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

{!1[n*]n*}

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

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

{%1[x*]y*}

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

— Конор О'Брайен
источник

2

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

— musicman523
источник

2

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

— Riley
источник

Looks like you enjoyed .D. First time I've seen it used.

— Magic Octopus Urn

ah, i dont get what is happening here.. seems to be too exotic and no explanation on how that works. =(

@xakepp35 Does that help?

— Riley

2

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

— sudee
источник

1

f y=foldr1(*)$y<$[1..y]на байт короче.

— Лайкони

1

product$y<$[1..y]

— Ними

Не уверен, как мне удалось забыть о продукте, спасибо! : D

— судя

2

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

— Justin Mariner
источник

2

машинный код 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

— ბიმო
источник

1

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

— Fatalize
источник

1

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

— Бизнес Кот
источник

1

Perl 6 , 13 байт

{[*] $_ xx$_}

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

— Шон
источник

1

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

— Луис Мендо
источник

1

Clojure, 22

#(apply *(repeat % %))

:)

— NikoNyrh
источник

1

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

— fergusq
источник

1

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

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

dsr1+[lrr1-d1<F*]dsFxp

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

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

— Максим Михайлов
источник

1

Не работает для x=1.

— eush77

You can shave off two bytes by replacing lr sequences at the end with two ds at the beginning.

— eush77

На самом деле, вам это не нужно. Просто увеличьте вершину стека перед первым вызовом. Таким образом, вы получите xкопии xв стеке (и, 1конечно,), а xзатем умножения. Таким образом, окончание может быть простым dsFxp.

— eush77

@ eush77 Я собирался сказать, что удаление второго lrздесь не сработает. Я впервые играю в гольф на стековом языке, так что это очень необычно. Спасибо за вашу помощь!

— Максим Михайлов

1

Пакет, 58 байт

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

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

— Нил
источник

1

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.

— Graviton
источник

1

MATLAB/Octave, 23 bytes

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

— Batman
источник

1

Python, 32 bytes

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

Try it online!

— userNaN
источник

Welcome to PPCG! You don't need to count the f= part, so you can shorten your submission to 30 bytes.

— Steadybox

@Steadybox The f= part does need to be counted, because it's recursive, so it relies upon the function being named f in order to work properly

— musicman523

@musicman523 Yes, you are right.

— Steadybox

1

Common Lisp, 59 42 40 bytes

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

Try it online!

— ceilingcat
источник

Увеличьте целое число x до степени x без встроенных возведений

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

Python , 25 байт

Mathematica, 16 байт

JavaScript (ES6), 33 28 25 24 байта

Попытайся

история

25 байт

28 байт

33 байта

Чистая Баш, 43

Алиса , 13 байт

объяснение

Стандартный ML , 42 байта

Желе , 3 байта

Как?

Cubix , 19 байт

R, 22 байта

машинный язык x86_64 для Linux, 14 11 10 байт

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

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

Scala, 32 26 bytes

05AB1E, 3 bytes

Haskell, 24 23 21 bytes

Japt, 4 bytes

объяснение

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

разобранный

Брахилог , 6 байт

объяснение

CJam , 7 байтов

Perl 6 , 13 байт

CJam , 6 байтов

Clojure, 22

Рёда , 17 байт

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

Пакет, 58 байт

brainf * ck , 148 байт

MATLAB/Octave, 23 bytes

Python, 32 bytes

Common Lisp, 59 42 40 bytes