Set puzzle: Difference between revisions

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:

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

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

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

cards];

=={{header|Nim}}==

type

playGame(Basic)

echo()

{{out}}

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

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

<span style="color: #008080;">function</span> <span style="color: #000000;">comb</span><span style="color: #0000FF;">(</span><span style="color: #004080;">sequence</span> <span style="color: #000000;">pool</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">integer</span> <span style="color: #000000;">needed</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">sequence</span> <span style="color: #000000;">res</span><span style="color: #0000FF;">={},</span> <span style="color: #004080;">integer</span> <span style="color: #000000;">done</span><span style="color: #0000FF;">=</span><span style="color: #000000;">0</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">sequence</span> <span style="color: #000000;">chosen</span><span style="color: #0000FF;">={})</span>

<span style="color: #000080;font-style:italic;">--play(12,6)

--play(9,6)</span>

{{out}}

<pre>

=={{header|Picat}}==

The problem generator check that it problem has exactly one solution, so that step can take a little time (some seconds). <code>fail/0</code> is used to check for unicity of the solution.

import cp.

],

SetLen = 3,

===Constraint model===

Here is the additional code for a '''constraint model'''. Note that the constraint solver only handles integers so the features must be converted to integers. To simplify, the random instance generator does not check for unicity of the problem instance, so it can have (and often have) a lot of solutions.

NumCards = 18,

NumWanted = 9,

%

generate_instance2(NumCards,_NumSets,_SetLen, Cards) =>

{{out}}

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

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

parse arg game seed . /*get optional # cards to deal and seed*/

if game=='' | game=="," then game= 9 /*Not specified? Then use the default.*/

/*──────────────────────────────────────────────────────────────────────────────────────*/

sey: if \tell then return /*¬ tell? Then suppress the output. */

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

<pre>

=={{header|Ruby}}==

Brute force.

SYMBOLS = %i(oval squiggle diamond)

NUMBERS = %i(one two three)

set_puzzle(9)

{{out}}

<pre>

</pre>

=={{header|Rust}}==

use itertools::Itertools;

use rand::Rng;

}

{{out}}

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

def deck: [ { by 1..3 -> (colour: $),

by 1..3 -> (symbol: $),

[9,4] -> setPuzzle -> formatSets -> !OUT::write

{{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 "/trait" for Comparable

import "/fmt" for Fmt

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>