Coconut, Sailors, and Monkeys
As you are dealing with whole numbers and remainders do not use floating point numbers. It's inaccurate and furthermore confusing because others may think that the result may be not a whole number.
As the solutions will get very high very fast consider to use BigInteger
During calculation make sure your divisions will always be without rest
Avoid return statements within the loop. Programmers have to search for breaking conditions through the code if you do not provide them in the loop header. Beside readability unexpected return, break or continue statements cause serious problems when extending the code or applying refactorings like "extract method".
Use lazy evaluation of boolean operators (&amp;&amp; instead of &amp;). In complex evaluations you give other developers the chance to count on the evaluation and produce side effects.
Separate responsibilities. Currently two algorithms are fighting against each other. One is providing a factor and the other is using the factor to try a calculation. But maybe the second algorithm is not satisfied by the factor what is evaluated during calculation. This should be modelled explicitly.


I am not a mathematician. Maybe there is a more efficient way (a shortcut) to calculate it. But I won't cover that.

So here is a refactored version. It's more verbose but it has less accuracy problems and shows the responsibilites of the two algorithms. They communicate through a result object that contains the calculated base value so far and the information if the method was satisfied by the factor given so the base value is a valid result.

    public static BigInteger calculateCoconuts(final long sailors) {

        long factor = 1;

        CalculationResult calculationResult = null;

        do {

            calculationResult = tryCoconutCalculation(sailors, factor);
            factor++;

        } while (!calculationResult.isSatisfied());

        return calculationResult.getBaseValue();

    }

    private static CalculationResult tryCoconutCalculation(final long sailors, long factor) {

        BigInteger factorBI = BigInteger.valueOf(factor);
        BigInteger sailorsBI = BigInteger.valueOf(sailors);
        BigInteger baseValueBI = factorBI.multiply(sailorsBI);

        long counter = 0;

        boolean satisfied = baseValueBI.remainder(sailorsBI.subtract(BigInteger.ONE)).equals(BigInteger.ZERO);

        while (satisfied &amp;&amp; (counter &lt; sailors)) {
            baseValueBI = baseValueBI.divide(sailorsBI.subtract(BigInteger.ONE)).multiply(sailorsBI).add(BigInteger.ONE);
            counter++;
            if (counter &lt; sailors) {
                satisfied = baseValueBI.remainder(sailorsBI.subtract(BigInteger.ONE)).equals(BigInteger.ZERO);
            }
        }

        return new CalculationResult(baseValueBI, satisfied);
    }


    public static class CalculationResult {

        private BigInteger baseValue;
        private boolean satisfied;

        public CalculationResult(BigInteger baseValue, boolean satisfied) {
            super();
            this.baseValue = baseValue;
            this.satisfied = satisfied;
        }

        public BigInteger getBaseValue() {
            return baseValue;
        }

        public boolean isSatisfied() {
            return satisfied;
        }

    }