Sailors, coconuts and a monkey problem: Difference between revisions

{{trans|Python}}

 

V nuts = sailors

L

V (nuts, wake_stats) = monkey_coconuts(sailors)

print("\nFor #. sailors the initial nut count is #.".format(sailors, nuts))

 

{{out}}

 

=={{header|AutoHotkey}}==

{

sailor := A_Index+4

result["Remaining"] := coconut

return result

{{out}}

<pre>---------------------------

 

=={{header|AWK}}==

# syntax: GAWK -f SAILORS_COCONUTS_AND_A_MONKEY_PROBLEM.AWK

# converted from LUA

return((nuts != 0) && (nuts % n == 0))

}

{{out}}

<pre>

This script implements a solution in the coconuts function for a number of sailors > 1 and a number of monkeys between 1 and sailors-1. It also executes the coconuts function for some values of sailors/monkeys.

 

print "coconuts(", sailors, ", ", monkeys, ") = "

if (sailors < 2 || monkeys < 1 || sailors <= monkeys) {

coconuts(5, 4)

coconuts(6, 1)

 

{{out}}

This is a translation of the second C solution. The output lists the number of sailors, the size of the original pile, and the final share each sailor receives the following morning.

 

nvg10*g10:+>#1$<

#>\:01g1-%#^_:0v

-|:-1\+1<+/-1g1<

1>$01g.">-",,48v

 

{{out}}

=={{header|Bracmat}}==

{{trans|Tcl}} (Though without the <code>assert</code> procedure.)

= a b

. !arg:(?a.?b)&(div$(!a.!b).mod$(!a.!b))

& minnuts$!n

)

 

Output:

 

=={{header|C}}==

int valid(int n, int nuts)

}

return 0;

{{out}}

<pre>2: 11

But it's faster to search backwards: if everyone receives some coconuts,

see if we can backtrack to the original pile:

 

// calculates if everyone got some nuts in the end, what was the original pile

}

return 0;

{{out}}

sailers: original pile, final share

=={{header|C sharp|C#}}==

{{trans|Java}}

{

static bool valid(int n, int nuts)

}

}

 

<pre>2: 11

=={{header|C++}}==

{{trans|C#}}

 

bool valid(int n, int nuts) {

 

return 0;

{{out}}

<pre>2: 11

A rather non-Clojure-like solution:

 

(with-local-vars [coconuts initial-coconut-count, hidings 0]

(while (and (> @coconuts sailors) (= (mod @coconuts sailors) 1)

(str "\tIn the morning, each sailor gets another " (/ @coconuts sailors) " coconuts."))

(println "\tThe monkey gets no more.\n"))))

 

{{Out}}

=={{header|D}}==

{{trans|Kotlin}}

import std.stdio;

 

}

}

 

{{out}}

{{trans|Ruby}}

===Brute Force===

def valid?(sailor, nuts), do: valid?(sailor, nuts, sailor)

n - 1 - d

end)

 

{{out}}

 

===Faster version===

def coconuts(sailor), do: coconuts(sailor, sailor)

defp coconuts(sailor, nuts) do

Enum.each(2..9, fn sailor ->

IO.puts "#{sailor}: #{Sailor.coconuts(sailor)}"

 

{{out}}

=={{header|Forth}}==

{{trans|uBasic/4tH}}

over * over 1- rot 0 ?do

over over mod if dup xor swap leave else over over / 1+ rot + swap then

;

 

{{out}}

<pre>2: 11 1

=={{header|FreeBASIC}}==

{{trans|Yabasic}}

Dim As Integer cocos = 11

 

Next ns

Sleep

 

 

=={{header|Go}}==

{{trans|Kotlin}}

 

import "fmt"

}

}

 

{{out}}

This program works by applying a function to increasing multiples of the number of sailors. The function takes a potential final number of coconuts (at the time the sailors awaken) and works backwards to get to the initial number of coconuts. At every step, it will abort the computation if the current number of coconuts can't arise as a result of splitting the previous pile.

 

import Data.Maybe (mapMaybe)

import System.Environment (getArgs)

s:_ -> read s

a = head . mapMaybe (tryFor n) $ [n,2 * n ..]

Examples:

<pre>

Here, we assume an answer which is less than 10000, and try each possibility, constraining ourselves to the list of answers which are valid. (As it happens, there's only one of those.)

 

 

These sailors must count coconuts extremely quickly.

When we do this with six sailors, it turns out that we have to assume a larger initial value:

 

 

If it were not obvious which of the answers here was the minimum value we could additionally pick the smallest value from the list. But that would require typing two extra characters (for example, replace I. with i.&1), and most people already have so much trouble reading J that the extra code would surely be too much.

=={{header|Java}}==

{{trans|C}}

 

static boolean valid(int n, int nuts) {

}

}

<pre>2: 11

3: 25

( As in the recursive Python example )

 

 

// wakeSplit :: Int -> Int -> Int -> Int

return intNuts;

});

 

{{out}}

 

 

===ES6===

"use strict";

 

// MAIN ---

return main();

 

{{Out}}

 

=={{header|jq}}==

 

If your jq does not have "until" defined, here is its definition:

 

===Simulation===

# the night-time squirreling away of the coconuts by "sailors" sailors, then give 1 to the

# monkey, let one sailor squirrel away (1/sailors) coconuts, and yield the remaining number;

 

# Test whether the input is a valid number of coconuts with respect to the story:

'''Five sailors''':

Find the minimum number of coconuts if there are 5 sailors --

start at 1 as there must be at least one to give to the monkey during the night:

{{out}}

3121

Find the minimum number of coconuts if there are 6 sailors --

start at 1 as there must be at least one to give to the monkey during the night:

{{out}}

233275

 

===Working backwards===

# the surreptitious squirreling away by one sailor,

# then emit the number of coconuts which that sailor originally

" and each sailor finally ended up with \(.[0])." ;

{{out}}

With 3 sailors, there were originally 25 coconuts, and each sailor finally ended up with 2.

With 4 sailors, there were originally 765 coconuts, and each sailor finally ended up with 60.

With 6 sailors, there were originally 233275 coconuts, and each sailor finally ended up with 13020.

With 7 sailors, there were originally 823537 coconuts, and each sailor finally ended up with 39990.

 

=={{header|Julia}}==

{{trans|C#}}

function validnutsforsailors(sailors, finalpile)

for i in sailors:-1:1

 

runsim()

{{output}}

<pre>

 

=={{header|Kotlin}}==

 

fun main(args: Array<String>) {

}

}

 

{{out}}

=={{header|Lua}}==

{{trans|C}}

local k = n

local i = 0

end

print(n..": "..x)

{{out}}

<pre>2: 11

 

=={{header|Mathematica}} / {{header|Wolfram Language}}==

SequenceOk[n_, k_] := Module[{m = n, q, r, valid = True},

Do[

i = 1;

While[! SequenceOk[i, 6], i++]

{{out}}

<pre>3121

 

=={{header|Modula-2}}==

FROM FormatString IMPORT FormatString;

FROM Terminal IMPORT WriteString,WriteLn,ReadChar;

 

ReadChar

 

=={{header|Nim}}==

{{trans|Kotlin}}

 

var coconuts = 11

else:

break # Failed. Continue search with more coconuts.

 

{{out}}

=={{header|Objeck}}==

{{trans|C}}

class Program {

function : Total(n : Int, nuts : Int) ~ Int {

}

}

{{out}}

<pre>

Use of <code>bigint</code> required or program silently fails for number of sailors > 13

{{trans|Raku}}

 

for $sailors (1..15) { check( $sailors, coconuts( 0+$sailors ) ) }

if ($sailors % 2 == 0 ) { ($sailors ** $sailors - 1) * ($sailors - 1) }

else { $sailors ** $sailors - $sailors + 1 }

{{out}}

<pre style="height:60ex;overflow:scroll;">

The morning pile must be a multiple of sailors, so this only tries multiples of sailors! Needed an ugly kludge for solve(1),

the limit of 1 billion suffices for solve(9), above that gets run-time type check errors as capacity of ints are blown anyway.

<span style="color: #008080;">procedure</span> <span style="color: #000000;">solve</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">sailors</span><span style="color: #0000FF;">)</span>

<span style="color: #004080;">integer</span> <span style="color: #000000;">m</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">sm1</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">sailors</span><span style="color: #0000FF;">-</span><span style="color: #000000;">1</span>

<span style="color: #000000;">solve</span><span style="color: #0000FF;">(</span><span style="color: #000000;">5</span><span style="color: #0000FF;">)</span>

<span style="color: #000000;">solve</span><span style="color: #0000FF;">(</span><span style="color: #000000;">6</span><span style="color: #0000FF;">)</span>

{{out}}

<pre>

 

=={{header|Picat}}==

between(2,9,N), % N: number of sailors

once s(N),

next_candidate(N+1,N,C), % C: original number of coconuts

divide(N,N,C,Cr), % Cr: remainder

printf("%d: original = %d, remainder = %d, final share = %d\n",N,C,Cr,Cr div N).

 

next_candidate(From,Step,X) => next_candidate(From+Step,Step,X).

 

divide(N,I,C,Cr) =>

(C-1) mod N == 0,

C1 = Q*(N-1),

divide(N,I-1,C1,Cr).

{{out}}

<pre>

You may want to read [http://paddy3118.blogspot.co.uk/2015/05/solving-monkey-and-coconuts-problem.html Solving the Monkey and coconuts problem] to get more background on the evolution of the Python code.

===Python: Procedural===

"Parameterised the number of sailors using an inner loop including the last mornings case"

nuts = sailors

print("\nFor %i sailors the initial nut count is %i" % (sailors, nuts))

print("On each waking, the nut count, portion taken, and monkeys share are:\n ",

 

{{out}}

===Python: Recursive===

 

if depth is None:

depth = sailors

nuts = monkey_coconuts(sailors)

print("For %i sailors the initial nut count is %i" % (sailors, nuts))

 

{{out}}

===by solving Diophantine equation===

The following is a more or less general solution for arbitrary number of sailors and varying numbers of coconuts the monkey gets. The monkey can be given more coconuts than there are sailors each turn. This is not part of task requirement.

def dioph(a, b, c):

aa,bb,x,y = a, b, 0, 1

 

# many sailors, many nuts

 

=={{header|R}}==

The only tricky bit is reading comprehension. For example, it's easy to miss that the coconut count after the final nighttime visit must be strictly positive and divisible by the number of sailors.

{

stopifnot(sailorCount > 1) #Problem makes no sense otherwise

}

}

{{out}}

<pre> Sailors Coconuts

=={{header|Racket}}==

{{trans|Python}}

 

(define (wake-and-split nuts sailors depth wakes)

(printf "For ~a sailors the initial nut count is ~a\n" sailors (first (last wakes)))

(map displayln (reverse wakes))

{{out}}

<pre>For 5 sailors the initial nut count is 3121

This will test combinations of sailors and coconuts to see if they form a valid pairing. The first 6 are done using brute force, testing every combination until a valid one is found. For cases of 7 to 15 sailors, it uses a carefully crafted filter to drastically reduce the number of trials needed to find a valid case (to one, as it happens... :-) )

 

my @teens = 'th' xx 10;

my @suffix = lazy flat (@ones, @teens, @ones xx 8) xx *;

 

multi sub coconuts ( $sailors where { $sailors % 2 == 0 } ) { ($sailors - 1) * ($sailors ** $sailors - 1) }

{{out}}

<pre>

{{trans|C}} {from the 1^st '''C''' example}<br>

 

parse arg L H .; if L=='' then L= 5 /*L not specified? Then use default.*/

if H=='' then H= 6 /*H " " " " default.*/

nuts=nuts - (1 + nuts % n) /*subtract number of coconuts from pile*/

end /*k*/

Programming note: &nbsp; The parentheses in the last REXX ('''return''') statement aren't necessary, but help for readability. <br>

 

This REXX version is the same as the above version (but the defaults are different),

<br>and it also eliminates the use of a subroutine, making it faster.

 

do n=2 to 9 /*traipse through number of sailors. */

end /*$*/

say 'sailors='n " coconuts="$ /*display number of sailors & coconuts.*/

{{out|output|text=&nbsp; when using the default inputs:}}

<pre>

{{trans|C}} {from the 2^nd '''C''' example}<br>

 

parse arg L H .; if L=='' then L= 2 /*L not specified? Then use default.*/

if H=='' then H= 9 /*H " " " " " */

nuts= nuts + 1 + nuts % nn /*bump the number coconuts to the pile.*/

end /*k*/

{{out|output|text=&nbsp; when using the default inputs:}}

<pre>

 

=={{header|Ring}}==

# Project : Sailors, coconuts and a monkey problem

 

next

see "In the morning each sailor gets " + m/sailors + " nuts" + nl + nl

Output:

<pre>

=={{header|Ruby}}==

===Brute Force===

sailor.times do

return false if (nuts % sailor) != 1

n -= 1 + div

end

{{out}}

<pre>5 sailors => 3121 coconuts

===Faster version===

{{works with|Ruby|2.1+}}

sailor.step(by:sailor) do |nuts|

flag = sailor.times do

(2..9).each do |sailor|

puts "#{sailor}: #{coconuts(sailor)}"

{{out}}

<pre>2: 11

9: 387420481</pre>

===A function to find the solution see [[User_talk:Nigel_Galloway#Inflammatory_stuff]] for a description===

def _ng (sailors, iter, start) #a method that given a possible answer applies the constraints of the tale to see if it is correct

n, g = [start], [start/sailors]

end

 

===A possible use of the function===

{{out}}

The output consists of two list. The first is the number of nuts in each pile, the second the number of nuts taken by each dishonest sailor. So in the case of three, start with 25 nuts, the first sailor takes 8 and discards 1 leaving a pile of 16. The second sailor takes 5 and discards 1 leaving 10. The last dishonest sailor takes 3 discards 1 leaving 6 nuts, which can be shared equally between the 3 (2 each).

Number of sailors = 10

[[31381059600, 34867844001, 38742048891, 43046720991, 47829689991, 53144099991, 59048999991, 65609999991, 72899999991, 80999999991, 89999999991], [3138105960, 3486784400, 3874204889, 4304672099, 4782968999, 5314409999, 5904899999, 6560999999, 7289999999, 8099999999, 8999999999]]</pre>

n = ng(100)

The number of coconuts requires is as follows, the whole output is at [[Sailors, coconuts and a monkey problem/Ruby output 100]]

<pre>9899999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999901</pre>

=={{header|Scala}}==

{{Out}}Best seen running in your browser either by [https://scalafiddle.io/sf/jBSqGXg/0 ScalaFiddle (ES aka JavaScript, non JVM, be patient)] or [https://scastie.scala-lang.org/lZXMc4YBSl2htEBw4D2TUQ Scastie (remote JVM)].

var x = 0

 

}

 

 

=={{header|Sidef}}==

{{trans|Bc}}

if ((sailors < 2) || (monkeys < 1) || (sailors <= monkeys)) {

return 0

2.to(9).each { |sailor|

say "#{sailor}: #{coconuts(sailor)}";

{{out}}

<pre>

This is a very straightforward implementation. The "overnight" proc attempts to fulfill the activities of the night, throwing an error (through "assert") if it cannot. "minnuts" keeps trying to call it with more nuts until it succeeds. On success, "overnight" will return a list which narrates the night's activities.

 

if {![uplevel 1 [list expr $expr]]} {

if {$msg eq ""} {

puts "Solution with $n sailors:"

minnuts $n

 

{{out}}

{{trans|C}}

For performance reasons, we limit ourselves to seven sailors.

t = 0

For x = 1 Step 1 While t = 0

b@ = b@ + 1 + b@ / a@

Next

{{out}}

<pre>2: 11 1

 

0 OK, 0:127</pre>

 

=={{header|VBA}}==

Public Sub coconuts()

Dim sailors As Integer

Debug.Print sailors, minimum, finalshare

Next sailors

<pre>Sailors Pile Final share

2 11 1

=={{header|Wren}}==

{{trans|Kotlin}}

for (ns in 2..9) {

var hidden = List.filled(ns, 0)

coconuts = coconuts + ns

}

 

{{out}}

=={{header|Yabasic}}==

{{trans|D}}

 

for ns = 2 to 9

coconuts = coconuts + ns

loop

 

=={{header|zkl}}==

{{trans|Python}}

nuts,wakes:=sailors,List();

while(True){

println("On each waking, the nut count, portion taken, and monkeys share are:\n ",

wake_stats.concat("\n "));

{{out}}

<pre>

</pre>

{{trans|C}}

nuts *= n;

foreach k in (n){

break;

}

{{out}}

<pre>