McNuggets problem: Difference between revisions

{{trans|Python}}

L(s, n, t) cart_product(0 .. 100 I/ 6,

0 .. 100 I/ 9,

nuggets.discard(6*s + 9*n + 20*t)

{{out}}

=={{header|Action!}}==

BYTE x,y,z,n

BYTE ARRAY nuggets(101)

FI

OD

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/McNuggets_problem.png Screenshot from Atari 8-bit computer]

=={{header|Ada}}==

procedure McNugget is

end if;

end loop;

{{out}}

<pre>

=={{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 #

)

)

{{out}}

<pre>

=={{header|APL}}==

{{works with|Dyalog APL}}

{{out}}

<pre>43</pre>

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

on setMember(x, objcSet)

missing value is not (objcSet's member:(x))

{{Out}}

<pre>43</pre>

=={{header|Arturo}}==

{{trans|Ruby}}

result: new 0..lim

]

{{out}}

=={{header|AWK}}==

# syntax: GAWK -f MCNUGGETS_PROBLEM.AWK

# converted from Go

exit(0)

}

{{out}}

<pre>

=={{header|BASIC}}==

20 FOR A=0 TO 100 STEP 6

30 FOR B=A TO 100 STEP 9

70 FOR A=100 TO 0 STEP -1

80 IF NOT F(A) THEN PRINT A: END

{{out}}

<pre> 43</pre>

=={{header|BCPL}}==

manifest $( limit = 100 $)

finish

$)

{{out}}

<pre>Maximum non-McNuggets number: 43.</pre>

=={{header|BQN}}==

{{out}}

<pre>43</pre>

=={{header|C}}==

int

return 0;

{{out}}

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

using System;

}

}

{{out}}

<pre>

=={{header|Clojure}}==

(if (empty? colls)

'(())

(let [possible (distinct (map nuggets (cart (map range [18 13 6]))))

mcmax (apply max (filter (fn [x] (not-any? #{x} possible)) (range 101)))]

{{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)

stream$putl(po, "Maximum non-McNuggets number: " || int$unparse(maxn))

{{out}}

<pre>Maximum non-McNuggets number: 43</pre>

=={{header|COBOL}}==

PROGRAM-ID. MCNUGGETS.

C-LOOP.

{{out}}

<pre>Largest non-McNugget number: 043</pre>

=={{header|Comal}}==

0020 DIM nugget#(0:limit#)

0030 FOR a#:=0 TO limit# STEP 6 DO

0110 END

0120 ENDIF

{{out}}

<pre>Maximum non-McNuggets number: 43</pre>

=={{header|Cowgol}}==

const LIMIT := 100;

end if;

a := a - 1;

{{out}}

<pre>Maximum non-McNuggets number: 43</pre>

=={{header|Dart}}==

main() {

var nuggets = List<int>.generate(101, (int index) => index);

}

print('Largest non-McNuggets number: ${nuggets.reduce(max).toString() ?? 'none'}.');

{{out}}

=={{header|Draco}}==

byte LIMIT = 100;

[LIMIT+1] bool nugget;

while nugget[a] do a := a - 1 od;

writeln("Maximum non-McNuggets number: ", a)

{{out}}

<pre>Maximum non-McNuggets number: 43</pre>

{{trans|Go}}

var sv = Array.Empty(limit + 1, false)

for s in 0^6..limit {

}

{{out}}

Uses MapSet and Comprehension

def solve(limit) do

0..limit

Mcnugget.solve(100) |> IO.puts

{{out}}

=={{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)))

{{out}}

<pre>

=={{header|Factor}}==

{{out}}

<pre>

=={{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

01.50 I (T(N))1.4

01.60 T %3,N,!

{{out}}

<pre>= 43</pre>

=={{header|FreeBASIC}}==

Dim As Integer l(100), a, b, c, n

For a = 0 To 100/6

Next n

End

{{out}}

<pre>

=={{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]

{{out}}

<pre>

=={{header|FutureBasic}}==

local fn McNuggetsProblem

BOOL l(100)

HandleEvents

{{output}}

<pre>

=={{header|Go}}==

import "fmt"

func main() {

mcnugget(100)

{{out}}

=={{header|Haskell}}==

------------------------ MCNUGGETS -----------------------

where

go (x : _) = show x

Or equivalently, making use of the list comprehension notation:

gaps :: [Int]

case gaps of

x:_ -> show x

<pre>43</pre>

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:

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) {

return;

}

{{Out}}

<pre>Largest non-McNugget number in the search space is 43</pre>

=={{header|JavaScript}}==

'use strict';

main()

);

{{Out}}

<pre>43</pre>

=={{header|jq}}==

{{trans|Clojure}}

[range(18) as $n6 |

range(13) as $n9 |

select($possible|contains([$n])|not)

] |

{{out}}

<pre>43</pre>

=={{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

println(mcnuggets(100))

43

</pre>

=={{header|Kotlin}}==

{{trans|Go}}

fun mcnugget(limit: Int) {

fun main(args: Array<String>) {

mcnugget(100)

{{output}}

=={{header|Locomotive Basic}}==

110 DIM a(100)

120 FOR a=0 TO 100/6

220 NEXT n

230 PRINT"The Largest non McNugget number is:";l

{{output}}

=={{header|Lua}}==

function range(A,B)

return function()

print(maximum(exclude(sum, range(1, N))))

{{out}}

<pre>

=={{header|MAD}}==

BOOLEAN NUGGET

DIMENSION NUGGET(101)

PRINT FORMAT F, I

VECTOR VALUES F = $29HMAXIMUM NON-MCNUGGET NUMBER: ,I2*$

{{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;

WriteCard(a, 2);

WriteLn();

{{out}}

<pre>Maximum non-McNuggets number: 43</pre>

=={{header|MiniZinc}}==

%McNuggets. Nigel Galloway, August 27th., 2019

var 0..99: n;

solve maximize n;

output [show(n)]

{{out}}

<pre>

=={{header|Nim}}==

var mcnuggets: array[0..Limit, bool]

if not mcnuggets[n]:

echo "The largest non-McNuggets number is: ", n

{{out}}

{{trans|Raku}}

{{libheader|ntheory}}

sub Mcnugget_number {

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

===Perl using Regex===

use warnings;

$_ = 1 . 0 x 100;

1 while s/ (?=1) (?:.{6}|.{9}|.{20}) \K 0 /1/x;

{{out}}

<pre>Maximum non-Mcnugget number is: 43</pre>

=={{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>

<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>

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>

<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>

=={{header|Picat}}==

Using constraint modelling (cp solver).

go =>

end,

solve($[max(N)],N),

{{out}}

=={{header|PicoLisp}}==

(let Lst (range 0 M)

(for A (range 0 M 6)

(for C (range B M 20)

(set (nth Lst (inc C))) ) ) )

Generator from fiber:

(co 'nugget

(for A (range 0 M 6)

(while (nugg 100)

(set (nth Lst @)) )

Test versions against each other:

T

(=

43

(nuggets1 100)

=={{header|PL/I}}==

declare nugget(0:100) bit, (a, b, c) fixed;

do a=0 to 100; nugget(a) = '0'b; end;

end;

end;

{{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;

CALL PRINT$NUMBER(A);

CALL EXIT;

{{out}}

<pre>43</pre>

=={{header|PowerShell}}==

{{trans|UNIX Shell}}

For ($i=0; $i -lt 18; $i++) {

For ($j=0; $j -lt 13; $j++) {

}

}

{{out}}

<pre>Maximum non-McNuggets number is 43</pre>

===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)):

>>> 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)))

{{out}}

<pre>

{{Works with|Python|3.7}}

from itertools import (chain, dropwhile)

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre>

=={{header|Quackery}}==

100 6 / times

[ i 6 *

[ say "The largest non-McNugget number below 101 is "

echo ]

'''Output:'''

There are two natural approaches. The first is to generate all valid x, y, and z and then apply the function:

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.

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}}

{{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)))

=={{header|Raku}}==

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.

return '∞' if 1 < [gcd] @counts;

put "Maximum non-Mcnugget number using {$counts.join: ', '} is: ",

Mcnugget-number(|$counts)

{{out}}

<pre>Maximum non-Mcnugget number using 6, 9, 20 is: 43

:* &nbsp; excludes meals that have a multiple order of nuggets

:* &nbsp; automatically computes the '''high''' value algebraically instead of using &nbsp; '''100'''.

parse arg y /*obtain optional arguments from the CL*/

if y='' | y="," then y= 6 9 20 /*Not specified? Then use the defaults*/

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

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

<pre>

=={{header|Ring}}==

Nuggets = list(100)

ok

next

{{out}}

<pre>

=={{header|Ruby}}==

{{trans|Go}}

sv = (0..limit).to_a

end

{{out}}

<pre>

</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)

=={{header|Rust}}==

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],

(m * y + cc) / aa

}

{{out}}

<pre>

=={{header|Swift}}==

var (max, sixes, nines, twenties, i) = (0, 0, 0, 0, 0)

}

{{out}}

=={{header|Tailspin}}==

templates largestNonMcNuggetNumber

@: { largest: 0, mcNuggetNumbers: [1..$+20 -> 0] };

100 -> largestNonMcNuggetNumber -> !OUT::write

{{out}}

<pre>

{{works with|ksh}}

{{works with|zsh}}

for (( i=0; i<18; ++i )); do

for (( j=0; j<13; ++j )); do

done

{{out}}

<pre>Maximum non-McNuggets number is 43</pre>

{{works with|sh}}

i=0

while [ $i -lt 18 ]; do

break

done

{{out}}

<pre>Maximum non-McNuggets number is 43</pre>

=={{header|Vlang}}==

{{trans|Go}}

mut sv := []bool{len: limit+1} // all false by default

for s := 0; s <= limit; s += 6 {

fn main() {

mcnugget(100)

{{out}}

=={{header|VTL-2}}==

20 :N+1)=0

30 N=N+1

170 #=:N+1)

180 ?="Largest non-McNuggets number: ";

{{out}}

<pre>Largest non-McNuggets number: 43</pre>

=={{header|Wren}}==

{{trans|Go}}

var sv = List.filled(limit+1, false)

var s = 0

}

{{out}}

=={{header|XPL0}}==

[for N:= 0 to 100 do A(N):= false;

for X:= 0 to 100/6 do

exit;

];

{{out}}

=={{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 }

{{out}}

<pre>