McNuggets problem: Difference between revisions
m
syntax highlighting fixup automation
Thundergnat (talk | contribs) m (syntax highlighting fixup automation) |
|||
Line 18:
{{trans|Python}}
<
L(s, n, t) cart_product(0 .. 100 I/ 6,
0 .. 100 I/ 9,
Line 24:
nuggets.discard(6*s + 9*n + 20*t)
print(max(nuggets))</
{{out}}
Line 32:
=={{header|Action!}}==
<
BYTE x,y,z,n
BYTE ARRAY nuggets(101)
Line 67:
FI
OD
RETURN</
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/McNuggets_problem.png Screenshot from Atari 8-bit computer]
Line 75:
=={{header|Ada}}==
<
procedure McNugget is
Line 98:
end if;
end loop;
end McNugget;</
{{out}}
<pre>
Line 105:
=={{header|ALGOL 68}}==
<
# Solve the McNuggets problem: find the largest n <= 100 for which there #
# are no non-negative integers x, y, z such that 6x + 9y + 20z = n #
Line 126:
)
)
END</
{{out}}
<pre>
Line 134:
=={{header|APL}}==
{{works with|Dyalog APL}}
<
{{out}}
<pre>43</pre>
Line 141:
Generalised for other set sizes, and for other triples of natural numbers.
Uses NSMutableSet, through the AppleScript ObjC interface:
<
use framework "Foundation"
use scripting additions
Line 317:
on setMember(x, objcSet)
missing value is not (objcSet's member:(x))
end setMember</
{{Out}}
<pre>43</pre>
Line 323:
=={{header|Arturo}}==
{{trans|Ruby}}
<
result: new 0..lim
Line 336:
]
print max nonMcNuggets 100</
{{out}}
Line 343:
=={{header|AWK}}==
<syntaxhighlight lang="awk">
# syntax: GAWK -f MCNUGGETS_PROBLEM.AWK
# converted from Go
Line 363:
exit(0)
}
</syntaxhighlight>
{{out}}
<pre>
Line 370:
=={{header|BASIC}}==
<
20 FOR A=0 TO 100 STEP 6
30 FOR B=A TO 100 STEP 9
Line 378:
70 FOR A=100 TO 0 STEP -1
80 IF NOT F(A) THEN PRINT A: END
90 NEXT A</
{{out}}
<pre> 43</pre>
=={{header|BCPL}}==
<
manifest $( limit = 100 $)
Line 400:
finish
$)
$)</
{{out}}
<pre>Maximum non-McNuggets number: 43.</pre>
=={{header|BQN}}==
<
{{out}}
<pre>43</pre>
Line 411:
=={{header|C}}==
<
int
Line 445:
return 0;
}</
{{out}}
Line 453:
=={{header|C sharp|C#}}==
<syntaxhighlight lang="c#">
using System;
Line 487:
}
}
</syntaxhighlight>
{{out}}
<pre>
Line 494:
=={{header|Clojure}}==
<
(if (empty? colls)
'(())
Line 505:
(let [possible (distinct (map nuggets (cart (map range [18 13 6]))))
mcmax (apply max (filter (fn [x] (not-any? #{x} possible)) (range 101)))]
(printf "Maximum non-McNuggets number is %d\n" mcmax))</
{{out}}
<pre>Maximum non-McNuggets number is 43</pre>
=={{header|CLU}}==
<
% This yields all the nugget numbers of the given box sizes from start to max.
gen_nuggets = iter (start, max: int, sizes: sequence[int]) yields (int)
Line 541:
stream$putl(po, "Maximum non-McNuggets number: " || int$unparse(maxn))
end start_up</
{{out}}
<pre>Maximum non-McNuggets number: 43</pre>
=={{header|COBOL}}==
<
PROGRAM-ID. MCNUGGETS.
Line 580:
C-LOOP.
IF C IS NOT EQUAL TO ZERO, MOVE 'X' TO NUGGET-FLAGS(C).</
{{out}}
<pre>Largest non-McNugget number: 043</pre>
=={{header|Comal}}==
<
0020 DIM nugget#(0:limit#)
0030 FOR a#:=0 TO limit# STEP 6 DO
Line 597:
0110 END
0120 ENDIF
0130 ENDFOR i#</
{{out}}
<pre>Maximum non-McNuggets number: 43</pre>
=={{header|Cowgol}}==
<
const LIMIT := 100;
Line 635:
end if;
a := a - 1;
end loop;</
{{out}}
<pre>Maximum non-McNuggets number: 43</pre>
=={{header|Dart}}==
<
main() {
var nuggets = List<int>.generate(101, (int index) => index);
Line 651:
}
print('Largest non-McNuggets number: ${nuggets.reduce(max).toString() ?? 'none'}.');
}</
{{out}}
Line 658:
=={{header|Draco}}==
<
byte LIMIT = 100;
[LIMIT+1] bool nugget;
Line 678:
while nugget[a] do a := a - 1 od;
writeln("Maximum non-McNuggets number: ", a)
corp</
{{out}}
<pre>Maximum non-McNuggets number: 43</pre>
Line 686:
{{trans|Go}}
<
var sv = Array.Empty(limit + 1, false)
for s in 0^6..limit {
Line 703:
}
mcnugget(100)</
{{out}}
Line 713:
Uses MapSet and Comprehension
<
def solve(limit) do
0..limit
Line 735:
Mcnugget.solve(100) |> IO.puts
</syntaxhighlight>
{{out}}
Line 742:
=={{header|F_Sharp|F#}}==
<
// McNuggets. Nigel Galloway: October 28th., 2018
let fN n g = Seq.initInfinite(fun ng->ng*n+g)|>Seq.takeWhile(fun n->n<=100)
printfn "%d" (Set.maxElement(Set.difference (set[1..100]) (fN 20 0|>Seq.collect(fun n->fN 9 n)|>Seq.collect(fun n->fN 6 n)|>Set.ofSeq)))
</syntaxhighlight>
{{out}}
<pre>
Line 753:
=={{header|Factor}}==
<
101 <iota> [ 0 6 9 20 [ 100 swap <range> amb-lazy ] tri@ ] bag-of diff last .</
{{out}}
<pre>
Line 761:
=={{header|FOCAL}}==
<
01.20 F A=0,6,100;F B=A,9,100;F C=B,20,100;S T(C)=-1
01.30 S N=101
Line 767:
01.50 I (T(N))1.4
01.60 T %3,N,!
01.70 Q</
{{out}}
<pre>= 43</pre>
=={{header|FreeBASIC}}==
<
Dim As Integer l(100), a, b, c, n
For a = 0 To 100/6
Line 786:
Next n
End
</syntaxhighlight>
{{out}}
<pre>
Line 794:
=={{header|Frink}}==
This is a nice demonstration for Frink's <CODE>multifor</CODE> loop which can perform arbitrarily-deeply-nested loops in a single statement. The "inner" (rightmost) loops can use values set by the "outer" (leftmost) as part of their bounds.
<
multifor [z,y,x] = [0 to 100 step 20, 0 to 100-z step 9, 0 to 100-z-y step 6]
a.remove[x+y+z]
println[max[a]]</
{{out}}
<pre>
Line 806:
=={{header|FutureBasic}}==
<
local fn McNuggetsProblem
BOOL l(100)
Line 828:
HandleEvents
</syntaxhighlight>
{{output}}
<pre>
Line 842:
=={{header|Go}}==
<
import "fmt"
Line 865:
func main() {
mcnugget(100)
}</
{{out}}
Line 873:
=={{header|Haskell}}==
<
------------------------ MCNUGGETS -----------------------
Line 899:
where
go (x : _) = show x
go [] = "No unreachable quantities found ..."</
Or equivalently, making use of the list comprehension notation:
<
gaps :: [Int]
Line 923:
case gaps of
x:_ -> show x
[] -> "No unreachable quantities found ..."</
<pre>43</pre>
Line 930:
Brute force solution: calculate all pure (just one kind of box) McNugget numbers which do not exceed 100, then compute all possible sums, and then remove those from the list of numbers up to 100 (which is obviously a McNugget number), then find the largest number remaining:
<
43</
Technically, we could have used 100 in place of 101 when we were finding how many pure McNugget numbers were in each series (because 100 is obviously a McNugget number), but it's not like that's a problem, either.
=={{header|Java}}==
<
public static void main(String... args) {
Line 990:
return;
}
}</
{{Out}}
<pre>Largest non-McNugget number in the search space is 43</pre>
=={{header|JavaScript}}==
<
'use strict';
Line 1,074:
main()
);
})();</
{{Out}}
<pre>43</pre>
Line 1,080:
=={{header|jq}}==
{{trans|Clojure}}
<
[range(18) as $n6 |
range(13) as $n9 |
Line 1,091:
select($possible|contains([$n])|not)
] |
max</
{{out}}
<pre>43</pre>
Line 1,097:
=={{header|Julia}}==
Simple brute force solution, though the BitSet would save memory considerably with larger max numbers.
<
b = BitSet(1:max)
for i in 0:6:max, j in 0:9:max, k in 0:20:max
Line 1,106:
println(mcnuggets(100))
</
43
</pre>
Line 1,112:
=={{header|Kotlin}}==
{{trans|Go}}
<
fun mcnugget(limit: Int) {
Line 1,130:
fun main(args: Array<String>) {
mcnugget(100)
}</
{{output}}
Line 1,138:
=={{header|Locomotive Basic}}==
<
110 DIM a(100)
120 FOR a=0 TO 100/6
Line 1,152:
220 NEXT n
230 PRINT"The Largest non McNugget number is:";l
240 END</
{{output}}
Line 1,158:
=={{header|Lua}}==
<
function range(A,B)
return function()
Line 1,231:
print(maximum(exclude(sum, range(1, N))))
</syntaxhighlight>
{{out}}
<pre>
Line 1,238:
=={{header|MAD}}==
<
BOOLEAN NUGGET
DIMENSION NUGGET(101)
Line 1,254:
PRINT FORMAT F, I
VECTOR VALUES F = $29HMAXIMUM NON-MCNUGGET NUMBER: ,I2*$
END OF PROGRAM </
{{out}}
<pre>MAXIMUM NON-MCNUGGET NUMBER: 43</pre>
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<
{{out}}
<pre>43</pre>
=={{header|Modula-2}}==
<
FROM InOut IMPORT WriteCard, WriteString, WriteLn;
Line 1,289:
WriteCard(a, 2);
WriteLn();
END McNuggets.</
{{out}}
<pre>Maximum non-McNuggets number: 43</pre>
=={{header|MiniZinc}}==
<syntaxhighlight lang="minizinc">
%McNuggets. Nigel Galloway, August 27th., 2019
var 0..99: n;
Line 1,300:
solve maximize n;
output [show(n)]
</syntaxhighlight>
{{out}}
<pre>
Line 1,309:
=={{header|Nim}}==
<
var mcnuggets: array[0..Limit, bool]
Line 1,321:
if not mcnuggets[n]:
echo "The largest non-McNuggets number is: ", n
break</
{{out}}
Line 1,329:
{{trans|Raku}}
{{libheader|ntheory}}
<
sub Mcnugget_number {
Line 1,371:
for my $counts ([6,9,20], [6,7,20], [1,3,20], [10,5,18], [5,17,44], [2,4,6], [3,6,15]) {
print 'Maximum non-Mcnugget number using ' . join(', ', @$counts) . ' is: ' . Mcnugget_number($counts) . "\n"
}</
{{out}}
<pre>Maximum non-Mcnugget number using 6, 9, 20 is: 43
Line 1,382:
===Perl using Regex===
<
use warnings;
$_ = 1 . 0 x 100;
1 while s/ (?=1) (?:.{6}|.{9}|.{20}) \K 0 /1/x;
/01*$/ and print "Maximum non-Mcnugget number is: $-[0]\n";</
{{out}}
<pre>Maximum non-Mcnugget number is: 43</pre>
Line 1,393:
=={{header|Phix}}==
{{trans|Go}}
<!--<
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #008080;">constant</span> <span style="color: #000000;">limit</span><span style="color: #0000FF;">=</span><span style="color: #000000;">100</span>
Line 1,405:
<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;">"Maximum non-McNuggets number is %d\n"</span><span style="color: #0000FF;">,</span> <span style="color: #7060A8;">rfind</span><span style="color: #0000FF;">(</span><span style="color: #004600;">false</span><span style="color: #0000FF;">,</span><span style="color: #000000;">nuggets</span><span style="color: #0000FF;">)-</span><span style="color: #000000;">1</span><span style="color: #0000FF;">)</span>
<!--</
{{out}}
<pre>
Line 1,412:
Also, since it is a bit more interesting, a
{{trans|Raku}}
<!--<
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #008080;">function</span> <span style="color: #000000;">Mcnugget_number</span><span style="color: #0000FF;">(</span><span style="color: #004080;">sequence</span> <span style="color: #000000;">counts</span><span style="color: #0000FF;">)</span>
Line 1,457:
<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;">"Maximum non-Mcnugget number using %V is: %s\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">ti</span><span style="color: #0000FF;">,</span><span style="color: #000000;">Mcnugget_number</span><span style="color: #0000FF;">(</span><span style="color: #000000;">ti</span><span style="color: #0000FF;">)})</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<!--</
{{out}}
<pre>
Line 1,471:
=={{header|Picat}}==
Using constraint modelling (cp solver).
<
go =>
Line 1,479:
end,
solve($[max(N)],N),
println(n=N).</
{{out}}
Line 1,485:
=={{header|PicoLisp}}==
<
(let Lst (range 0 M)
(for A (range 0 M 6)
Line 1,491:
(for C (range B M 20)
(set (nth Lst (inc C))) ) ) )
(apply max Lst) ) )</
Generator from fiber:
<
(co 'nugget
(for A (range 0 M 6)
Line 1,503:
(while (nugg 100)
(set (nth Lst @)) )
(apply max Lst) ) )</
Test versions against each other:
<
T
(=
43
(nuggets1 100)
(nuggets2 100) ) )</
=={{header|PL/I}}==
<
declare nugget(0:100) bit, (a, b, c) fixed;
do a=0 to 100; nugget(a) = '0'b; end;
Line 1,531:
end;
end;
end mcnugget;</
{{out}}
<pre>Maximum non-McNuggets number: 43</pre>
=={{header|PL/M}}==
<
BDOS: PROCEDURE (FN, ARG); DECLARE FN BYTE, ARG ADDRESS; GO TO 5; END BDOS;
EXIT: PROCEDURE; CALL BDOS(0,0); END EXIT;
Line 1,569:
CALL PRINT$NUMBER(A);
CALL EXIT;
EOF</
{{out}}
<pre>43</pre>
Line 1,575:
=={{header|PowerShell}}==
{{trans|UNIX Shell}}
<
For ($i=0; $i -lt 18; $i++) {
For ($j=0; $j -lt 13; $j++) {
Line 1,592:
}
}
Write-Host "Maximum non-McNuggets number is $n"</
{{out}}
<pre>Maximum non-McNuggets number is 43</pre>
Line 1,599:
===Python: REPL===
It's a simple solution done on the command line:
<
>>> nuggets = set(range(101))
>>> for s, n, t in product(range(100//6+1), range(100//9+1), range(100//20+1)):
Line 1,607:
>>> max(nuggets)
43
>>> </
Single expression version (expect to be slower, however no noticeable difference on a Celeron B820 and haven't benchmarked):
<
>>> max(x for x in range(100+1) if x not in
... (6*s + 9*n + 20*t for s, n, t in
... product(range(100//6+1), range(100//9+1), range(100//20+1))))
43
>>> </
===Using Set Comprehension===
{{trans|FSharp}}
<
#Wherein I observe that Set Comprehension is not intrinsically dysfunctional. Nigel Galloway: October 28th., 2018
n = {n for x in range(0,101,20) for y in range(x,101,9) for n in range(y,101,6)}
g = {n for n in range(101)}
print(max(g.difference(n)))
</syntaxhighlight>
{{out}}
<pre>
Line 1,636:
{{Works with|Python|3.7}}
<
from itertools import (chain, dropwhile)
Line 1,762:
# MAIN ---
if __name__ == '__main__':
main()</
{{Out}}
<pre>
Line 1,771:
=={{header|Quackery}}==
<
100 6 / times
[ i 6 *
Line 1,796:
[ say "The largest non-McNugget number below 101 is "
echo ]
char . emit</
'''Output:'''
Line 1,805:
There are two natural approaches. The first is to generate all valid x, y, and z and then apply the function:
<
mcNuggets <- do.call(function(x, y, z) 6 * x + 9 * y + 20 * z, allInputs)</
The second is to find all of the valid 6x, 9y, and 20z, and then sum them:
<
Either way, we get identical results, as checked by:
<
For our final answer, note that our choice to remove values from the vector 0:100 means our outputs will already be sorted, unique, and no greater than 100.
<
cat("The non-McNuggets numbers that are no greater than 100 are:", results, "\nThe largest is", max(results), "\n")</
Ultimately, this can be done in one line:
<
However, using seq without naming its arguments is considered bad practice. It works here, but breaking this code up is probably a better idea.
{{output}}
Line 1,829:
{{trans|Python}} (one of them)
<
(apply max (set->list (for*/fold ((s (list->set (range 1 101))))
((x (in-range 0 101 20))
(y (in-range x 101 9))
(n (in-range y 101 6)))
(set-remove s n))))</
=={{header|Raku}}==
Line 1,843:
Finds the smallest count value, then looks for the first run of consecutive count totals able to be generated, that is at least the length of the smallest count size. From then on, every number can be generated by simply adding multiples of the minimum count to each of the totals in that run.
<syntaxhighlight lang="raku"
return '∞' if 1 < [gcd] @counts;
Line 1,873:
put "Maximum non-Mcnugget number using {$counts.join: ', '} is: ",
Mcnugget-number(|$counts)
}</
{{out}}
<pre>Maximum non-Mcnugget number using 6, 9, 20 is: 43
Line 1,890:
:* excludes meals that have a multiple order of nuggets
:* automatically computes the '''high''' value algebraically instead of using '''100'''.
<
parse arg y /*obtain optional arguments from the CL*/
if y='' | y="," then y= 6 9 20 /*Not specified? Then use the defaults*/
Line 1,934:
do while $\==''; parse var $ y $; y= abs(y); if y==0 then iterate
do until y==0; parse value x//y y with y x; end
end; return x</
{{out|output|text= when using the default inputs:}}
<pre>
Line 1,943:
=={{header|Ring}}==
<
Nuggets = list(100)
Line 1,963:
ok
next
</syntaxhighlight>
{{out}}
<pre>
Line 1,971:
=={{header|Ruby}}==
{{trans|Go}}
<
sv = (0..limit).to_a
Line 1,985:
end
puts(mcnugget 100)</
{{out}}
<pre>
Line 1,991:
</pre>
Generic solution, allowing for more or less then 3 portion-sizes:
<
nugget_portions = [6, 9, 20]
arrs = nugget_portions.map{|n| 0.step(limit, n).to_a }
hits = arrs.pop.product(*arrs).map(&:sum)
p ((0..limit).to_a - hits).max # => 43</
=={{header|Rust}}==
Line 2,002:
Generalization of Rødseth’s Algorithm explained in [https://parramining.blogspot.com/2019/09/generalization-of-rdseths-algorithm-for.html post].
Working code: [https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&gist=1424a910a196fb3d0e964c754fbf325c Rust playground].
<
let test_cases = vec![
[6, 9, 20],
Line 2,090:
(m * y + cc) / aa
}
}</
{{out}}
<pre>
Line 2,108:
=={{header|Swift}}==
<
var (max, sixes, nines, twenties, i) = (0, 0, 0, 0, 0)
Line 2,152:
}
print(maxNugget(limit: 100))</
{{out}}
Line 2,159:
=={{header|Tailspin}}==
<
templates largestNonMcNuggetNumber
@: { largest: 0, mcNuggetNumbers: [1..$+20 -> 0] };
Line 2,170:
100 -> largestNonMcNuggetNumber -> !OUT::write
</syntaxhighlight>
{{out}}
<pre>
Line 2,181:
{{works with|ksh}}
{{works with|zsh}}
<
for (( i=0; i<18; ++i )); do
for (( j=0; j<13; ++j )); do
Line 2,200:
done
printf 'Maximum non-McNuggets number is %d\n' $n</
{{out}}
<pre>Maximum non-McNuggets number is 43</pre>
{{works with|sh}}
<
i=0
while [ $i -lt 18 ]; do
Line 2,227:
break
done
echo "Maximum non-McNuggets number is $n"</
{{out}}
<pre>Maximum non-McNuggets number is 43</pre>
Line 2,233:
=={{header|Vlang}}==
{{trans|Go}}
<
mut sv := []bool{len: limit+1} // all false by default
for s := 0; s <= limit; s += 6 {
Line 2,252:
fn main() {
mcnugget(100)
}</
{{out}}
Line 2,259:
=={{header|VTL-2}}==
<
20 :N+1)=0
30 N=N+1
Line 2,277:
170 #=:N+1)
180 ?="Largest non-McNuggets number: ";
190 ?=N</
{{out}}
<pre>Largest non-McNuggets number: 43</pre>
Line 2,283:
=={{header|Wren}}==
{{trans|Go}}
<
var sv = List.filled(limit+1, false)
var s = 0
Line 2,306:
}
mcnugget.call(100)</
{{out}}
Line 2,314:
=={{header|XPL0}}==
<
[for N:= 0 to 100 do A(N):= false;
for X:= 0 to 100/6 do
Line 2,327:
exit;
];
]</
{{out}}
Line 2,334:
=={{header|zkl}}==
{{trans|Python}}
<
foreach s,n,t in ([0..100/6],[0..100/9],[0..100/20])
{ nuggets[(6*s + 9*n + 20*t).min(101)]=0 }
println((0).max(nuggets));</
{{out}}
<pre>
|