Votre objectif est d'écrire un programme qui prend une entrée et, une fois enchaîné N, effectue une "multiplication séquentielle". Qu'est-ce que la multiplication séquentielle, vous demandez-vous? C'est une séquence avec une graine adéfinie comme suit:

f(0) = a
f(n+1) = f(n)*(f(n)-1)

Alors, laisse a = 5. Ainsi, f(0) = 5, f(1) = f(0)*(f(0)-1) = 5*4 = 20et f(2) = f(1)*(f(1)-1) = 20*19 = 380.

Si votre programme l'était ABC, alors ABCdevrait prendre l'entrée aet la sortie f(1). Le programme ABCABCdoit sortir f(2), etc. Votre série de programmes ne doit recevoir une entrée qu'une seule fois et une seule sortie.

Il s'agit d'un code-golf, donc le programme le plus court en octets l'emporte. Les failles standard sont interdites.

Gelée, 3 octets

×’$

Essayez-le en ligne!

Comment ça fonctionne

×’$    Main link (or part thereof). Argument (initially input): n

 ’     Compute n - 1.
×      Multiply n by (n - 1).
  $    Combine the previous two atoms into a monadic quicklink.

La répétition de l'extrait n fois l'exécutera n fois, résultant en la sortie souhaitée.

Sérieusement, 4 octets

,;D*

Explication:

,;D*
,     push input (NOP once input is exhausted)
 ;D   dupe and push n-1
   *  multiply
      (implicit output at EOF)

Tout comme dans la réponse Jelly de Dennis , la répétition de ce programme nentraînera des ntemps d' exécution . C'est l'un des nombreux avantages des langages impératifs basés sur la pile.

Essayez-le en ligne!

MATL, 3 octets

tq*

Vous pouvez l' essayer en ligne! Fondamentalement similaire aux réponses Sérieusement et Jelly. Tout d'abord, il duplique le haut de la pile (entrée de get la première fois lorsque la pile est vide). Décrémente le haut de la pile et multiplie les deux éléments pour donner l'entrée ou le résultat suivant.

Python 3, 56 octets

+1if 0else 0
try:n
except:n=int(input())
n*=n-1
print(n)

Je voulais juste une solution sans supercherie d'écrasement de sortie. L'absence d'une nouvelle ligne de fin est importante.

CJam, 5 octets

r~_(*

Essayez-le en ligne!

Comment ça fonctionne

r     e# Read a whitespace-separated token from STDIN.
      e# This pushes the input (when called for the first time) or an empty string.
 ~    e# Evaluate.
      e# This turns the input into an integer or discards an empty string.
  _   e# Copy the top of the stack.
   (  e# Decrement.
    * e# Multiply.

pl, 5 octets

_▼•=_

Essayez-le en ligne.

Serait de 4 octets si je n'avais pas été paresseux et non implémenté "assign to _" ...

Explication

_▼•=_

_       push _ (input var)
 ▼      decrement last used var (_)
  •     multiply, since it is off by one it auto-adds _ to the arg list
   =_   assign result to _

05AB1E , 3 octets

Code:

D<*

Explication:

D    # Duplicate top of the stack, or input when empty
 <   # Decrement on top item
  *  # Multiply

Essayez-le en ligne!

GolfScript, 5 octets

~.(*`

Essayez-le en ligne.

De-golfé et commenté:

~    # Eval the input to turn it from a string into a number.
.    # Duplicate the number.
(    # Decrement one of the copies by one.
*    # Multiply the copies together.
`    # Un-eval the number, turning it back into a string.

L'interpréteur GolfScript lit automatiquement l'entrée et la place sur la pile, mais sous forme de chaîne et non sous forme de nombre. Par conséquent, nous devons transformer l'entrée en un nombre avec ~, et la reformuler ensuite avec `. À la fin, l'interprète imprimera automatiquement le numéro stringifié sur la pile.

(Maintenant, si le défi avait été d'itérer f(n+1) = f(n)*(-f(n)-1), j'aurais pu le faire en 4 octets avec ~.~*. Comprendre comment et pourquoi cela fonctionne est laissé comme un exercice. :)

JavaScript REPL, 25 20 octets

a=prompt();
a*=a-1//

Va travailler sur l'élimination d'un REPL

Lua, 35 18 octets

C'est quelque chose que Lua peut faire assez facilement pour une fois!

Edit: J'ai découvert beaucoup de choses à Lua depuis que je l'ai fait, donc je le mets à jour :)

print(...*(...-1))

...contient l'argument de ligne de commande décompressé, en soulignant qu'il utilisera sa première valeur dans ce cas car il ne sera pas autorisé à dépenser, ce qui entraînera simplement l'impression n*(n-1).

Y , 7 octets

jzC:t*!

Essayez-le ici!

Voici comment cela fonctionne: jprend une entrée numérique. zactive l'impression implicite. Ccommence un nouveau lien. :duplique la valeur de la pile et la tdiminue, nous laissant avec [a a-1]. Ensuite, nous sortons [a*a-a]de *. !saute la commande suivante; sur EOF, ça ne fait rien. Lorsqu'il est enchaîné, il saute la commande d'entrée et le processus recommence.

Jolf, 6 octets

Essayez-le ici!

oj*jwj

Explication

oj*jwj
oj      set j to
  *jwj  j times j-1
        implicit output

𝔼𝕊𝕄𝕚𝕟, 5 caractères / 7 octets

ïׇï;

Try it here (Firefox only).

Dois-je vraiment expliquer cela? Eh bien, c'est parti ...

Explication

Il évalue essentiellement à input*=--input;JS.

Perl, 23 octets

l;$_|=<>;$_*=~-$_;print

Version alternative, 10 octets

$_*=~-$_;

Cela nécessite le -pcommutateur. Je ne sais pas si c'est un jeu équitable dans une question de mise en page source .

Haskell, 14 11 octets

(*)=<<pred$

Exemple d'utilisation

Prelude> (*)=<<pred$5
20
Prelude> (*)=<<pred$(*)=<<pred$5
380
Prelude> (*)=<<pred$(*)=<<pred$(*)=<<pred$5
144020

Peut-être que ce n'est pas une fonction appropriée. Si vous tatouillez, vous pouvez aller avec(*)=<<pred$id (<-il y a un espace à la fin) pour 14 octets.

Edit: @Zgarb a réécrit la fonction en utilisant la fonction monad et a enregistré 3 octets. Merci!

Pure bash (pas d'utilitaires), 40

((a=a?a:$1,a*=a-1))
trap 'echo $a' exit

TI-Basic, 6 5 octets

Fonctionne sur les calculatrices TI-83/84

:Ans²-Ans

Ce programme fonctionne en raison du fait qu'une expression sur la dernière ligne d'un programme est imprimée au lieu du Donetexte normal .

Mathcad, 39 "octets"

Du point de vue de l'utilisateur, Mathcad est en fait un tableau blanc 2D, avec des expressions évaluées de gauche à droite, de haut en bas. Mathcad ne prend pas en charge une entrée "texte" conventionnelle, mais utilise à la place une combinaison de texte et de touches spéciales / barre d'outils / éléments de menu pour insérer une expression, du texte, un tracé ou un composant. Par exemple, tapez ":" pour saisir l'opérateur de définition (affiché à l'écran sous la forme ": ="), "[" pour saisir un index de tableau ou "ctl-]" pour saisir un opérateur de boucle while (y compris les espaces réservés pour le condition de contrôle et une expression corporelle). Ce que vous voyez dans l'image ci-dessus est exactement ce qui apparaît sur l'interface utilisateur et comme "tapé".

À des fins de golf, le nombre "d'octets" est le nombre équivalent d'opérations au clavier requises pour entrer une expression.

Une chose dont je suis encore moins sûr (du point de vue de l'équivalence "octet") est de savoir comment compter pour créer une nouvelle région (par exemple, a: = 5 ou k: = 0..n-1). J'ai assimilé chaque déplacement à une nouvelle région comme étant égal à une nouvelle ligne, et donc 1 octet (en pratique, j'utilise la souris pour cliquer où je veux la région).

J'ai seulement inclus les instructions actives et non les commentaires, et j'ai inclus 2 octets chacun pour les entrées a et n mais pas les valeurs elles-mêmes (5 et 7 dans l'exemple).

Haskell, 72 octets

Ce défi n'est pas convivial pour Haskell. Cependant, ce qui suit fonctionne si l'entrée est en unaire et que le code est exécuté dans GHCI:

(\x->if odd x then let y=until((>x).(10^))(+1)0 in y*(y-1)else x*(x-1))$

Explication:

Unaire est toujours étrange, donc la première application sera convertie en décimal. x*(x-1)est toujours pair, donc sinon il retourne x*(x-1), où xest l'entrée. Parce que Haskell est fortement typé et que les symboles `` spéciaux '' ne peuvent pas être appelés comme &1, je pense que c'est à peu près la seule façon de le faire dans Haskell, à moins que l'on n'utilise des variables globales ou un formulaire d'entrée encore plus étrange.

C ++ (gcc) , 173/176 octets

Les deux versions ont une nouvelle ligne cruciale à la fin.

Version macro, 173 octets

#ifndef M
#define M(a,b)a##b
#define W(z,x)M(z,x)
#define B int W(m,__LINE__)=x++
#include<iostream>
int x,n;int main(){for(std::cin>>n;x--;)n*=n-1;std::cout<<n;}
#endif
B;

Essayez-le en ligne!

Version du modèle, 176 octets

Un peu plus de C ++:

#ifndef B
#define B template
#include<iostream>
int x,n;B<int N>struct A{static int i;};int main(){for(std::cin>>n;x--;)n*=n-1;std::cout<<n;}
#endif
B<>int A<__LINE__>::i=x++;

Essayez-le en ligne!

Burlesque - 5 octets

J?d?*

blsq ) 5 J?d?*
20
blsq ) 5 J?d?* J?d?*
380
blsq ) 5 J?d?* J?d?* J?d?*
144020