Set puzzle: Difference between revisions

:purple, three, oval, open

<br><br>

 

=={{header|Ada}}==

We start with the specification of a package "Set_Puzzle.

 

type Three is range 1..3;

-- calls Do_Something once for each set it finds.

 

Now we implement the package "Set_Puzzle".

 

 

package body Set_Puzzle is

begin

Rand.Reset(R);

 

Finally, we write the main program, using the above package. It reads two parameters from the command line. The first parameter describes the number of cards, the second one the number of sets. Thus, for the basic mode one has to call "puzzle 9 4", for the advanced mode "puzzle 12 6", but the program would support any other combination of parameters just as well.

 

 

procedure Puzzle is

Print_Sets(Cards); -- print the sets

 

{{out}}

 

=={{header|AutoHotkey}}==

Loop, 81

deck .= ToBase(A_Index-1, 3)+1111 ","

c%j% += 1

}

{{out|Sample output}}

<pre>Dealt 9 cards:

=={{header|C}}==

Brute force. Each card is a unique number in the range of [0,81]. Randomly deal a hand of cards until exactly the required number of sets are found.

#include <stdlib.h>

 

 

return 0;

 

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

{{works with|C sharp|8}}

using System.Collections.Generic;

using static System.Linq.Enumerable;

static bool AreSameOrDifferent(int a, int b, int c) => (a + b + c) % 3 == 0;

static IEnumerable<int> To(this int start, int end) => Range(start, end - start - 1);

{{out}}

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

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

{{trans|Java}}

#include <time.h>

#include <algorithm>

return 0;

}

{{out}}

<pre>

=={{header|Ceylon}}==

Add import ceylon.random "1.3.3" to your module.ceylon file

Random,

DefaultRandom

}

 

 

=={{header|D}}==

===Basic Version===

std.exception, std.range, std.algorithm;

 

writefln("\nFOUND %d SET%s:", len, len == 1 ? "" : "S");

writefln("%(%(%s\n%)\n\n%)", sets);

{{out|Sample output}}

<pre>DEALT 9 CARDS:

===Short Version===

This requires the third solution module of the Combinations Task.

import std.stdio, std.algorithm, std.range, std.random, combinations3;

 

writefln("Dealt %d cards:\n%(%-(%8s %)\n%)\n", draw.length, draw);

writefln("Containing:\n%(%(%-(%8s %)\n%)\n\n%)", sets);

{{out}}

<pre>Dealt 9 cards:

purple one squiggle striped

green three diamond striped</pre>

 

=={{header|EchoLisp}}==

(require 'list)

 

))

 

{{out}}

<pre>

=={{header|Elixir}}==

{{trans|Ruby}}

def set_puzzle(deal, goal) do

{puzzle, sets} = get_puzzle_and_answer(deal, goal, produce_deck)

 

RC.set_puzzle(9, 4)

 

{{out}}

=={{header|Erlang}}==

Until a better solution is found this is one.

-module( set ).

 

make_sets_acc( true, Set, Sets ) -> [Set | Sets];

make_sets_acc( false, _Set, Sets ) -> Sets.

{{out}}

<pre>

 

=={{header|F Sharp|F#}}==

 

type Number = One | Two | Three

solve 12 6

 

Output:

<pre>

 

=={{header|Factor}}==

fry grouping io kernel literals math.combinatorics math.matrices

prettyprint qw random sequences sets ;

12 6 set-puzzle ;

 

{{out}}

<pre style="height:65ex">

 

=={{header|Go}}==

 

import (

fmt.Printf(" %s\n %s\n %s\n",s[0],s[1],s[2])

}

{{out}}

<pre>

 

=={{header|Haskell}}==

(State, evalState, replicateM, runState, state)

import System.Random (StdGen, newStdGen, randomR)

main = do

showSolutions 9 4

{{out}}

<pre style="font-size:80%">Showing hand of 9 cards with 4 solutions.

=={{header|J}}==

'''Solution:'''

 

Number=: ;:'one two three'

echo LF,'Found ',(":target),' Sets:'

echo sayCards sort"2 getSets Hand

 

'''Example:'''

Dealt 9 Cards:

one, red, solid, oval

three, red, open, oval

three, green, solid, oval

 

=={{header|Java}}==

 

public class SetPuzzle {

return tot == 0;

}

<pre>GIVEN 12 CARDS:

 

=={{header|Julia}}==

Plays one basic game and one advanced game.

 

function SetGameTM(basic = true)

SetGameTM()

SetGameTM(false)

Dealt 9 cards:

("green", "one", "oval", "open")

 

=={{header|Kotlin}}==

 

import java.util.Collections.shuffle

println()

playGame(Degree.ADVANCED)

 

Sample output:

</pre>

 

A simple brute force approach. This code highlights two things: 1) a few of Mathematica's "higher-level" functions such as Tuples and Subsets and 2) the straightforwardness enabled by the language's "dynamic typing" (more precisely, its symbolic semantics) and its usage of lists for everything (in this particular example, the fact that functions such as Tuples and Entropy can be used on lists with arbitrary content).

 

symbols = {"0", "\[TildeTilde]", "\[Diamond]"};

numbers = {1, 2, 3};

cards = RandomSample[allCards, numDeal];

count = Count[Subsets[cards, {3}], _?validSetQ]];

cards];

 

 

=={{header|PARI/GP}}==

howmany(a,b,c)=hammingweight(bitor(a,bitor(b,c)));

name(v)=Str(["red","green",0,"purple"][v[1]],", ",["oval","squiggle",0,"diamond"][v[2]],", ",["one","two",0,"three"][v[3]],", ",["solid","open",0,"striped"][v[4]]);

};

deal(9,4)

{{output}}

<pre>green, diamond, one, open

It's actually slightly simplified, since generating Enum classes

and objects would be overkill for this particular task.

use strict;

use warnings;

 

__END__

{{out}}

<pre>Drew 12 cards:

=={{header|Phix}}==

Converts cards 1..81 (that idea from C) to 1/2/4 [/7] (that idea from Perl) but inverts the validation

{{out}}

<pre>

8: red diamond two open

</pre>

 

=={{header|Prolog}}==

 

card_sets(N, Cards, Sets),

!,

match([A|T1],[B|T2],[C|T3]) :-

dif(A,B), dif(B,C), dif(A,C),

{{out}}

<pre>

 

=={{header|Python}}==

from itertools import product, combinations

break

printit(deal, sets)

<small>Note: You could remove the inner square brackets of the <code>'if all( [...] )'</code> part of the sets computation in the getsets function. It is a remnant of Python 2.7 debugging which gives access to the name <code>feature</code>. The code works on Python 3.X too, but not that access.</small>

 

===Short Version===

{{trans|D}}

from itertools import product, combinations

 

pprint.pprint(draw)

print "\nContaining %d sets:" % len(sets)

{{out}}

<pre>Dealt 9 cards:

('green', 'three', 'oval', 'open'),

('purple', 'three', 'squiggle', 'solid'))]</pre>

 

=={{header|Racket}}==

#lang racket

 

(deal 9 4)

(deal 12 6)

 

=={{header|Raku}}==

 

The trick here is to allocate three different bits for each enum, with the result that the cards of a matching set OR together to produce a 4-digit octal number that contains only the digits 1, 2, 4, or 7. This OR is done by funny looking <tt>[+|]</tt>, which is the reduction form of <tt>+|</tt>, which is the numeric bitwise OR. (Because Raku stole the bare <tt>|</tt> operator for composing junctions instead.)

enum Count (one => 0o100, two => 0o200, three => 0o400);

enum Shape (oval => 0o10, squiggle => 0o20, diamond => 0o40);

show-cards @cards;

}

{{out}}

<pre>Drew 9 cards:

 

The particular set of cards dealt (show below) used Regina 3.9.3 under a Windows/XP environment.

 

 

'''output''' when using the default input:

<pre>

4 sets found.

</pre>

<pre>

dealing 12 cards:

=={{header|Ruby}}==

Brute force.

SYMBOLS = %i(oval squiggle diamond)

NUMBERS = %i(one two three)

 

set_puzzle(9)

{{out}}

<pre>

green oval two open

red diamond two striped

</pre>

 

=={{header|Tailspin}}==

Dealing cards at random to the size of the desired hand, then trying again if the desired set count is not achieved.

];

 

templates isSet

def set : $;

// if it is an array where all elements of 3, 6 or 9, it is a set

when <[<=3|=6|=9>+ VOID]> do $set !

def nCards: $(1);

def nSets: $(2);

when <{sets: <[]($nSets..)>}> do $ !

otherwise

 

templates formatCard

$ -> '$colours($.colour);-$symbols($.symbol);-$numbers($.number);-$shadings($.shading);' !

end formatCard

end formatSets

 

{{out}}

<pre>

 

Twelve cards with six sets

[12,6] -> setPuzzle -> formatSets -> !OUT::write

{{out}}

<pre>

The principle behind this code is that the space of possible solutions is a substantial proportion of the space of possible hands, so picking a random hand and verifying that it is a solution, repeating until that verification succeeds, is a much quicker way to find a solution than a systematic search.

It also makes the code substantially simpler.

proc random n {expr {int(rand() * $n)}}

 

}

return [list $hand $sets]

Demonstrating:

proc PrettyHand {hand {separator \n}} {

set Co {. red green . purple}

PrettyOutput [SetPuzzle 9 4]

puts "=== ADVANCED PUZZLE ======"

{{out|Sample output}}

<pre>

{{libheader|Wren-math}}

{{libheader|Wren-sort}}

import "random" for Random

 

playGame.call(Degree.BASIC)

System.print()

 

{{out}}

=={{header|zkl}}==

{{trans|D}}

var [const] UH=Utils.Helpers; // baked in stash of goodies

deck:=Walker.cproduct("red green purple".split(), // Cartesian product of 4 lists of lists

draw.pump(Void,fcn(card){ println(("%8s "*4).fmt(card.xplode())) });

println("\nContaining:");

{{out}}

<pre>