Açıkçası, kod golf en az kod en iyi şekilde yapmak ile ilgilidir. Gerçek çıktının ne olduğunu kim gerçekten önemsiyor?

En yüksek girdi-çıktı oranı için bir sorun yaşadığımız halde , bu, verilen kod uzunluklarına sahip çoğu sonlu ve deterministik çıktı için bir çağrıdır . İronik olarak, bu zorluk kod golfü değildir .

Kurallar:

1. Üç bağımsız snippet yazın (tam programlar / işlevler değil).

2. Parçacıklar aynı dilde olmalıdır.

3. Skor, toplam üretilen bayt sayısıdır.

4. Çıktılar sonuç, STDOUT vb. Şeklinde olabilir.

5. Parçacıklar herhangi bir hataya neden olmayabilir.

6. Parçacıklar farklı çıktı biçimlerine neden olabilir.

7. Sondaki yeni satır karakterleri sayılmaz.

8. İlk snippet, 1 bayt veya en az 1 bayt çıkış üreten minimum uzunluk olmalıdır.

9. İkinci pasaj bundan bir bayt daha uzun olmalıdır.

10. Üçüncü snippet, birinciden iki bayt daha uzun olmalıdır.

GS2, 412 + 5.37 * 10 ⁹⁰² + 10 ^{10 903,1} bayt

1. f-baytlık bir dize 1\n2\nFizz\n4\nBuzz\n...\nFizzBuzzolarak iter 412.

2. fôtüm permütasyonlarını, yani 412! * 412karakterleri yazdırır .

3. fôôher bir öğenin 412 karakter uzunluğunda olduğu 412 * (412!)!bayt olarak , bu 412! öğesinin tüm permütasyonlarını yazdırır .

EDIT: Bir şeyleri perspektife koymak için, bu en azından

10^{1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000}

baytlar, şimdiye kadar diğer tüm cevapları cüce.

Pyth, 26 + 1140850688 + (> 4.37 × 10 ^20201781 )

Üçüncü program için çıktı tam uzunluğunu hesaplamak mümkün olup olmadığı hakkında hiçbir fikrim yok. Sadece sınırlar verebilirim. Bu arasına birşeyler basalım 4.37 × 10^20201781ve 1.25 × 10^20201790karakter.

G
yG
yyG

Bu yazdırır:

abcdefghijklmnopqrstuvwxyz
['', 'a', 'b', ..., 'abcdefghijklmnopqrstuvwxyz']
[[], [''], ['a'], ['b'], ['c'], ..., ['', 'a', 'b', ..., 'abcdefghijklmnopqrstuvwxyz']]

Birincisi alfabeyi, ikincisi tüm alfabenin alt kümelerini, üçüncüsü ise bir uzunluk listesi olan alfabenin alt kümelerinin alt kümelerini yazdırır 2^(2^26) ~= 1.09 × 10^20201781.

Açıkçası hiçbir bilgisayar bu büyük listeyi hesaplayamayacak ve çıktısını alamayacak.

CJam, 17 + 34 + 72987060245299200000 = 72987060245299200051 bayt çıkış

Daha kolay karşılaştırma için, bu yaklaşık 7.3 * 10 ^19'dur .

P
PP
Ke!

Baskılar:

3.141592653589793
3.1415926535897933.141592653589793
012345678910111213141516171819012345678910111213141516171918012...

Sonuncusu [0 1 2 ... 19], sayıların bir araya getirilmesiyle yapılan tüm permütasyonlardan oluşur . Ben denemek tavsiye etmem ... ( 4e!Bir tat almak gibi deneyin .)

Burada test edin: Program 1 , Program 2 , Program 3'ün akıllı versiyonu .

Jöle , 1.2 × 10 ²⁵⁶⁸ bayt çıkış

ȷ
ȷ*
ȷ*!

1000 , 1000 ¹⁰⁰⁰ ve 1000 ¹⁰⁰⁰ hesaplar ^!.

Çevrimiçi deneyin: ilk program | ikinci program |üçüncü program (değiştirildi)

Bayt sayma amacıyla, ȷbayt 0xa0 olarak kodlanabilir mevcut Jelly sürümünde .

Nasıl çalışır

Jelly'de, ȷsayı değişmezlerinin içinde Python'un e(bilimsel gösterim) olarak kullanılabilir. Örneğin, 30000 değerini3ȷ4 döndürür . Jelly bilimsel gösterimde, katsayı varsayılan 1 ve üs varsayılan 3 , bu nedenle , ve hepsi aynı sayı döndürür.ȷ1ȷ31000

ȷ      Return 1000.

ȷ      Return 1000.
       Parse the remaining code as a program with input 1000.
 *     Hook; compute 1000 ** 1000.

ȷ      Return 1000.
       Parse the remaining code as a program with input 1000.
  !    Return 1000!.
 *     Fork; compute 1000 ** 1000!.

Altıgen , 1 + 3 + 6 = 10 bayt çıkış

Şey ... çok etkileyici bir puan değil, ama en azından bunun optimal olduğunu iddia edebilirim. Tek bir bayt ile bir şey yazdırmak ve sonlandırmak imkansızdır , bu yüzden iki baytla başlıyoruz:

!@

Katlanmamış kod

 ! @
. . .
 . .

Bu bir bayt yazdırır ve sonlandırır.

Üç bayt kod için, üç bayt çıktı yazdırabiliriz. Örneğin:

o!@

veya katlanmamış:

 o !
@ . .
 . .

yazdırır 111. Dan herhangi küçük harf diçin zçalışır ve baskılar onun karakter kodu. Bunlar, 3 bayt kodunu 3 bayt yazdırmanın tek 23 yoludur.

Son olarak, dört bayt için 6 bayt yazdırmanın 169 yolu vardır. Hiçbiri, basit çözümden daha ilginç (tek kontrol akışı hariç) bir şey yapmadığından, şunları sunacağım:

o!!@

Kırımsız:

 o !
! @ .
 . .

Tahmin ettin. Yazdırır 111111.

Bunların optimal olduğunu nasıl bilebilirim? Doğruluk makinesi kataloğu için yazdığım kaba zorlayıcıyı 7000 döngüde maksimum sonlu çıktı aramak için uyarladım (4 bayt ile meşgul bir kunduz yazabilirsiniz, 7000 döngü için çalışıyor, ancak yine de sonlandırılıyor.)

Ciddi, 2025409 bayt

1 bayt:

N

(11.756 bayt çıktı üretir)

2 bayt:

Nñ

153.717 bayt çıktı üretir

3 bayt:

9!!

1.859.936 bayt çıktı üretir

Ciddi olarak "tüm altkümeler" veya "tüm kombinasyonlar" gibi şeyleri içermez, bu nedenle puanlar nispeten düşüktür.

Python 3, 1 + 22 + 23 = 56

9
id
abs

Çıktı

9
<built-in function id>
<built-in function abs>

Baskı 9 ve daha sonra tanım idve abs.

Labirent , 1 + 2 + 4 = 7 bayt

Başka bir düşük puan, ki bu daha çok gönderiyorum çünkü dil için optimal olduğunu kanıtladım.

Hexagony gibi, Labirent tek bir bayt ile yazdıramaz ve sonlandıramaz, bu yüzden iki baytla başlarız:

!@

Sıfır basar ve sonlanır.

Üç bayt için saf çözümü yenemeyiz:

!!@

Bu, sonlandırılmadan önce iki bayt yazdırır. Veya veya -1ile yazdırma gibi birkaç seçenek daha vardır . Kaynak kodu döndürmeyi kullanan oldukça güzel bir çözüm var:(!@~!@,!@

!>@

Bu bir sıfır basar, sonra kaynağı olmak için kaydırır @!>. Bu noktada, çıkmaza !girmeden önce bir çıkmaza çarpar, arkasını döner ve tekrar geri döner.

Dört bayt için biraz daha eğlenceli, çünkü 4 karakter yazdırmanın tek yolu yukarıdaki numarayı kullanmaktır:

!!>@

İki sıfır yazdırın, kaydırın, iki sıfır daha yazdırın @!!>.

Tüm bu durumlarda, \veya ile bir bayt yazdırabileceğinizi görmezden geliyorum ., çünkü bunlar her zaman tam olarak bir bayt !yazdıracak, en azından bir ve potansiyel olarak birkaçını yazdıracaktır.

Bash, 1726 bayt

(Şimdi düzelttim. Lütfen oylamayı düşünün.)

1 bayt :"

Çıktılar:

>

307 bayt: id

Çıktılar:

uid=501(geokavel) gid=20(staff) groups=20(staff),701(com.apple.sharepoint.group.1),12(everyone),61(localaccounts),79(_appserverusr),80(admin),81(_appserveradm),98(_lpadmin),33(_appstore),100(_lpoperator),204(_developer),395(com.apple.access_ftp),398(com.apple.access_screensharing),399(com.apple.access_ssh)

1418 bayt: zip (STDOUT'a yazdırır)

Telif hakkı (c) 1990-2008 Info-ZIP - Yazılım lisansı için 'zip "-L" yazın.
Zip 3.0 (5 Temmuz 2008). Kullanımı:
zip [-seçimler] [-b yol] [-t mmddyyyy] [-n sonekleri] [zipfile list] [-xi list]
  Varsayılan eylem listeye zipfile girdileri eklemek veya listeyi değiştirmek
  özel adı içerebilir - standart girişi sıkıştırmak için.
  Zip dosyası ve liste atlanırsa, zip stdin'i stdout'a sıkıştırır.
  -f tazelemek: sadece değiştirilmiş dosyalar -u güncelleme: sadece değiştirilmiş veya yeni dosyalar
  -d zip dosyasındaki girişleri sil -m zip dosyasına geç (OS dosyalarını sil)
  -r dizinlere recurse -j önemsiz (kaydetme) dizin adları
  -0 mağaza sadece -l dönüştürmek LF CR LF (-ll CR LF LF)
  -1 daha hızlı sıkıştır -9 daha iyi sıkıştır
  -q sessiz çalışma -v ayrıntılı çalışma / baskı sürümü bilgileri
  -c tek satırlık yorumlar ekle -z zipfile yorum ekle
  - @ stdin'den isimleri oku - zip dosyasını son giriş kadar eski hale getir
  -x aşağıdaki adları hariç tutar -i yalnızca aşağıdaki adları içerir
  -F düzeltme zip dosyası (-FF daha çok deneyin) -D dizin girişleri eklemeyin
  -Bir kendi kendine ayıklanan exe ayarlayın -J önemsiz zipfile öneki (unzipsfx)
  -T test zipfile bütünlüğü -X eXtra eXtra dosya özniteliklerini içerir
  -y sembolik bağlantıları başvurulan dosya yerine bağlantı olarak sakla
  -e şifrelemek -n bu sonekleri sıkıştırmayın
  -h2 daha fazla yardım göster

MATL , 313

Dilin şu anki sürümü ( 3.1.0 ) kullanılır;

1. Kod (önceden tanımlanmış değişmez değer: örtük olarak yazdırılan 2 sayısını üretir):

   H
   

   Çıktı (1 bayt):

   2
   

2. Kod (pi dolaylı olarak 15 ondalık sayı ile yazdırılan pi sayısı üretir):

   YP
   

   Çıktı (17 bayt):

   3.141592653589793
   

3. Kod (1'den 99'a kadar olan sayılar, varsayılan olarak aralarındaki boşluklarla yazdırılır):

    99:
   

   Çıktı (295 bayt):

   1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99
   

İşleme, 39 bayt

deterministik

1 bayt :

print(X);

Çıktılar 0.

9 bayt :

print(PI);

çıktılar 3.1415927

29 bayt :

print(P3D);

çıktılar processing.opengl.PGraphics3D

Deterministik olmayan,> = 129 bayt

> = 32 bayt:

print(g);

çıktılar processing.awt.PGraphicsJava2D@ + [mem-address]

> = 32 bayt:

print( g);

çıktılar processing.awt.PGraphicsJava2D@ + [mem-address]

> = 65 bayt: (Bu öneri için @anOKsquirrel'e teşekkür ederiz.)

print(g,g);

çıktılar

processing.awt.PGraphicsJava2D@ + [mem-address]
processing.awt.PGraphicsJava2D@ + [mem-address]

JavaScript, 1 + 3 + 18 = 18 22

Çok ilginç bir cevap değil ama muhtemelen en iyi JavaScript yeteneğine sahiptir.

alert(1)
alert(.1)
alert(1/9)

@UndefinedFunction sayesinde 4 puan eklendi !

Metin olarak çıktılar:

1
0.1
0.1111111111111111

Befunge, 2 + 4 + 6 = 12

.@
..@
...@

Uzunluk 2'den kısa olan herhangi bir snippet çıktı veremez veya çıkışını sonlandıramaz.

Befunge uygulamasında, .yığının en üst değerini bir tamsayı ve ardından bir boşluk olarak verir. Bir alan yeni satır değildir, bu nedenle sayıma dahil edilir. Buna ek olarak, yığın "sonsuz" 0 ile doldurulur, böylece programlar (sırasıyla) çıktı:

0 
0 0 
0 0 0 

SmileBASIC, 1 + 4 + 10 = 15 bayt

Program 1:

Bir şeyi yazdırmanın en kısa yolu? (PRINT) ve tek bir karakter içerir. Bu bir sayı veya değişken adı olabilir ve hepsi aynı uzunlukta olduğu için önemli değildir.

?1
1

Program 2:

Şimdi birkaç şeye daha erişebiliyoruz. Yapılabilecek en uzun ifade, sırasıyla 128, 256 ve 512 değerlerine sahip olan #Y, #L veya #R sabitlerinden biri olacaktır. Ancak, bunun yerine, (bu durumda) 3 fazladan boşluk basılacak şekilde virgül kullanıyorum.

?1,
1   

Program 3:

3 karakterle E-notasyon sayıları yazabilirsiniz:

?1E9
1000000000

HQ9 +, 71304

9

"99 şişe bira" nın 11.884 karakterlik sözlerini yazdırır

99

"99 şişe bira" iki kez yazdırır

999

"99 şişe bira" üç kez yazdırır

Japt -Q, Çıktılar1.0123378918474279e+150 bayt

Tam sayı

1,012,337,891,847,427,807,734,770,805,740,683,255,348,979,141,331,502,541,182,800,555,980,960,810,784,280,906,237,433,006,787,771,597,919,201,659,212,694,207,520,340,705,280,000,000,000,000,000,000,568

bayt.

# 1

M

çıktılar

{"P":3.141592653589793,"Q":1.618033988749895,"T":6.283185307179586}

67 bayt için. (Shaggy'ye kredi)

# 2

LÆ

çıktılar

[null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null]

ki bu 501 bayttır.

(@Shaggy'e kredi)

# 3

;Eá

Yazdırılabilir 95 ASCII karakterinin tüm permütasyonlarını ["...","...","..."...],

$1,012,337,891,847,427,807,734,770,805,740,683,255,348,979,141,331,502,541,182,800,555,980,960,810,784,280,906,237,433,006,787,771,597,919,201,659,212,694,207,520,340,705,280,000,000,000,000,000,000,001$ çıkış baytı.

-FJapt'ta bayrağı kullanırsanız sonsuz miktarda çıkış baytı alabilirsiniz. Yaptığı şey, programın son ifadesi yanlış olarak değerlendirilirse, bunun yerine bayrakta belirtilen değeri verir. Sanırım Japt için puan -F"Insert Super Long String Here"sonsuz.

Malbolge , 1 + 2 + 3 = 6 bayt

(=aN
(&a`M
(=a`_L

Çevrimiçi deneyin: birinci , ikinci , üçüncü

Çıktılar:

r
ll
xxx

Kaba zorla. Varsayımlar \0geçerli bir çıktı karakteri değil

İle \0:

cP
cbO
cbaN

Çıktılar:

\0
\0\0
\0\0\0

scg , 1 + 27 + 188 = 216

Birincisi:

1

Yığın programın sonunda çıktığı için sadece 1 yazdırır.

İkinci:

.d

Aşağıdaki gibi görünmesi gereken hata ayıklama bilgilerini yazdırır:

Stack: []
Array Markers: []

Üçüncü:

99r

yığına 99 ekler, sonra aralık işlevini kullanır. Çıktılar 01234567891011 .... (bu faktöriyel fonksiyonu uyguladığımı dilediğim zamanlardan biri. Yapmadım)

Marbelous 1 + 1 + 2 = 4 bayt çıkış

Marbelous, iki baytlık talimatlarla burada hamstung. Anlamsız yorumlar veya gereksiz boşluk, tek bir bayt sayımı almanın tek yoludur.

"A" yazdırın ve sonlandırın:

`A

boş bir EOL yorumu ile "B" yazdırın ve sonlandırın

`B#

"CD" yazdırarak sonlandırın:

`C`D

Mathematica + 461 + 6 763 = 1230 1225 618 163 çıkış bayt

%  (* -> Out[0] *)

?D  (* ->

D[f, x] gives the partial derivative ∂ f/∂ x. 
                                              n        n
D[f, {x, n}] gives the multiple derivative ∂  f/∂ x . 
D[f, x, y, …] differentiates f successively with respect to x, y, ….
D[f, {{x , x , …}}] for a scalar f
        1   2
     gives the vector derivative (∂ f/∂ x , ∂ f/∂ x , …). 
                                             1             2
D[f, {array}] gives a tensor derivative.

*)

?Do (* ->

Do[expr, {i   }] evaluates expr i    times. 
           max                   max
Do[expr, {i, i   }] evaluates expr with the variable i successively taking on the values 1 through i    (in steps of 1). 
              max                                                                                   max
Do[expr, {i, i   , i   }] starts with i = i   . 
              min   max                    min
Do[expr, {i, i   , i   , di}] uses steps di. 
              min   max
Do[expr, {i, {i , i , …}}] uses the successive values i , i , ….
               1   2                                     1   2
Do[expr, {i, i   , i   }, {j, j   , j   }, …] evaluates expr looping over different values of j, etc. for each i. 
              min   max        min   max

*)

Şu anda, son iki Informationsembol birçok bayt çıktısı alabilen semboller hakkında belge almak için kullanıyor . Bunun 10.1 komut satırında çalıştırıldığını unutmayın MathKernel.

Javascript, 72 bayt

Bu, Mozilla JSShell Javascript komut satırı yorumlayıcısında çalışır.

1 bayt: 1

çıktılar 1

35 bayt: gc

çıktılar

function gc() {
    [native code]
}

36 bayt: run

çıktılar

function run() {
    [native code]
}

Oktav, 2818417 bayt

e

İçin 14 bayt ans = 2.7183\n

pi

İçin 14 bayt ans = 3.1416\n

doc

Tüm belgeleri görüntüleyin. 2818389 bayt, ile sayıldı dd Çevrimiçi deneyin! çünkü evalcişe yaramadı.

SmileBASIC 4, 1 + 13 + 15 = 29 bayt

Bu, birkaç ayarlama ile 12Me21'in SmileBASIC 3 cevabına benzeyecek.

1

Daha önce olduğu gibi, bir çıktı üretmek için en kısa kod miktarı 2 bayttır: ?( PRINT) ve bazı tek baytlık ifade. Konsensüs olduğunu PRINTmu değil nedeniyle yol metin ekranı işleri için, sonraki satıra ilerlediğinde Yeni satır üretirler. Böylece bu bir baytlık çıktı ile sonuçlanır.

?1
1

2

3 bayt ile farklı bir şey yapabiliriz. SB4 INSPECT, ??tek bir değer hakkında bilgi yazdıran diğer adla tanıtılır . Örneğin boş bir dize verirsek, bu SB3'ün yapabileceğinden çok daha fazla çıktı üretebilir. Bu bize 13 bayt kazandırır.

??"
STRING: (0)""

3

Çalışmamız gereken 4 bayt var, bu nedenle çıktımızı en üst düzeye çıkarmak için ne yapmamız gerektiğine karar vermeliyiz. İle ??oynamak güvenli bir bahis; ifademizde yalnızca 2 baytımız var, ancak ek çıktısı INSPECTtemel olarak ücretsiz. Bu yüzden bir etiket dizesi yazdırmak için kullanıyorum. Bu 15 bayt.

??@A
STRING: (2)"@A"

Toplam 29 bayttır.

Mikroskopi II, 23 + 47 + 71 = 141 bayt

1: C

Sürekliliklerin dizilemesi spesifikasyonlar tarafından kesin olarak tanımlanmamıştır, ancak referans uygulamasında bu kendi başına çalışır, 23 baytlık bir dize verir.

<Continuation @t=\d\d\dus> (\d basamakları değişen bir rakamı temsil eder).

Bilgisayarımda, en azından, bu her zaman çalıştırmak için yaklaşık 180 ila yaklaşık 400 mikrosaniye sürer.

Aslında bu talimat için kullandığım ilk kullanım.

2: CP

47 bayt çıkış - aradaki satırsonu ile ilkinden iki kez çıktı.

3: CPP

Yeterince açıksözlü. 71 bayt çıktı - ilk satırdan üç defa çıktı ve aralarında satırsonu var.

PowerShell, ~ 4300 bayt

Üzerinde çalıştığı sistem göz önüne alındığında, yaklaşık çıkış uzunluğu. Aşağıdaki tüm snippet'ler belirleyicidir, çünkü bilgisayarın aynı başlangıç ​​durumu verilirse aynı metni çıkarır, sadece pratikte çıktı yürütmeden yürütmeye değişebilir.

Uzunluk 1, 107 bayt

?

Bu bir takma ad Where-Object. Ek bilgi isteyen bir kullanıcı istemi çıkarır:

cmdlet Where-Object at command pipeline position 1
Supply values for the following parameters:
Property: 

Uzunluk 2, 113 bayt

rp

Bu bir takma ad Remove-ItemProperty. Ek bilgi isteyen bir kullanıcı istemi çıkarır:

cmdlet Remove-ItemProperty at command pipeline position 1
Supply values for the following parameters:
Path[0]: 

Sadece 1 snippet'ten zar zor daha uzun.

Uzunluk 3, ~ 4100 bayt

gps

Bu, Get-Processsistemde çalışan tüm işlemlerin biçimlendirilmiş bir tablosunu çıktılayacak bir diğer addır :

Handles  NPM(K)    PM(K)      WS(K) VM(M)   CPU(s)     Id ProcessName                                                                                          
-------  ------    -----      ----- -----   ------     -- -----------                                                                                
     85       8     1232       4452    46     0.14    544 armsvc                                                                                               
    151      10     6800       9888    39     0.58   5116 audiodg                                                                                              
    480      25     6060      17200   124     0.84   4536 AuthManSvr            
...

Javascript, 312 + 318 + 624 = 1254 bayt çıktı

$
$$
$+$

İki işlev $ve $$tüm büyük tarayıcılar konsolları mevcuttur olduğunca kısayollar document.querySelectorvedocument.querySelectorAll sırasıyla. Farklı tarayıcılarda yerel kodlar birbirinden biraz farklı bir şekilde zorlanır ve IE her işlevde düz JS kullanır ve bu da çok daha uzun sunum sağlar.

Bayt sayısı için, bazen değiştirilmiş konsol ekranı yerine her birinin dize temsilinin uzunluğunu alıyorum, bu nedenle toplam baytlar, aşağıdaki tarayıcıların her biri için:

• Krom: 56 + 57 + 112 = 225 bayt
• IE: 312 + 318 + 624 = 1254
• Firefox: 33 + 33 + 66 = 132

(IE sonucunun "resmi" sayı olduğunu düşünüyorum çünkü en uzun.)

Konsol dışı tarayıcı ortamlarında, en büyük çıktılar aşağıdakilerden gelir:

1
!1 // Or '{}' if being fed to a function instead of beginning a statement
Map

Tarayıcıya göre sonuç uzunluğu:

• Chrome: 1 + 5 (veya 15 ise {} kullanılabilirse ) + 32 = 38 (veya 48) bayt
• IE: 1 + 5 (veya {}kullanılabilir ise 15 ) + 38 = 44 (veya 54)
• Firefox: 1 + 5 (veya {}kullanılabilirse 15 ) + 36 = 42 (veya 52)

Bu iki girdi seti, tüm bu tarayıcılarda ve konsollarda mümkün olan en büyük çıktıyı üretir. Bunu kanıtlamak için tüm alternatifleri kontrol edelim:

• Mevcut değişkenler: Maksimum üç karakterli tüm yerel kullanılabilir değişkenleri bulabiliriz Object.getOwnPropertyNames(window).filter(x=>x.length<=3)ve daha sonra mapdaha büyük olanları belirlemek için dize çıktılarında bulabiliriz. (Firefox gibi bazı tarayıcılarda, pencerenin bir özelliği olmadığı için belirli özel konsol değişkenlerine bu şekilde erişilemeyeceğini unutmayın.)
• JS, bu kadar az karakterle oluşturulabilecek sınırlı sayıda değişmez değere sahiptir:
  • Spesifikasyona göre, ondalık sayılar 1234567890isteğe bağlı olarak bir ondalık basamak ( ) .ve ardından daha fazla ondalık basamak ve / veya bir üs parçası veya .ardından bir veya daha fazla ondalık basamak ve isteğe bağlı olarak bir üs parçası olmalıdır. Sayıların Diğer türlü olmalı ya 0o, 0xya0b (veya formlar büyük), bir veya daha fazla rakam takip eder. Amaçlarımız için aşağıdakileri çıkarabiliriz:
    • 0 ile 9 arasında tamsayılar olan yalnızca on adet tek karakterli sayı vardır. Yalnızca iki karakterli sayılar 0-99 tamsayılarıdır (ondalık ekleyerek 0-9 arası) ve ilk sıfırı atlayarak 0,1 ile 0,9 arası sayılardır. . Yalnızca üç karakterli sayılar, 0x0-0xf, 0o0-0o7, ​​0b0 ve 0b1, üstel 1e1 ila 9e9 (10 karakter) ve 0.1-9.9 ve .01 ila .99 sayıları dahil 0-999'dur. Teknik olarak bir sayı değişmezi olmasa da, NaN'ye üç karakterle de başvurulabilir.
  • Her biri en fazla tek bir içerik karakteri alabilen dizeler, diziler ve normal ifadeler. Bir dizi $, virgül veya tek basamaklı bir sayı ile doldurulabilir . Yalnızca bir öğeye sahip diziler, öğenin kendisi olarak dizelere zorlanır. Boş diziler boş dizgiler haline gelir.
  • Ortama bağlı olarak, üç karakterli basit nesneler oluşturmak mümkün olabilir veya olmayabilir. Normalde, {}bir komut dosyasının başlangıcında tek başına bir nesne oluşturmak yerine bir muhafaza olarak değerlendirilir. eval({})undefined, eval({$})işlevi döndürür $. Çevrelemek için yetersiz karakter vardır {}in ().
• Kullanmak için yeterince kısa anahtar kelime yok. Anahtar kelimeler if, in, do, new, for, try, var, ve lettüm limitini aşan, kullanımı diğer iki karakterden az gerektirecektir.
• Mevcut tekli operatörler dahil ~, +, -, !, ++, ve --. İki karakterli işleçler yalnızca tek bir ( $) karakteri olan tek bir karakter değişkeni ile kullanılabilir.NaN . Diğer dört operatör, aşağıdakilerden oluşan herhangi bir veya iki karakterlik değerle kullanılabilir:
  • Birkaç değişken. (Bazı konsollarda $, $_, $0, $1, $2, $3, $4, $, $$, $x). Bu operatörleri ile kullanıldığında, sonuçlar sınırlıdır -1, true, false, ve NaN.
  • 109 numara. Sonuçlar: Tam sayılar -100 99 arasındaki, -0.9 -0.1 aracılığıyla, true, false.
  • Boş dizeler. Sonuçlar:-1 , 0( -0olur 0toString üzerine), true.
  • Tek karakterli tekli bir operatörle ilişkili yukarıdaki tek karakterlik değerlerin herhangi birinin sonuçları. Yeni sonuçlar: Yok.
• Hangi (her iki işlenenler için sol oda var tek bir karakter olmalı) Kullanılabilir ikili operatörler +, -, *, /, %, <, >, &, |, ^. Her iki tarafta da tek karakterli bir değerle kullanılabilirler. Değerler için seçenekler $ve 0-9 arasında tamsayılar bulunur. Bunların tüm kombinasyonlarının sonuçları şunları içerir:Infinity yukarıda belirtilen bazı sayılar ve ikili değerleri ve 19 veya daha az karakterden oluşan dizelere zorlanan çok sayıda kesiri ( yukarıda önerilen 18'den 1/7farklı olarak 19 karakterdir 1/9) ve $öncekinin veya ardından tek basamaklı bir tam sayı veya kendisi gelir.
• Son olarak, kalan tüm işleçler ve ifadeler: Üye işleç ., var olan bir değişkeni ve bir özelliğe başvuran bir tanımlayıcı gerektirir. Buradaki tüm kullanımlar bununla sonuçlanır undefined. Bir değeri ( )çevrelemek, değeri atamak gibi döndürür =. ()Bir değeri işlev olarak çağırmak için veya `` kullanmak tanımsız veya kullanılabilir tüm değerlerde hatalarla sonuçlanır.

Tüm bunları toplayarak, bir Chrome konsolu kullanılırken toplam 1651 olası çıkış vardır. Bir, iki ve üç karakterden en uzun çıkışlar vardır $, $$ve $+$sırasıyla.

dc , 2 + 5 + 18 = 25 bayt

1: Ffverim ( Çevrimiçi deneyin! ):

15

2: Fdf verim ( Çevrimiçi deneyin! ):

15
15

3: Fd^f verim ( Çevrimiçi deneyin! )

437893890380859375

Bunların hiçbiri özellikle ilginç dcdeğil , ancak çıktı yığınlarını tükürmek için gerçekten harika değil. Her cevabın bir öncekine dayanmasını seviyorum. Her neyse, Fsadece 15 numara; ftüm yığını yazdırır; dyığının tepesini çoğaltır; ^yığının üstünden üste yığının üst kısmının gücüne yükseltir (bu durumda, 15 ^ 15). Bunun üstesinden gelebileceğine inanmıyorumdc .

Yakut, 3 + 14 + 28 = 45 bayt

Bunu neden yaptım.

p

Baskılar nil.

$>

Baskılar #<IO:<STDOUT>>.

dup

Satırları boyunca bir şeyler yazdırır #<Object:0x0000000003610988>.

irb

Interactive Ruby örneğini başlatır. Çıktıktan sonra, döndürülen nesne #<IRB::Irb: @context=#<IRB::Context:0x0000000003643040>, @signal_status=:IN_EVAL, @scanner=#<RubyLex:0x00000000038900a0>>121 içindir, ancak ^Dgerçekten irb örneğinden çıkmanız için bir şey basmanızı veya bir şey gerektirdiğinden , gerçekten "3 bayt" içinde bir çözüm olarak sayılacağından emin değildim, Tamam olsun sürece aslında skor dahil.

Perl 6, 53 (17 + 18 + 18) bayt

e
-e
e*e

1. e çıktılar $e$ 15 ondalık basamağa
2. -e çıktılar $-e$ 15 ondalık basamağa
3. e*e çıktılar $e^2$, ama tuhaf bir şekilde, ondalık bir yer daha veriyor

Runik Büyüler, 4.000.000 bayt çıktı

İlk program:

a@

2 bayt alır: yığına bir değer itin, yığından bir değer yazdırın ve sonlandırın. Bu durumda yazdırır 10(0 ile 16 arasındaki herhangi bir tam sayı değeri de aynı derecede geçerlidir)

3 bayt için:

aY@

10000Yine, baskılar a1 ila 16 dahil olabilir (orijinal programdan daha fazla çıktı üretmek için, 0 diğer operatörler altında potansiyel olarak geçerlidir) ve tek bir girdi alan ve çıktı üreten bir sürü operatör yoktur, çok daha az uzun çıktı. XCYZ:Etek gerçek seçenek. aY@sadece en fazla çıktı ile sonuçlanır .

P$!;

Dil spesifikasyonuna göre, bu sonsuz bir şekilde çalışır. Yorumlayıcı bir inşa etti Ancak olarak "Tamam, yeter bu kadar" maksimum yürütme sınırı, bu şekilde (128kib aştıkları için ~ 130,000 bayt sonra yürütme kapalı ve TIO kesikler) 4 karakterden en çok çıkış ulaşılabilir olduğunu ve tercüman dilini tanımlar bu, İşler. Ve bu eşiği daha önce bir kez yükseltmişken (10 bin adımdan 1 milyona), yakın zamanda onunla uğraşmayı planlamıyorum.

Daha büyük?

Burada yaptığım üç varsayımı çağırırsam , o zaman eminim.

`AA@

Hangi işe yarıyor Ack(65,Ack(65,64)), başlangıçta Ackerman işlevine itmek için çok büyük değerler değil - kesinlikle eski yazıdaki 255'ten daha küçük - ama tamam, Ack'ı 4 talimatta iki kez çağırabiliriz.

Ve sadece tanrı ne basacağını bilir.

_{Not: o Azamandan beri Mathtalimat, yığın üzerinde 3 nesne tüketen meta-talimat yapılmıştır : hangi talimatın gerçekleştirileceği için bir karakter ve daha sonra x ve y olmak üzere iki giriş. Bu nedenle, bu program aslında hiçbir şey yapmaz, çünkü ne bir matematik fonksiyonuna ne Ade @haritaya ve sonraki iki çağrı bir yığın düşük akışına neden olur.}