Maximiser la sortie d'une entrée minimale


16

De toute évidence, le golf par code consiste à tirer le meilleur parti du moins de code. Qui se soucie vraiment de la sortie réelle?

Bien que nous ayons eu un défi pour le rapport entrée-sortie le plus élevé , il s'agit d'un appel à la sortie la plus finie et déterministe avec des longueurs de code données. Ironiquement, ce défi n'est donc pas du .

Règles:

  1. Écrivez trois extraits indépendants (pas des programmes / fonctions complets).

  2. Les extraits doivent être dans la même langue.

  3. Le score est le nombre total d'octets sortis.

  4. Les sorties peuvent être sous la forme d'un résultat, STDOUT, etc.

  5. Les extraits de code peuvent ne provoquer aucune erreur.

  6. Les extraits peuvent provoquer différentes formes de sortie.

  7. Les caractères de fin de ligne ne sont pas comptés.

  8. Le premier extrait doit être de 1 octet ou la longueur minimale qui produit au moins 1 octet de sortie.

  9. Le deuxième extrait doit être un octet de plus que cela.

  10. Le troisième extrait doit être plus long de deux octets que le premier.


5
Oui, je pense que la sortie doit être limitée pour être théoriquement finie, vous devriez également spécifier qu'elle devrait être déterministe (à moins que je ne comprenne mal et que le hasard soit quelque chose que vous voudriez réellement ...)
FryAmTheEggman

Sommes-nous autorisés à supposer que chaque extrait est exécuté sur une nouvelle instance REPL?
SuperJedi224

@ SuperJedi224 Oui.
2015

Qu'est-ce que "forme" dans "différentes formes de sortie"?
Luis Mendo

@LuisMendo Par exemple, un extrait peut faire apparaître une boîte de message, tandis qu'un autre s'imprime sur STDOUT.
2015

Réponses:


26

gs2, 412 + 5,37 * 10 902 + 10 10 903,1 octets

  1. fpousse 1\n2\nFizz\n4\nBuzz\n...\nFizzBuzzcomme une 412chaîne de -byte.

  2. imprime toutes ses permutations, donc des 412! * 412caractères.

  3. fôôimprime toutes les permutations de cette liste d'éléments 412!, où chaque élément est long de 412 caractères, donc 412 * (412!)!octets.

EDIT: Pour mettre les choses en perspective, c'est au moins

dix1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

octets, éclipsant toutes les autres réponses jusqu'ici.


9

Pyth, 26 + 1140850688 + (> 4,37 × 10 20201781 )

Je n'ai aucune idée s'il est possible de calculer la longueur exacte de la sortie pour le troisième programme. Je ne peux que donner des limites. Il imprimera quelque chose entre les caractères 4.37 × 10^20201781et 1.25 × 10^20201790.

G
yG
yyG

Cela imprime:

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

Le premier imprime l'alphabet, le second tous les sous-ensembles de l'alphabet et le troisième les sous-ensembles des sous-ensembles de l'alphabet, qui est une liste de longueur 2^(2^26) ~= 1.09 × 10^20201781.

De toute évidence, aucun ordinateur ne pourra jamais calculer cette grande liste et la produire.


1
Si mon calcul est correct, il devrait avoir 2 ^ (2 ^ 26-1) * (2 ^ 25 * 26 + 2 ^ 26 * 4) + 2 ^ (2 ^ 26) * 2 = 6,239 * 10 ^ 20201789 caractères. Notez que chaque chaîne est apparue le même nombre de fois, c'est donc environ la moitié de votre limite supérieure.
jimmy23013

1
Si @ jimmy23013 et mes calculs sont corrects, la concaténation de ces trois nombres doit être égale à la longueur de sortie du troisième programme.
LegionMammal978

6

CJam, 17 + 34 + 72987060245299200000 = 72987060245299200051 octets de sortie

Pour une comparaison plus facile, il s'agit d'environ 7,3 * 10 19 .

P
PP
Ke!

Tirages:

3.141592653589793
3.1415926535897933.141592653589793
012345678910111213141516171819012345678910111213141516171918012...

Eh bien, la dernière consiste en toutes les permutations [0 1 2 ... 19]avec les nombres écrasés ensemble. Je ne recommanderais pas de l'essayer ... (Essayez comme 4e!pour avoir un avant-goût.)

Testez-le ici: programme 1 , programme 2 , version saine du programme 3 .


4

Gelée , 1,2 × 10 2568 octets de sortie

ȷ
ȷ*
ȷ*!

Calcule 1000 , 1000 1000 et 1000 1000!.

Essayez-le en ligne: premier programme | deuxième programme | troisième programme (modifié)

À des fins de comptage d'octets, ȷpeut être codé comme l'octet 0xa0 dans la version actuelle de Jelly .

Comment ça fonctionne

Dans Jelly, ȷpeut être utilisé à l'intérieur des littéraux numériques comme Python e(notation scientifique). Par exemple, 3ȷ4renvoie 30000 . Dans la notation scientifique de Jelly, le coefficient par défaut est 1 et l'exposant par défaut 3 , donc ȷ, 1ȷ3et 1000tous renvoient le même nombre.

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

Avez-vous un équivalent d'APL ?
2015

@NBZ Oui. L'équivalent des APL ıest R(plage). ıet ȷfaire quelque chose de totalement indépendant dans Jelly. J'ajouterai une explication dans quelques minutes.
Dennis

Ma première tentative de Jelly: combien de sortie cela ȷRRcause-t-il?
2015

@NBZ Environ 2,4 mégaoctets.
Dennis

Je vois ȷRRest ⍳¨⍳1000. Je voulais ⍳⍳1000. Dans Dyalog, il ⍳⍳7obtient 91244, ⍳⍳8803487 et ⍳⍳97904816, car il répertorie tous les indices dans un tableau 1 × 2 × 3 × 4 × .... Donc ⍳⍳1000, théoriquement (WS FULL!) Générerait un tableau de! 1000 listes de 1000 éléments chacune!
2015

4

Hexagonie , 1 + 3 + 6 = 10 octets de sortie

Bon ... pas un score très impressionnant, mais au moins je peux affirmer que c'est optimal. Avec un seul octet, il est impossible d'imprimer quelque chose et de terminer, nous commençons donc avec deux octets:

!@

Le code déplié est

 ! @
. . .
 . .

Cela imprime un octet et se termine.

Pour trois octets de code, nous pouvons imprimer trois octets de sortie. Par exemple:

o!@

ou déplié:

 o !
@ . .
 . .

impressions 111. Toute lettre minuscule de dà zfonctionne et imprime son code de caractère. Ce sont les 23 seules façons d'imprimer 3 octets avec 3 octets de code.

Enfin, pour quatre octets, il existe 169 façons d'imprimer 6 octets. Puisqu'aucun d'eux ne fait quelque chose de plus intéressant (à l'exception d'un flux de contrôle impair) que la solution simple, je présenterai cela:

o!!@

Déplié:

 o !
! @ .
 . .

Tu l'as deviné. Il imprime 111111.

Comment savoir si elles sont optimales? J'ai adapté le forceur brut que j'ai écrit pour le catalogue de la machine de vérité pour rechercher une sortie finie maximale en 7000 cycles (je ne pense pas que vous puissiez écrire un castor occupé avec 4 octets, qui fonctionne pendant 7000 cycles mais se termine toujours plus tard.)


alors ... est-ce que le forceur brut est accessible au public? Je serais intéressé par les programmes de forçage brut qui produisent 12345et s'arrêtent. . .pour la curiosité, vous comprenez.
quintopie

@quintopia c'est dans le repo GitHub, mais bonne chance pour trouver un programme de 8 octets avec. ;)
Martin Ender

Eh bien, seulement 7 d'entre elles sont inconnues, et vous avez déjà démontré sa capacité à rechercher des solutions à 7 octets pour trouver des implémentations Truth-machine ...
quintopie

4

Sérieusement, 2025409 octets

1 octet:

N

(produit 11 756 octets de sortie)

2 octets:

Produit 153 717 octets de sortie

3 octets:

9!!

Produit 1 859 936 octets de sortie

Sérieusement, il ne comporte pas encore de choses comme "tous les sous-ensembles" ou "toutes les combinaisons", donc les scores sont relativement faibles à ce sujet.


1
Qu'est- Nce que cela fait pour produire autant de sortie?
geokavel

3
Poussez les paroles de 99 bouteilles de bière
Quintopia

3

Python 3, 1 + 22 + 23 = 56

9
id
abs

Production

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

Imprimez 9, puis la définition de idet abs.


3

Labyrinthe , 1 + 2 + 4 = 7 octets

Un autre faible score, que je poste principalement parce que je l'ai prouvé optimal pour la langue.

Comme Hexagony, Labyrinth ne peut pas imprimer et se terminer avec un seul octet, nous commençons donc avec deux octets:

!@

Imprime un zéro et se termine.

Pendant trois octets, nous ne pouvons pas battre la solution naïve:

!!@

Cela imprime deux octets avant de se terminer. Il existe quelques autres options, comme l'impression -1avec (!@ou ~!@ou ,!@. Il existe cependant une solution plutôt cool qui utilise la rotation du code source:

!>@

Cela imprime un zéro, puis décale la source pour devenir @!>. À ce stade, il frappe une impasse, se retourne et exécute le! nouveau sur le chemin du retour, avant de se terminer.

Pour quatre octets, c'est un peu plus amusant, car la seule façon d'imprimer 4 caractères est d'utiliser l'astuce ci-dessus:

!!>@

Imprimez deux zéros, passez à @!!>, imprimez deux autres zéros.

Dans tous ces cas, j'ignore que vous pouvez également imprimer un octet avec \ou ., car ceux-ci imprimeront toujours exactement un octet, alors !qu'ils en imprimeront au moins un et potentiellement plusieurs.


3

Bash, 1726 octets

(Je l'ai corrigé maintenant. Veuillez envisager de voter.)

1 octet :"

Les sorties:

>

307 octets: id

Les sorties:

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 octets: zip (Imprime vers STDOUT)

Copyright (c) 1990-2008 Info-ZIP - Tapez 'zip "-L"' pour la licence du logiciel.
Zip 3.0 (5 juillet 2008). Usage:
zip [-options] [-b chemin] [-t mmddyyyy] [-n suffixes] [zipfile list] [-xi list]
  L'action par défaut consiste à ajouter ou à remplacer des entrées de fichier zip à partir de la liste, ce qui
  peut inclure le nom spécial - pour compresser l'entrée standard.
  Si zipfile et list sont omis, zip compresse stdin en stdout.
  -f rafraîchir: uniquement les fichiers modifiés -u mise à jour: uniquement les fichiers modifiés ou nouveaux
  -d supprimer les entrées dans le fichier zip -m déplacer dans le fichier zip (supprimer les fichiers du système d'exploitation)
  -r recurse dans les répertoires -j noms de répertoires indésirables (ne pas enregistrer)
  -0 stocker uniquement -l convertir LF en CR LF (-ll CR LF en LF)
  -1 compression plus rapide -9 compression meilleure
  -q opération silencieuse -v opération détaillée / informations sur la version imprimée
  -c ajouter des commentaires sur une ligne -z ajouter un commentaire sur le fichier zip
  - @ lire les noms de stdin -o rendre le fichier zip aussi ancien que la dernière entrée
  -x exclut les noms suivants -i n'inclut que les noms suivants
  -F corrige le fichier zip (-FF essayez plus fort) -D n'ajoute pas d'entrées de répertoire
  -A ajuster l'exe auto-extractible -J junk zipfile prefix (unzipsfx)
  -T   test zipfile integrity       -X   eXclude eXtra file attributes
  -y   store symbolic links as the link instead of the referenced file
  -e   encrypt                      -n   don't compress these suffixes
  -h2  show more help

Let me know what you think is wrong with it. As long as you don't wait too long, it really does always print the same thing. The kilobyte count at the end proves it.
geokavel

There are two problems with this: 1. The first command produces no output at all, since STDERR is not an accepted output method. 2. The output of du depends on which files/directories are in the current folder, so this is not at all self-contained or reproducible.
Dennis

@Dennis How do you know the first one is STDERR, if it's just printing usage? Ok, now I see how the second one breaks the rules
geokavel

2
This requires zip. Zip is not included with bash.
noɥʇʎԀʎzɐɹƆ

1
@CrazyPython I could change the title if necessary to bash with common utilities or default bash on Mac OS X.
geokavel

2

MATL, 313

The current version of the language (3.1.0) is used, which is earlier than this challenge.

  1. Code (predefined literal: produces number 2, which is implicitly printed):

    H
    

    Output (1 byte):

    2
    
  2. Code (produces number pi, which is implicitly printed with 15 decimals):

    YP
    

    Output (17 bytes):

    3.141592653589793
    
  3. Code (numbers from 1 to 99, which are printed by default with spaces in between):

     99:
    

    Output (295 bytes):

    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
    

2

Processing, 39 bytes

Deterministic

1 byte:

print(X);

Outputs 0.

9 bytes:

print(PI);

Outputs 3.1415927

29 bytes:

print(P3D);

Outputs processing.opengl.PGraphics3D

Non-deterministic, >= 129 bytes

>= 32 bytes:

print(g);

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

>= 32 bytes:

print( g);

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

>= 65 bytes: (Thank you to @anOKsquirrel for this suggestion.)

print(g,g);

Outputs

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

in the second section could you have used something like 1,g or g,g? or even g+g?
anOKsquirrel

2

JavaScript, 1 + 3 + 18 = 18 22

Not a very interesting answer but probably the best JavaScript is capable of.

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

Added 4 score thanks to @UndefinedFunction!

Outputs as text:

1
0.1
0.1111111111111111

If you just write alert() you get output of undefined (at least in Safari).
geokavel

@geokavel Oh really? In Chrome it just shows an empty alert. I haven't checked Firefox. In Safari the score would be even less. :s
user81655

alert(.1) gives 0.1, and alert(1/9) gives 0.1111111111111111
jrich

@UndefinedFunction Nice tips, thanks!
user81655

Writing alert gives me function alert() { [native code] }
ev3commander

2

Befunge, 2 + 4 + 6 = 12

.@
..@
...@

Any snippet shorter than length 2 either cannot output, or cannot terminate its output.

In Befunge, . outputs the top value of the stack as an integer, followed by a space. A space is not a newline, so it is included in the count. Additionally, the stack is "infinitely" filled up with 0's, so the programs output (respectively):

0 
0 0 
0 0 0 

1
..<@ prints 8 bytes.
jimmy23013

2

SmileBASIC, 1+4+10= 15 bytes

Program 1:

The shortest way to print something is with ? (PRINT) and a single character. This can be either a number or a variable name, and it doesn't matter since they're all the same length.

?1
1

Program 2:

Now we have access to a few more things. The longest expression which can be made would be one of the constants #Y, #L, or #R, which have values 128, 256, and 512, respectively. However, instead of that, I use a comma so that (in this case) 3 extra spaces are printed.

?1,
1   

Program 3:

With 3 characters, you can write E-notation numbers:

?1E9
1000000000

2

HQ9+, 71304

9

Prints the 11,884-character lyrics of "99 bottles of beer"

99

Prints "99 bottles of beer" twice

999

Prints "99 bottles of beer" three times


2

Japt -Q, Outputs 1.0123378918474279e+150 bytes

The full number is

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

bytes.

# 1

M

Outputs

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

For 67 bytes. (Credit to Shaggy)

# 2

Outputs

[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]

which is 501 bytes.

(Credit to @Shaggy)

# 3

;Eá

Outputs all permutations of the 95 printable ASCII characters in the format ["...","...","..."...], which is

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 bytes of output.


You can get an infinite amount of output bytes if you use the -F flag in Japt. What it does is that if the last expression of the program evaluates to false, it outputs the value specified in the flag instead. So I guess the score for Japt-F"Insert Super Long String Here" is infinity.


You can get 501 bytes out of the second one.
Shaggy

And 4 bytes or a risky 8 out of the first.
Shaggy

A-ha! I knew there was a way to get undefined in 1 byte: $.
Shaggy

@Shaggy Or I could use K and get 26 bytes of output, but your 501 byter is just genius
Embodiment of Ignorance

Does output not have to be deterministic?
Shaggy

2

Malbolge, 1 + 2 + 3 = 6 bytes

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

Try it online: first, second, third

Outputs:

r
ll
xxx

Brute forced. Assumes \0 is not a valid output character

With \0:

cP
cbO
cbaN

Outputs:

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

1

scg, 1 + 27 + 188 = 216

First one:

1

Just prints 1, as the stack is outputted at the end of program.

Second:

.d

Prints debug info, which should look like this:

Stack: []
Array Markers: []

Third:

99r

adds 99 to stack, then uses range function. Outputs 01234567891011.... (this is one of those times I wish I implemented the factorial function. I haven't)


1

Marbelous 1 + 1 + 2 = 4 bytes of output

Marbelous is hamstrung here by having two-byte instructions. Pointless comments or unnecessary whitespace are the only ways to get an odd byte count.

print "A" and terminate:

`A

print "B" and terminate, with an empty EOL comment

`B#

print "CD" and terminate:

`C`D

1

Mathematica, 6 + 461 + 763 = 1230 1225 618 163 bytes of output

%  (* -> 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

*)

Currently, the last two use Information to get documentation about the symbols, which can output many bytes. Note that this was run on the 10.1 command-line MathKernel.


1

Javascript, 72 bytes

This works in the Mozilla JSShell Javascript command line interpreter.

1 byte: 1

Outputs 1

35 bytes: gc

Outputs

function gc() {
    [native code]
}

36 bytes: run

Outputs

function run() {
    [native code]
}

So...Node.js?..
CalculatorFeline

@CalculatorFeline I'm not familiar with Node.js, but on my Mac if you type in js on the command line, you get a JavaScript shell.
geokavel

-bash: js: command not found Please specify more.
CalculatorFeline

@CalculatorFeline I'm getting the same message. Maybe they took out js in the latest version of Bash.
geokavel

gc doesn't seem to exist in TIO Node, so please find an implementation or remove this answer.
CalculatorFeline

1

Octave, 2818417 bytes

e

14 bytes for ans = 2.7183\n

pi

14 bytes for ans = 3.1416\n

doc

Display the entire documentation. 2818389 bytes, counted with dd Try it online! because evalc didn't work.


1

SmileBASIC 4, 1 + 13 + 15 = 29 bytes

This is going to be similar to 12Me21's SmileBASIC 3 answer, with a couple adjustments.

1

As before, the shortest amount of code to produce some output is 2 bytes: ? (PRINT) and some single-byte expression. The consensus is that PRINT does not produce a newline when it advances to the next line, due to the way the text screen works. So this results in one byte of output.

?1
1

2

With 3 bytes, we can do something different. SB4 introduces INSPECT, aliased as ??, which prints info about a single value. If we give it an empty string, for example, this can produce much more output than SB3 could. This gets us 13 bytes.

??"
STRING: (0)""

3

We have 4 bytes to work with, so we have to decide what we should do to maximize our output. Going with ?? is a safe bet; we only have 2 bytes to use on our expression, but the additional output of INSPECT is basically free. So I use it to print a label string. This is 15 bytes.

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

The total is 29 bytes.


0

Microscript II, 23+47+71=141 bytes

1: C

The stringification of continuations is not strictly defined by the specs, but in the reference implementation this, run on its own, yields a 23 byte string.

<Continuation @t=\d\d\dus> (\d represents a digit, which digits varies).

On my computer, at least, this does, in fact, always take between about 180 and about 400 microseconds to run.

The first use I've ever actually had for this instruction.

2: CP

47 bytes of output- the output from the first one twice with a newline in between.

3: CPP

Fairly straightforward. 71 bytes of output- the output from the first one three times with newlines in between.


Is this deterministic? If I understand you right, it contains varying digits...
Adám

@NBZ It does not produce the exact same strings every time, but it has produced strings of the same length every time I've tested it so far.
SuperJedi224

Maybe leave it as-is, but provide an alternate answer that is truly deterministic?
Adám

0

PowerShell, ~4300 bytes

Approximate output length, given the system that it's run on. All the snippets below are deterministic, in that if given the same initial state of the computer will output the same text, just that in practice the output could change from execution to execution.

Length 1, 107 bytes

?

This is an alias for Where-Object. It will output a user prompt asking for additional information:

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

Length 2, 113 bytes

rp

This is an alias for Remove-ItemProperty. It will output a user prompt asking for additional information:

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

Just barely longer than the length 1 snippet.

Length 3, ~4100 bytes

gps

This is an alias for Get-Process which will output a formatted table of all running processes on the system:

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

"output could change" - that's an understatement. In praxis, it would be impossible to reset the machine to the same state. Maybe a more deterministic alternative to the third?
Adám

1
Impracticality does not preclude determinism ... Unless you're meaning a different definition of "deterministic," in which case you should explicitly state so in the challenge.
AdmBorkBork

According to you, almost every program is deterministic, given the exact same machine state. The only exception would be equipment with true RNGs, e.g. based on microphone noise or camera input.
Adám

1
@NBZ True. I would certainly hope that almost every program is deterministic. Are you intending "immutable" perhaps?
AdmBorkBork

0

Javascript, 312 + 318 + 624 = 1254 bytes of output

$
$$
$+$

The two functions $ and $$ are available in all major browsers' consoles, as shortcuts for document.querySelector and document.querySelectorAll respectively. Different browsers have native code coerced to strings somewhat differently from each other, and IE uses plain JS in each function resulting in much longer representation.

For the byte count, I'm taking the length of the string representation of each rather than the sometimes-modified console display, so the total bytes are, for each of the following browsers:

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

(I'm considering the IE result to be the "official" count because it's the longest.)

For non-console browser environments, the largest outputs come from the following:

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

Results length by browser:

  • Chrome: 1 + 5 (or 15 if {} is usable) + 32 = 38 (or 48) bytes
  • IE: 1 + 5 (or 15 if {} is usable) + 38 = 44 (or 54)
  • Firefox: 1 + 5 (or 15 if {} is usable) + 36 = 42 (or 52)

These two sets of input produce the largest output possible in all of these browsers and consoles. To prove this, let's check all alternatives:

  • Existing variables: We can find all native available variables with maximum three characters with Object.getOwnPropertyNames(window).filter(x=>x.length<=3), and then map them to their string outputs to determine the larger ones. (Note that in some browsers such as Firefox, certain special console variables cannot be accessed this way as they're not a property of the window.)
  • JS has a limited number of types of literals that can be created with so few characters:
    • Per the spec, decimal numbers must be a decimal digit (1234567890) optionally followed by . and more decimal digits and/or an exponent part, or be a . followed by one or more decimal digits and optionally an exponent part. Other kinds of numbers must be either 0o, 0x, or 0b (or uppercase forms), followed by one or more digits. For our purposes, we can deduce the following:
      • There are only ten single-character numbers, which are the integers 0 through 9. The only two-character numbers are integers 0-99 (0-9 by adding a decimal after), and the numbers 0.1 through 0.9 by omitting the initial zero. The only three-character numbers are 0-999, including 0x0-0xf, 0o0-0o7, 0b0, and 0b1, the exponential 1e1 through 9e9 (10 characters), and the numbers 0.1-9.9 and .01 through .99. While not technically a number literal, NaN can also be referenced in three characters.
    • Strings, arrays, and regexps, each of which can take at max only a single character of content. An array could be filled with $, a comma, or a single-digit number. Arrays with only one element are coerced to strings as the element itself. Empty arrays become empty strings.
    • Depending on environment, it may or may not be possible to create simple objects with three characters. Normally, {} alone at the beginning of a script would be treated as an enclosure rather than creating an object. eval({}) returns undefined, eval({$}) returns the $ function. There are insufficient characters to surround the {} in ().
  • There are no keywords that are short enough to use. The keywords if, in, do, new, for, try, var, and let would all require a minimum of two other characters to use, exceeding the limit.
  • Available unary operators include ~, +, -, !, ++, and --. The two-character operators can only be used with a single character variable, of which there is only one ($), which yields NaN. The other four operators can be used with any one- or two- character value, of which there are:
    • Several variables. (On some consoles $, $_, $0, $1, $2, $3, $4, $, $$, $x ). When used with these operators, the results are limited to -1, true, false, and NaN.
    • 109 numbers. Results: Integers -100 through 99, -0.9 through -0.1, true, false.
    • Empty strings. Results: -1, 0 (-0 becomes 0 on toString), true.
    • The results of any of the one-character values above associated with a one-character unary operator. New results: None.
  • Usable binary operators (which must be a single character to have room left for both operands) are +, -, *, /, %, <, >, &, |, ^. They can only be used with a single-character value on each side. Options for values include $ and integers 0-9. Results of all combinations of these include Infinity, some numbers and binary values mentioned above, and numerous fractions which are coerced to strings of 19 characters or less (1/7 is 19 characters, unlike 1/9 suggested above which is only 18), and the text representation of $ preceded or followed by a single-digit integer or itself.
  • Finally, all remaining operators and expressions: The member operator . requires an existing variable and a identifier referring to a property. All uses of this here result in undefined. Surrounding a value in ( ) returns the value, as does assigning it with =. Using () or `` to call a value as a function results in undefined or errors with all available values.

Adding all this up, there are a grand total of 1651 possible outputs when using a Chrome console. The longest outputs for one, two, and three characters are from $, $$, and $+$ respectively.


0

dc, 2+5+18=25 bytes

1: Ff yields (Try it online!):

15

2: Fdf yields (Try it online!):

15
15

3: Fd^f yields (Try it online!)

437893890380859375

None of which are particularly interesting, but dc isn't really great for spitting out piles of output. I do like that each answer builds on the previous. Anyway, F is just the number 15; f prints the entire stack; d duplicates top-of-stack; ^ raises next-to-top-of-stack to the power of top-of-stack (in this case, 15^15). I don't believe this can be topped in dc.


0

Ruby, 3+14+28 = 45 bytes

Why did I do this.

p

Prints nil.

$>

Prints #<IO:<STDOUT>>.

dup

Prints something along the lines of #<Object:0x0000000003610988>.

irb

Launches an instance of Interactive Ruby. Upon exiting, the returned object is #<IRB::Irb: @context=#<IRB::Context:0x0000000003643040>, @signal_status=:IN_EVAL, @scanner=#<RubyLex:0x00000000038900a0>> for 121, but since it requires you to press ^D or something to actually exit the irb instance, I wasn't sure if it'd actually count as a solution in "3 bytes" so I'm not actually including it in the score unless it gets an OK.


0

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

e
-e
e*e
  1. e outputs e to 15 decimal places
  2. -e outputs e to 15 decimal places
  3. e*e outputs e2, but oddly, it gives one more decimal place

0

Runic Enchantments, 4,000,000 bytes of output

The first program is:

a@

Takes 2 bytes to: push a value to the stack, print a value from the stack, and terminate. In this case it prints 10 (though any integer value from 0 to 16 are also just as valid)

For 3 bytes:

aY@

Prints 10000, Again, a could be 1 through 16 inclusive (in order to generate more output than the original program, 0 is potentially valid under other operators) and there aren't a whole lot of operators that take a single input and produce any output, much less longer output. XCYZ:E are the only real options. aY@ is just the one that results in the most output.

P$!;

According to language specification, this runs infinitely. However as the interpreter has a built in "ok, that's enough" maximum execution limit, this is the most output achievable in 4 characters (and TIO cuts off execution after ~130,000 bytes for exceeding 128kib) and as the interpreter defines the language, this works. And while I have raised that threshold once before (from 10k steps to 1 million), I don't plan on messing with it any time soon.

Bigger?

If I invoke the three assumptions I made here, then sure.

`AA@

Which works out to Ack(65,Ack(65,64)), which aren't terribly large values to go shoving into the Ackerman function initially--certainly smaller than the 255 in the older post--but its ok, we can call Ack twice in 4 instructions.

And only god knows what it'll print.

Note: the A instruction has since then been made the Math meta-instruction, which consumes 3 objects on the stack: a char for what instruction to perform and then two inputs, x and y. As such this program doesn't actually do anything, both because neither A nor @ map to a math function and because two subsequent calls results in a stack underflow.

En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.