always-cautious/ortools-clone
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Added magic_square_and_cards.cs kenken2.cs labeled_dice.cs

Browse Source
This commit is contained in:
hakank
2012-01-29 22:46:49 +00:00
parent 6eafbab77b
commit dba10256b0
3 changed files with 568 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

244
csharp/kenken2.cs Normal file
View File

@@ -0,0 +1,244 @@
//
// Copyright 2012 Hakan Kjellerstrand
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using Google.OrTools.ConstraintSolver;
public class KenKen2
{
/**
* Ensure that the sum of the segments
* in cc == res
*
*/
public static void calc(Solver solver,
int[] cc,
IntVar[,] x,
int res)
{
int ccLen = cc.Length;
if (ccLen == 4) {
// for two operands there's
// a lot of possible variants
IntVar a = x[cc[0]-1, cc[1]-1];
IntVar b = x[cc[2]-1, cc[3]-1];
IntVar r1 = (a + b).IsEqual(res);
IntVar r2 = (a * b).IsEqual(res);
IntVar r3 = (a * res).IsEqual(b);
IntVar r4 = (b * res).IsEqual(a);
IntVar r5 = (a - b).IsEqual(res);
IntVar r6 = (b - a).IsEqual(res);
solver.Add(r1+r2+r3+r4+r5+r6 >= 1);
} else {
// For length > 2 then res is either the sum
// the the product of the segment
// sum the numbers
int len = cc.Length / 2;
IntVar[] xx = (from i in Enumerable.Range(0, len)
select x[cc[i*2]-1,cc[i*2+1]-1].Var()).ToArray();
// Sum
IntVar this_sum = xx.Sum().IsEqual(res);
// Product
// IntVar this_prod = (xx.Prod() == res).Var(); // don't work
IntVar this_prod;
if (xx.Length == 3) {
this_prod = (x[cc[0]-1,cc[1]-1] *
x[cc[2]-1,cc[3]-1] *
x[cc[4]-1,cc[5]-1]).IsEqual(res);
} else {
this_prod = (
x[cc[0]-1,cc[1]-1] *
x[cc[2]-1,cc[3]-1] *
x[cc[4]-1,cc[5]-1] *
x[cc[6]-1,cc[7]-1]).IsEqual(res);
}
solver.Add(this_sum + this_prod >= 1);
}
}
/**
*
* KenKen puzzle.
*
* http://en.wikipedia.org/wiki/KenKen
* """
* KenKen or KEN-KEN is a style of arithmetic and logical puzzle sharing
* several characteristics with sudoku. The name comes from Japanese and
* is translated as 'square wisdom' or 'cleverness squared'.
* ...
* The objective is to fill the grid in with the digits 1 through 6 such that:
*
* * Each row contains exactly one of each digit
* * Each column contains exactly one of each digit
* * Each bold-outlined group of cells is a cage containing digits which
* achieve the specified result using the specified mathematical operation:
* addition (+),
* subtraction (-),
* multiplication (x),
* and division (/).
* (Unlike in Killer sudoku, digits may repeat within a group.)
*
* ...
* More complex KenKen problems are formed using the principles described
* above but omitting the symbols +, -, x and /, thus leaving them as
* yet another unknown to be determined.
* """
*
* The solution is:
*
* 5 6 3 4 1 2
* 6 1 4 5 2 3
* 4 5 2 3 6 1
* 3 4 1 2 5 6
* 2 3 6 1 4 5
* 1 2 5 6 3 4
*
*
* Also see http://www.hakank.org/or-tools/kenken2.py
* though this C# model has another representation of
* the problem instance.
*
*/
private static void Solve()
{
Solver solver = new Solver("KenKen2");
// size of matrix
int n = 6;
IEnumerable<int> RANGE = Enumerable.Range(0, n);
// For a better view of the problem, see
// http://en.wikipedia.org/wiki/File:KenKenProblem.svg
// hints
// sum, the hints
// Note: this is 1-based
int[][] problem =
{
new int[] { 11, 1,1, 2,1},
new int[] { 2, 1,2, 1,3},
new int[] { 20, 1,4, 2,4},
new int[] { 6, 1,5, 1,6, 2,6, 3,6},
new int[] { 3, 2,2, 2,3},
new int[] { 3, 2,5, 3,5},
new int[] {240, 3,1, 3,2, 4,1, 4,2},
new int[] { 6, 3,3, 3,4},
new int[] { 6, 4,3, 5,3},
new int[] { 7, 4,4, 5,4, 5,5},
new int[] { 30, 4,5, 4,6},
new int[] { 6, 5,1, 5,2},
new int[] { 9, 5,6, 6,6},
new int[] { 8, 6,1, 6,2, 6,3},
new int[] { 2, 6,4, 6,5}
};
int num_p = problem.GetLength(0); // Number of segments
//
// Decision variables
//
IntVar[,] x = solver.MakeIntVarMatrix(n, n, 1, n, "x");
IntVar[] x_flat = x.Flatten();
//
// Constraints
//
//
// alldifferent rows and columns
foreach(int i in RANGE) {
// rows
solver.Add( (from j in RANGE
select x[i,j].Var()).ToArray().AllDifferent());
// cols
solver.Add( (from j in RANGE
select x[j,i].Var()).ToArray().AllDifferent());
}
// Calculate the segments
for(int i = 0; i < num_p; i++) {
int[] segment = problem[i];
// Remove the sum from the segment
int len = segment.Length-1;
int[] s2 = new int[len];
Array.Copy(segment, 1, s2, 0, len);
// sum this segment
calc(solver, s2, x, segment[0]);
}
//
// Search
//
DecisionBuilder db = solver.MakePhase(x_flat,
Solver.INT_VAR_DEFAULT,
Solver.INT_VALUE_DEFAULT);
solver.NewSearch(db);
while (solver.NextSolution()) {
for(int i = 0; i < n; i++) {
for(int j = 0; j < n; j++) {
Console.Write(x[i,j].Value() + " ");
}
Console.WriteLine();
}
Console.WriteLine();
}
Console.WriteLine("\nSolutions: {0}", solver.Solutions());
Console.WriteLine("WallTime: {0}ms", solver.WallTime());
Console.WriteLine("Failures: {0}", solver.Failures());
Console.WriteLine("Branches: {0} ", solver.Branches());
solver.EndSearch();
}
public static void Main(String[] args)
{
Solve();
}
}

184
csharp/labeled_dice.cs Normal file
View File

@@ -0,0 +1,184 @@
//
// Copyright 2012 Hakan Kjellerstrand
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using Google.OrTools.ConstraintSolver;
public class LabeledDice
{
/**
*
* Labeled dice problem.
*
* From Jim Orlin 'Colored letters, labeled dice: a logic puzzle'
* http://jimorlin.wordpress.com/2009/02/17/colored-letters-labeled-dice-a-logic-puzzle/
* """
* My daughter Jenn bough a puzzle book, and showed me a cute puzzle. There
* are 13 words as follows: BUOY, CAVE, CELT, FLUB, FORK, HEMP, JUDY,
* JUNK, LIMN, QUIP, SWAG, VISA, WISH.
*
* There are 24 different letters that appear in the 13 words. The question
* is: can one assign the 24 letters to 4 different cubes so that the
* four letters of each word appears on different cubes. (There is one
* letter from each word on each cube.) It might be fun for you to try
* it. I'll give a small hint at the end of this post. The puzzle was
* created by Humphrey Dudley.
* """
*
* Jim Orlin's followup 'Update on Logic Puzzle':
* http://jimorlin.wordpress.com/2009/02/21/update-on-logic-puzzle/
*
*
* Also see http://www.hakank.org/or-tools/labeled_dice.py
*
*/
private static void Solve()
{
Solver solver = new Solver("LabeledDice");
//
// Data
//
int n = 4;
int m = 24;
int A = 0;
int B = 1;
int C = 2;
int D = 3;
int E = 4;
int F = 5;
int G = 6;
int H = 7;
int I = 8;
int J = 9;
int K = 10;
int L = 11;
int M = 12;
int N = 13;
int O = 14;
int P = 15;
int Q = 16;
int R = 17;
int S = 18;
int T = 19;
int U = 20;
int V = 21;
int W = 22;
int Y = 23;
String[] letters_str = {"A","B","C","D","E","F","G","H","I","J","K","L","M",
"N","O","P","Q","R","S","T","U","V","W","Y"};
int num_words = 13;
int[,] words =
{
{B,U,O,Y},
{C,A,V,E},
{C,E,L,T},
{F,L,U,B},
{F,O,R,K},
{H,E,M,P},
{J,U,D,Y},
{J,U,N,K},
{L,I,M,N},
{Q,U,I,P},
{S,W,A,G},
{V,I,S,A},
{W,I,S,H}
};
//
// Decision variables
//
IntVar[] dice = solver.MakeIntVarArray(m, 0, n-1, "dice");
IntVar[] gcc = solver.MakeIntVarArray(n, 6, 6, "gcc");
//
// Constraints
//
// the letters in a word must be on a different die
for(int i = 0; i < num_words; i++) {
solver.Add( (from j in Enumerable.Range(0, n)
select dice[words[i,j]].Var()
).ToArray().AllDifferent());
}
// there must be exactly 6 letters of each die
/*
for(int i = 0; i < n; i++) {
solver.Add( ( from j in Enumerable.Range(0, m)
select dice[j].IsEqual(i)
).ToArray().Sum() == 6 );
}
*/
// Use Distribute (Global Cardinality Count) instead.
solver.Add(dice.Distribute(gcc));
//
// Search
//
DecisionBuilder db = solver.MakePhase(dice,
Solver.CHOOSE_FIRST_UNBOUND,
Solver.ASSIGN_MIN_VALUE);
solver.NewSearch(db);
while (solver.NextSolution()) {
for(int d = 0; d < n; d++) {
Console.Write("die {0}: ", d);
for(int i = 0; i < m; i++) {
if (dice[i].Value() == d) {
Console.Write(letters_str[i]);
}
}
Console.WriteLine();
}
Console.WriteLine("The words with the cube label:");
for(int i = 0; i < num_words; i++) {
for(int j = 0; j < n; j++) {
Console.Write("{0} ({1})", letters_str[words[i,j]], dice[words[i,j]].Value());
}
Console.WriteLine();
}
Console.WriteLine();
}
Console.WriteLine("\nSolutions: {0}", solver.Solutions());
Console.WriteLine("WallTime: {0}ms", solver.WallTime());
Console.WriteLine("Failures: {0}", solver.Failures());
Console.WriteLine("Branches: {0} ", solver.Branches());
solver.EndSearch();
}
public static void Main(String[] args)
{
Solve();
}
}

140
csharp/magic_square_and_cards.cs Normal file
View File

@@ -0,0 +1,140 @@
//
// Copyright 2012 Hakan Kjellerstrand
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using Google.OrTools.ConstraintSolver;
public class MagicSquareAndCards
{
/**
*
* Magic squares and cards problem.
*
* Martin Gardner (July 1971)
* """
* Allowing duplicates values, what is the largest constant sum for an order-3
* magic square that can be formed with nine cards from the deck.
* """
*
*
* Also see http://www.hakank.org/or-tools/magic_square_and_cards.py
*
*/
private static void Solve(int n=3)
{
Solver solver = new Solver("MagicSquareAndCards");
IEnumerable<int> RANGE = Enumerable.Range(0, n);
//
// Decision variables
//
IntVar[,] x = solver.MakeIntVarMatrix(n, n, 1, 13, "x");
IntVar[] x_flat = x.Flatten();
IntVar s = solver.MakeIntVar(1, 13*4, "s");
IntVar[] counts = solver.MakeIntVarArray(14, 0, 4, "counts");
//
// Constraints
//
solver.Add(x_flat.Distribute(counts));
// the standard magic square constraints (sans all_different)
foreach(int i in RANGE) {
// rows
solver.Add( (from j in RANGE
select x[i,j].Var()
).ToArray().Sum() == s);
// columns
solver.Add( (from j in RANGE
select x[j,i].Var()
).ToArray().Sum() == s);
}
// diagonals
solver.Add( (from i in RANGE
select x[i,i].Var()
).ToArray().Sum() == s);
solver.Add( (from i in RANGE
select x[i,n-i-1].Var()
).ToArray().Sum() == s);
// redundant constraint
solver.Add(counts.Sum() == n*n);
//
// Objective
//
OptimizeVar obj = s.Maximize(1);
//
// Search
//
DecisionBuilder db = solver.MakePhase(x_flat,
Solver.CHOOSE_FIRST_UNBOUND,
Solver.ASSIGN_MAX_VALUE);
solver.NewSearch(db, obj);
while (solver.NextSolution()) {
Console.WriteLine("s: {0}", s.Value());
Console.Write("counts:");
for(int i = 0; i < 14; i++) {
Console.Write(counts[i].Value() + " ");
}
Console.WriteLine();
for(int i = 0; i < n; i++) {
for(int j = 0; j < n; j++) {
Console.Write(x[i,j].Value() + " ");
}
Console.WriteLine();
}
Console.WriteLine();
}
Console.WriteLine("\nSolutions: {0}", solver.Solutions());
Console.WriteLine("WallTime: {0}ms", solver.WallTime());
Console.WriteLine("Failures: {0}", solver.Failures());
Console.WriteLine("Branches: {0} ", solver.Branches());
solver.EndSearch();
}
public static void Main(String[] args)
{
int n = 3;
if (args.Length > 0) {
n = Convert.ToInt32(args[0]);
}
Solve(n);
}
}