Solve hanging lantern problem: Difference between revisions

=={{header|APL}}==

{{trans|Pascal}}

{{Out}}

<pre> lanterns 1 2 3

{{trans|FreeBASIC}}

The result for n >= 5 is slow to emerge

n = 4

dim a(n)

if res = 0 then res = 1

return res

{{out}}

<pre>Same as FreeBASIC entry.</pre>

{{trans|Python}}

The (1,2,3) example takes about 30 seconds to run on a stock C64; (1,2,3,4) takes about an hour and 40 minutes. Even on a 64 equipped with a 20MHz SuperCPU it takes about 5 minutes.

110 INPUT "HOW MANY COLUMNS "; N

120 DIM NL(N-1):T=0

410 GOTO 320

420 IF R(SP)=0 THEN R(SP)=1

 

{{Out}}

==={{header|FreeBASIC}}===

{{trans|Python}}

Dim As Ulong res = 0

For i As Ulong = 1 To Ubound(arr)

Print "] = "; getLantern(a())

Next i

{{out}}

<pre>[ 1 ] = 1

{{trans|FreeBASIC}}

The result for n >= 5 is slow to emerge

res = 0

FOR i = 1 TO UBOUND(arr)

PRINT "] = "; getLantern(a())

NEXT i

{{out}}

<pre>Same as FreeBASIC entry.</pre>

{{trans|FreeBASIC}}

The result for n >= 5 is slow to emerge

Procedure getLantern(Array arr(1))

res.l = 0

Next i

Input()

{{out}}

<pre>Same as FreeBASIC entry.</pre>

====Recursive version====

;Main code

Dim n As Integer, c As Integer

Dim a() As Integer

If res = 0 Then res = 1

getLantern = res

 

;Form code:

VERSION 5.00

Begin VB.Form Form1

Attribute VB_Creatable = False

Attribute VB_PredeclaredId = True

 

====Math solution====

Reimplemented "getLantern" function above

 

Dim tot As Integer, res As Integer

Dim i As Integer

factorial = factorial * i

Next i

 

==={{header|Yabasic}}===

{{trans|FreeBASIC}}

The result for n >= 5 is slow to emerge

dim a(n)

for i = 1 to arraysize(a(),1)

if res = 0 res = 1

return res

{{out}}

<pre>Same as FreeBASIC entry.</pre>

Translation of [[#APL|APL]]:

 

 

Example use:

 

60

lanterns 1 3 3

140

 

Also, a pedantic version where we must manually count how many values we are providing the computer:

 

assert. ({. = #@}.) y

lanterns }.y

 

And, in the spirit of providing unnecessary but perhaps pleasant (for some) overhead, we'll throw in an unnecessary comma between this count and the relevant values:

 

60

pedantic 3, 1 3 3

 

If we wanted to impose even more overhead, we could insist that the numbers be read from a file where tabs, spaces and newlines are all treated equivalently. For that, we must specify the file name and implement some parsing:

 

pedantic ({.~ 1+{.) _ ". rplc&(TAB,' ',LF,' ') fread y

 

Examples of this approach are left as an exercise for the user (note: do not use commas with this version, unless you modify the code to treat them as whitespace).

Finally, enumerating solutions might be approached recursively:

 

arrange=. ($ $ (* +/\)@,) y $&>1

echo 'lantern ids:'

echo 'all lantern removal sequences:'

echo >a:-.~ -.&0 each;0 recur cols

 

Example use:

 

lantern ids:

1 2 4

4 1 3 2

4 3 1 2

 

=={{header|Julia}}==

using Combinatorics

lanternproblem()

lanternproblem(false)

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

Input number of columns, then column heights in sequence:

 

This solution avoids recursion and calculates the result mathematically. As noted in the Picat solution, the result is a multinomial coefficient, e.g. with columns of length 3, 6, 4 the result is (3 + 6 + 4)!/(3!*6!*4!).

program LanternProblem;

uses SysUtils;

until false;

end.

{{out}}

<pre>

 

=={{header|Perl}}==

 

use strict; # https://rosettacode.org/wiki/Solve_hanging_lantern_problem

find( $` . $', $found . $& ) while $in =~ /\w\b/g;

$in =~ /\w/ or $answer .= '[' . $found =~ s/\B/,/gr . "]\n";

{{out}}

<pre>

 

=={{header|Phix}}==

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #008080;">include</span> <span style="color: #004080;">mpfr</span><span style="color: #0000FF;">.</span><span style="color: #000000;">e</span>

<span style="color: #000000;">test</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">[</span><span style="color: #000000;">1</span><span style="color: #0000FF;">..</span><span style="color: #000000;">i</span><span style="color: #0000FF;">])</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>

{{out}}

<pre>

=={{header|Picat}}==

{{trans|Python}}

run_lantern().

 

if Res == 0 then

Res := 1

 

Some tests:

A = [1,2,3],

println(lantern(A)),

println(1..N=lantern(1..N))

end,

 

{{out}}

===Recursive version===

{{trans|Visual Basic}}

def getLantern(arr):

res = 0

a.append(int(input()))

print(getLantern(a))

 

===Math solution===

import math

n = int(input())

res /= math.factorial(a[i])

print(int(res))

 

===Showing Sequences===

if not any(x):

yield tuple()

# an example

for x in seq([1, 2, 3]):

 

=={{header|Raku}}==

If all we need is the count, then we can compute that directly:

 

 

sub postfix:<!>($n) { [*] 1..$n }

 

 

{{Out}}

If we want to list all of the sequences, we have to do some more work. This version outputs the sequences as lists of column numbers (assigned from 1 to N left to right); at each step the bottommost lantern from the numbered column is removed.

 

 

my @sequences = @columns

say +@sequences;

}

 

{{Out}}

If we want individually-numbered lanterns in the sequence instead of column numbers, as in the example given in the task description, that requires yet more work:

 

 

my @sequences = @columns

} else {

say +@sequences;

 

{{Out}}

{{trans|Python}}

The result for n == 5 is slow to emerge.

lantern = Fn.new { |n, a|

var count = 0

n = n + 1

System.print("%(a) => %(lantern.call(n, a))")

 

{{out}}

{{libheader|Wren-big}}

Alternatively, using library methods.

import "./big" for BigInt

 

System.print("%(a) => %(BigInt.multinomial(36, a))")

listPerms.call([1, 2, 3], 4)

 

{{out}}

 

=={{header|XPL0}}==

 

proc Tally(Level);

Tally(0);

IntOut(0, Sequences);

 

{{out}}