text:
Splix.io - King of the land
You are an enterprising dot who wants to increase the land under its control. This is quite simple - travel outside your current land and loop back into your land and everything in that loop is now owned by you. But there is a catch. If some other dot somehow finds your loop and crosses it, you die.
If you haven't already tried it, go to Splix.io and try a game. Use the arrow keys to control your movement.
GIF

Credit: http://splix.io/
Specifics
All players start at random positions on a 200x200 board. (I reserve the right to change this :). You will have a certain amount of moves to amass the greatest number of points possible. Points are tallied by:

The number of players you have killed times 300
The amount of land you own at the end of the round

This brings up the point that others can steal your land. If they start a loop that intersects some of your land, they can claim it. If you die during the round, you lose all points for that round.
Each round has a randomly selected group of players (max 5 unique players) (subject to change). Every player participates in an equal number of rounds. Your bot's final score is determined by its average per-game score. Each game consists of 2000 turns (also subject to change). All bots make their moves at the same time.
Death Cases
Head Butt

Both players die when they head butt each other. This is still true even when both players are at the edge of their space.

However, when only one of the players is in his land, the other player dies.

Line Cross

In this case, only the purple player dies.
You can't cross your own line.

Exiting the board

If a player attempts to exit the board, he will die and lose all points.
Capturing area
A player will capture area when he has a trail and he enters his own land again.

Red fills in between the two red lines. The only case where a player does not fill in is when another player is inside the loop. To be clear, this only applies when the other player himself is in the loop, not just land owned by him. A player can capture land from another person. If a player cannot fill in the area surrounded by his trail, the trail is converted directly to normal land. If the player inside another players land loop dies, the area in that loop is filled. Every time a player dies, the board is reexamined for an area that can be filled in.
Controller details
The controller is here. It is very similar to the original game, but small changes have been made to make this a better fit for KotH and for technical reasons. It is built with @NathanMerrill's KotHComm library, and with substantial help from @NathanMerrill as well. Please let me know of any bugs you find in the controller in the chat room. To be consistent with KotHComm, I have used Eclipse collections throughout the controller, but bots can be written using only the Java Collections library.
Everything is packaged in an uberjar on the github releases page. To use it, download it and attach it to your project so you can use it for auto-compleat (instructions for IntelliJ, Eclipse). To test your submissions, you run the jar with java -jar SplixKoTH-all.jar -d path\to\submissions\folder. Ensure that path\to\submissions\folder has a subfoler named java, and to place all your files there. Do not use package names in your bots (although it may be possible with KotHComm, it's just a bit more trouble). To see all options, use --help. To load all the bots, use --question-id 126815.
Writing a bot
To start writing a bot, you must extend SplixPlayer.

Direction makeMove(ReadOnlyGame game, ReadOnlyBoard board)

This is where you decide which move you want your bot to make. Must not return null.

HiddenPlayer getThisHidden()

Get the HiddenPlayer version of this. Useful for comparing your bot to the board.

enum Direction

Values

East (x = 1; y = 0)
West (x = -1; y = 0)
North (x = 0; y = 1)
South (x = 0; y = -1)

Direction  leftTurn()

Get the Direction that you would get if you made a left turn.

Direction  RightTurn()

Get the Direction that you would get if you made a right turn.

ReadOnlyBoard
This is the class where you access the board. You can either get a local view (20x20) of the board with the player positions shown, or a global view (the entire board) with only the information of who owns and claims positions on the board. This is also where you get your position.

SquareRegion getBounds()

Retrieve the size of the board.

MutableMap<com.nmerrill.kothcomm.game.maps.Point2D,ReadOnlySplixPoint> getGlobal()

Get a global map of the board.

MutableMap<com.nmerrill.kothcomm.game.maps.Point2D,ReadOnlySplixPoint> getView()

Same as getGlobal(), except that it is limited to a 20x20 area around your player, and that it shows player positions.

Point2D getPosition(SplixPlayer me)

Get the position of your player. Use as board.getPosition(this).

Point2D getSelfPosition(ReadOnlyBoard)

Get your position on the board. Usage: Point2D mypos = getSelfPosition(board)

ReadOnlyGame
ReadOnlyGame only provides access to the number of turns left in the game through int getRemainingIterations().
ReadOnlySplixPoint

HiddenPlayer getClaimer()

Get the HiddenPlayer version of who is claiming a point - claiming = a trail.

HiddenPlayer getOwner()

Get who owns a point.

HiddenPlayer getWhosOnSpot()

If the player is positioned on this point, return the hidden version of it. Only works in getLocal().

Point2D
Unlike the other classes here, Point2D is contained in the KotHComm library. com.nmerrill.kothcomm.game.maps.Point2D

Point2D(int x, int y)
int getX()
int getY()
Point2D moveX(int x)
Point2D moveY(int y)
Point2D wrapX(int maxX)

Wrap the x value to be within the range of maxX.

Point2D wrapY(int maxY)

Wrap the y value to be within the range of maxY.

int cartesianDistance(Point2D other)

This translates to how many turns it would take for a player to move from point a to point b.

Clojure support
The Clojure compiler is bundled with the SplixKoTH-all.jar, so you can use Clojure for your bot! Refer to my random_bot to see how to use it.
Debugging a bot
The controller comes with a debugger to help test strategies. To start it, run the jar with the --gui option.
To attach the debugger to your jar, follow these instructions for IntelliJ, or these instructions for Eclipse (Eclipse version untested).

If you are using a debugger with your code, you can use this to help visualize what your bot is seeing. Set a breakpoint at the beginning of makeMove on your bot, and ensure that it only pauses the current thread. Next, click the start button on the UI and step through your code.

Now, to put it all together:
Running bots
To run your bots with others, you need to run the jar on the releases page. Here is a list of flags:

--iterations (-i) <= int (default 500)

Specify the number of games to run.

--test-bot (-t) <= String

Run only the games that the bot is included in.

--directory (-d) <= Path

The directory to run submissions from. Use this to run your bots. Ensure that your bots are a in a subfolder of the path named java.

--question-id (-q) <= int (only use 126815)

Download and compile the other submissions from the site.

--random-seed (-r) <= int (defaults to a random number)

Give a seed to the runner so that bots that use random can have results reproduced.

--gui (-g)

Run the debugger ui instead of running a tournament. Best used with --test-bot.

--multi-thread (-m) <= boolean (default true)

Run a tournoment in multi-thread mode. This enables a faster result if your computer has multiple cores.

--thread-count (-c) <= int (default 4)

Number of threads to run if multi-thread is allowed.

--help (-h)

Print a help message similar to this.

To run all the submissions on this page, use java -jar SplixKoTH-all.jar -q 126815.
Formatting your post
To ensure that the controller can download all the bots, you should follow this format.
[BotName], Java                     // this is a header
                                    // any explanation you want
[BotName].java                      // filename, in the codeblock
[code]

Also, do not use a package declaration.

Scoreboard
+------+--------------+-----------+
| Rank | Name         |     Score |
+------+--------------+-----------+
|    1 | ImNotACoward | 8940444.0 |
|    2 | TrapBot      |  257328.0 |
|    3 | HunterBot    |  218382.0 |
+------+--------------+-----------+

Please let me know if any portion of the rules are unclear, or if you find any errors in the controller in the chat room.
Have fun!

Hey, this finally got posted! I was wondering :D

How long have you been waiting? ;) Do you plan on submitting?

I don't know whether or not I will be able to solve a challenge like this, as I mainly write programs in esolangs. But I saw it in the sandbox and it looked like a great challenge!

@hyperneutrino I saw the edit, does it really bother you? Political correctness is nowhere in the purview of this post, and it is perfectly correct English grammar...

@Phoenix Totally! I also use IntelliJ for my other projects (scala, groovy, haskell, clojure) and it works perfectly!

Well actually I'm not asleep @MDXF I just wanted to leave TNB for the night (as I said, sleep is overrated :P). It didn't actually bother me, but here's my rationale for why I edited it. First of all, given how the internet can be sometimes, that may attract negative comments or votes, though I doubt anyone would downvote for that given that higher rep users usually have more sense than that, but I would hate to see such a good challenge attract negative feedback for that, so unless unspecified bothers you, I would rather be safe than sorry. Thanks!

@HyperNeutrino "leave TNB for the night" not a phrase I understand :P but good to know about the edit. Thanks

@MDXF Eh you're right I know I'm going to end up going back someone soon though my phone cuts off connection to the router at midnight

@HyperNeutrino Ah, ok. I don't mind, just curious since that seems really small...

0.o small world? I know (of) the developer of splix.io. (Tweeted this @ him)

Alright. Yeah, I mean it is a very small edit (that's why I just went ahead and did it instead of creating a comment thread about it) but I'd hate for this challenge to experience issues because of that. And I should make some interface to port these answers into actual Splix.io and see how well it performs against the actual players of Splix! :D

That would be pretty cool! And even the perfect player here would probably not be unbeatable on the real site, because of lag.

Are we allowed to use any JVM language in this challenge? I might try it in Clojure (since it has support for class extension).

That would be really awesome, except the submissions are downloaded from this page in java and are compiled by KotHComm, which doesn't understand clojure yet. If you're willing to hold off for a bit though, I may be able to extend the support. KotHComm comes with the ability to support other languages. I'll see if I can extend it to other JVM languages.

@Qwerp-Derp Update. It is possible, and I think it can be done in the next 2-3 days, if you're willing to wait that long. Even if you don't plan on using it, I'll be working on it since it seems like a cool/useful project.

As usual, a cross-language API would be desirable.

Of course, but I don't want to deal with that. KoTHComm supports an io based bot, but that requires making a text based format for transmitting board information -- every turn -- and supporting the languages on my machine. Not to mention the enormous performance hit. Clojure and other JVM languages have the benefit of very low performance overhead, and being able to (more or less) directly interface with my code. Plus the platform support issue goes away, since I can even include the Clojure compiler in my jar (hopefully this is true for others as well).

@Qwerp-Derp Clojure support is now available! It ain't pretty, but it works ;)

http://splix.io/#team-baMPy for the code-golf team.

The real question is, can we use these bots on splix :p

ImNotACoward, Java
This bot is a coward survival expert. If there is no enemy nearby, he claims a part of the land. If the loop of another player can be reached safely, he stabs the other player in the back engages the other player in a duel. If the other player cannot be attacked safely, he flees performs a strategic retreat to his own land.
ImNotACoward.java
import org.eclipse.collections.api.map.MutableMap;
import org.eclipse.collections.api.set.MutableSet;
import org.eclipse.collections.impl.factory.Lists;
import org.eclipse.collections.impl.factory.Maps;
import org.eclipse.collections.impl.factory.Sets;

import com.jatkin.splixkoth.ppcg.game.Direction;
import com.jatkin.splixkoth.ppcg.game.SplixPlayer;
import com.jatkin.splixkoth.ppcg.game.readonly.HiddenPlayer;
import com.jatkin.splixkoth.ppcg.game.readonly.ReadOnlyBoard;
import com.jatkin.splixkoth.ppcg.game.readonly.ReadOnlyGame;
import com.jatkin.splixkoth.ppcg.game.readonly.ReadOnlySplixPoint;
import com.nmerrill.kothcomm.game.maps.Point2D;
import com.nmerrill.kothcomm.game.maps.graphmaps.bounds.point2D.SquareRegion;

public class ImNotACoward extends SplixPlayer {
    private static final MutableSet<Direction> DIRECTIONS = Sets.mutable.of(Direction.values());

    private static class Board {
        public MutableSet<Point2D> allPoints = null;
        private SquareRegion globalBounds = null;
        private SquareRegion viewBounds = null;
        private MutableMap<Point2D, ReadOnlySplixPoint> global = null;
        private MutableMap<Point2D, ReadOnlySplixPoint> view = null;

        public void update(ReadOnlyBoard readOnlyBoard) {
            if (this.allPoints == null) {
                this.allPoints = readOnlyBoard.getGlobal().keysView().toSet();
                this.globalBounds = readOnlyBoard.getBounds();
            }
            this.viewBounds = readOnlyBoard.viewingArea;
            this.global = readOnlyBoard.getGlobal();
            this.view = readOnlyBoard.getView();
        }

        public boolean inBounds(Point2D point) {
            return globalBounds.inBounds(point);
        }

        public boolean inView(Point2D point) {
            return viewBounds.inBounds(point);
        }

        public ReadOnlySplixPoint getSplixPoint(Point2D point) {
            return inView(point) ? view.get(point) : global.get(point);
        }

        public MutableSet<Point2D> getNeighbors(Point2D point) {
            return DIRECTIONS.collect(d -> point.move(d.vector.getX(), d.vector.getY())).select(this::inBounds);
        }

        public MutableSet<Point2D> getNeighbors(MutableSet<Point2D> points) {
            return points.flatCollect(this::getNeighbors);
        }

        public MutableSet<Point2D> getBorders(SquareRegion region) {
            return allPoints.select(p -> region.inBounds(p) &&
                    (p.getX() == region.getLeft() || p.getX() == region.getRight() ||
                    p.getY() == region.getTop() || p.getY() == region.getBottom() ||
                    p.getX() == globalBounds.getLeft() || p.getX() == globalBounds.getRight() ||
                    p.getY() == globalBounds.getTop() || p.getY() == globalBounds.getBottom()));
        }
    }

    private class Player {
        public final HiddenPlayer hiddenPlayer;
        public MutableSet<Point2D> owned = Sets.mutable.empty();
        private MutableSet<Point2D> unowned = null;
        private MutableSet<Point2D> oldClaimed = Sets.mutable.empty();
        public MutableSet<Point2D> claimed = Sets.mutable.empty();
        private MutableSet<Point2D> oldPos = Sets.mutable.empty();
        public MutableSet<Point2D> pos = Sets.mutable.empty();

        public Player(HiddenPlayer hiddenPlayer) {
            super();
            this.hiddenPlayer = hiddenPlayer;
        }

        public void nextMove() {
            owned.clear();
            unowned = null;
            oldClaimed = claimed;
            claimed = Sets.mutable.empty();
            oldPos = pos;
            pos = Sets.mutable.empty();
        }

        public MutableSet<Point2D> getUnowned() {
            if (unowned == null) {
                unowned = board.allPoints.difference(owned);
            }
            return unowned;
        }

        public void addOwned(Point2D point) {
            owned.add(point);
        }

        public void addClaimed(Point2D point) {
            claimed.add(point);
        }

        public void setPos(Point2D point) {
            pos.clear();
            pos.add(point);
        }

        public void calcPos() {
            if (pos.isEmpty()) {
                MutableSet<Point2D> claimedDiff = claimed.difference(oldClaimed);
                if (claimedDiff.size() == 1) {
                    pos = board.getNeighbors(claimedDiff).select(p -> !claimed.contains(p) && !board.inView(p));
                } else if (!oldPos.isEmpty()) {
                    pos = board.getNeighbors(oldPos).select(p -> owned.contains(p) && !board.inView(p));
                } else {
                    pos = owned.select(p -> !board.inView(p));
                }
            }
        }
    }

    private Board board = new Board();
    private Point2D myPos = null;
    private final Player nobody = new Player(new HiddenPlayer(null));
    private final Player me = new Player(new HiddenPlayer(this));
    private MutableMap<HiddenPlayer, Player> enemies = Maps.mutable.empty();
    private MutableMap<HiddenPlayer, Player> players = Maps.mutable.of(nobody.hiddenPlayer, nobody, me.hiddenPlayer, me);
    private MutableSet<Point2D> path = Sets.mutable.empty();

    private Player getPlayer(HiddenPlayer hiddenPlayer) {
        Player player = players.get(hiddenPlayer);
        if (player == null) {
            player = new Player(hiddenPlayer);
            players.put(player.hiddenPlayer, player);
            enemies.put(player.hiddenPlayer, player);
        }
        return player;
    }

    private Direction moveToOwned() {
        MutableSet<Point2D> targets = me.owned.difference(me.pos);
        if (targets.isEmpty()) {
            return moveTo(myPos);
        } else {
            return moveTo(targets.minBy(myPos::cartesianDistance));
        }
    }

    private Direction moveTo(Point2D target) {
        return DIRECTIONS.minBy(d -> {
            Point2D p = myPos.move(d.vector.getX(), d.vector.getY());
            return !board.inBounds(p) || me.claimed.contains(p) ? Integer.MAX_VALUE : target.cartesianDistance(p);
        });
    }

    @Override
    protected Direction makeMove(ReadOnlyGame readOnlyGame, ReadOnlyBoard readOnlyBoard) {
        board.update(readOnlyBoard);
        myPos = readOnlyBoard.getPosition(this);
        path.remove(myPos);

        for (Player e : players.valuesView()) {
            e.nextMove();
        }
        for (Point2D point : board.allPoints) {
            ReadOnlySplixPoint splixPoint = board.getSplixPoint(point);
            getPlayer(splixPoint.getOwner()).addOwned(point);
            getPlayer(splixPoint.getClaimer()).addClaimed(point);
            getPlayer(splixPoint.getWhosOnSpot()).setPos(point);
        }
        for (Player e : players.valuesView()) {
            e.calcPos();
        }

        if (me.owned.contains(myPos) && path.allSatisfy(p -> me.owned.contains(p))) {
            path.clear();
        }

        if (path.isEmpty()) {
            MutableSet<Point2D> enemyPositions = enemies.valuesView().flatCollect(e -> e.pos).toSet();
            int enemyDistance = enemyPositions.isEmpty() ? Integer.MAX_VALUE :
                    enemyPositions.minBy(myPos::cartesianDistance).cartesianDistance(myPos);

            if (enemyDistance < 20) {
                MutableSet<Point2D> enemyClaimed = enemies.valuesView().flatCollect(e -> e.claimed).toSet();
                if (!enemyClaimed.isEmpty()) {
                    Point2D closestClaimed = enemyClaimed.minBy(myPos::cartesianDistance);
                    if (closestClaimed.cartesianDistance(myPos) < enemyDistance) {
                        return moveTo(closestClaimed);
                    } else if (enemyDistance < 10) {
                        return moveToOwned();
                    }
                }
            }

            if (me.owned.contains(myPos)) {
                if (!me.getUnowned().isEmpty()) {
                    Point2D target = me.getUnowned().minBy(myPos::cartesianDistance);
                    if (target.cartesianDistance(myPos) > 2) {
                        return moveTo(target);
                    }
                }

                int safeSize = Math.max(1, Math.min(enemyDistance / 6, readOnlyGame.getRemainingIterations() / 4));
                SquareRegion region = Lists.mutable
                        .of(new SquareRegion(myPos, myPos.move(safeSize, safeSize)),
                                new SquareRegion(myPos, myPos.move(safeSize, -safeSize)),
                                new SquareRegion(myPos, myPos.move(-safeSize, safeSize)),
                                new SquareRegion(myPos, myPos.move(-safeSize, -safeSize)))
                        .maxBy(r -> me.getUnowned().count(p -> r.inBounds(p)));
                path = board.getBorders(region);
            } else {
                return moveToOwned();
            }
        }

        if (!path.isEmpty()) {
            return moveTo(path.minBy(myPos::cartesianDistance));
        }

        return moveToOwned();
    }
}

TrapBot, Java
TrapBot.java

import com.jatkin.splixkoth.ppcg.game.Direction;
import com.jatkin.splixkoth.ppcg.game.SplixPlayer;
import com.jatkin.splixkoth.ppcg.game.readonly.ReadOnlyBoard;
import com.jatkin.splixkoth.ppcg.game.readonly.ReadOnlyGame;
import com.jatkin.splixkoth.ppcg.game.readonly.ReadOnlySplixPoint;
import com.nmerrill.kothcomm.game.maps.Point2D;
import com.nmerrill.kothcomm.game.maps.graphmaps.bounds.point2D.SquareRegion;
import javafx.util.Pair;
import org.eclipse.collections.api.map.MutableMap;
import org.eclipse.collections.impl.factory.Lists;

import java.util.Comparator;

/**
 * Trap bot goes to the wall and traces the entirety around. Hopes that
 * the players in the middle die and that nobody challenges him. Nearly
 * all turns are left turns.
 */
public class TrapBot extends SplixPlayer {

    /**
     * Mode when the bot is attempting to reach the wall from it's original spawn
     * location.
     */
    public static final int MODE_GOING_TO_WALL = 1;

    /**
     * Mode when we have reached the wall and are now going around the board.
     */
    public static final int MODE_FOLLOWING_WALL = 2;

    private int mode = MODE_GOING_TO_WALL;

    public static int WALL_EAST = 1;
    public static int WALL_NORTH = 2;
    public static int WALL_WEST = 3;
    public static int WALL_SOUTH = 4;

    /**
     * How long the bot would like to go before he turns around to go back home.
     */
    private static final int PREFERRED_LINE_DIST = 5;

    private int distToTravel = 0;

    private Direction lastMove = Direction.East;// could be anything that's not null
    private int lastTrailLength = 0;

    @Override
    protected Direction makeMove(ReadOnlyGame game, ReadOnlyBoard board) {
        Direction ret = null;
        MutableMap<Point2D, ReadOnlySplixPoint> view = board.getView();
        int trailLength = getTrailLength(board, view);

        if (trailLength == 0) {

            int closestWall = getClosestWall(board);
            Direction directionToWall = getDirectionToWall(closestWall);

            if (lastTrailLength != 0) {
                ret = lastMove.leftTurn();
                // move to the other half of 2 width line so we can start without shifting to the left
            }

            if (mode == MODE_GOING_TO_WALL && ret == null) {
                int distCanTravel = getDistCanTravel(
                        getSelfPosition(board), board.getBounds(), directionToWall);
                if (distCanTravel == 0) mode = MODE_FOLLOWING_WALL;
                else ret = directionToWall;
                distToTravel = distCanTravel;

            }

            if (mode == MODE_FOLLOWING_WALL && ret == null) {
                int distCanTravel = 0;
                ret = directionToWall;
                while (distCanTravel == 0) {// keep turning left until we can get somewhere
                    ret = ret.leftTurn();
                    distCanTravel = getDistCanTravel(
                            getSelfPosition(board), board.getBounds(), ret);
                }

                distToTravel = distCanTravel;
            }
        }

        // once we have started we are on auto pilot (can't run after the before block)
        else if (trailLength == distToTravel || trailLength == (distToTravel + 1))
            ret = lastMove.leftTurn();

        if (ret == null)// if we don't have a move otherwise, we must be on our trail. ret same as last time
            ret = lastMove;

        lastTrailLength = trailLength;
        lastMove = ret;
        return ret;
    }

    int getClosestWall(ReadOnlyBoard board) {
        Point2D thisPos = getSelfPosition(board);
        return Lists.mutable.of(
                new Pair<>(WALL_NORTH, board.getBounds().getTop() - thisPos.getY()),
                new Pair<>(WALL_SOUTH, thisPos.getY()),
                new Pair<>(WALL_EAST, board.getBounds().getRight() - thisPos.getX()),
                new Pair<>(WALL_WEST, thisPos.getX())
        ).min(Comparator.comparingInt(Pair::getValue)).getKey();
    }

    /**
     * This goes around some intended behavior in the controller to get the correct result. When a player goes outside
     * his territory the land under him is converted to a trail -- on the next step of the game. So a trail length may
     * be the count of the trail locations plus one. That is what this function calculates. Depends on the whole trail
     * being contained inside the view passed to it.
     * @return
     */
    int getTrailLength(ReadOnlyBoard board, MutableMap<Point2D, ReadOnlySplixPoint> view) {
        boolean isPlayerOutsideHome = !view.get(getSelfPosition(board)).getOwner().equals(getThisHidden());
        int trailLength = view.count(rop -> rop.getClaimer().equals(getThisHidden()));
        return trailLength + (isPlayerOutsideHome? 1 : 0);
    }

    /**
     * Calculate how far we can travel in the direction before we hit the wall.
     * @return
     */
    int getDistCanTravel(Point2D currPos, SquareRegion bounds, Direction direction) {
        for (int i = 1; i <= PREFERRED_LINE_DIST; i++) {
            if (!bounds.inBounds(currPos.move(direction.vector.getX()*i, direction.vector.getY()*i)))
                return i-1;
        }
        return PREFERRED_LINE_DIST;
    }

    /**
     * Get which direction needs to be traveled to reach the specified wall.
     * Requires that neither Direction nor the values of `WALL_...` change.
     * @param targetWall
     * @return
     */
    Direction getDirectionToWall(int targetWall) {
        return Direction.values()[targetWall-1];
    }
}

This is perhaps the most simple bot. All it does is trace out the edge of the board, doubling back on itself to reduce risk of being killed.

Cool to see you used Eclipse Collections.  There is a Pair interface in EC.
You can use Tuples.pair() to get a Pair instance.  There is also a PrimitiveTuples class if either or both of the values in the pair are primitives.

random_bot, Clojure
This is RandomBot, but I had to stick to naming conventions, and some issues prevent me from using the hyphen in the name, so underscores reign! The make-move fn returns a vec with the first item being the Direction you want to move in, and the second being the state you want to be passed back to you on the next turn. Do not use any external atoms, since this code may be running multiple games in parallel.
 random_bot.clj
 (ns random-bot
     (:import
      [com.jatkin.splixkoth.ppcg.game Direction]))

 (defn make-move [game board state]
       [(rand-nth [Direction/East
                   Direction/West
                   Direction/North
                   Direction/South])
        nil])

HunterBot, Java
HunterBot.java

import com.jatkin.splixkoth.ppcg.game.Direction;
import com.jatkin.splixkoth.ppcg.game.SplixPlayer;
import com.jatkin.splixkoth.ppcg.game.readonly.HiddenPlayer;
import com.jatkin.splixkoth.ppcg.game.readonly.ReadOnlyBoard;
import com.jatkin.splixkoth.ppcg.game.readonly.ReadOnlyGame;
import com.jatkin.splixkoth.ppcg.game.readonly.ReadOnlySplixPoint;
import com.nmerrill.kothcomm.game.maps.Point2D;
import org.eclipse.collections.api.map.MutableMap;
import org.eclipse.collections.api.set.ImmutableSet;
import org.eclipse.collections.impl.factory.Sets;

import java.util.Comparator;

/**
 * This bot looks for any trail points left behind by another player and sets that as his target. If the target ever
 * disappears, it will continue on in hopes that the player will return soon, or if another target appears, it will
 * go towards that one. Works best when the other player repeatedly goes in the same general direction.
 */
public class HunterBot extends SplixPlayer {

    private Point2D lastTarget;

    private Direction lastMove = Direction.East;

    @Override
    protected Direction makeMove(ReadOnlyGame game, ReadOnlyBoard board) {
        Point2D thisPos = getSelfPosition(board);
        MutableMap<Point2D, ReadOnlySplixPoint> global = board.getGlobal();
        MutableMap<Point2D, ReadOnlySplixPoint> targets = global.select((pt, rosp) ->
                !rosp.getClaimer().equals(getThisHidden())
                        && !rosp.getClaimer().equals(new HiddenPlayer(null)));

        if (targets.size() == 0 && lastTarget == null) {
            lastMove = lastMove.leftTurn();
            return lastMove;
        }

        Point2D target = null;
        if (targets.size() == 0) target = lastTarget;
        else target = targets.keysView().min(Comparator.comparingInt(thisPos::cartesianDistance));
        if (target.equals(thisPos)) {
            lastTarget = null;
            if (global.get(thisPos).getOwner().equals(getThisHidden())) {
                lastMove = lastMove.leftTurn();
                return lastMove;
            } else
            // time to go home
            target = global.select((z_, x) -> getThisHidden().equals(x.getOwner())).keySet().iterator().next();

        }

        lastTarget = target;
        lastMove = makeSafeMove(target, global, board, thisPos);
        return lastMove;
    }

    private Direction makeSafeMove(Point2D targetLocation, MutableMap<Point2D, ReadOnlySplixPoint> map, ReadOnlyBoard board, Point2D currLoc) {
        Point2D dist = targetLocation.move(-currLoc.getX(), -currLoc.getY());
        ImmutableSet<Direction> possibleMoves = Sets.immutable.of(Direction.values())
                .select(x -> {
                    Point2D pos = currLoc.move(x.vector.getX(), x.vector.getY());
                    return !board.getBounds().outOfBounds(pos) && !getThisHidden().equals(map.get(pos).getClaimer());
                });
        Direction prefMove;
        if (Math.abs(dist.getX()) > Math.abs(dist.getY()))
            prefMove = getDirectionFroPoint(new Point2D(normalizeNum(dist.getX()), 0));
        else
            prefMove = getDirectionFroPoint(new Point2D(0, normalizeNum(dist.getY())));

        if (possibleMoves.contains(prefMove)) return prefMove;
        if (possibleMoves.contains(prefMove.leftTurn())) return prefMove.leftTurn();
        if (possibleMoves.contains(prefMove.rightTurn())) return prefMove.rightTurn();
        return prefMove.leftTurn().leftTurn();
    }

    private Direction getDirectionFroPoint(Point2D dir) {
        return Sets.immutable.of(Direction.values()).select(d -> d.vector.equals(dir)).getOnly();
    }

    private int normalizeNum(int n) { if (n < -1) return -1; if (n > 1) return 1; else return n;}

}

One of the most basic bots. It searches the board for spots to kill others, and it will follow the shortest path possible to get to a killing position. If it is outside its territory, it will make random moves until it has another opening to kill another player. It has some logic to prevent it fomr running over itself, and when all other players are dead it goes back to its home. Once home it just goes in a little square.


text:
Approximate the plastic number
The challenge
The plastic number is a number related to the golden ratio, with many interesting mathematical properties. As such, there are many approaches that can be used to calculate the number.
In order to precisely specify the number for the purposes of this challenge, we'll use the following definition (although there are plenty of equivalent definitions, and you can use any definition you wish as long as it comes to the same number):

The plastic number is a real number ρ such that ρ³=ρ+1.

Your challenge is to write a program or function which takes an integer x as input (with x > 1), and produces an approximation to ρ as output, such that the larger the value of x gets, the closer the output gets to ρ (with at most finitely many exceptions; staying at the same value counts as "closer" for this purpose), and for any positive number δ, there's some input x to your program that produces an output that's within δ of ρ.
Clarifications

If you're outputting via a method that inherently outputs strings (e.g. the standard output stream), you can format output either in decimal (e.g. 1.3247179572), or as a ratio of two integers with a / character between them.
If you're outputting as a value within your programming language (e.g. returning from a function), it must be of a fixed-point, floating-point, or rational type. (In particular, you can't use data types that store numbers symbolically, unless they're used only to hold the ratio of two integers. So if you're using Mathematica or a similar language, you'll need to include the extra code to actually generate the digits of the output.)
Your answer must work in a hypothetical variant of your language in which integers can be arbitrarily large, and memory (including stack) is unlimited. You may not assume that floating-point arithmetic in your language is arbitrarily accurate, but must instead use its actual accuracy (meaning that outputting a floating-point number is only going to be possible in languages where the accuracy of floating-point numbers can be controlled at runtime).
x can have any meaning you want (so long as increasing it gives more accurate outputs). I imagine that most submissions will have it control the number of digits of output to produce, or the number of iterations of the algorithm used by your program to converge on the plastic number, but other meanings are acceptable.

Testcase
Here are the first few digits of the plastic number:
1.32471795724474602596090885

More digits are available on OEIS.
Victory condition
As usual for code-golf, shorter is better, measured in bytes. However, feel free to post answers even if they don't win, so long as they add something (e.g. a different language, or a different algorithm) to the existing answers.

hmm, (cbrt(108+12sqrt(69))+cbrt(108-12sqrt(69)))/6 this seems like a good time to use `the Drake approximation': sqrt(69)=8.something http://bit.ly/2rCqedX ^_^

Can we also assume the recursion/stack depth is unlimited?

To clarify the second point, can we use arbitrary precision libraries (e.g. mpmath in Python)? They use an auxiliary data type, but do you count that as storing things "symbolically"?

@Batman: I believe mpmath works by storing a decimal expansion. That's not a symbolic data type, so it's fine.

@xnor: Yes, as usual on PPCG. I'll edit that into the question.

This is a great model for irrational number challenges. I really like the x parameter to control accuracy.

Is {{x -> 1.32471795724474602596090885}} a valid output format?

@Jenny_mathy: I'm not sure that we have a standard rule for that on PPCG; it might be worth asking on Meta (this is a situation where we'd expect the standard rules to be usable). I'm currently inclined towards no, but wouldn't much care if a meta discussion found otherwise.

Does such that the larger the value of x gets, the closer the output gets to ρ have to hold for all pairs of x?

@Dennis: Well, if it didn't, simply outputting all rationals in some order would be a valid solution; the rule's to prevent that. I don't think answers like this are what people would really expect from this sort of challenge.

Well, at the very least I'd expect answers to converge to ρ. Also, an "honest" solution could easily fail the test x > y --> |ρx - ρ| > |ρy - ρ| for a finite number of (x, y) pairs. If that isn't acceptable, I think this should be made more explicit in the spec.

@Dennis: OK, I've clarified the ambiguity by allowing finitely many exceptions (given that it's not very interesting to be forced to add a constant to x to jump past exceptions with low values).

Many answerers have fallen into the trap(?) of computing an x digit approximation to ρ, the problem being that there are probably infinitely many x such that an (x + 1)-digit approximation is no better than an x digit approximation. You should probably clarify whether you intended this to be allowed. If you don’t, replace “closer” with “strictly closer”; if you do, “at least as close”, or something. You could also consider the looser requirement that the sequence converges to ρ, which would additionally allow xnor’s answer.

@AndersKaseorg: OK, that was a clear bug in the problem (with zero digits getting no closer). I've fixed it. As for converging, I'm rather torn on that; note that most of the current solutions that converge (but go backwards infinitely many times) can easily be fixed by using 2**x rather than just x.

@ais523 I'd favor just going with convergence because it's a standard definition rather than a custom-made one. It's what I'd expect for a challenge to approximate a value arbitrarily well.

Python 2, 49 bytes
n=x=input()
while n**3/x/x<n+x:n+=1
print n,'/',x

Try it online!
The idea is to express the ρ with ρ³=ρ+1 as a fraction n/x whose denominator x is the input accuracy parameter. We take (n/x)³=n/x+1 and clear denominators to get n³=x²(x+n).
Since the LHS increases in n faster than the RHS, we can approximate the equality point n as the smallest with n³≥x²(x+n). The code counts up n until this is the case, starting at x which is smaller.
A small byte save is to divide both sides by x² to write n³/x²≥x+n (negated in the while condition). This is floor division in the code, but the fractional part lost is negligible.
A same-length alternative instead puts x as the numerator:
Python 2, 49 bytes
n=x=input()
while x**3/n/n<n+x:n-=1
print x,'/',n

Try it online!

Although this output converges to ρ (∀ε > 0 ∃x₀ ∀x ≥ x₀ |f(x) − ρ| < ε), it doesn’t satisfy “the larger the value of x gets, the closer the output gets to ρ (with at most finitely many exceptions)” (∃x₀ ∀x ≥ x₀ |f(x + 1) − ρ| < |f(x) − ρ|).

This problem can be fixed by using 2**input() rather than just input(); then, each approximation will be as least as accurate as the one before.

Mathematica, 20 bytes
#^3-#-1&~Root~1~N~#&

Mathematica's builtin Root function gives the solutions to a polynomial equation f[x] == 0.
Explanation
#^3-#-1&~Root~1~N~#&
                   &  (* Function *)
#^3-#-1&              (* A pure-function polynomial, x^3-x-1 *)
        ~Root~1       (* Find the first root *)
               ~N~#   (* approximate to (input) digits *)

Sample I/O
In[1]:= f=#^3-#-1&~Root~1~N~#&;
        f[1]

Out[1]= 1.

In[2]:= f[9]

Out[2]= 1.32471796

In[3]:= f[100]

Out[3]= 1.324717957244746025960908854478097340734404056901733364534015050302827851245547594054699347981787280

PS: Root[x^3-x-1,1]~N~#& works fine (despite not telling it that x is a variable) for the same byte count.

@AndersKaseorg: I changed that rule because it was clearly broken. No valid answers were invalidated, but some answers (like this one) became valid.

Mathematica, 27 bytes
x/.Solve[x^3==x+1>2,x]~N~#&

-1 byte from Martin
-2 bytes from ovs
input

[27]

output

{1.32471795724474602596090885}

Solve[x^3==x+1>2,x]~N~#& for 24 bytes

The result of this is {{x -> 1.32...}} though. You might want to check with ais whether that's a valid output format.

ok.. all fixed i guess

It's still {1.32...} actually, but that format is probably less contentious.

@Martin what are the rules about this format?

I made the challenge a bit more general so that this would be valid, it wasn't meant to disallow "first x digits" solutions. So this is valid now, even though it wasn't before.

sed, 67 60 (59+1) bytes
s,^,1/1/1 ,
:;s,(1*/(1*)/(1*).*)1$,\2\3/\1,
t
s,(/1*).*,\1,

Try it online!
+1 for the -E flag (ERE instead of BRE). Input and output are both unary: input 11111 for x=5 e.g. Output is a fraction of two unary numbers: the aforementioned 11111 input yields output 11111/1111 (5/4 in decimal).
Approximates the plastic number as a fraction between to consecutive elements of the Padovan sequence.

FWIW you don't need a space after the b command, but you can make it shorter still by using the empty label (: and b with no argument). https://tio.run/#%23K05N@f@/WCdOx1AfCBV0uKysi3U0DLX0gVgTTOhpaRqq6MQYxRjrxxjqcOkbqugncQHV6IPldIBi//8bIoN/@QUlmfl5xf91XQE

Oh excellent. And I can save yet another 4 bytes by using t instead of b, so that's a pretty nice save. Thanks :)

Mathematica, 27 bytes
Nest[(1+#)^(1/3)&,1,#]~N~#&

Uses a truncated approximation of the nested cubic radical form ³√(1+³√(1+³√(1+...))). While the output will always have x-1 decimal places, the result is actually less accurate than that, because the expression converges more slowly than one digit per iteration (x is also used as the number of nested radicals that are computed). For example x = 100 gives
_________________________________________________________________________
1.324717957244746025960908854478097340734404056901733364534015050302827850993693624204577670741656151

where the overlined part is correct.

I was planning to write this algorithm in dc, but got stymied because it turns out that it doesn't have a cube root operation, and raising a number to the power ⅓ doesn't work either :-( At least you can always count on Mathematica to have appropriate builtins…

@ais523 There's actually CubeRoot but ain't nobody got bytes for that.

MATL (27 28 bytes)
7BG:"t@)y@Q)+h]tG3+)yG2+)/

My first solution (27 bytes)
Try it online!
It's certainly not optimal, I'm still getting used to MATL.
Explanation:
I create a Padovan sequence up to input+3 then find the ratio of the last two numbers.
7B     % Turn 7 into binary to give 1 1 1
G:"    % For k=1:input do...
t@)    % Existing sequence member k
y@1+)  % Existing sequence member k+1
+h     % Add them together and concatenate to the sequence array
]      % End loop
tG3+)  % Final sequence member
yG2+)  % Second last sequence member
/      % Divide to approximate ρ

Proper fraction output (35 bytes) (28 bytes, @Sanchises):
However, the first solution doesn't fulfill the need for arbitrary precision being the floating point limit of default MATL settings. So rather than adding several bytes to extend this precision, it's simpler to take the proper fraction route and write a fraction of the final two integers in the (N-1)th and Nth elements of the truncated Padovan sequence.
e.g "114/86"
7BG:"t@)y@1+)+h]tG3+)V'/'YcyG2+)VYc
7BG:"t@tQh)sh]tJ)V47hyJq)Vh&

Courtesy of user @Sanchises. :)
Try it online!
Non-iterative evaluation:
Notably, my shortest code for the 'exact' version is (23 bytes):
1-1h69X^12**108+1I/^6/s

Try it online!
...but doesn't give arbitrary precision. I wonder if anyone can adjust this to fulfill the rules (use the input etc) and still add less than 5 bytes? :P

1+ can be shortened to Q.With that in mind, you can replace @)y@1+)+ with just @tQh)s. Furthermore, you can use J to indicate the end of an array; and finally, MATL doesn't distinguish between normal arrays and character arrays, so you can replace Yc by h (you don't need the extra functionality of Yc). This gives just 28 bytes: 7BG:"t@tQh)sh]tJ)V47hyJq)Vh& (notice the & to prevent superfluous output, and replacing '/' by 47).

Kudos for the 7B though, much better than naively pushing lllv

Thank you Sanchises! :) I added your extensions into the main post with attribution of course. I'm actually more maths than comsci, so it's a bit over my head rn, but I will try to learn these tricks you've used over time. :) Thanks for the help!

Do you have an updated list of MATL functions? I am using the original paper and it seems that "&" and "J" have both changed in their use since then! :P http://bit.ly/2slXc40

Oh and yeah, the 7B trick is nice, I saw it used in some older MATL solutions on Padovan's here on PPCG, so can't take credit there. :)

@DrQuarius The latest version can always be found in this GitHub link

@DrQuarius No, this behaviour is present in the rather old MATL spec I generally use. You should really check out Table 3. Not only does clipboard J by default contain 1j, but the clipboard L also contains many useful indexing functions (note that 1j equals end in MATL).

Also, don't worry, I'm an mechanical engineer. I think MATL(AB) has little use outside of a scientific environment, so I would guess that the majority of MATL(AB)/Octave golfers are from outside CS.

As for &, note that every MATL program implicitly has a XD appended to it. &XD is equivalent to 1$XD, or 'only display one item of the stack', which conveniently discards all other contents on the stack.

M, 15 14 bytes
²×3’
*3Ḥ‘÷Ç
Ç¡

Try it online!
Algorithm
This uses rationals and Newton's method. Specifically, for input x, the first x iterations with starting value x are applied.
We're trying to find a specific root of the polynomial p(t) = t³ - t - 1. Newton's method achieves this by taking a starting value t0 – sufficiently close to ρ – and recursively defining a sequence by
tn+1 = tn - p(tn) / p'(tn).
Since p'(t) = 3t² -1, we get
tn+1 = tn - (tn³ - tn - 1)/(3tn² - 1) = (3tn³ - tn - tn³ + tn + 1) / (3tn² - 1) = (2tn³ + 1) / (3tn² - 1).
Note that the initial approximation x gets progressively worse as x increases. While the output for x = 3 is slightly less precise than the output for x = 2, since Newton's method converges quadratically to ρ, this shouldn't be an issue for large values of x.
How it works
Ç¡    Main link. Argument: x

Ç¡    Call the second helper link x times, which initial argument x.

*3Ḥ‘÷Ç  Second helper link. Argument: t

*3      Compute t³.
  Ḥ     Unhalve; yield 2t³.
   ‘    Increment; yield 2t³+1.
     Ç  Call the first helper link with argument t.
    ÷   Divide the left result by the right one.

²×3’    First helper link. Argument: t

²       Compute t².
 ×3     Compute 3t².
   ’    Decrement; yield 3t²-1.

Too bad you can't use ...µ¡...

Octave, 50 bytes
@(n)char(digits(n)*0+vpasolve(sym('r^3-r-1'))(1));

Try it online!
Defines an anonymous function, withn the desired number of digits of output.
This answer abuses that digits returns the current setting for the number of digits in variable precision arithmetic. This means we can just use it in an anonymous function without errors about 'Too many output arguments'.
Other than that, it's really straightforward: vpasolve is short for Variable-Precision Arithmetic Solve, with the precision set by the last call of digits. Since vpa is a Symbolic data type in Octave, which is banned per the spec, we just wrap the whole function in char(...) to get string output. Note that in solve and vpasolve, the f==0 is implied, so r^3==r+1 has been replaced by r^3-r-1 (==0)

I went and changed the question so that it doesn't disallow answers like this (it wasn't meant to).

@ais523 Thanks for the notification!

Julia 0.5,  44  40 bytes
|(x,r=1)=x<1?r:~-x|big(2r^3+1)//(3r^2-1)

Uses rationals and Newton's method.
Try it online!

APL (Dyalog Extended), 19 bytes
{{(⍺+⍵*÷3)*÷3}/⍵/1}

Try it online!
Uses the cube root approximation method, which very, very slowly creeps towards the value of the plastic number.
Explanation
{{(⍺+⍵*÷3)*÷3}/⍵/1} ⍵ → input
               ⍵/1} replicate 1 ⍵ times
 {           }/     reduce by inner fn:
          *÷3       cube root of
     ⍵*÷3           cube root of right arg
   ⍺+               plus left arg

Rust, 66 bytes
|n|{let mut i=(1,1,1);for _ in 0..n{i=(i.1,i.2,i.0+i.1)}(i.1,i.2)}

Try it online!
Uses the padovan sequence to approximate the plastic number. Returns a tupled (num,denom). A readable version that works with arbitrary precision integers can be found here.

AWK, 34 bytes
{for(;$1^3>$1+1;)$1=($1+1)^(1/3)}1

Step by step:
{                  # $1 is the input (a positive integer)
for(;$1^3>$1+1;)   # as long as $1 cubed is bigger than the input plus one
  $1=($1+1)^(1/3)  # assigns $1 this new value: cube root of $1 plus one
}
1                  # prints $1

Try it online!

05AB1E, 23 bytes
U[X3m¹/¹/¹X+›#X>U]X'/¹J

Try it online!

Direct port of https://codegolf.stackexchange.com/a/126822/59376 by xnor.

Charcoal, 28 bytes
ＡＩθθＡθνＷ‹∕∕Ｘν³θθ⁺νθＡ⁺ν¹νＩ∕νθ

Try it online! Link to verbose mode. Also I apparently messed up Divide and IntDivide :|
Uses the same method as the Python and JavaScript answers.

NewStack, 14 bytes
¹Fᵢ{E2x³⁺÷3x²⁻

Break down:
¹                Add arbitrary number 1 to the stack.
 Fᵢ{             Define for loop with a user's input amount of itterations.
    E            Define new edit for element 0 (element 0 being the 1 added. earlier).
     2x³⁺÷3x²⁻   update x to equal (2x^3+1)/(3x^2-1). (x = element 0).

How it works:
The formula (2x3+1)/(3x2-1) comes from the simplification of Newton's method for the equasion x3=x+1. You can find it here. Repeating this process an infinite amoune of times converges to the plastic number. It's rate of convergence is rather quick at around 2.6 decimals per iteration.
INPUT ITERATION >> VALUE
0 >> 1
1 >> 1.5
2 >> 1.3478260869565217
3 >> 1.325200398950907
4 >> 1.3247181739990537
5 >> 1.3247179572447898
6 >> 1.324717957244746    <- 16 decimal precision in 6 iterations!
...
100 >> 1.324717957244746

Padovan sequence alternative, 27 25 17 bytes
¹Fᵢ{[ƨ2+ƨ3]ℲƤƨ/ƨ2

Break down:
¹                  Append first element of Padovan sequence.
 Fᵢ{       Ⅎ       Define for loop of user's input amount of iterations.
    [ƨ2+ƨ3]        Append sum second and third to last elements.
            Ƥƨ/ƨ2  Print ratio of last two elements.

-2 bytes by choosing better print strategy
-8 bytes by choosing better way to index stack
How it works:
As the Padovan sequence continues, the ratio of the last two elements converge to the plastic number.
INPUT ITERATION >> VALUE
0 >> 1
1 >> 2
...
10 >> 1.3157894736842106
...
89 >> 1.324717957244746    <- 16 decimal precision in 89 iterations
...
100> > 1.324717957244746

Ruby, 35 bytes
->x{n=1;n+=0.1**x while n**3-n<1;n}

Try it online!

Clojure, 46 bytes
#(nth(iterate(fn[i](Math/pow(inc i)(/ 3)))1)%)

Uses the iterated cube-root formula. This is a bit more interesting but longer:
(def f #(apply comp(repeat %(fn[i](Math/pow(inc i)(/ 3))))))

((f 10)1)
1.3247179361449652

“You may not assume that floating-point arithmetic in your language is arbitrarily accurate, but must instead use its actual accuracy (meaning that outputting a floating-point number is only going to be possible in languages where the accuracy of floating-point numbers can be controlled at runtime).”

Ooh I did not notice that, what a bummer. And implementing cubic root with BigDecimal seems quite tricky.

Javascript, 36 bytes
f=(x,n=x)=>n**3/x/x<n+x?f(x,++n):n/x

Works the same as the top python answer. No console.log was included because if you run f(x) in console it will be logged automatically.

f=(x,n=x)=>n**3/x/x<n+x?f(x,++n):n/x
console.log(f(300))

><>, 38+3 = 41 bytes
11\n;
?!\}2,:01{::::}**-+0(?$-{+{1-:}

Expects the input to be present on the stack at program start, so +3 bytes for the -v flag.
Try it online!
Effectively performs a binary search to narrow in on the output value. Increasing x increases the number of iterations to perform.
Edit: refactored calculation slightly to save 1 byte, previous version:
11\n;
?!\}2,:0{::::}**$-1-0)?$-{+{1-:}

k, 27 bytes
{"/"/$1_|x({y,z,x+y}.)/3#1}

Try it online! This assumes infinite integers (which, alas, is not true). It uses the Padovan sequence.

C#, 317 bytes
using m=System.Math;a=x=>{if(a==0)return "1/1";var d=a(x-1).Split('/');var b=int.Parse(d[0]);var c=int.Parse(d[1]);return string.Format("{0}/{1}",(2*m.Pow(b,3)+m.Pow(c,3)).ToString(new string('#',int.MaxValue.ToString().Length)),(3*m.Pow(b,2)*c-m.Pow(c,3)).ToString(new string('#',int.MaxValue.ToString().Length)));};

It returns the result as a fraction.
Explanation
It uses the Newton's method with x iterations for finding the root of the polynomial p^3-p-1=0. The formula is x_n=1-(f(x_(n-1)))/(f'(x_(n-1))), and x_0 is a starting point.
The polynomials derivative is 3p^2-1, and let's say x_(n-1)=b/c. Then, by using the above formula we get, that  x_n=(2 b^3+c^3)/(3 b^2 c-c^3). Let's also say, that we start from 1, this will happen, when x=2, because x>1, and is an integer.  Idented, and commented code:
using System;
string PlasticNumber(int x)
{
    if (x == 2)
        return "1/1";

//If x=2, we return our starting value, but we need to return it as a fraction

    var d = PlasticNumber(x - 1).Split('/');
    var b = System.Convert.ToInt32(d[0]);
    var c = int.Parse(d[1]);

//We parse the previous value of the fraction, and put it into two variables

    return string.Format("{0}/{1}",
        (2 * Math.Pow(b, 3) + Math.Pow(c, 3))
        .ToString(new string('#', int.MaxValue.ToString().Length)),
        (3 * Math.Pow(b, 2) * c - Math.Pow(c, 3))
        .ToString(new string('#', int.MaxValue.ToString().Length)));

//We return the result as a fraction, but it's important not to return it in
  scientific notation, because that will cause issues in the parsing process

}

Axiom, 96 bytes
h(n:NNI):Float==(n>1.E5=>-1;n:=n+1;j:=digits(n::PI);r:=solve(x^3-x=1,10.^-n);digits(j);rhs(r.1))

results
(31) -> [h(i) for i in 0..10]
   (31)
   [1.0, 1.3, 1.33, 1.325, 1.3247, 1.32472, 1.324718, 1.324718, 1.32471796,
    1.324717957, 1.3247179572]
                                                         Type: List Float

how you can see h(2) should be 1.32 and not 1.33 so there is some error in last digits
Then there would be this one of 110 bytes
g(n:NNI):Float==(n>1.E5=>-1;n:=n+1;j:=digits(n::PI);x:=sqrt(23./108);r:=(.5+x)^(1/3)+(.5-x)^(1/3);digits(j);r)

It use the formula for resolve equation of III grade of type x^3-3*p*x-2*q=0
in the case q^2-p^3>=0 that is m=sqrt(q^2-p^3) and x=(q+m)^(1/3)+(q-m)^(1/3)
In our case r^3-r-1=0 this can be written as r^3-3*(1/3)r-2*(1/2)=0 so p=1/3 q=1/2 m=1/4-1/27=23/108
x=(0.5+m)^(1/3)+(0.5-m)^(1/3)
this one that use Newton iteration with start point r=1
f(n:NNI):Float==(n>1.E5=>-1;n:=n+1;j:=digits(n::PI);e:=10^-n;r:=1.;repeat(v:=(r^3-r-1)/(3*r^2-1);abs(v)<e=>break;r:=r-v);digits(j);r)

it change in the function, digits value for obtain one obj of n+1 digits afther
the float point. At end the digits() value is assigned back to preciding value.

TI-BASIC, 21 bytes
:Prompt X //Prompt for input, 3 bytes
:While X  //While X, 3 bytes
:³√(1+Y→Y //Calculate cube root of 1+Y and store to Y, 7 bytes
:DS<(X,0  //Decrement X and skip next command (which doesn't do anything), 5 bytes
:End      //End While loop, 2 bytes
:Y        //Display Y, 1 byte

Uses this recursive formula.
Interestingly, hard-coding the number and rounding it gives the same byte-count:
TI-BASIC, 21 bytes
:Prompt X    //Prompt for input, 3 bytes
:.5√(3       //Store √(3)/2 to Ans, 5 bytes
:Ansֿ¹cosh(3ֿ¹coshֿ¹(3Ans //Store the plastic number to Ans, 9 bytes
:round(Ans,X //Round the plastic number X decimal digits, 4 bytes

Uses this trigonometric formula.

I don't think you can use TI-BASIC's floats here: Your answer must work in a hypothetical variant of your language in which integers can be arbitrarily large, and memory (including stack) is unlimited. You may not assume that floating-point arithmetic in your language is arbitrarily accurate, but must instead use its actual accuracy (meaning that outputting a floating-point number is only going to be possible in languages where the accuracy of floating-point numbers can be controlled at runtime).

PHP, 86 bytes
for($p=[1,1,1];$i++<$argn;)$p[]=bcadd($p[$i],$p[$i-1]);echo bcdiv($p[$i+1],$p[$i],$i);

PHP Sandbox Online
Creates the Padovan Spiral and print the ratio of the last two numbers.

source: Stack Exchange

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/

sort: votes


text:
Count like Chuck Norris
As is well known,

Chuck Norris counted to infinity. Twice

Besides,

Chuck Norris can count to infinity backwards.

Also, although perhaps less known, Chuck Norris can speak a little Spanish in addition to English.
The challenge
Write a program (or function) that can be run in two different languages. In one language the program should output the sequence
1, 1, 2, 2, 3, 3, 4, 4, ...

and in the other language it should produce the sequence (including leading zeros)
1, 2, ..., 9, 01, 11, 21, 31, ..., 89, 99, 001, 101, 201, ...

Rules

Programs or functions are allowed, in any programming language. Standard loopholes are forbidden.
Different versions of the same language (such as Python 2/3) don't count as different languages. Related languages (such as C/C++ or Matlab/Octave) do count as different.
No input will be taken.
The program should continue to output terms of the sequence until stopped by the user. Since the program will not stop by itself, output cannot be produced at the end. It must be produced while the program runs, either continuously or in batches.
Output can use STDOUT or equivalent, or can be displayed in a graphic window. Any non-numeric separator between sequence terms is allowed, as long as each term can be clearly distinguished from its neighbouring terms. It is also acceptable if the screen is cleared between terms.
Either sequence can start at 0 instead of 1. In that case, in the "twice" sequence the 0 should be repeated, just like the other numbers.
Leading zeros are significant in the "backwards" sequence. For example, the tenth term is 01; neither 1 nor 001 are acceptable.
If the two languages use different character encodings, the program is defined by its bytes, not its characters. That is, the bytes should be the same in the two languages.
Shortest code in bytes wins.

Downvoters, any suggestion for improvement?

Chuck Norris is too powerful to count, if he did, the first number he'd count would exceed infinity and shatter the realm of known mathematics. Therefore, I refuse to compete.

@carusocomputing, very wise given the world-wide shortage of push-ups since Chuck Norris did them all.

Chuck Norris' counting strategy: 0. 1/0. manages to kill counting.

Chuck Norris can complete this challenge in 0 bytes. He can just look at the computer and the computer does whatever he wants.

Chuck Norris/sirroN kcuhC, 5 bytes: count

Chuck Norris didn't try to win this challenge, he just allowed you to lose.

@LuisMendo they don't like that people think computers can count as well as Chuck Norris

“should continue to output terms of the sequence until stopped by the user” The user definitely cannot stop Chuck Norris. BTW counting Octave and Matlab as different is a bit risky I would say given that they are mostly compatible.

Why does the second sequence not start with 0, when the tenth/twentieth/etc terms all represent the respective zero?

@Andrea Yes, what languages to consider different and which the same is always tricky

@1Darco1 The second sequence is 1, 2, 3,..., 9,10, 11,... with the digits of each number in reverse order. As the rules indicate, you can start at 0 instead of 1

Chuck Norris already submitted a solution in BrainF*** and Malbolge, but due to it F***ing the Brains of the first person who read it then sending them to Malbolge hell, he roundhouse kicked the answer straight out of the Stack Exchange servers.

I can't wait for somebody to do this in ChuckScript https://github.com/angrykoala/chuckscript

Can I really use any separator? Is \nint main(i){for(;;i++)printf("%d %d ",i,i);}// a valid separator?

@BusinessCat I should have limited the acceptable separators more, but yes, that's valid. Some answers are using similar weird separators

05AB1E / Jelly,  14  13 bytes
-1 byte thanks to Adnan (avoid triplicate with non-popping print)
Raw bytes (hexadecimal):
31 5b 3d 3d 3e 5d fc 06 b6 3b 87 08 15

In 05AB1E's code-page:
1[==>]üε¶;‡ηΩ

Try it online!
In Jelly's code-page:
1[==>]‘©Ṛ;⁷®ß

Try it online!
How?
The 05AB1E program prints the double count with each entry separated by newlines:
1[==>]üε¶;‡ηΩ
1             - push 1 onto the stack
 [            - start infinite loop:
  =           - print top of stack
   =          - print top of stack
    >         -   increment the top of the stack (pop(1), x+=1, push)
     ]        - end the infinite loop
      üε¶;‡ηΩ - this code is never executed nor is it parsed

The Jelly program prints the reversed count with each entry separated by newlines.
The parser will treat a valid literal between [ and ] as the enclosed literal, otherwise these bytes are undefined tokens and as such become equivalent to tokens separating the code into lines. ==> does not parse as a literal, so the code is effectively:
1 - link 1 (not executed but parsed)
1 - literal 1

==> - link 2 (not executed but parsed)
=   - left equals right? (vectorises)
 =  - left equals right? (vectorises)
  > - is greater than the right argument? (vectorises)

‘©Ṛ;⁷®ß - Main link: no arguments
‘       - increment (implicit 0 on left increments to 1 on the first pass)
 ©      - copy the result to the register and yield it
  Ṛ     - reverse, this has an implicit decimal list build, e.g. 142 -> [2,4,1]
    ⁷   - a newline character
   ;    - concatenate, e.g. [2,4,1] -> [2,4,1,'\n']
     ®  - recall the number from the register, e.g. 142
        - The chain has reduced to one item of arity 0, causing a pre-evaluation print:
        -     ...and since the list contains a character it gets smashed together
        -     e.g. [2,4,1,'\n'] prints 241 followed by a newline character
      ß - call this link with the same arity, e.g. as a monad with left = 142

I haven't checked if it works for Jelly, but if it does work, you can replace Ð,, by ==.

That should parse in Jelly. I had looked in info.txt for a non-popping print, and did not see that. Thanks.

Python 2/C (clang), 109 107 100 84 95 88 89 88 87 84 bytes
i=0;
#/*
while 1:i+=1L;print`i`[::-1]
'''*/
a(){for(;;)printf("%i %1$i ",++i);}//'''

Python: Try it online!
C: Try it online!
The L in the Python code is part of the delimiter.
Explanation:
In the C code, It first sets i to 0. Then, it starts a comment (# is valid code in C for #include statements) where the Python code goes. At the end of the comment, it defines a function that forever increments a variable and prints it twice, space-delimited. It then begins a comment.
In the Python code, i=0; sets i to zero. Python ignores the next line because # starts a single-line comment. It then forever increments it and turns it into a long a number and prints its reversed string representation. The 'L' from the long is part of the delimiter. After that, it starts a multi-line string to comment the C code, that ends later.

-2 bytes thanks to @LuisMendo. -7 bytes thanks to @ZacharyT. -6 more bytes thanks to @ZacharyT. +11 bytes to fix a bug thanks to @mbomb007. -7 bytes thanks to @Doorknob. +1 byte to fix a bug thanks to @Doorknob. -1 byte thanks to @yoann. -1 more byte thanks to @yoann. -3 bytes thanks to @Cyoce.

Hmm, I think that you could use recursion in C code - a(i){printf("%i %i ",i,i);a(i+1)}

Why not to use while loop for C code?

@enedil It takes more bytes.

I think you can use \i`instead ofstr(i)`

You can use for(;;)printf("%i %1$i ",i++); to save one byte. The 1$ is a positional argument that tells printf to display the first argument (after the format string).

@yoann Thank you very much, edited.

@Cyoce I am afraid that won't work: large numbers in Python have an L after them, and using str gets rid of the L, whereas backticks do not.

Then here's a thought. How about changing i=1 to i=0, instead of incrementing after the print statement with ;i+=1, increment before and convert it to a long with i+=1L;. Then, change i++ to ++i in the C version. For the Python version, you can claim that L is part of the delimeter.

@Cyoce Clever idea, edited.

Jelly/Pyth, 15 bytes
.V1_`b;"1üÉÉ$

Unprintables are mangled by the SE software, so here's a hexdump:
00000000: 2e56 315f 6062 3b22 7f31 fcc9 c924 0b    .V1_`b;".1...$.

Run with jelly f file and pyth file respectively.
Explanation
First comes the Pyth part. .V runs an infinite loop over the incrementing sequence starting from its input, which is here 1. Then we reverse (_) the stringified (`) loop index (b) and implicitly output it. The ; is there to end the loop, and the " is necessary to treat the rest of the program as a string literal so that the parser doesn't choke on it.
The Jelly part will be explained by first translating the remainder of the program from the Jelly codepage:
¶1‘ṄṄ$¿

The ¶ acts as a line feed, effectively ignoring the first part of the program by making it a link that is never called. Then we start at 1 and run a while loop (¿) that uses ṄṄ$ (print twice) as its condition, and increments (‘) the value as the loop body.

Incidentally, replacing the Pyth part with 1[DR,>] would create a valid Jelly/05AB1E submission in 14 bytes, but the current interpeter contains a bug that prevents this.

@JonathanAllan You're right, that was the trailing newline added by my text editor.

Perl/JavaScript, 87 bytes
s=0;print=console.log;m=s;$_=s=s=s=m;while(++$_){print((m/s,$_+`
`+$_||/&&reverse.$/))}

Perl
s/0;print/console.log;m/s;$_=s/s/s/m;while(++$_){print((/s,$_+`
`+$_||/&&reverse.$/))}

A mechanism I've used a lot in JS/Perl polyglots is to abuse the fact that substitution can accept pretty much any delimiter, using = means I can use the initial pointless substitutions (first replacing 0;print with console.log;m with a flag of /s in $_, which is currently undef), then setting $_ to the result of replacing s with s in multiline mode (/m), which is 0. Now $_ is 0 and I start the while loop, this then increments $_. Next I call print, passing in a regular expression that matches (due to || at the end which matches an empty string) and use the && operator to then send the reverse of $_ concatenated with a newline ($/ is pre-initialised to "\n"). This counts to infinity backwards.
JavaScript
s=0;print=console.log;m=s;$_=s=s=s=m;while(++$_){print((m/s,$_+`
`+$_||/&&reverse.$/))}

Lots of variable assignments here, masked in the Perl s/// calls. I set up variables s and m as 0, alias console.log to print, run some pointless division, set $_ to 0 and begin the while loop incrementing $_, call print passing in 0 (m/s, this starts the call to m in Perl, but is treated as standard division in JS) and our target string ($_+"\n"+$_) via the comma operator, which returns the last item in the list. I avoid the last piece of Perl code (&&reverse.$/) because $_+"\n"+$_ will be truthy and so I can use || to produce a RegExp object containing the end of the Perl code which is never evaluated.
Tested using Perl 5 and Node 6.

NodeJS / PHP, 131 106 bytes
-25 bytes thanks to @Titus
<!--
printf=(_,i)=>process.stdout.write(i+i),strrev=i=>i+" "//--><?
for($i=0;;)printf("%s ",strrev($i++));

Using NodeJS instead of browser JS for better output formatting and better infinite loop handling.
Try the JavaScript online
Try the PHP online
Note that the TIO output is cut off after 128KB.

102 bytes starting at 0: <!--←printf=(_,i)=>process.stdout.write(i),strrev=i=i>>1//--><?←for($i=0;;)printf("%s ",strrev($i++));. 84 bytes (but not half as nice as your approach): <!--←for(i=1;;)process.stdout.write(i+" "+i+++" ")//--><?for(;;)echo strrev(++$i),_; or <!--←for(i=1;;)process.stdout.write((++i>>1)++" ")//--><?for(;;)echo strrev(++$i),_;.

@Titus Nice idea with the i>>1 to repeat the number, but I had to change the write(i) to include a space, and because write() doesn't accept a number. And you had a typo (strrev=i=i>>1 -> strrev=i=>i>>1) that added another byte. Ended up being shorter to do write(i+i) and strrev=i=>i+" ".

V/Brain-flak Classic, 27, 26 bytes
(()){[[({}())[]]]}é1òÙæ_æ

Hexdump:
00000000: 2828 2929 7b5b 5b28 7b7d 2829 295b 5d5d  (()){[[({}())[]]
00000010: 5d7d e931 f2d9 e65f 01e6                 ]}.1..._..

Try it online! in V (modified slightly so that it will terminate so you can see the output. On TIO, V only outputs if the program terminates)
Try it online! in Brain-flak Classic
This isn't the most interesting of polyglots, since the V code has no effect on brain-flak classic, and vice-versa, however it's really fun to use both of my own languages on a challenge, and the two solutions are pretty interesting on their own.
V Explanation:
é1              " Insert a '1'
  ò             "   Recursively:
   Ù            "   Duplicate this number
    æ_          "   Flip this line
      <C-a>     "   Increment the number on this line
           æ    "   Flip it back (the '_' is implicit because it's at the end of the program)

BFC explanation:
#Push a one onto the main stack
(())

#Forever:
{

  #Print twice:
  [[

    #Increment the top of the stack.
    #Evaluates to *i + 1*
    ({}())

    #Minus one
    []
  ]]

#Endwhile
}

As soon as I saw the languages I knew you posted this one.

Why is it "Brain-flak Classic"?  Is there a different Brain-flak?

@nmjcman101 Brain-flak classic was the original version of Brain-flak. The difference is explained in more detail here, but the reason I picked it is because it has explicit output, which modern brain-flak does not. (allowing for infinite output)

Retina / Python 2, 61 bytes
#{*M`
#*M`
"""

}`$
1
""";i=1
while 1:print str(i)[::-1];i+=1

Retina | Python 2

I tried replacing str() with ``, but apparently disturbed the Retina code. I don't know why?

You can't do that anyway. If it's going to make it to large numbers and work properly, it has to be str, otherwise you'll get L in the results. But it actually does work in Retina. You must've changed more than what you said you did, like moving something onto a different line.

R/Octave, 83 80 78 71 bytes
-3 bytes thanks to Luis Mendo
i=0;
while(1)
#{
print(c(i<-i+1,i))
#}
disp(flip(num2str(i)))
i+=1;
end

#{ }# is an Octave block comment and # just so happens to be the comment for R. The R interpreter only sees the next line as the body of the while loop, and the Octave interpreter skips right ahead to the Octave code
The R part prints out pairs of numbers starting at 1, and the Octave portion prints out the backwards numbers starting at 0.
I fully expect to be outgolfed (even by the same combination of languages); I've just been writing so much Matlab and R code recently that I figured I'd give it a shot.
Try it online! - Octave link

Does the top one need to be i=i+1?

@ZacharyT unfortunately, += doesn't work in R, so yeah, it does have to be like that.

Is the end necessary?

@BLT, yeah, that marks the end of the while loop for octave.

Ok, thanks. I was thinking that since it was never going to end anyway (while(1)) you could save those bytes.

CJam / ><>, 27 23 bytes
"la,:naonao
"1{_sW%n)}h

To CJam:
Try it online! - note that you have to wait until the 60 second limit to see the output, but it works offline.
"la,:naonao
"

This defines a multi-line string literal that is never used.
 1{_sW%n)}h

The second line goes like this:
1     e# Push 1:               | 1
{     e# Forever:              | 1
  _   e#   Duplicate:          | 1 1
  s   e#   Convert to string:  | 1 "1"
  W%  e#   Reverse:            | 1 "1"
  n   e#   Print with newline: | 1
  )   e#   Increment:          | 2
}h    e# End loop

To ><>:
"

Begins a string literal.
 la,:naonao

Content of the string literal. Each of the character codes is individually pushed to the stack.
"

The IP wraps around to reach " again, which ends string mode.
 la,

l takes the length of the stack, a pushes 10, and , divides. This gives us the length of the stack / 10.
    :nao

: duplicates, n prints as a number, a pushes 10, and o prints as a character code (a newline).
        nao

Same thing. Print the number followed by a newline. The stack now has length 10 again (the original string literal's content is on the stack).
The IP then wraps around to the " again, leading to 10 more elements to be pushed. Next time, l returns 20, so 2 is printed, etc.
The second line is never touched by the IP.

Bash / Check, 50 28 bytes
Thanks to @Doorknob for saving a bunch of bytes by switching from Python to Bash
#>
#v
 #p<p<)#
seq 1 inf|rev

To Bash:
#>
#v
 #p<p<)#

These are just some comments, which are ignored.
seq 1 inf|rev

Start a sequence going from 1 to infinity, then pipe the result to rev.
To Check:
#>

This immediately switches into 2D mode, going right. > directs the IP right, which has no effect. It wraps around to the beginning of the line and hits # again, which switches out of 2D mode. It then hits > in 1D mode, which pushes 0 to the stack. Because it is in 1D mode, the IP wraps to the next line.
#v

# switches the IP into 2D mode again and v directs it downwards.
 #p<p<)#

The first # switches back to 1D mode again. p outputs the TOS as a number (but does not pop it), and then < prints a newline. This is done twice, and then the number is incremented with ). # switches to 2D mode again, so the IP wraps to the beginning of the line, hits # to switch to 1D mode, etc.

Bash uses # for comments and can perform the "reversed numbers" task very easily: seq 1 inf|rev.

Ruby code i=1;loop{puts i.to_s.reverse;i+=1} is one byte shorter

Ruby / Python2: 68 64 bytes
i=0
"#{loop{p i+=1,i}}"
exec('while 1:print str(i)[::-1];i+=1')

Ruby perspective
simple init of variable:
i = 0

"#{}" is syntax for string interpolation.
I use it to exec expression instead.
"#{loop{p i+=1,i}}"

p is a shorthand for puts. loop creates an infinite loop.
Next there is the exec thing, but it never gets evaluated, as the infinite loop is by definition infinite. Needed exec not to yield syntax error with Python code.
Python perspective
From perspective of Python, there is a common i=0. Next, Python has different syntax for string interpolation, so this line is simply discarded. Next there is an infinite loop similar to what others posted.

QBIC / QBasic 4.5, 58 bytes
do
p=p+1
if q then
'?`_f!p$|
else
?p,p,
end if
loop

This heavily abuses the fact that all lowercase letters are seen as literal QBasic code by the QBIC interpreter and are therefor just passed along to the QBasic layer of QBIC. How both languages see this code, side by side:
LOC         QBasic                    QBIC
-------------------------------------------------------
do                   Start an infinite loop
p=p+1                Increment p, starts off as 0
if q then    q = 0, goto ELSE         q = 1, execute IF
'?`_f!p$|    ' = comment, invalid     '?` is a 'code literal', passing PRINT to QBASIC
             syntax is ignored        followed by QBIC code to flip p cast as string.
else         q=0, execute             q=1, so ignored
?p,p,        PRINT p twice,
             separated by tab
end if               End of the branching logic
loop                 Wrap around for the next pass

Röda/C (gcc), 90 bytes
main(){f(0);}f(a){a=1//1{[` $a`[::-1]];a++}while[]/*
;for(;;a++)printf("%d %d ",a,a);/**/}

Röda: Try it online!
C: Try it online!
Explanation
This abuses the fact that // is int divison in Röda but a line comment in C.
In both languages, main(){} denotes the main program, and they both call function f with a dummy argument of 0.
In Röda, a=1//1 does int division and assigns the result 1 to a. C sees a=1 and does the same thing, but everything after that assignment is a comment for C. From there, the two languages branch off.
Röda
We have an infinite loop with while[] (an empty condition is truthy). Inside that, ` $a` converts the integer a into a string (with a leading space) after which [::-1] reverses it (and it outputs with a trailing space). Then the value of a is incremented by one.
Outside of the while loop, a multiline comment starts /* and ends just before the end of the function.
C
After having ignored the rest of the line, the program goes to the second line. We start with a semicolon because the a=1 statement needs to be terminated. After that, we encounter a simple for loop that prints the iterating variable, a, twice on each iteration.
Outside of the for loop, the /* is just there to ignore Röda's ending */ comment.

laserLANG / ><>, 163 bytes
!\0 \
/:+1/!   ]oo\
\:a( ?\:a%$a ,!
/r[-1l//" ,"/
/!n-%1:\?(1l
 \ --\/ <<---\
/----/'
\----  v
/>>--\#>---->/
\     /
/----<
\  \
/ -<< \
 /<< \
 "
">=>= /
\>=>=/

First time golfing, so it's a bit larger than it probably could be. I wanted to use ><>, but since a few people already used it to create the second sequence, I decided I wanted to give creating the first sequence a go.
Try ><> online!
For laserLANG, an offline interpreter is needed to try it. It can be found here.
laserLANG
!\
 \ --\/ <<---\
/----/'
\----  v
/>>--\#>---->/
\     /
/----<
\  \
/ -<< \
 /<< \
 "
">=>= /
\>=>=/

execution starts at ! which is ignored completely. it then reaches the \ and starts traveling down past several characters that it completely ignores. Finally it reaches another \ and the fun begins. I basically took the idea behind the "Hello, World!" loop and condensed it as well as I could. It was a bit of a challenge dealing with the fact that laserLANG is only about to decrement/increment the memory counter when the program counter is going left/right respectively. I feel like the most bytes could be saved here by doing some tricks I haven't thought of.
><>
!\0 \
/:+1/!   ]oo\
\:a( ?\:a%$a ,!
/r[-1l//" ,"/
/!n-%1:\?(1l

Execution starts at ! which causes it to skip the \. It then continues on as if the laserLANG code wasn't there. I didn't realize ><> only had support for float division, so a short and simple truncation was a bit confusing at first.

Befunge-98/><>, 32 bytes
\r.#%a/# :_::p#+a#1,#
>l::naonao

Wrote this before I saw how many ><> answers there were. Some background: \ is a direction changing operator in ><>, in this case pushing it down, while in Befunge it swaps the top two items on the stack. The Befunge code looks like:
\r.#%a/# :_::p#+a#1,#

Try it online!
Prints out the backwards numbers separated by newlines. Befunge prints a space automatically after each number, so each digit is separated by spaces. Repeatedly gets the last digit, prints it and divides the number by 10 until it is 0. Then increment and repeat.
The ><> code immediately goes down to the second line.
>l::naonao

Try it online!
And is pretty simple. Get length of stack, print twice with newlines and leave a copy of the length on the stack for the next loop.

Ruby/Stacked, 37 bytes
0#/0[1+:tostr rev out]
loop{p p$.+=1}

Try it online!
This prints 1 1 2 2... in Ruby and 1 2 3 ... 01 11 21... in Stacked.
Explanation
In Ruby:
0#/0[1+:tostr rev out]
loop{p p$.+=1}

After removing the comment, this becomes:
0
loop{p p$.+=1}

The only relevant line here is the last. p returns its argument, so p p prints its argument twice. $. starts at 0, so $.+=1 increments $., returning the incremented value. Therefore, this prints each number from 1 twice.
In Stacked:
0#/0[1+:tostr rev out]
loop{p p$.+=1}

This is equivalent to the following tokens:
0 #/ 0 [ 1 + : tostr rev out ] loop { p p $ . + = 1 }

The first two are not relevant (basically, transforming 0 into a reduce f Unction). Then, 0 is pushed to the stack. After, the function [1+:tostr rev out] is pushed to the stack. loop pops this function and executes it infinitely.
The inside of the function increments the top of the stack (1+), duplicates it (:), converts it to a string (tostr), reverses it (rev) and outputs it (out). This process is repeated infinitely. Since the loop is infinite, anything that comes after that token is essentially ignored by the interpreter.

><> / Jelly, 37 bytes (25 in Jelly's codepage)
01+:nao:nao!
DU;⁷Ṙ€
®‘©Çß

Try ><> online!
Try Jelly online!
><> prints the sequence to infinity twice, Jelly counts backwards.
><> is only concerned with the top line:
And thanks to @Challenger5 for saving some bytes here on the linefeed
01+:nao:nao!                           Stack at: 1st run   2nd run ...
0                 Push a 0             0         -
 1                Push a 1             0,1       1,1
  +               Pop 2, add them      1         2
   :              Duplicate top item   1, 1      2, 2
    n             Pop top, show as num 1         2
     a            Push the number 10   1, 10     2, 10
      o           Pop and show 10 as an ACII char (ie '\lf')
                                       1         2
         :nao     And again, for repetition
             !    ><> wraps around; this skips pushing a 0 again.

Jelly executes its code bottom-to-top. Only the last 2 lines are relevant.
®‘©Çß       main link, keeps track of the current number

®           Get a number from the register (0 on first run)
 ‘          Increment that by 1
  ©         Store in register
   Ç        Call helper (printer) link
    ß       Call this link again

DU;⁷Ṙ€      Printer

            (Say we are at number 21)
D           Break into digits         [2, 1]
 U          Reverse array             [1, 2]
  ;⁷        Append a line break       [1, 2, \n]
    Ṙ€      Print each char in array

@LuisMendo The characters used in this ><> code have ASCII code-points that correspond with the Jelly Codepage. I don't know too much about this codepage business, but I think this would result in the same bytes used to represent the code. The characters on the lower lines are ignored by ><> so it doesn't matter if they are exactly the same between the codepages. The byte count was taken from the ><> TIO link.

Aren't these being printed without a separator in ><>?

@Challenger5 you'r right; fixed.

Fish doesn't have a character type; "," just pushes the ASCII value of , to the stack, so you can use a instead for a newline separator.

It looks like the commas are still there on first line of the ><> explanation.

C (gcc)/PHP, 102 86 80 bytes
#//\
for(;;)echo strrev(++$i).'
int main(i){for(;;i++)printf("%d %d ",i,i);}//';

Outputs the double sequence in C and the reverse sequence in PHP.
Try it in C!
Try it in PHP!
Explanations
C
In C, the # forms preprocessor stuff. I don't really know much about C but it doesn't complain when there's any empty line for this stuff. The // forms a line comment. A \ at the end of a line is essentially "escaping" the newline and making the two lines be treated as one. This also works for line comments, so the second line is seen as a comment in C. The third line does the work of outputting the numbers with a simple for loop. Afterwards, there is simply a comment.
PHP
In PHP, # forms a line comment, so the first line is ignored entirely. The second line prints the numbers reversed with a for loop, and separates them with \nint main(i){for(;;i++)printf("%d %d ",i,i);}// (the C code wrapped in a string).

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/