Amacınız bir girdi alan ve birlikte zincirlendiğinde N"sıralı çarpma" gerçekleştiren bir program yazmaktır . Sıralı çarpma nedir, sorabilirsiniz? Bu aşekilde tanımlanmış bir tohum içeren bir sekanstır :

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

Öyleyse, hadi a = 5. Böylece f(0) = 5, f(1) = f(0)*(f(0)-1) = 5*4 = 20ve f(2) = f(1)*(f(1)-1) = 20*19 = 380.

Programınız ABCöyleyse ABC, girdi ave çıktı almalıdır f(1). Program ABCABCçıktısı f(2)vb. Olmalıdır. Program serileriniz yalnızca bir kez ve yalnızca bir kez çıktı almalıdır.

Bu bir kod golfü yani baytlardaki en kısa program kazanıyor. Standart boşluklar yasaklanmıştır.

Jöle, 3 bayt

×’$

Çevrimiçi deneyin!

Nasıl çalışır

×’$    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.

Snippet'i n kez tekrarlamak, onu n kez yürütür ve istenen çıktıya neden olur.

Ciddi, 4 bayt

,;D*

Açıklama:

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

Tıpkı Dennis'in Jelly cevabında olduğu gibi , bu program nsürelerinin tekrarlanması çalışma nsürelerine neden olacaktır . Bu, zorunlu yığın tabanlı dillerin birçok avantajından biridir.

Çevrimiçi deneyin!

MATL, 3 bayt

tq*

Şunları yapabilirsiniz çevrimiçi deneyin! Temel olarak Ciddi ve Jelly cevaplarına benzer. İlk olarak, yığının üstünü çoğaltır (yığın boş olduğunda ilk kez get girişi). Yığının üstünü azaltır ve sonraki girdiyi veya sonucu vermek için iki öğeyi çarpar.

Python 3, 56 bayt

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

Sadece çıktı üzerine yazma hilesi olmadan bir çözüm istedim. Sondaki yeni satırın olmaması önemlidir.

CJam, 5 bayt

r~_(*

Çevrimiçi deneyin!

Nasıl çalışır

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 bayt

_▼•=_

Çevrimiçi deneyin.

Tembel olmasaydı ve "atamak _" uygulanmamış olsaydı 4 bayt olurdu ...

açıklama

_▼•=_

_       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 bayt

Kod:

D<*

Açıklama:

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

Çevrimiçi deneyin!

GolfScript, 5 bayt

~.(*`

Çevrimiçi deneyin.

Golfu kaldırıldı ve yorum yaptı:

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

GolfScript yorumlayıcısı girdiyi otomatik olarak okur ve yığına yerleştirir, ancak sayı olarak değil, bir dize olarak yerleştirir. Bu nedenle, girdiyi ile bir sayıya dönüştürmeli ~ve daha sonra ile tekrar dizgilendirmeliyiz `. Sonunda, yorumlayıcı yığındaki dizgi numarasını otomatik olarak yazdıracaktır.

Meydan yineleme için olsaydı (Şimdi f(n+1) = f(n)*(-f(n)-1), yaptığım verebilecek ile 4 bayt ~.~*. Bulmaktan nasıl ve neden bu eserler bir egzersiz olarak bırakılmıştır. :)

JavaScript REPL, 25 20 bayt

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

Bir REPL ortadan kaldırmak için çalışacak

Lua, 35 18 Bayt

Lua'nın bir kez kolayca yapabileceği bir şey!

Düzenleme: Bunu yaptığımdan beri Lua'da bir çok şey keşfettim, bu yüzden güncelliyorum :)

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

..., paketlenmemiş komut satırı argümanını içerir, bu durumda ilk değerini kullanmasına izin verir, çünkü harcanmasına izin verilmeyecektir, bu da sadece yazdırma ile sonuçlanır n*(n-1).

Y , 7 bayt

jzC:t*!

Burada deneyin!

Bu şekilde çalışır: jsayısal girdi alır. zörtük yazdırmayı etkinleştirir. Cyeni bir bağlantı başlatır. :yığındaki değeri çoğaltır ve değerini tdüşürerek bize bırakır [a a-1]. Daha sonra, elde [a*a-a]dan *. !sonraki komutu atlar; EOF'da hiçbir şey yapmaz. Birlikte zincirlendiğinde, giriş komutunu atlar ve işlem yeniden başlar.

Jolf, 6 bayt

Burada deneyin!

oj*jwj

açıklama

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

𝔼𝕊𝕄𝕚𝕟, 5 karakter / 7 bayt

ïׇï;

Try it here (Firefox only).

Bunu gerçekten açıklamalı mıyım? Ah, işte gidiyor ...

açıklama

Temelde input*=--input;JS'de değerlendirir .

Perl, 23 bayt

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

Alternatif sürüm, 10 bayt

$_*=~-$_;

Bu -panahtar gerektirir . Bir kaynak düzeni sorusunda adil bir oyun olup olmadığından emin değilim .

Haskell, 14 11 bayt

(*)=<<pred$

Kullanım örneği

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

Belki bu uygun bir işlev değildir. Nitpicking iseniz (*)=<<pred$id14 bayt için (<sonunda bir boşluk var) ile gidebilirsiniz .

Edit: @Zgarb işlevi monad işlevini kullanarak yeniden yazdı ve 3 bayt kaydetti. Teşekkürler!

Saf bash (yardımcı program yok), 40

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

TI-Basic, 6 5 bayt

TI-83/84 hesap makinelerinde çalışır

:Ans²-Ans

Bu program, normal Donemetin yerine bir programın son satırına bir ifade basılması nedeniyle çalışır .

Mathcad, 39 "bayt"

Kullanıcı açısından, Mathcad etkili bir şekilde 2D beyaz tahtadır ve ifadeler soldan sağa, yukarıdan aşağıya değerlendirilmiştir. Mathcad geleneksel bir "metin" girişini desteklemez, bunun yerine ifade, metin, çizim veya bileşen eklemek için metin ve özel tuşlar / araç çubuğu / menü öğelerinin birleşimini kullanır. Örneğin, tanım operatörünü girmek için ":" yazın (ekranda ": =" olarak gösterilir), "[" bir dizi dizini girin veya "ctl-]" bir while döngüsü operatörü (yer tutucuları dahil) kontrol koşulu ve bir vücut ifadesi). Yukarıdaki resimde gördüğünüz, tam olarak kullanıcı arayüzünde görünen ve "yazılan" olarak görünen şeydir.

Golf amacıyla, "bayt" sayısı bir ifade girmek için gereken klavye işlemlerinin sayısıdır.

Daha az emin olduğum bir şey ("bayt" denklik bakış açısından) yeni bir bölge oluşturmanın nasıl sayılacağıdır (örneğin, a: = 5 veya k: = 0..n-1). Her hareketi yeni bir bölgeye yeni bir satıra eşit olarak eşitledim ve dolayısıyla 1 bayt (pratikte, bölgeyi istediğim yere tıklamak için fareyi kullanıyorum).

Ben sadece aktif ifadeler dahil değil, yorumları, ve a ve n girişleri için 2 bayt her dahil ettik ama değerleri kendilerini değil (örnek 5 ve 7).

Haskell, 72 bayt

Bu zorluk Haskell için kolay değildir .. Ancak, girdi tekli ve kod GHCI yürütülürse, aşağıdakiler çalışır:

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

Açıklama:

Unary her zaman tuhaftır, bu nedenle ilk uygulama ondalığa dönüştürülür. x*(x-1)her zaman eşittir, aksi halde geri döner x*(x-1), xgirdi nerede olur. Haskell güçlü bir şekilde yazıldığından ve 'özel' semboller gibi adlandırılamadığından &1, küresel değişkenler veya daha da garip bir giriş formu kullanmadığı sürece bunun Haskell'de bunu tamamlamanın tek yolu olduğuna inanıyorum.

C ++ (gcc) , 173/176 bayt

Her iki versiyonun da son derece önemli bir yeni satırı var.

Makro sürümü, 173 bayt

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

Çevrimiçi deneyin!

Şablon sürümü, 176 bayt

Biraz daha fazla C ++ ish:

#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++;

Çevrimiçi deneyin!

Burlesque - 5 bayt

J?d?*

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