16

Tâche - Le titre résume assez bien: augmenter un entier x pour alimenter x , où 0<x.

Restrictions:

L' utilisation de exponentiation, exp(), ln()et tout autre comme langue connexes-pouvoirs Encastrements, pow(), x^x, x**xest interdite.
Vous pouvez supposer que l'entier donné correspond aux limites du langage de programmation de votre choix.

Cas de test:

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

Il s'agit de code-golf , donc le programme le plus court en octets l'emporte.

code-golf math arithmetic

— Hirsute
source

Pouvons-nous accepter l'entrée comme une chaîne?

— Shaggy

J'ai apporté une modification à cela, en espérant qu'il sera rouvert. J'ai supprimé la règle 3 et ai plutôt déclaré que ce devrait être un programme complet, comme le PO le prévoyait probablement

— M. Xcoder

Beaucoup mieux, @ Mr.Xcoder mais je suggère de supprimer (ou reformuler) la deuxième restriction. "Pas de fonction" exclut-il JS de participer? Je suggérerais également, aux fins du défi, que nous devrions avoir à gérer 0et que la sortie attendue soit spécifiée ( 0ou 1ou soit). Enfin, avoir à gérer des nombres entiers négatifs serait un bon ajout au défi.

— Shaggy

@Shaggy a ajouté js dans ... calculé 0 ^ 0 sur la calculatrice Apple et il a renvoyé 1. Peut-être que 1 devrait être la valeur choisie, car Python revient également 1pour 0^0. Cependant, Foundation+ Swift renvoie 0

— M. Xcoder

1

@ Mr.Xcoder, j'ai supprimé la "restriction" que nous n'avons pas besoin de gérer 0et au lieu de cela spécifié 0<xdans l' entrée . J'ai également supprimé la restriction selon laquelle le code ne devrait pas générer d'erreur. Cela devrait être évident. N'hésitez pas à revenir en arrière si nécessaire.

— Shaggy

15

APL (Dyalog) , 4 octets

Pour x ^x , prend x comme argument gauche et x comme argument droit.

×/⍴⍨

Essayez tous les cas en ligne!

×/ produit de

⍴⍨ arg copies arg

Et en voici un qui gère également les entiers négatifs:

×/|⍴|*×

Essayez tous les cas!

×/ le produit de

| valeur absolue

⍴ r épétitions de

| la valeur absolue

* au pouvoir de

× le signum

La primitive Power intégrée est:

x*y

— Adam
source

13

Python , 25 octets

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

Essayez-le en ligne!

— xnor
source

9

Mathematica, 16 octets

J'ai deux solutions à ce nombre d'octets:

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

Ici, #~Table~#crée une liste de ncopies de n. Ensuite, la Listtête est remplacée par 1##&ce qui multiplie tous ses arguments ensemble.

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

Cela stocke simplement l'entrée npuis multiplie 1par n, nfois.

— Martin Ender
source

1

#~Product~{#}&

— alephalpha

1

@alephalpha ah, bon point. Vous pouvez poster cela comme une réponse distincte.

— Martin Ender

5

JavaScript (ES6), 33 28 25 24 octets

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

Essayez-le

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>

Développer l'extrait

Histoire

25 octets

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

28 octets

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

33 octets

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

— Hirsute
source

4

Pure bash, 43

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

Essayez-le en ligne .

Je ne sais pas si cela déforme trop les règles - je n'utilise aucun des modules internes interdits répertoriés, mais j'utilise la conversion de base.

printf 1%0$1dsorties a 1suivi de n 0s
$[b#a]est une expansion arithmétique à traiter acomme un bnombre de base , qui donne le résultat requis. Malheureusement, la base <2 ne fonctionne pas, donc les ?:bits supplémentaires gèrent l'entrée n = 1.

L'entrée maximale est de 15, car bash utilise des entiers signés 64 bits (jusqu'à 2 ³¹ -1).

— Traumatisme numérique
source

Même problème que moi, cela ne fonctionne pas pour x = 1. Néanmoins, approche très intéressante.

— Maxim Mikhaylov

@MaxLawnboy Merci de l'avoir signalé - cela a malheureusement gonflé ma réponse. Peut-être que je peux trouver une autre version plus courte ...

— Digital Trauma

Truc cool.

4

Alice , 13 octets

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

Essayez-le en ligne!

Explication

/o
\i@/...

Il s'agit d'un cadre pour les programmes qui lisent et écrivent des entiers décimaux et fonctionnent entièrement en mode Cardinal (donc les programmes pour la plupart des problèmes arithmétiques).

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

— Martin Ender
source

4

ML standard , 42 octets

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

Essayez-le en ligne!

Explication:

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
source

1

Bienvenue chez PPCG!

— Martin Ender

1

TIO a maintenant MLton. tio.run/nexus/…

— Dennis

Oh c'est super! Merci!

— musicman523

3

Gelée , 3 octets

ẋ⁸P

Essayez-le en ligne!

Comment?

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

— Jonathan Allan
source

Bon sang, je voulais faire ça. : P

— HyperNeutrino

@Jonathan Allan est-ce 3 octets, ou 3 caractères larges? voyons le vidage hexadécimal du code source, s'il vous plaît, pour prendre la bonne décision sur la taille réelle du code. ;-) et faites les corrections

1

@ xakepp35 Jelly utilise un SBCS et le lien d' octets dans l'en-tête pointe vers lui. Le programme avec hexdump F7 88 50fonctionne comme prévu.

— Dennis

@Dennis merci pour la réponse! je ne pouvais jamais imaginer un tel langage avant =)

3

Cubix , 19 octets

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

Essayez-le en ligne!

Pas à pas

S'étend sur un cube de longueur latérale 2

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

I:1 Prend l'entrée, la duplique et appuie sur 1. Ceci configure la pile avec un compteur, un multiplicateur et un résultat.
*s; Multiplie le TOS, échange le résultat avec le précédent et supprime le précédent.
puApportez le contre-objet au TOS. Demi-tour. Il s'agissait d'un changement de voie, mais il fallait raser un octet.
|($Cela a été fait pour enregistrer un octet. Lorsqu'il est touché, il saute le décrément. réfléchit, décrémente le compteur et ignore le pas d'opération qui entoure le cube.
!vqWTestez le compteur. Si vous ignorez la redirection, mettez le compteur sur BOS, changez de voie sur le multiplicateur. Sinon, redirigez.
|sO@il s'agit de la séquence de fin redirigée vers le contre-test. Dépasse le reflet horizontal, échange le TOS apportant le résultat au TOS, sortie et arrêt.

— MickyT
source

3

R, 22 octets

lit xde stdin.

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

génère une liste de xcopies de x, puis calcule le produit des éléments de cette liste. Quand x=0, le repretour numeric(0), qui est un vecteur numérique de longueur 0, mais prodqui est 1, donc0^0=1 par cette méthode, qui est cohérente avec l'exponentiation intégrée de R, donc c'est plutôt bien.

Essayez-le en ligne!

— Giuseppe
source

3

Langage machine x86_64 pour Linux, 14 11 10 octets

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

Pour l' essayer en ligne! , compilez et exécutez le programme C suivant.

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

— plafond
source

2

Rubis, 20 18 octets

-2 octets car la spécification a changé et je n'ai plus besoin d'un argument exposant.

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

Essayez-le en ligne!

— Encre de valeur
source

2

Empilé , 10 octets

{!1[n*]n*}

Essayez-le en ligne!

Exponentiation à deux arguments pour la même taille:

{%1[x*]y*}

Les deux sont des fonctions. Répète une fonction qui se multiplie 1par le n ntemps.

— Conor O'Brien
source

2

Scala , 32 26 octets

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

Essayez-le en ligne! (Ajout de la conversion en long dans le TIO afin qu'il ne déborde pas sur n = 10.)

— musicman523
source

2

05AB1E , 3 octets

.DP

Essayez-le en ligne! ou Essayez tous les exemples

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

On dirait que vous avez apprécié .D. La première fois que je l'ai vu utilisé.

— Urne Magic Octopus

ah, je ne comprends pas ce qui se passe ici .. semble être trop exotique et aucune explication sur la façon dont cela fonctionne. = (

@ xakepp35 Est-ce que cela aide?

— Riley

2

Haskell , 24 23 21 octets

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

Essayez-le en ligne!

1 octet enregistré grâce à Laikoni
Enregistré 2 octets, grâce à nimi

— sudee
source

1

f y=foldr1(*)$y<$[1..y]est un octet plus court.

— Laikoni

1

product$y<$[1..y]

— nimi

Je ne sais pas comment j'ai réussi à oublier le produit, merci! : D

— sudee

2

Japt , 4 octets

ÆUÃ×

Essayez-le en ligne!

Explication

Æ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
source

2

x86 machine code (Linux), 18 bytes

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

It expects a C declaration as follows 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

— ბიმო
source

1

Brachylog, 6 bytes

g;?j₎×

Try it online!

Explanation

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

— Fatalize
source

1

CJam, 7 bytes

ri_a*:*

Try it online!

Explanation

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

— Business Cat
source

1

Perl 6, 13 bytes

{[*] $_ xx$_}

$_ xx $_ evaluates to a list of $_ copies of $_ ($_ being the argument to the anonymous function), and then [*] reduces that list with multiplication.

— Sean
source

1

CJam, 6 bytes

ri_m*,

Try it online!

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

— Luis Mendo
source

1

Clojure, 22

#(apply *(repeat % %))

:)

— NikoNyrh
source

1

Röda, 17 bytes

{product([_]*_1)}

Try it online!

It's an anonymous function that takes it's input from the stream.

Explanation:

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

1

dc, 24 23 26 22 bytes

This is my first attempt writing a recursive macro in dc. I am sure it is a sub-optimal solution which can be improved a lot.

dsr1+[lrr1-d1<F*]dsFxp

Try it online!

Edit: Thanks eush77! -4 bytes.

— Maxim Mikhaylov
source

1

Does not work for x=1.

— eush77

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

— eush77

Actually, you don't need that. Just increment the top of the stack before calling for the first time. This way you will end up with x copies of x on the stack (and 1 of course), and x multiplications thereafter. So the ending can just be plain dsFxp.

— eush77

@eush77 I was about to say that removing second lr wouldn't work here. It's my first time golfing in a stack-based language, so it feels very unusual. Thanks for your help!

— Maxim Mikhaylov

1

Batch, 58 bytes

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

Only works for single-digit inputs due to 32-bit arithmetic.

— Neil
source

1

brainf*ck, 148 bytes

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

Try it online!

No built-ins ;)

How it works

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

In a nutshell, this works by multiplying x (the input) by itself x times. (a.k.a. iterating iterated addition). The net result is x^x.

I/O

The program takes a single ASCII input, and processes it as it's ASCII index minus 48. The minus 48 is to normalize inputs of actual numbers (4 becomes 52 -> 52-48 -> 4). To input a number higher than 9, use the next corrosponging ASCII character (: -> 58-48 -> 10). The program ouputs in a similar fashion.

Test I/O

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
source

1

MATLAB/Octave, 23 bytes

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

— Batman
source

1

Python, 32 bytes

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

Try it online!

— userNaN
source

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
source

Augmenter l'entier x pour alimenter x, sans intégré d'exponentiation

APL (Dyalog) , 4 octets

Python , 25 octets

Mathematica, 16 octets

JavaScript (ES6), 33 28 25 24 octets

Essayez-le

Histoire

25 octets

28 octets

33 octets

Pure bash, 43

Alice , 13 octets

Explication

ML standard , 42 octets

Gelée , 3 octets

Comment?

Cubix , 19 octets

R, 22 octets

Langage machine x86_64 pour Linux, 14 11 10 octets

Rubis, 20 18 octets

Empilé , 10 octets

Scala , 32 26 octets

05AB1E , 3 octets

Haskell , 24 23 21 octets

Japt , 4 octets

Explication

x86 machine code (Linux), 18 bytes

Disassembled

Brachylog, 6 bytes

Explanation

CJam, 7 bytes

Perl 6, 13 bytes

CJam, 6 bytes

Clojure, 22

Röda, 17 bytes

dc, 24 23 26 22 bytes

Batch, 58 bytes

brainf*ck, 148 bytes

MATLAB/Octave, 23 bytes

Python, 32 bytes

Common Lisp, 59 42 40 bytes