118
\$\begingroup\$

It looks like we have a consensus that we want certain defaults for the format which answers are expected in for . 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.

Update

The current results of the polls are now part of the tag wiki. Please notify me, if results change significantly and the wiki should be amended.

\$\endgroup\$
2
  • \$\begingroup\$ Related (Can numeric input/output be in the form of byte values) \$\endgroup\$
    – mbomb007
    Dec 13, 2016 at 16:10
  • 5
    \$\begingroup\$ "The current results of the polls are now part of the tag wiki" which tag wiki? meta wiki has nothing for code-golf tag. ppcg wiki has codegolf.stackexchange.com/tags/code-golf/info but it's missing a lot of answers here. \$\endgroup\$
    – Sparr
    Jul 18, 2018 at 18:17

107 Answers 107

1 2 3
4
0
\$\begingroup\$

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

\$\endgroup\$
0
\$\begingroup\$

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

\$\endgroup\$
1
  • \$\begingroup\$ This would seem similar to the "Languages without input like /// may input through insertion into their source code" \$\endgroup\$ Jul 25, 2021 at 14:42
0
\$\begingroup\$

Output may have any number of leading white space.

There is already a suggestion concerning trailing blanks. This is about preceding blanks. Why should this be acceptable? Suppose you wanna to write a program in Pascal that prints the answer to the ultimate question of life, the universe, and everything. You’ll simply write

program p(output);begin writeLn(42)end.

However, when the destination is a text file (like output is), for numeric write arguments there’s an invisible implementation-defined default minimum-width specifier. Thus this program may print:

         42

i. e. the program is effectively doing a

writeLn(output, 42:11)

The :11 indicates the minimum number of characters the argument occupies (for numeric arguments, for char, string and Boolean it specifies the exact width). The default value is implementation-defined thus different compilers may have different default values, possibly even 1. If leading white space is prohibited you’ll have to write :1 yourself.

Ultimately, like trailing blanks it does not inhibit legibility. Specifically for many numbers it actually improves legibility, that’s why Pascal allows and some compilers do have a reasonably large default minimum-width.

\$\endgroup\$
-2
\$\begingroup\$

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

\$\endgroup\$
8
  • \$\begingroup\$ Well, cryptographic random values can still be generated in Turing tarpits. \$\endgroup\$
    – Nissa
    Dec 5, 2017 at 18:29
  • 1
    \$\begingroup\$ @StephenLeppik I was thinking more of completely deterministic languages where you would need the random seed for any subsequent random values. \$\endgroup\$
    – Οurous
    Dec 5, 2017 at 18:49
  • \$\begingroup\$ I don't like this idea (it's related to this meta. Accessing system information can require quite some bytes (maybe an import and/or system calls with long function names). Taking just another input variable instead is an unfair advantage. We always had challenges which cannot be solved with all languages (e.g. graphical output), but most can, so it's not a problem. \$\endgroup\$
    – nimi
    Dec 6, 2017 at 23:03
  • 4
    \$\begingroup\$ @nimi This isn't for those languages that can access system information/resources only in an expensive manner. This proposal is for languages (like brainfuck) that have no way to access that information/those resources. Because BF has no source of randomness, this proposal would allow BF to take a seed value as an additional input to be fed into a PRNG. \$\endgroup\$
    – user45941
    Dec 12, 2017 at 6:19
  • \$\begingroup\$ @Mego: yes, I know, maybe I wasn't clear enough. My point is: getting some system information via additional input is usually much cheaper (in bytes) than having to call some system library functions. Some languages would be allowed to use the former, others not, although both compete within the same challenge. That's unfair. ... \$\endgroup\$
    – nimi
    Dec 12, 2017 at 14:36
  • 3
    \$\begingroup\$ @Mego: (cont.) Stupid example to illustrate the point: challenge: output the system time. Fictional stack based esolang #1: St (system call "time" + implicit print -> 2 bytes). Fictional stack based esolang #2: No systems calls available, therefore the time is expected as input on top of the stack + implicit print -> 0 bytes). #2 wins, because #1 has to use the system calls. Same example for non-esolangs: import Time;f=print(system_time()) vs. f(x)=print(x). \$\endgroup\$
    – nimi
    Dec 12, 2017 at 14:36
  • 1
    \$\begingroup\$ @nimi That falls afoul of this loophole. \$\endgroup\$
    – user45941
    Dec 12, 2017 at 14:38
  • \$\begingroup\$ @Mego: True for my mini example. However, the advantage for #2 remains even if the task is more complicated. \$\endgroup\$
    – nimi
    Dec 12, 2017 at 14:44
-2
\$\begingroup\$

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

This usually apply to open-ended questions if possible

\$\endgroup\$
1
  • 5
    \$\begingroup\$ I'm not sure I understand this proposal (and given the lack of votes, I don't think anyone else does either) \$\endgroup\$
    – Jo King Mod
    Apr 7 at 13:22
-3
\$\begingroup\$

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.

\$\endgroup\$
2
  • 2
    \$\begingroup\$ This has my vote \$\endgroup\$
    – TheDoctor
    Nov 4, 2014 at 23:40
  • 66
    \$\begingroup\$ I don't think this should be a default. Definitely fine if asker specifies it as a valid input format for the question! Excited to see your upcoming challenge involving this. \$\endgroup\$
    – hmatt1
    Nov 5, 2014 at 2:12
-3
\$\begingroup\$

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';
\$\endgroup\$
-3
\$\begingroup\$

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.

\$\endgroup\$
1
  • 3
    \$\begingroup\$ I'm going to say no, because this is equivalent to taking input from a pre-defined name in e.g. Bash \$\endgroup\$
    – pxeger
    Jan 5, 2021 at 20:42
-4
\$\begingroup\$

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!';");
\$\endgroup\$
2
  • \$\begingroup\$ Just for clarification, this only applies in challenges that allow snippets, correct? I don't think you're suggesting we allow snippets by default, but just to be safe... \$\endgroup\$ Feb 11, 2017 at 2:22
  • \$\begingroup\$ @ETHproductions Rewrote to avoid mentioning that. \$\endgroup\$
    – jimmy23013
    Feb 12, 2017 at 2:41
-4
\$\begingroup\$

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.

\$\endgroup\$
4
  • 4
    \$\begingroup\$ I don't think it's necessary to allow things that are "Kind of like functions" just because a language doesn't have functions. As long as an answer can be written as a full program using existing allowed I/O I don't think we need a special exception to allow answers in "function-like behavior". \$\endgroup\$ Oct 27, 2017 at 19:26
  • \$\begingroup\$ Then why do we allow the same thing in "assembly" languages? \$\endgroup\$
    – 12Me21
    Oct 27, 2017 at 19:53
  • 3
    \$\begingroup\$ Answers talking about "Assembly" refer to any language which does not have an output other than storing things in a special register. If a program can be written in the language which inputs and outputs in a more standard way then it doesn't need those allowances. \$\endgroup\$ Oct 27, 2017 at 20:07
  • \$\begingroup\$ Registers in assembly language are analogous to local vars and temporaries (like a return-value object) in languages like C. Languages that don't have locals or return-values don't have anything like registers. I didn't downvote, though; if the language has a gosub and real-world (non-golf) usage does write "functions" this way, there's certainly an argument to be made. The justification by analogy with asm is pretty weak, though. In asm you need registers just to evaluate expressions, and there are only a small fixed number of them. \$\endgroup\$ Oct 8, 2019 at 18:17
-4
\$\begingroup\$

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;}
\$\endgroup\$
3
  • \$\begingroup\$ I used this method on a challenge but never seen before, no one complained but since I was not sure I searched here in the Meta.. The only similar answer was the one linked, the title mentioned "write to out arguments" but here we don't use out argument but out global variable \$\endgroup\$
    – AZTECCO
    Nov 17, 2021 at 7:51
  • \$\begingroup\$ I'm not a fan of this. I think it's basically becoming a snippet format, and I don't really feel like a case for this has been made here. \$\endgroup\$
    – Wheat Wizard Mod
    Nov 17, 2021 at 16:21
  • \$\begingroup\$ @Grain Ghost thanks, I'm not sure too, I would probably downvote this, that's why I posted it, I think it's good to clearly define if it is acceptable or not before it become used. As for now there are only 2 answers using this I'm aware of(one is mine). I'll correct mine and warn the other in a couple of days \$\endgroup\$
    – AZTECCO
    Nov 17, 2021 at 17:19
-4
\$\begingroup\$

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

\$\endgroup\$
4
  • \$\begingroup\$ Interesting. I'd be curious to see the reasoning for these downvotes \$\endgroup\$ Jan 12 at 15:15
  • 3
    \$\begingroup\$ I think its because this becomes more of a snippet format \$\endgroup\$
    – Seggan
    Jul 7 at 17:14
  • \$\begingroup\$ This is already listed here. \$\endgroup\$
    – Steffan
    Aug 28 at 3:14
  • \$\begingroup\$ @Steffan it is not, read the titles of both very closely \$\endgroup\$ Aug 28 at 16:34
-6
\$\begingroup\$

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.

\$\endgroup\$
3
  • 7
    \$\begingroup\$ This would definitely cause problems for decision problem challenges if you could just return [True, False] no matter the input. \$\endgroup\$
    – xnor
    May 13, 2021 at 11:00
  • 5
    \$\begingroup\$ Suggest editing this to “as long as a specified one of them is the requested output”. \$\endgroup\$ Jun 9, 2021 at 2:56
  • 1
    \$\begingroup\$ Anders Kaseorg's suggestion makes a lot of sense - it allows people to output extraneous information without cheating on questions. \$\endgroup\$
    – user
    Jun 25, 2021 at 20:16
-8
\$\begingroup\$

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

\$\endgroup\$
2
  • \$\begingroup\$ this seems to be a special case of "functions may use out parameters" \$\endgroup\$
    – Jasen
    Dec 22, 2016 at 10:55
  • \$\begingroup\$ but ps doesn't report it after the program ends :( \$\endgroup\$
    – Jasen
    Dec 22, 2016 at 11:01
-20
\$\begingroup\$

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.

\$\endgroup\$
4
  • 4
    \$\begingroup\$ Isn't the PHP example actually reading from STDIN? In which case, why shouldn't all of those bytes count? \$\endgroup\$ Nov 3, 2014 at 0:09
  • \$\begingroup\$ Depending on the way you handle it, if you read everything on STDIN at once, you can consider it a single input. I don't know if I'm making myself clear. But if your code is restricted to only 1 read to the STDIN, you can only consider the size in bytes of the name of the var. If multiple accesses are made (loops, conditions, partial reads...), everything is counted on the code. \$\endgroup\$ Nov 3, 2014 at 0:14
  • 1
    \$\begingroup\$ @MartinBüttner He's referring to the fact that different languages have different character counts for an STDIN read. Also, shouldn't this be CW? \$\endgroup\$
    – TheDoctor
    Nov 4, 2014 at 23:42
  • 3
    \$\begingroup\$ @TheDoctor Doesn't matter anyway - no rep gain/loss for meta. \$\endgroup\$
    – user10766
    Nov 6, 2014 at 21:44
-30
\$\begingroup\$

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

\$\endgroup\$
4
  • 24
    \$\begingroup\$ This essentially makes the submission a snippet instead of a full program, which the other meta question decided should not be a valid default. \$\endgroup\$ Sep 11, 2015 at 18:25
  • \$\begingroup\$ @MartinBüttner Unless the programming language is, of course, a turing machine. (I do vote for placing the tape head at the return value) \$\endgroup\$
    – yyny
    Jan 31, 2016 at 0:41
  • 2
    \$\begingroup\$ In C#, a lambda is more a variable than a function. Lambdas are build on top of Delegates. Are they still valid? (By this, i think so) \$\endgroup\$
    – aloisdg
    Jul 6, 2016 at 20:32
  • 1
    \$\begingroup\$ In what way is this fundamentally different from the same rule about functions? Why is it allowed for functions and not for full programs? \$\endgroup\$
    – Kaddath
    May 5, 2021 at 15:04
-47
\$\begingroup\$

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

\$\endgroup\$
6
  • 7
    \$\begingroup\$ -1 (Can't vote) \$\endgroup\$ Mar 17, 2016 at 21:43
  • 1
    \$\begingroup\$ This just skips the "reading" step of a program. I don't think programs should be allowed to assume the output of an arbitrary computation, e.g. the one asked for in the question, is stored in a predefined variable either. \$\endgroup\$
    – djechlin
    Jun 6, 2016 at 18:11
  • 1
    \$\begingroup\$ @djechlin we are intentionally separating input/output methods. Outputting on variables is listed here: meta.codegolf.stackexchange.com/a/6965/20198 \$\endgroup\$ Jun 6, 2016 at 18:14
  • \$\begingroup\$ Okay, I still don't think you can skip the "reading" step of a program any more than you can skip the "writing" step of a program. That's all I'm trying to say. \$\endgroup\$
    – djechlin
    Jun 6, 2016 at 18:15
  • 2
    \$\begingroup\$ I'm confused what you are talking about. Programs have input and output. We define valid input methods (such as reading from a file, or parameters to a function), and valid output methods (writing to a file, or return values). This post is directly targeted at input methods. There is another answer on this question targeted at output methods. We split them so people can vote separately. \$\endgroup\$ Jun 6, 2016 at 18:18
  • 2
    \$\begingroup\$ This is most relevant to the Sinclair ZX80 and ZX81 BASIC. \$\endgroup\$ Apr 4, 2017 at 9:04
1 2 3
4

You must log in to answer this question.

Not the answer you're looking for? Browse other questions tagged .