Rosetta Code

Knapsack problem/Continuous: Difference between revisions

Page Discussion

Knapsack problem/Continuous (view source)

Revision as of 17:12, 27 August 2022

2,329 bytes added ,  1 year ago
m
syntax highlighting fixup automation
(Knapsack problem/Continuous in FreeBASIC)
m (syntax highlighting fixup automation)
Line 55:
{{trans|Python}}
 
<langsyntaxhighlight lang="11l">V items = [(‘beef’, 3.8, 36.0),
(‘pork’, 5.4, 43.0),
(‘ham’, 3.6, 90.0),
Line 83:
print(‘ ITEM PORTION VALUE’)
print(bagged.map((n, p, a) -> ‘#10 #3.2 #3.2’.format(n, p, a)).join("\n"))
print("\nTOTAL WEIGHT: #2.2\nTOTAL VALUE: #2.2".format(wt, val))</langsyntaxhighlight>
 
{{out}}
Line 99:
 
=={{header|Ada}}==
<langsyntaxhighlight Adalang="ada">with Ada.Text_IO;
with Ada.Float_Text_IO;
with Ada.Strings.Unbounded;
Line 201:
end loop;
end Knapsack_Continuous;
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 215:
 
=={{header|AWK}}==
<langsyntaxhighlight AWKlang="awk"># syntax: GAWK -f KNAPSACK_PROBLEM_CONTINUOUS.AWK
BEGIN {
# arr["item,weight,price"]
Line 257:
exit(0)
}
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 271:
=={{header|BBC BASIC}}==
{{works with|BBC BASIC for Windows}}
<langsyntaxhighlight lang="bbcbasic"> INSTALL @lib$+"SORTSALIB"
Sort% = FN_sortSAinit(1, 0) : REM Descending
Line 309:
PRINT '"Total weight = " ; TotalWeight " kg"
PRINT "Total price = " ; TotalPrice
END</langsyntaxhighlight>
Output:
<pre>Take all the salami
Line 325:
The table of weights and prices are stored as strings to make them easier to edit. Two characters for the weight (with the decimal point dropped), two characters for the price, and then the name of the item. The total numbers of items (9) is specified by the first value on the stack.
 
<langsyntaxhighlight lang="befunge">9:02p>:5+::::::0\g68*-55+*\1\g68*-+\0\pv>2gg!*::!2v
>\`!v|:-1p\3\0p\2\+-*86g\3\*+55-*86g\2<<1v*g21\*g2<
nib@_>0022p6>12p:212gg48*:**012gg/\-:0`3^+>,,55+%6v
Line 339:
3767welt
3095salami
5998sausage</langsyntaxhighlight>
 
{{out}}
Line 349:
 
=={{header|Bracmat}}==
<langsyntaxhighlight lang="bracmat">( ( fixed {function to convert a rational number to fixed point notation.
The second argument is the number of decimals. }
= value decimals powerOf10
Line 398:
| out$(fixed$(!totalPrice.2))
)
);</langsyntaxhighlight>
Output:<pre>3.5 kg of welt
2.4 kg of greaves
Line 407:
 
=={{header|C}}==
<langsyntaxhighlight lang="c">#include <stdio.h>
#include <stdlib.h>
 
Line 443:
 
return 0;
}</langsyntaxhighlight>output<pre>
take all salami
take all ham
Line 452:
 
=={{header|C sharp|C#}}==
<langsyntaxhighlight lang="csharp">using System; //4790@3.6
class Program
{
Line 484:
static string[] items = {"beef","pork","ham","greaves","flitch",
"brawn","welt","salami","sausage"};
}</langsyntaxhighlight>
Sorting three times is expensive,
an alternative is sorting once, with an indices array.
<langsyntaxhighlight lang="csharp">using System;
class Program
{
Line 519:
static string[] items = {"beef","pork","ham","greaves","flitch",
"brawn","welt","salami","sausage"};
}</langsyntaxhighlight>
 
=={{header|C++}}==
<langsyntaxhighlight lang="cpp">#include<iostream>
#include<algorithm>
#include<string.h>
Line 616:
 
return 0;
}</langsyntaxhighlight>
 
{{out}}
Line 631:
 
===Alternate Version===
<langsyntaxhighlight lang="cpp">// C++11 version
#include <iostream>
#include <vector>
Line 683:
space -= item.weight;
}
}</langsyntaxhighlight>
 
{{out}}
Line 695:
 
=={{header|Clojure}}==
<syntaxhighlight lang="clojure">
<lang Clojure>
; Solve Continuous Knapsack Problem
; Nicolas Modrzyk
Line 744:
 
(rob items maxW)
</syntaxhighlight>
</lang>
Output<pre>
Take all :salami
Line 755:
 
===Alternate Version===
<syntaxhighlight lang="clojure">
<lang Clojure>
(def items
[{:name "beef" :weight 3.8 :price 36}
Line 780:
 
(rob items 15)
</syntaxhighlight>
</lang>
 
=={{header|Common Lisp}}==
<langsyntaxhighlight lang="lisp">(defstruct item
(name nil :type string)
(weight nil :type real)
Line 810:
(make-item :name "sausage" :weight 5.9 :price 98))))
(loop for (name amount) in (knapsack items 15)
do (format t "~8A: ~,2F kg~%" name amount))))</langsyntaxhighlight>
{{out}}
<pre>salami : 3.00 kg
Line 819:
 
=={{header|D}}==
<langsyntaxhighlight lang="d">import std.stdio, std.algorithm, std.string;
 
struct Item {
Line 866:
writefln("%(%s\n%)", chosen);
Item("TOTAL", chosen.sumBy!"amount", chosen.sumBy!"value").writeln;
}</langsyntaxhighlight>
{{out}}
<pre> ITEM AMOUNT VALUE $/unit
Line 877:
 
===Alternative Version===
<langsyntaxhighlight lang="d">void main() {
import std.stdio, std.algorithm;
 
Line 902:
} else
return writefln("Take %.1fkg %s", left, it.item);
}</langsyntaxhighlight>
{{out}}
<pre>Take all the salami
Line 911:
 
=={{header|EchoLisp}}==
<langsyntaxhighlight lang="scheme">
(lib 'struct)
(lib 'sql) ;; for table
Line 950:
 
 
</syntaxhighlight>
</lang>
 
=={{header|Eiffel}}==
<syntaxhighlight lang="eiffel">
<lang Eiffel>
class
CONTINUOUS_KNAPSACK
Line 1,025:
 
end
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 1,038:
=={{header|Elixir}}==
{{trans|Erlang}}
<langsyntaxhighlight lang="elixir">defmodule KnapsackProblem do
def select( max_weight, items ) do
Enum.sort_by( items, fn {_name, weight, price} -> - price / weight end )
Line 1,073:
{"sausage", 5.9, 98} ]
 
KnapsackProblem.task( items, 15 )</langsyntaxhighlight>
 
{{out}}
Line 1,087:
===Alternate Version===
{{trans|Ruby}}
<langsyntaxhighlight lang="elixir">defmodule KnapsackProblem do
def continuous(items, max_weight) do
Enum.sort_by(items, fn {_item, {weight, price}} -> -price / weight end)
Line 1,118:
sausage: {5.9, 98} ]
 
KnapsackProblem.continuous( items, 15 )</langsyntaxhighlight>
 
{{out}}
Line 1,133:
=={{header|Erlang}}==
Note use of lists:foldr/2, since sort is ascending.
<syntaxhighlight lang="erlang">
<lang Erlang>
-module( knapsack_problem_continuous ).
 
Line 1,170:
select_until_weight( Weight, Remains ) when Weight < Remains -> Weight;
select_until_weight( _Weight, Remains ) -> Remains.
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 1,183:
 
=={{header|F_Sharp|F#}}==
<langsyntaxhighlight lang="fsharp">
//Fill a knapsack optimally - Nigel Galloway: February 1st., 2015
let items = [("beef", 3.8, 36);("pork", 5.4, 43);("ham", 3.6, 90);("greaves", 2.4, 45);("flitch" , 4.0, 30);("brawn", 2.5, 56);("welt", 3.7, 67);("salami" , 3.0, 95);("sausage", 5.9, 98)]
Line 1,201:
| [] -> printfn "Everything taken! Total value of swag is £%0.2f; Total weight of bag is %0.2fkg" a n
take(0.0, items, 0.0)
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 1,230:
{{trans|D}}
{{works with|4tH|3.62.0}}
<langsyntaxhighlight lang="forth">include lib/selcsort.4th \ use a tiny sorting algorithm
 
150 value left \ capacity in 1/10th kilo
Line 1,268:
;
 
knapsack</langsyntaxhighlight>
 
=={{header|Fortran}}==
{{works with|Fortran|90 and later}}
 
<langsyntaxhighlight lang="fortran">program KNAPSACK_CONTINUOUS
implicit none
Line 1,327:
write(*, "(f15.2, f8.2)") total_weight, total_value
end program KNAPSACK_CONTINUOUS</langsyntaxhighlight>
 
=={{header|FreeBASIC}}==
<langsyntaxhighlight lang="freebasic">#define PesoMax 15.0
Type Knapsack
articulo As String*7
Line 1,378:
Print Using "Total weight: ###.## kg"; TPeso
Print Using "Total value: ###.##"; TPrecio
Sleep</langsyntaxhighlight>
{{out}}
<pre>You can carry the following materials in the knapsack:
Line 1,392:
 
=={{header|GNU APL}}==
<langsyntaxhighlight APLlang="apl">⍝ Data
Items←'beef' 'pork' 'ham' 'greaves' 'flitch' 'brawn' 'welt' 'salami' 'sausage'
Weights←3.8 5.4 3.6 2.4 4 2.5 3.7 3 5.9
Line 1,409:
⎕←''
⎕←'total cost:' TotalCost
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 1,423:
 
=={{header|Go}}==
<langsyntaxhighlight lang="go">package main
 
import (
Line 1,472:
}
}
}</langsyntaxhighlight>
Output:
<pre>
Line 1,484:
=={{header|Groovy}}==
Solution: obvious greedy algorithm
<langsyntaxhighlight lang="groovy">import static java.math.RoundingMode.*
 
def knapsackCont = { list, maxWeight = 15.0 ->
Line 1,502:
}
sack
}</langsyntaxhighlight>
 
Test:
<langsyntaxhighlight lang="groovy">def possibleItems = [
[name:'beef', weight:3.8, value:36],
[name:'pork', weight:5.4, value:43],
Line 1,521:
contents.each {
printf(" name: %-7s weight: ${it.weight} value: ${it.value}\n", it.name)
}</langsyntaxhighlight>
 
Output:
Line 1,535:
We use a greedy algorithm.
 
<langsyntaxhighlight lang="haskell">import Data.List (sortBy)
import Data.Ord (comparing)
import Text.Printf (printf)
Line 1,583:
where
a = floor q
b = q - toEnum a</langsyntaxhighlight>
{{Out}}
<pre>3 kg of salami
Line 1,593:
 
Or similar to above (but more succinct):
<langsyntaxhighlight lang="haskell">import Data.List (sortBy)
import Data.Ord (comparing)
import Text.Printf (printf)
Line 1,618:
| otherwise = printf "Take %.2f kg of the %s\n" (k :: Float) name
 
main = solution 15 items</langsyntaxhighlight>
{{Out}}
<pre>Take all the salami
Line 1,628:
=={{header|Icon}} and {{header|Unicon}}==
This implements the greedy algorithm. This also uses a Unicon extension to ''reverse'' which reverses a list. In Icon, an IPL procedure is available to do the same.
<langsyntaxhighlight Iconlang="icon">link printf
 
procedure main()
Line 1,663:
item("salami", 3.0, 95),
item("sausage", 5.9, 98) ]
end</langsyntaxhighlight>
 
{{libheader|Icon Programming Library}}
Line 1,679:
We take as much as we can of the most valuable items first, and continue until we run out of space. Only one item needs to be cut.
 
<langsyntaxhighlight Jlang="j">'names numbers'=:|:;:;._2]0 :0
beef 3.8 36
pork 5.4 43
Line 1,693:
order=: \:prices%weights
take=: 15&<.&.(+/\) order{weights
result=: (*take)#(order{names),.' ',.":,.take</langsyntaxhighlight>
 
This gives the result:
Line 1,703:
 
For a total value of:
<langsyntaxhighlight Jlang="j"> +/prices * (take/:order) % weights
349.378</langsyntaxhighlight>
 
See [[Knapsack_problem/Continuous/J]] for some comments on intermediate results...
Line 1,711:
Greedy solution.
 
<langsyntaxhighlight lang="java">
package hu.pj.alg.test;
 
Line 1,784:
}
 
} // class</langsyntaxhighlight>
 
<langsyntaxhighlight lang="java">
package hu.pj.alg;
 
Line 1,862:
}
 
} // class</langsyntaxhighlight>
 
<langsyntaxhighlight lang="java">
package hu.pj.obj;
 
Line 1,923:
}
 
} // class</langsyntaxhighlight>
 
output:
Line 1,941:
{{ works with|jq|1.4}}
 
<langsyntaxhighlight lang="jq"># continuous_knapsack(W) expects the input to be
# an array of objects {"name": _, "weight": _, "value": _}
# where "value" is the value of the given weight of the object.
Line 1,962:
| (.[] | {name, weight}),
"Total value: \( map(.value) | add)",
"Total weight: \(W - $remainder)" ;</langsyntaxhighlight>
'''The task:'''
<langsyntaxhighlight lang="jq">def items: [
{ "name": "beef", "weight": 3.8, "value": 36},
{ "name": "pork", "weight": 5.4, "value": 43},
Line 1,975:
{ "name": "sausage", "weight": 5.9, "value": 98} ];
 
items | continuous_knapsack(15)</langsyntaxhighlight>
{{out}}
<langsyntaxhighlight lang="sh">$ jq -r -c -n -f knapsack_continuous.jq
{"name":"salami","weight":3}
{"name":"ham","weight":3.6}
Line 1,984:
{"name":"welt","weight":3.5000000000000004}
Total value: 349.3783783783784
Total weight: 15</langsyntaxhighlight>
 
=={{header|Julia}}==
Line 1,992:
 
'''Type and Functions''':
<langsyntaxhighlight lang="julia">using Printf
 
struct KPCSupply{T<:Real}
Line 2,023:
end
return sack
end</langsyntaxhighlight>
 
'''Main''':
<langsyntaxhighlight lang="julia">store = [KPCSupply("beef", 38//10, 36),
KPCSupply("pork", 54//10, 43),
KPCSupply("ham", 36//10, 90),
Line 2,039:
println("The store contains:\n - ", join(store, "\n - "))
println("\nThe thief should take::\n - ", join(sack, "\n - "))
@printf("\nTotal value in the sack: %.2f €\n", sum(getfield.(sack, :value)))</langsyntaxhighlight>
 
{{out}}
Line 2,063:
 
=={{header|Kotlin}}==
<langsyntaxhighlight lang="scala">// version 1.1.2
 
data class Item(val name: String, val weight: Double, val value: Double)
Line 2,109:
println("----------- ------ ------")
println("${itemCount} items 15.0 ${"%6.2f".format(sumValue)}")
}</langsyntaxhighlight>
 
{{out}}
Line 2,128:
 
=={{header|M2000 Interpreter}}==
<syntaxhighlight lang="m2000 interpreter">
<lang M2000 Interpreter>
Module Knapsack {
Form 60, 40
Line 2,210:
}
Knapsack
</syntaxhighlight>
</lang>
Output the same as other examples, with some color.
 
Line 2,218:
The output is then all items prior to this one, along with that item corrected for it's excess weighter (overW)
 
<langsyntaxhighlight Mathematicalang="mathematica">Knapsack[shop_, capacity_] := Block[{sortedTable, overN, overW, output},
sortedTable = SortBy[{#1, #2, #3, #3/#2} & @@@ shop, -#[[4]] &];
overN = Position[Accumulate[sortedTable[[1 ;;, 2]]], a_ /; a > capacity, 1,1][[1, 1]];
Line 2,226:
output[[-1, 2]] = output[[-1, 2]] - overW;
output[[-1, 3]] = output[[-1, 2]] output[[-1, 4]];
Append[output[[1 ;;, 1 ;; 3]], {"Total",Sequence @@ Total[output[[1 ;;, 2 ;; 3]]]}]]</langsyntaxhighlight>
 
A test using the specified data:
<langsyntaxhighlight Mathematicalang="mathematica">weightPriceTable =
{{"beef", 3.8, 36}, {"pork", 5.4, 43}, {"ham", 3.6, 90}, {"greaves", 2.4, 45}, {"flitch", 4., 30},
{"brawn", 2.5, 56}, {"welt", 3.7, 67}, {"salami", 3., 95}, {"sausage", 5.9, 98}};
Line 2,241:
welt 3.5 63.3784
Total 15. 349.378
</syntaxhighlight>
</lang>
 
=={{header|Mathprog}}==
<syntaxhighlight lang="text">/*Knapsack
This model finds the optimal packing of a knapsack
Line 2,274:
sausage 5.9 98
;
end;</langsyntaxhighlight>
 
The solution is here at [[Knapsack problem/Continuous/Mathprog]].
 
=={{header|MiniZinc}}==
<syntaxhighlight lang="minizinc">
<lang MiniZinc>
%Knapsack Continuous. Nigel Galloway: October 7th., 2020.
enum Items={beef,pork,ham,greaves,flitch,brawn,welt,salami,sausage};
Line 2,291:
solve maximize wValue;
output[concat([let {string: g=show(quantity[n])} in "Take "++(if g==show(weight[n]) then "all" else g endif)++" of \(n)\n" | n in Items where show(quantity[n])!="0.0"])++"\nTotal Weight=\(wTaken) Total Value="++show_float(4,2,wValue)]
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 2,303:
</pre>
=={{header|Nim}}==
<langsyntaxhighlight Nimlang="nim">import algorithm
import strformat
 
Line 2,340:
break
 
echo fmt"Total value: {value:.2f}"</langsyntaxhighlight>
 
{{out}}
Line 2,353:
 
=={{header|OCaml}}==
<langsyntaxhighlight lang="ocaml">let items =
[ "beef", 3.8, 36;
"pork", 5.4, 43;
Line 2,386:
Printf.printf " %7s: %6.2f %6.2f\n" last rem_weight last_price;
Printf.printf " Total Price: %.3f\n" (float price +. last_price);
;;</langsyntaxhighlight>
 
{{out}}
Line 2,400:
=={{header|Oforth}}==
 
<langsyntaxhighlight lang="oforth">[
[ "beef", 3.8, 36 ], [ "pork", 5.4, 43 ], [ "ham", 3.6, 90 ],
[ "greaves", 2.4, 45 ], [ "flitch", 4.0, 30 ], [ "brawn", 2.5, 56 ],
Line 2,417:
"And part of" . item first . " :" . dup .cr
item third * item second / value + "Total value :" . .cr break
] ;</langsyntaxhighlight>
 
{{out}}
Line 2,433:
=={{header|ooRexx}}==
===version 1===
<langsyntaxhighlight lang="oorexx">/*--------------------------------------------------------------------
* 20.09.2014 Walter Pachl translated from REXX version 2
* utilizing ooRexx features like objects, array(s) and sort
Line 2,507:
Otherwise res='-1'
End
Return res</langsyntaxhighlight>
{{out}}
<pre>
Line 2,530:
total 15.000 349.378</pre>
===version 2===
<langsyntaxhighlight lang="oorexx">/*--------------------------------------------------------------------
* 20.09.2014 Walter Pachl translated from REXX version 2
* utilizing ooRexx features like objects, array(s) and sort
Line 2,602:
Expose vpu
use Arg other
return -sign(vpu - other~vpu)</langsyntaxhighlight>
Output is the same as for version 1.
 
=={{header|Perl}}==
<langsyntaxhighlight lang="perl">my @items = sort { $b->[2]/$b->[1] <=> $a->[2]/$a->[1] }
(
[qw'beef 3.8 36'],
Line 2,636:
 
print "-" x 40, "\ntotal value: $value\n";
</syntaxhighlight>
</lang>
Output:<pre>item fraction weight value
salami all 3.0 95
Line 2,648:
 
=={{header|Phix}}==
<!--<langsyntaxhighlight Phixlang="phix">(phixonline)-->
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #008080;">constant</span> <span style="color: #000000;">meats</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{</span>
Line 2,680:
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"Total value: %f\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">worth</span><span style="color: #0000FF;">})</span>
<!--</langsyntaxhighlight>-->
{{out}}
<pre>
Line 2,692:
 
=={{header|PHP}}==
<langsyntaxhighlight PHPlang="php">/* Added by @1x24. Translated from C++. Uses the PHP 7.x spaceship operator */
$data = [
[
Line 2,756:
$limit -= $item['weight'];
endforeach;
</syntaxhighlight>
</lang>
Output:
<pre>Take all the salami
Line 2,765:
 
=={{header|Picat}}==
<langsyntaxhighlight Picatlang="picat">go =>
items(Items),
weights(Weights),
Line 2,810:
items([beef,pork,ham,greaves,flitch,brawn,welt,salami,sausage]).
weights([3.8,5.4,3.6,2.4,4.0,2.5,3.7,3.0,5.9]).
values([36,43,90,45,30,56,67,95,98]).</langsyntaxhighlight>
 
{{out}}
Line 2,822:
 
=={{header|PicoLisp}}==
<langsyntaxhighlight PicoLisplang="picolisp">(scl 2)
 
(de *Items
Line 2,854:
NIL
(format (sum cadr K) *Scl)
(format (sum caddr K) *Scl) ) )</langsyntaxhighlight>
Output:
<pre> salami 3.00 95.00
Line 2,864:
 
=={{header|PL/I}}==
<langsyntaxhighlight lang="pli">*process source xref attributes;
KNAPSACK_CONTINUOUS: Proc Options(main);
/*--------------------------------------------------------------------
Line 2,938:
item(i).value = value;
End;
End;</langsyntaxhighlight>
{{out}}
<pre>
Line 2,962:
=={{header|Prolog}}==
Works with SWI-Prolog and <b>library(simplex)</b> written by <b>Markus Triska</b>
<langsyntaxhighlight Prologlang="prolog">:- use_module(library(simplex)).
% tuples (name, weights, value).
knapsack :-
Line 3,028:
print_results(S, A1, A2, A3, T, TN, W2, V2).
 
</syntaxhighlight>
</lang>
Output :
<pre> ?- knapsack.
Line 3,041:
=={{header|PureBasic}}==
Using the greedy algorithm.
<langsyntaxhighlight PureBasiclang="purebasic">Structure item
name.s
weight.f ;units are kilograms (kg)
Line 3,112:
Input()
CloseConsole()
EndIf </langsyntaxhighlight>
Sample output:
<pre>Maximal weight = 15 kg
Line 3,127:
=={{header|Python}}==
I think this greedy algorithm of taking the largest amounts of items ordered by their value per unit weight is maximal:
<langsyntaxhighlight lang="python"># NAME, WEIGHT, VALUE (for this weight)
items = [("beef", 3.8, 36.0),
("pork", 5.4, 43.0),
Line 3,156:
print(" ITEM PORTION VALUE")
print("\n".join("%10s %6.2f %6.2f" % item for item in bagged))
print("\nTOTAL WEIGHT: %5.2f\nTOTAL VALUE: %5.2f" % (wt, val))</langsyntaxhighlight>
 
'''Sample Output'''
Line 3,171:
=={{header|R}}==
Translated into r-script by Shana White (vandersm@mail.uc.edu) from pseudocode found in 'Algorithms: Sequential Parallel and Distributed', by Kenneth A. Berman and Jerome L. Paul
<syntaxhighlight lang="r">
<lang r>
knapsack<- function(Value, Weight, Objects, Capacity){
Fraction = rep(0, length(Value))
Line 3,214:
print("Total value of tasty meats:")
print(Total_Value)
}</langsyntaxhighlight>
 
'''Sample Input'''
Line 3,235:
=={{header|Racket}}==
 
<langsyntaxhighlight lang="racket">#lang racket
(define shop-inventory
'((beef 3.8 36)
Line 3,279:
 
(call-with-values (lambda () (continuous-knapsack shop-inventory null 15 0))
report-knapsack)</langsyntaxhighlight>
 
{{out}}
Line 3,294:
{{works with|rakudo|2015-09-16}}
This Solutions sorts the item by WEIGHT/VALUE
<syntaxhighlight lang="raku" perl6line>class KnapsackItem {
has $.name;
has $.weight is rw;
Line 3,337:
$max-w -= .weight;
last if $last-one;
}</langsyntaxhighlight>
'''Output:'''
<pre>Item Portion Value
Line 3,350:
Originally used the Fortran program as a prototype.
<br>Some amount of code was added to format the output better.
<langsyntaxhighlight lang="rexx">/*REXX pgm solves the continuous burglar's knapsack problem; items with weight and value*/
@.= /*═══════ name weight value ══════*/
@.1 = 'flitch 4 30 '
Line 3,391:
syf: call sy arg(1), $(format(arg(2), , d)), $(format(arg(3), , d)); return
title: call sy center('item',nL), center("weight", wL), center('value', vL); return
$: parse arg x;if pos(.,x)>1 then x=left(strip(strip(x,'T',0),,.),length(x)); return x</langsyntaxhighlight>
'''output''' &nbsp; using the default inputs of: &nbsp; <tt> 15 &nbsp; 3 </tt>
<pre>
Line 3,425:
 
===version 2===
<langsyntaxhighlight lang="rexx"> /*--------------------------------------------------------------------
* 19.09.2014 Walter Pachl translated from FORTRAN
* While this program works with all REXX interpreters,
Line 3,501:
input.i=name'*'weight'*'value
input.0=i
Return</langsyntaxhighlight>
{{out}}
<pre># vpu name weight value
Line 3,524:
 
=={{header|Ruby}}==
<langsyntaxhighlight lang="ruby">items = [ [:beef , 3.8, 36],
[:pork , 5.4, 43],
[:ham , 3.6, 90],
Line 3,543:
break
end
end</langsyntaxhighlight>
{{out}}
<pre>
Line 3,557:
=={{header|Run BASIC}}==
{{incorrect|Run BASIC}}
<langsyntaxhighlight lang="runbasic">dim name$(9)
dim wgt(9)
dim price(9)
Line 3,613:
print "-------- Total ";using("###.#",totTake);chr$(9);"Weight: ";totWgt
end if
next i</langsyntaxhighlight>Output:
<pre>Best 2 Options
 
Line 3,624:
 
=={{header|Rust}}==
<langsyntaxhighlight lang="rust">fn main() {
let items: [(&str, f32, u8); 9] = [
("beef", 3.8, 36),
Line 3,657:
}
}
}</langsyntaxhighlight> Output:<pre>
Grab 3.0 kgs of salami
Grab 3.6 kgs of ham
Line 3,667:
=={{header|SAS}}==
Use LP solver in SAS/OR:
<langsyntaxhighlight lang="sas">/* create SAS data set */
data mydata;
input item $ weight value;
Line 3,702:
print TotalValue;
print {i in ITEMS: WeightSelected[i].sol > 1e-3} WeightSelected;
quit;</langsyntaxhighlight>
 
Output:
Line 3,717:
=={{header|Scala}}==
===Functional approach (Tail recursive)===
<langsyntaxhighlight Scalalang="scala">import scala.annotation.tailrec
 
object ContinousKnapsackForRobber extends App {
Line 3,773:
 
println(packer(sortedItems, Lootsack(Nil)))
}</langsyntaxhighlight>
{{Out}}
<pre>100.00% Salami 3.0 95.00
Line 3,785:
=={{header|Sidef}}==
{{trans|Perl}}
<langsyntaxhighlight lang="ruby">var items =
[
[:beef, 3.8, 36],
Line 3,814:
}
 
say "#{'-'*28}\ntotal value: #{'%.14g' % value }"</langsyntaxhighlight>
{{out}}
<pre>
Line 3,828:
 
=={{header|Tcl}}==
<langsyntaxhighlight lang="tcl">package require Tcl 8.5
 
# Uses the trivial greedy algorithm
Line 3,864:
# We return the total value too, purely for convenience
return [list $result $totalValue]
}</langsyntaxhighlight>
Driver for this particular problem:
<langsyntaxhighlight lang="tcl">set items {
{beef 3.8 36}
{pork 5.4 43}
Line 3,884:
lassign $item name mass value
puts [format "\t%.1fkg of %s, value %.2f" $mass $name $value]
}</langsyntaxhighlight>
Output:
<pre>
Line 3,901:
[http://www.gnu.org/software/glpk/glpk.html glpk] depending on the
[http://www.basis.netii.net/avram run-time system] configuration).
<langsyntaxhighlight Ursalalang="ursala">#import flo
#import lin
 
Line 3,927:
#cast %em
 
main = solution system items</langsyntaxhighlight>
output:
<pre><
Line 3,937:
 
=={{header|Vlang}}==
<langsyntaxhighlight lang="vlang">struct Item {
item string
weight f64
Line 3,978:
}
//println(items)
}</langsyntaxhighlight>
{{out}}
<pre>
Line 3,993:
{{libheader|Wren-math}}
{{libheader|Wren-sort}}
<langsyntaxhighlight lang="ecmascript">import "/fmt" for Fmt
import "/math" for Math
import "/sort" for Sort
Line 4,046:
}
System.print("----------- ------ ------")
Fmt.print("$d items 15.0 $6.2f", itemCount, sumValue)</langsyntaxhighlight>
 
{{out}}
Line 4,062:
 
=={{header|XPL0}}==
<langsyntaxhighlight XPL0lang="xpl0">int Name, Price, I, BestItem;
real Weight, Best, ItemWt, TotalWt;
def Items = 9;
Line 4,091:
Text(0, Name(BestItem)); CrLf(0);
until TotalWt >= 15.0; \all we can steal
]</langsyntaxhighlight>
 
Output:
Line 4,104:
=={{header|zkl}}==
{{trans|C}}
<langsyntaxhighlight lang="zkl">items:=List( T(3.8, 36.0, "beef"), T(5.4, 43.0, "pork"), // weight, value, name
T(3.6, 90.0, "ham"), T(2.4, 45.0, "greaves"),
T(4.0, 30.0, "flitch"),T(2.5, 56.0, "brawn"),
Line 4,117:
if (space >= w){ println("take all ",nm); space-=w }
else{ println("take %gkg of %gkg of %s".fmt(space,w,nm)); break }
}</langsyntaxhighlight>
{{out}}
<pre>
Thundergnat
10,327

edits

Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/327781"