Default for Code Golf: Input/Output methods

Question

It looks like we have a consensus that we want certain defaults for the format which answers are expected in for code-golf. On that poll, the question arose twice, which input/output formats should be allowed for programs and functions.

So here is another poll. This one works different though. All the input/output methods are independent of each other, so there will be one answer per method. Upvote all you think are reasonable for the default. Downvote those which you think shouldn't be allowed unless the OP explicitly permits them.

To keep this remotely manageable, I have not posted individual answers for all possible inputs for functions. So there are only four: functions can take input/output via their arguments and return values. Or functions can use any method full programs can. I don't think there is any point in (say) allowing programs to take input from STDIN (only) and to allow functions to take input from ARGV (only) or something like that. If you disagree, please leave a comment.

If I've overlooked an I/O method, feel free to add your own answer.

Note: Some votes have been reverted because they were detected as serial voting. If you vote on multiple answers, please leave some time between votes.

A method is allowed if it has 5 net votes and at least twice as many upvotes as downvotes.

---

Return to FAQ index

Answer 1

Functions may take input from the output of a callback function

The callback function should be provided using a valid input method.

Complementing

• Functions may return a function that returns the result (outputted function may output)
• Functions may take multiple arguments via currying (outputted function may take input (and also output))
• Functions may output by calling a callback function or event (inputted function may receive output)

Answer 2

Languages that output on program completion can assume termination even when built to hang for the purpose of providing output.

That is, if a program is built to not a terminate, and requires output while running (say, for an Internal Truth Machine, or Scream Very Loudly, etc.), the program can assume to crash or be manually stopped to verify the output scales appropriately.

The argument for this is that several languages (such as Processing[Java], for example) will not print output unless a certain state is reached (the end of a Draw statement in Processing, per se). This means that programs stuck in While Loops would never provide any output. Languages like GolfScript, though it has a Print function, also doesn't actually Print the output until the program is complete - it holds the print in a buffer until the program eventually stops (for any reason, even interrupting). Likewise, GS prints the stack when it closes for any reason (depending on your interpreter; TIO fails at this) - so filling the stack with infinite As then waiting for a crash would also be within this parameter.

Several languages would otherwise fail infinitely-printing hanging challenges due to the act they wouldn't ever be capable of printing given the assumed infinite time and memory, which is the main argument for allowing this sort of output.

Answer 3

A 2d-list can be anything indexable by 2d-like-things

Many questions' inputs are a 2d-array or 2d-list of characters of numbers. I would consider all of the following python types (and equivalents in other languages) acceptable in meeting the spec.

list[list[T]]
list[dict[int, T]]
dict[int, list[T]]
dict[int, dict[int, T]]
dict[(int, int), T]
# numpy/scipy arrays
# iterables and generators are also okay
dict[complex, T]

The last one may be controversial, but with some handwaving, a complex number is like a pair of numbers. It's also borderline unobservable.

Answer 4

Functions may output by calling a callback function or event

The callback function should be provided using a valid input method.

Example in JavaScript that outputs Hello world!:

f=>f("Hello world!")

This may be shorter than returning a value in some languages:

import random as r
def f(x):
    q=r.random()
    return(q+q/2)/2

As opposed to:

import random as r
def f(x,g):
    q=r.random()
    g((q+q/2)/2)

Answer 5

Building off of Submissions may use list of strings instead of multi-line strings

Submissions may use an arbitrarily nested list of lists of strings to represent newline-separated chunks

Well I didn't explain it well so here's an example:

Say the challenge specifies

abc
def

ghi
jkl


lmnop
qrs

tuv
wxyz

This could instead be treated as [[[abc, def], [ghi, jkl]], [[lmnop, qrs], [tuv,wxyz]]]

Answer 6

Classes, objects or other entities may have separate methods to read the input and return the result

This includes the constructor and destructor.

Answer 7

Functions may output by setting the default variable(s)

Perl has a "default" scalar $_. Unless specifically overridden by the =~ operator, regular expressions and such will operate on this variable. It also has @_, the "default" array, and %_, the "default" hash.

Answer 8

Program may take one argument as one input and filename of another input

This allows "input two letters, concat them" in bash

cat $1; echo $1

Like Programs may take input based on their executable name, your filename should be possible to carry any possible input. If input may contain * and your filesystem doesn't support it, you can't use this method.

Answer 9

Cellular automata and 2d languages may output by interfacing with a user-built structure

Many of these languages do not have any other way to produce (non-visual) output. By "interfacing", I mean additional structures being created by the user to interact with the existing code in a way that the program provides only the necessary information (such as some sort of serial representation of the outputted values) in a way that could feasibly be used by the user's program to control another turing-complete automaton (so not in a tiny space in the middle of the program, or in an area that will be overwritten).

Answer 10

Cellular automata and 2d languages may take input by interfacing with a user-built structure

Many of these languages do not have any other way to take input. By "interfacing", I mean additional structures being created by the user to interact with the existing code in a way that provides only the necessary information (such as some sort of serial representation of the inputted values) in a way that could feasibly be used by the user's program and controlled by another turing-complete automaton (so not in a tiny space in the middle of the program, or in an area that will be overwritten).

Answer 11

Property setters may take input from the set value

Answer 12

Source files or libraries may output via the return value importing them

For example, this PHP code has no effects as a complete program:

<?php return 'Hello, world!';

But as a library named '1.php', the return value could be printed to stdout using this:

<?php echo include '1.php';

Answer 13

Programs may use the camera and microphone

I wouldn't expect to see this very often, but it could be applicable to my upcoming challenge.

Answer 14

Program may take input from environment variables

Environment variables are generally supported by many languages:

• C program may access environment variables from getenv
• Python program may access environment variables from os.environ
• etc.

Environment variables are typically a constant in program, which is quite different from a variable in languages.

Many real word software supports / suggests user config some options from environments. For example, docker docs, aws cli, even ls command ...

Environment variables are similar to function submissions which accept its arguments by name instead by position.

Answer 15

eval is considered an interpreter and the eval'd code may output via the return value

For example, this PHP code has no effects as a complete program in the php interpreter:

return 'Hello, world!';

But the return value is accessible using the eval interpreter:

<?php echo eval("return 'Hello, world!';");

Answer 16

Languages that cannot obtain world-state-sensitive information can accept the information as an additional input

Some challenges may require the use of the current time, cryptographic random values, or other information present on the system used to run the program. Additionally, many languages (for various reasons) lack the ability to access this information, and thus compete at all.

To overcome this, answers may accept such information as additional input in a minimally processed format (eg: unix timestamp instead of a date string, a single random value instead of a random generator function).

Answer 17

Functions may get input from predefined variables in languages where this is standard

In some BASIC dialects, the standard way to implement functions is to use GOSUB (similar to CALL in assembly). You can't pass variables to GOSUB, so function arguments/returns are just global variables. If you need a function that takes a number as input, and outputs that number multiplied by 2, the normal way to do this would be something like:

@TIMES2
 OUT=IN*2
RETURN

To call it, you would do

IN=7
GOSUB @TIMES2
'result is in variable OUT

The exact same process is allowed in assembly languages.

Answer 18

Languages that do have I/O capabilities may take input via hardcoding

i.e. you may insert input into the code directly, as if it were an output only language like ///

Answer 19

Programs may output only one copy as two intended ones if they're always same

This usually apply to open-ended questions if possible

Answer 20

You can have as many newlines after your output as you want.

It doesn’t matter what type of newline.

Answer 21

Submissions to decision-problem challenges may take no input and output a (potentially infinite) set of all possible truthy/falsey outputs.

If the challenge is "Is the number even or odd?", a submission could output a set of all even numbers (or, a set of all odd numbers).

If the challenge is "Is the number a fibonacci number?", a submission could output a set of all fibonacci numbers.

A few submissions in TypeScript’s type system have used this where the submission is a union type (like a set) and you get truthy/falsey by whether assigning a variable to the union throws an error or not. I don’t see why this wouldn’t be allowed in other languages as well.

Answer 22

Programs running under Unix may produce output by overwriting their command-line arguments, which changes what ps reports.

I'm posting this because it was brought up as a loophole in my answer to this question. I personally think it should not be allowed, because it's obscure, not available in all languages, and ephemeral (someone has to run ps while the program is still executing).

Answer 23

Functions may output by modifying a global variable

This is similar to Functions may output by modifying their arguments or writing to out arguments
The difference is that we don't pass any reference to the function, instead we declare a global variable the function is aware of and assigns the result to it.
Obviously the global variable declaration used must be included in the score.

For example a C function which was like this:

f(x,Type*r){... ;*r=result;}

May be

Type r;f(x){.... ;r=result;}

Answer 24

Functions may return multiple values, even if the question only asks for one.

As long as one of them is the requested output, the function is considered valid.

Answer 25

You may output with reasonable constant trailing and leading data

This does not apply to kolmogorov-complexity challenges.

For example, if you need to output 3, you can output __3__.

Answer 26

Dynamic creation of a "fake" STDIN, when one isn't present (creating also a separation between the code and the input).

For example, Javascript doesn't have STDIN(for obvious reasons).

One could make something like function(a){[code here]} and only count the content inside it + 1.

On php, one can read from STDIN using $f=fread(STDIN,1024); and this would count only as 2 chars.

On other languages, this would vary a bit.

Any questions, I may answer on the comments.

Answer 27

Output is saved in a certain variable at the time the program has finished execution

This eliminates the disadvantages languages like Java have when printing System.out.println("asdf")

For languages without variables this could be top of the stack etc...

Answer 28

Programs may take input by assuming it is stored in predefined variables.