148
\$\begingroup\$

Your task, if you wish to accept it, is to write a program that outputs a positive integer (higher than 0). The tricky part is that if I duplicate your source code, the output must be double the original integer.

Rules

  • You must build a full program. That is, your output has to be printed to STDOUT.

  • The initial source must be at least 1 byte long.

  • Both the integers must be in base 10 (outputting them in any other base or with scientific notation is forbidden).

  • Your program must not take input (or have an unused, empty input).

  • Outputting the integers with trailing / leading spaces is allowed.

  • You may not assume a newline between copies of your source.

  • This is , so the shortest (original) code in each language wins!

  • Default Loopholes apply.

Example

Let's say your source code is ABC and its corresponding output is 4. If I write ABCABC instead and run it, the output must be 8.

Leaderboard

This uses uses @manatwork's layout.

/* Configuration */

var QUESTION_ID = 132558; // Obtain this from the url
// It will be like https://XYZ.stackexchange.com/questions/QUESTION_ID/... on any question page
var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe";
var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk";
var OVERRIDE_USER = 8349457; // This should be the user ID of the challenge author.

/* App */

var answers = [], answers_hash, answer_ids, answer_page = 1, more_answers = true, comment_page;

function answersUrl(index) {
  return "https://api.stackexchange.com/2.2/questions/" +  QUESTION_ID + "/answers?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + ANSWER_FILTER;
}

function commentUrl(index, answers) {
  return "https://api.stackexchange.com/2.2/answers/" + answers.join(';') + "/comments?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + COMMENT_FILTER;
}

function getAnswers() {
  jQuery.ajax({
    url: answersUrl(answer_page++),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function (data) {
      answers.push.apply(answers, data.items);
      answers_hash = [];
      answer_ids = [];
      data.items.forEach(function(a) {
        a.comments = [];
        var id = +a.share_link.match(/\d+/);
        answer_ids.push(id);
        answers_hash[id] = a;
      });
      if (!data.has_more) more_answers = false;
      comment_page = 1;
      getComments();
    }
  });
}

function getComments() {
  jQuery.ajax({
    url: commentUrl(comment_page++, answer_ids),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function (data) {
      data.items.forEach(function(c) {
        if (c.owner.user_id === OVERRIDE_USER)
          answers_hash[c.post_id].comments.push(c);
      });
      if (data.has_more) getComments();
      else if (more_answers) getAnswers();
      else process();
    }
  });  
}

getAnswers();

var SCORE_REG = /<h\d>\s*([^\n,]*[^\s,]),.*?(-?\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/;

var OVERRIDE_REG = /^Override\s*header:\s*/i;

function getAuthorName(a) {
  return a.owner.display_name;
}

function process() {
  var valid = [];
  
  answers.forEach(function(a) {
    var body = a.body;
    a.comments.forEach(function(c) {
      if(OVERRIDE_REG.test(c.body))
        body = '<h1>' + c.body.replace(OVERRIDE_REG, '') + '</h1>';
    });
    
    var match = body.match(SCORE_REG);
    if (match)
      valid.push({
        user: getAuthorName(a),
        size: +match[2],
        language: match[1],
        link: a.share_link,
      });
    
  });
  
  valid.sort(function (a, b) {
    var aB = a.size,
        bB = b.size;
    return aB - bB
  });

  var languages = {};
  var place = 1;
  var lastSize = null;
  var lastPlace = 1;
  valid.forEach(function (a) {
    if (a.size != lastSize)
      lastPlace = place;
    lastSize = a.size;
    ++place;
    
    var answer = jQuery("#answer-template").html();
    answer = answer.replace("{{PLACE}}", lastPlace + ".")
                   .replace("{{NAME}}", a.user)
                   .replace("{{LANGUAGE}}", a.language)
                   .replace("{{SIZE}}", a.size)
                   .replace("{{LINK}}", a.link);
    answer = jQuery(answer);
    jQuery("#answers").append(answer);

    var lang = a.language;
    if (! /<a/.test(lang)) lang = '<i>' + lang + '</i>';
    lang = jQuery(lang).text().toLowerCase();

    languages[lang] = languages[lang] || {lang: a.language, user: a.user, size: a.size, link: a.link, uniq: lang};
  });

  var langs = [];
  for (var lang in languages)
    if (languages.hasOwnProperty(lang))
      langs.push(languages[lang]);

  langs.sort(function (a, b) {
    if (a.uniq > b.uniq) return 1;
    if (a.uniq < b.uniq) return -1;
    return 0;
  });

  for (var i = 0; i < langs.length; ++i)
  {
    var language = jQuery("#language-template").html();
    var lang = langs[i];
    language = language.replace("{{LANGUAGE}}", lang.lang)
                       .replace("{{NAME}}", lang.user)
                       .replace("{{SIZE}}", lang.size)
                       .replace("{{LINK}}", lang.link);
    language = jQuery(language);
    jQuery("#languages").append(language);
  }

}
body { text-align: left !important}

#answer-list {
  padding: 10px;
  width: 290px;
  float: left;
}

#language-list {
  padding: 10px;
  width: 290px;
  float: left;
}

table thead {
  font-weight: bold;
}

table td {
  padding: 5px;
}
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/Sites/codegolf/all.css?v=617d0685f6f3">
<div id="answer-list">
  <h2>Leaderboard</h2>
  <table class="answer-list">
    <thead>
      <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr>
    </thead>
    <tbody id="answers">

    </tbody>
  </table>
</div>
<div id="language-list">
  <h2>Winners by Language</h2>
  <table class="language-list">
    <thead>
      <tr><td>Language</td><td>User</td><td>Score</td></tr>
    </thead>
    <tbody id="languages">

    </tbody>
  </table>
</div>
<table style="display: none">
  <tbody id="answer-template">
    <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td><a href="{{LINK}}">{{SIZE}}</a></td></tr>
  </tbody>
</table>
<table style="display: none">
  <tbody id="language-template">
    <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td><a href="{{LINK}}">{{SIZE}}</a></td></tr>
  </tbody>
</table>

\$\endgroup\$
32
  • 2
    \$\begingroup\$ @Mr.Xcoder Then I'll just have to include one in my own source. \$\endgroup\$
    – steenbergh
    Jul 15, 2017 at 17:55
  • 3
    \$\begingroup\$ @Mr.Xcoder I think that you should have prevented reading your own source code. \$\endgroup\$ Jul 15, 2017 at 18:09
  • 2
    \$\begingroup\$ It only needs to work when doubled once? We don't need to support n many doublings? \$\endgroup\$
    – Cody Gray
    Jul 16, 2017 at 8:36
  • 7
    \$\begingroup\$ @Daniel Let's say your source is `` (empty program) and it produces 5. If you double it, your source is `` (empty program) and that produces 5 as well, no matter what you do. That being said, an empty program duplicated is still the empty program, and always produces the same output, except for the case where the empty program means something else (a random number generator, for example), which could not be valid anyway. \$\endgroup\$
    – Mr. Xcoder
    Jul 17, 2017 at 9:11
  • 1
    \$\begingroup\$ This shouldn't be hard for esolangs that automatically dump the top of stack upon program termination. \$\endgroup\$
    – MD XF
    Jul 18, 2017 at 22:26

154 Answers 154

2
\$\begingroup\$

Bash + coreutils, 43 bytes

x=$(history|cut -c 8-|tail -1);echo ${#x};#

Explanation

Outputs the length of the last command entered. Uses the same concept as the Python and PHP solutions to prevent execution of any further copies (finishes with a comment marker, so anything after it is ignored). Length of the command will be doubled when it is written twice, hence the output.

\$\endgroup\$
6
  • \$\begingroup\$ Can't you simplify this to echo ${#0};#? \$\endgroup\$
    – Neil
    Jul 15, 2017 at 19:12
  • 1
    \$\begingroup\$ i dont know about the above comment, but tail -n 1 can be shortened to tail -1 \$\endgroup\$
    – phil294
    Jul 15, 2017 at 20:00
  • \$\begingroup\$ @Neil I tried that but echo ${#0};# outputs 4 and echo ${#0};#echo ${#0};# also outputs 4 \$\endgroup\$
    – Darren H
    Jul 15, 2017 at 20:44
  • \$\begingroup\$ @Blauhirn nicely spotted, thank you \$\endgroup\$
    – Darren H
    Jul 15, 2017 at 20:44
  • 1
    \$\begingroup\$ @Neil That would output the filename next to the count. You need to use a pipe like wc -c <$0 # \$\endgroup\$
    – Richard
    Jul 17, 2017 at 14:35
2
\$\begingroup\$

Julia 0.6, 41 bytes

My first two ideas were already done in python answers (check file length, use a finalizer on an object). So here I check if π is an integer to gate the code that sets π=1 and registers the print to occur on exit. Then just double π each time.

π%1>0?(π=1;atexit(()->show(π))):π*=2;

Try it online!

Try twice it online!

\$\endgroup\$
2
  • \$\begingroup\$ π>3 instead of π%1>0 works too \$\endgroup\$
    – MarcMush
    Mar 4, 2021 at 10:26
  • \$\begingroup\$ as well as π=2 instead of π*=2 \$\endgroup\$
    – MarcMush
    Mar 4, 2021 at 10:27
2
\$\begingroup\$

Julia 0.6, 24 bytes

Riffing off of lungj's Python 3 answer. This works on my terminal on my mac, but not on TIO. The \r should reset back to the start of the line, so it always overwrites the previous output. Uses string interpolation with $ to execute π=2π÷1 which doubles π and uses integer division to round it to an integer. It does output "WARNING: imported binding for π overwritten in module Main" as well, but thats not an error, and is pretty close to a compiler warning.

print("\r$(π=2π÷1)");

Try it online!

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

Wumpus, 6 bytes

$@1$O+

Try it online!

Doubled:

$@1$O+$@1$O+

Try it online!

The first program pushes 1, adds the top two items on the stack (the 1 and an implicit 0), reflects off the end of the line, outputs and exits.

The second program does the same, except it adds two 1s to the stack, meaning it prints 2 and exits. This works for any number from 1-9.

A shorter solution may exist that takes advantage of two lines making the pointer bounce differently.

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

///, 20 bytes

Prints 1:

/\\1\//\/1\/2\/\//\1

Try it online!

Duplicated prints 2:

/\\1\//\/1\/2\/\//\1/\\1\//\/1\/2\/\//\1

Try it online!

How it works

  • The initial substitution /\\1\//\/1\/2\/\// (in both versions) searches for the string \1/ in the remainder and replaces it by /1/2//.
  • In the single program there is no such string, and nothing is replaced. The program is now reduced to the final \1, which prints a 1.
  • In the duplicated program \1/ crosses the boundary between the copies.
    • After substituting, the remaining program becomes /1/2//\\1\//\/1\/2\/\//\1, which is the substitution /1/2/ followed by the single program.
    • This substitution then replaces every 1 in the single program by 2, giving /\\2\//\/2\/2\/\//\2.
    • This then runs pretty much like the single program does, except for printing 2 instead of 1.
  • The normally redundant \ before the final 1, and the corresponding \\ in the initial substitution, are needed because without them, the substitution would be applied again to the /1/2/ result, causing an infinite loop.
\$\endgroup\$
1
  • \$\begingroup\$ Was just thinking about doing a /// submission, but it looks like you beat me to it! \$\endgroup\$ Feb 12, 2018 at 4:17
2
\$\begingroup\$

Momema, 12 bytes

00 1+1*1-8*1

Try it online! This outputs 1.

Try it doubled! This outputs 02.

Explanation

The ungolfed form of the singular program 00 1+1*1-8*1 is

0   0     # set the 0th cell to 0 (this has no effect).
1   +1*1  # set the 1st cell (initialized to 0) to itself plus one (i.e. 1).
-8  *1    # output the value of the first cell as a decimal (1).

The ungolfed version of the doubled program 00 1+1*1-8*100 1+1*1-8*1 is

0   0     # set the 0th cell to 0.
1   +1*1  # increment the 1st cell.
-8  *100  # output the value of the 100th cell (0).
1   +1*1  # increment the 1st cell.
-8  *1    # output the value of the 1st cell (2).

This submission hinges on Momema's syntax: in particular, it allows leading 0s in a numeric literal to be parsed as separate numbers. This allows the leading 00 in the program to be parsed as a pointless assignment statement.

When the program is doubled, however, the 0s are no longer leading a numeric literal—they are a continuation of the literal 1 at the end of the program, forming 100.

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

Labyrinth, 8 5 bytes

-3 bytes thanks to @MartinEnder

Single version

^)!@

Try it online!

Double version

^)!@
^)!@

Try it online!

\$\endgroup\$
1
  • \$\begingroup\$ Nice work, this is a really neat solution! :) I got curious and set a brute force solution on this problem and it found a whole bunch of 5-byte solutions (all of which print 1 and 2, some of them with leading zeros). Feel free to add any of them to your answer pastebin.com/RRFxZEuN (I don't care about posting them myself, since you clearly put more effort into your 8-byte solution than I did into just brute forcing the optimal ones.) \$\endgroup\$ Feb 18, 2018 at 16:55
2
\$\begingroup\$

Rust, 81 bytes

mod x{pub const Y:i8=1;}use x::*;fn main(){print!("{}",Y)}/*
const Y:i8=2;// *///

Doubled:

mod x{pub const Y:i8=1;}use x::*;fn main(){print!("{}",Y)}/*
const Y:i8=2;// *///mod x{pub const Y:i8=1;}use x::*;fn main(){print!("{}",Y)}/*
const Y:i8=2;// *///

Rust pretty much doesn't allow duplicate items in a source code. For instance, following code causes an error due to an item defined multiple times.

const Y: i32 = 2;
const Y: i32 = 2;

There are three exceptions to this rule.

  • Macros - which are pretty much useless, as macros don't follow the usual visibility rules - code cannot refer to a macro later in the code.
  • Wildcard imports - if there is a non-wildcard import, it has precedence while resolving item references. This is to help avoid incompatibilities caused by other crates (including std itself) adding more public items.
  • Overriding a builtin item or item from prelude - see bonus below, this way turned out to be longer, but also has more potential for improvements.

I decided to go with duplicating an item by using a glob import. This necessiated making a module.

mod x { ... }

That had a public item in it. Not public items aren't accessible outside of module that defined them. i8 type was chosen because it's the shortest integer type -- a type needs to be declared for const items, this cannot be skipped.

A string literal wasn't used as &str is 2 bytes longer, and also quotes would be necessary, not saving bytes even with removal of "{}", from main function. Adding 6 bytes is not worth it for removing 5 bytes.

pub const Y: i8 = 1;

Later I glob import this constant. Note that the constant can be overridden by a different non-wildcard declaration.

use x::*;

And a function prints whatever value Y holds. Note that Y can be overridden by a non-wildcard declaration. This is important when doubling source code.

print! ends with an exclamation mark as it is a macro. As the first parameter is a formatting pattern, I cannot use an integer directly, instead I have to specify "{}", formatting pattern.

Missing semicolon at the end of block means that this block returns a value. This is fine, as main returns () (implicit, due to not specifying another return type), and print! macro returns () (as in, it doesn't have an useful return value).

fn main() {
    print!("{}", Y)
}

Later, I want there to be a second declaration of Y, but I don't want it come into play for the first pass, so I comment it out. There is a newline, so that a line comment that will be declared later won't skip over a constant declaration. There is a space after // as there is nested comments feature, otherwise Rust would see /* inside block comment and start a nested comment.

/*
const Y:i8=2;// */

At end, I put //, so that first line of code of code is skipped when the code is doubled. It involves items that cannot be defined multiple times.

//

The execution may conntinue from second line. If it does, value of Y used by main function will be different.

 const Y: i8 = 2;

A line comment is included so that closing block comment that was needed for first pass won't cause issues.

// *///

And that's it, a program that detect it being duplicated in Rust done in 81 characters. Thank you for reading this explanation.

Bonus (alternative way for possible improvements, 93 92 bytes)

Instead of using glob imports, it's possible to override one builtin items from either a builtin type or something imported from prelude.

fn main(){println!("{}",i8::max_value())}/*
enum i8{}impl i8{fn max_value()->u8{254}}// *///

However, this solution is currently longer than the solution above.

\$\endgroup\$
2
  • \$\begingroup\$ Same length (81 bytes), but I thought I'd share a slightly different version of your answer that uses #[test] instead: TIO. \$\endgroup\$
    – TehPers
    Aug 6, 2020 at 22:27
  • \$\begingroup\$ @TehPers I like the idea of using #[test], clever :). \$\endgroup\$ Aug 7, 2020 at 10:46
2
\$\begingroup\$

JavaScript (console), 30 bytes

[$^=1]+{valueOf:x=>alert(2-$)}

In console environments, we have the $ default global variable, which is two characters shorter than Map, which is the shortest in other environments.

The way this works:

  1. $ is coerced to a number, and has bitwise XOR applied to it, making it 1.
  2. The object at the end is part of an addition equation, so it is also coerced into a number, calling the valueOf function which alerts 2-$, which equals 1.

When the code is repeated, it looks like this:

[$^=1]+{valueOf:x=>alert(2-$)}[$^=1]+{valueOf:x=>alert(2-$)}

The first instance of the object now has a member operator attached, so instead of the object's valueOf being called, instead we have (object)[$^=1 /* 0 */ ], which is undefined. The first instance doesn't alert anything, but the second one does, and by now $ has been changed to 0 because $^=1 has run twice, so it alerts 2.

Or, for non-console environments, we can use Map instead of $ (34 bytes):

[Map^=1]+{valueOf:x=>alert(2-Map)}

Or, we could use...

JavaScript, 32 bytes

-0?alert(2)+'':[,a=alert(1)]=[1]

When not repeated:

When repeated:

-0?alert(2)+'':[,a=alert(1)]=[1]-0?alert(2)+'':[,a=alert(1)]=[1]

  • -0 is still false, so we go to [,a=alert(1)]=[1]-0?alert(2)+'':[,a=alert(1)]=[1]
  • [1]-0 returns 1 which is true, so we alert(2) and coerce the undefined result to a string by adding an empty string. This returns "undefined". a is still being set to the "undefined"[1] which is this case is the letter "n". Since "n" is a value, the default alert(1) isn't run.
\$\endgroup\$
1
  • \$\begingroup\$ Wow, this is brilliant. I learnt a lot! I don't get yet why Map or $ are coerced to the value 1, though. \$\endgroup\$ Sep 20, 2020 at 13:21
2
\$\begingroup\$

Ruby, 10 bytes

+1;a||=p 1

Try it online!

Try it online!Try it online!

Explanation:

  • Single version (+1;a||=p 1):
    • +1 is ignored
    • a is assigned to 1 (printing 1 in the process) because a was previously undefined
  • Double version (+1;a||=p 1+1;a||=p 1)
    • +1 is ignored
    • a is set to 1+1 (2) (printing 2 in the process) because a was undefined
    • The next part is not executed because a is already defined
\$\endgroup\$
2
\$\begingroup\$

CJam, 4 bytes

1]:+

Try it online!

Explanation:

1]:+

1    push 1 to stack
 ]:+ sum stack

CJam, 1 byte

)

Try it online!

I'd say this uses 2 bytes since there is a 0 in the header. I don't know if this is a valid loophole or forbidden.

\$\endgroup\$
1
  • \$\begingroup\$ The second one isn't valid since it doesn't work without the 0 \$\endgroup\$
    – Jo King
    Jan 19, 2019 at 4:16
2
\$\begingroup\$

Perl 5, 10 bytes

print-s$0#

Try it online!

Doubled, 20 bytes

print-s$0#print-s$0#

Try it online!

Inspired by Sriotchilism O'Zaic recursive comment approach (Nice work by the way).

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

Octave, 25 13 11 3 bytes

3;ans=fix(ans);ans=ans*2.

Try it online! Try it doubled!

Edit 1

Got rid of the fix

1;ans=3*ans-0

Try it online! Try it doubled!

Edit 2

Got rid of the *

3;ans=ans+0

Try it online! Try it doubled!

Edit 3

Got rid of ans ... 😅

3+0

Try it online! Try it doubled!

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

Google Sheets, 12

This answer is much shorter. But here's one for a "normal" = formula.

=LEN("&00001

Google Sheets auto-closes quotes and parens. This outputs 6 (the length of &000001). Here is the doubled version:

=LEN("&00001=LEN("&00001

This outputs 12 because &00001=LEN( is 11 characters, concatenated with 1 gives 12 characters.

\$\endgroup\$
2
  • 1
    \$\begingroup\$ Wow...Are you the person who's posting Google Sheets answers everywhere? They're pretty ingenious \$\endgroup\$
    – user
    Aug 6, 2020 at 18:48
  • 2
    \$\begingroup\$ @user Yeah, I guess I've been doing a lot of that lately, huh? I do find GS/Excel "programming" to be quite entertaining/hilarious. It's like a bit like a cult-classic movie. If someone else can get some enjoyment out of it, then I'm happy. \$\endgroup\$ Aug 6, 2020 at 19:08
2
\$\begingroup\$

BRASCA, 2 bytes

Original:

C}

Doubled:

C}C}

Try it!

Try it!Try it!

Explanation

Original:

C     - Sets implicit output to number mode
 }    - Increment top of stack (stack is infinite zeroes by default)

Doubled:

C     - Sets implicit output to number mode
 }    - Increment top of stack (stack is infinite zeroes by default)
  C   - Implicit output is already set to number mode, so it does nothing
   }  - Increment top of stack again
\$\endgroup\$
2
\$\begingroup\$

Zsh, 9 bytes

wc -l<<<x

Note there is no trailing newline.

Attempt This Online! (outputs 1)

Attempt This Online!Attempt This Online! (outputs 2)

Explanation:

  • wc: output word-count information:
    • -l: the number of lines in the input
  • <<<x: and input the single-line string x

ExplanationExplanation:

  • wc: output word-count information:
    • -l: the number of lines in the input
  • <<<xwc: and input the single-line string xwc
  • -l: redundant duplication of the previous -l option
  • <<<x: and input a second single-line string x

Zsh, 6 bytes

If output requirements followed standard rules, we could output via exit code for 6 bytes:

grep x

Again, no trailing newline.

  • grep x searches for x in the (empty) input, which has no results and outputs with status code 1
  • grep xgrep x searches for xgrep in the (non-existent) file x, which is an error and outputs with status code 2

Attempt This Online! (returns 1)

Attempt This Online!Attempt This Online! (returns 2)

There might be an even shorter option using exit codes.

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

Rust, 69 bytes

use std::u8::*;fn main(){print!("{}",MIN+1)}#[test]
const MIN:u8=1;//

Try it online

Try it online (doubled)

This follows the suggestion in Konrad's bonus solution to override a standard library item and uses #[test] instead to "disable" a declaration on the next line. It's not as short as this solution, but it doesn't require reading the source.

\$\endgroup\$
1
\$\begingroup\$

Pip, 2 bytes

+1

Try it online!

Try the double version!

\$\endgroup\$
1
\$\begingroup\$

Ohm, 2 bytes

Try it online!

Try the double version!

aaaaaaaaaaaaaaa i can't find a language where this is one byte aaaaaaaaaaaaaaa

\$\endgroup\$
2
  • \$\begingroup\$ What does the sigma do? \$\endgroup\$
    – Cyoce
    Jul 17, 2017 at 4:36
  • \$\begingroup\$ It sums an array or the stack depending on what type the TOS is \$\endgroup\$ Jul 17, 2017 at 11:59
1
\$\begingroup\$

QBIC, 12 bytes

p=p+q┘Z=!p$┘

Explanation

p=p+q        Adds 1 to p (q = 1 in QBIC, and p starts out as 0)
┘            (Syntactic linebreak)
Z=!p$        Set Z$ to a string representation of p.
┘            (Syntactic linebreak)       

At the end of a QBIC program, if Z$<> "" it gets printed. So when running this code once, p gets increased by 1, the result is saved in Z$, the program ends and we print 1. By running it twice, Z$ will get overridden on the second iteration by p, which is now 2.

\$\endgroup\$
1
\$\begingroup\$

Vim, 5 bytes

i0<esc><C-a>:

Since V is backwards compatible, you can Try it online! or Try it doubled!

\$\endgroup\$
1
  • \$\begingroup\$ Seemed doubled version outputs 1, not 2; did I missee the result? \$\endgroup\$
    – user100411
    May 4, 2021 at 6:44
1
\$\begingroup\$

LOGO, 16 bytes

 ct pr bf gensym

output 1.

When doubled, it becomes

 ct pr bf gensym ct pr bf gensym

output 2.

Explanation:

  • ClearText clears all the output.
  • Print just print whatever it is given.
  • ButFirst return the input with the first item removed.
  • GenSym (perhaps GenerateSymbol) return g1 the first time it is invoked, g2 the second time, etc.

Because the output of GenSym depends on previous outputs, the interpreter should be reset between runs.

\$\endgroup\$
1
\$\begingroup\$

JavaScript (Node.js), 60 bytes

console.log(require('fs').readFileSync(__filename).length)//

Inspired by this Python 2 answer, this reads the length of the current file and prints it, preventing any duplicates of this code from being executed with the trailing comment.

Try it online!

Try it online doubled!

\$\endgroup\$
1
\$\begingroup\$

BlitzMax, 13 bytes

Print..
+1..'

No trailing newline.

Newlines act as statement terminators in BlitzMax unless prevented by a ... The ' symbol introduces a line comment. So if run as-is, the program outputs the result of the expression +1, which is 1. If doubled, the second Print is commented out and the program outputs the result of +1+1, which is 2. If you double the program a second time, you get 4, etc.

\$\endgroup\$
1
\$\begingroup\$

Ohm, 3 bytes

Original:

0Wl

Duplicated:

0Wl0Wl

Owles?

Explanation

0Wl    Main wire
0      Push 0
 W     Wrap in an array
  l    Push Length (1)
0Wl0Wl
0Wl    Push 1 ^
   0   Push another 0
    W  Wrap in an array ([0,1])
     l Push the length (2)

Try it online!
Try it online!Try it online!

\$\endgroup\$
1
\$\begingroup\$

JavaScript, 41 chars

clearTimeout(1);x=setTimeout('alert(x)');

clearTimeout(1);x=setTimeout('alert(x)');clearTimeout(1);x=setTimeout('alert(x)');

\$\endgroup\$
2
  • \$\begingroup\$ Shows 3 and 4 for me using the Run code snippet button \$\endgroup\$
    – FliiFe
    Jul 18, 2017 at 20:07
  • \$\begingroup\$ @FliiFe, try in incognito window with all browser extensions disabled. \$\endgroup\$
    – Qwertiy
    Jul 18, 2017 at 20:54
1
\$\begingroup\$

><>, 9 bytes

l";3"+10p

Try it online!

Explanation

l";3"+10p
l              | Push the length of the stack to the stack; STACK[0]
 ";3"          | Push 59 and 51 to the stack;               STACK[0, 59, 51]
     +         | Add the stack top 2 items;                 STACK[0, 110]
      10p      | At codebox[0,1] put the stack top item;    STACK[0]
                   NEW CODEBOX; ln;3"+10p
ln;            | Push length, print stack top and end;

When doubled we run through the code twice, it edits the print function in the same spot but doubles the amount of items we push to the stack.

><>, 18 bytes Doubled version

l";3"+10pl";3"+10p

Try it online!

\$\endgroup\$
1
\$\begingroup\$

Bash 35 bytes

trap 'echo $a' 0
a=$((2**${a:-1}))

single source output:

2

double source output:

4

This uses bash default value parameter expansion to set a to either 1 or the result of 2^a. An exit trap is defined that will print the current value of a, so each additional copy of the source will double the output.

\$\endgroup\$
1
\$\begingroup\$

Python 3, 62 60 bytes

This time, back to stdout and no cheating.

class X:
 def __del__(s):print(y)
try:y*=2
except:y=1;z=X()

Saved 2 bytes thanks to @OldBunny2800!

\$\endgroup\$
5
  • \$\begingroup\$ Can't you remove the newline/indent in front of class? \$\endgroup\$
    – AAM111
    Jul 25, 2017 at 13:28
  • \$\begingroup\$ There shouldn't be one in front of class; do you mean the def? I think that's necessary. I don't know how to put method definition on the same line as the class definition. \$\endgroup\$
    – lungj
    Jul 25, 2017 at 13:32
  • \$\begingroup\$ I mean, would class X():def __del__(s):print(y) work? \$\endgroup\$
    – AAM111
    Jul 25, 2017 at 13:33
  • \$\begingroup\$ Also, don't think you need parentheses after a class declaration. \$\endgroup\$
    – AAM111
    Jul 25, 2017 at 13:34
  • \$\begingroup\$ The one liner does not work on Python 3.6.0 on macOS installed via homebrew, but it's possible works on some other Python 3. \$\endgroup\$
    – lungj
    Jul 25, 2017 at 13:35
1
\$\begingroup\$

Python 3, 48 bytes

Apparently, file I/O is acceptable as an output format.

try:y*=2
except:y=1
open('x','w').write(str(y))

The 48th character is a new-line character at the end of this program.

\$\endgroup\$

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.