The puzzle game Magnets involves placing a set of domino-shaped magnets (or electrets or other polarized objects) in a subset of slots on a board so as to satisfy a set of constraints. For example, the puzzle on the left has the solution shown on the right:
Each slot contains either a blank entry (indicated by ‘x’s), or a “magnet” with a positive and negative end. The numbers along the left and top sides show the numbers of ‘+’ squares in particular rows or columns. Those along the right and bottom show the number of ‘-’ signs in particular rows or columns. Rows and columns without a number at one or both ends are unconstrained as to the number of ‘+’ or ‘-’ signs, depending on which number is not present. In addition to fulfilling these numerical constraints, a puzzle solution must also satisfy the constraint that no two orthogonally touching squares may have the same sign (diagonally joined squares are not constrained). You are given top[], bottom[], left[], right[] arrays indicates the count of + or – along the top(+), bottom(-), left(+) and right(-) edges respectively. Values of -1 indicate any number of + and – signs. Also given matrix rules[][] contain any one T, B, L or R characters. For a vertical slot in the board, T indicates its top end and B indicates the bottom end. For a horizontal slot in the board, L indicates left end and R indicates the right end.
Examples:
Input : M = 5, N = 6
top[] = { 1, -1, -1, 2, 1, -1 }
bottom[] = { 2, -1, -1, 2, -1, 3 }
left[] = { 2, 3, -1, -1, -1 }
right[] = { -1, -1, -1, 1, -1 }
rules[][] = { { L, R, L, R, T, T },
{ L, R, L, R, B, B },
{ T, T, T, T, L, R },
{ B, B, B, B, T, T },
{ L, R, L, R, B, B }};
Output : + - + - X -
- + - + X +
X X + - + -
X X - + X +
- + X X X -
Input : M = 4, N = 3
top[] = { 2, -1, -1 }
bottom[] = { -1, -1, 2 }
left[] = { -1, -1, 2, -1 }
right[] = { 0, -1, -1, -1 }
rules[][] = { { T, T, T },
{ B, B, B },
{ T, L, R },
{ B, L, R } };
Output : + X +
– X –
+ – +
– + –
We can solve this problem using Backtracking.
// Write Python3 code here #include<bits/stdc++.h> using namespace std;
bool checkConstraints(vector<vector< char >> &rules){
int M = 5;
int N = 6;
vector< int > top = { 1, -1, -1, 2, 1, -1 };
vector< int > bottom = {2, -1, -1, 2, -1, 3 };
vector< int > left = {2, 3, -1, -1, -1};
vector< int > right = {-1, -1, -1, 1, -1};
vector< int > pCountH(rules.size(), 0);
vector< int > nCountH(rules.size(), 0);
for ( int row = 0; row < rules.size(); row++){
for ( int col = 0; col < rules[0].size(); col++){
char ch = rules[row][col];
if (ch == '+' ){
pCountH[row] += 1;
}
else if (ch == '-' ){
nCountH[row] += 1;
}
}
}
vector< int > pCountV(rules[0].size(), 0);
vector< int > nCountV(rules[0].size(), 0);
for ( int col = 0; col < rules[0].size(); col++){
for ( int row = 0; row < rules.size(); row++){
char ch = rules[row][col];
if (ch == '+' ){
pCountV[col] += 1;
}
else if (ch == '-' ){
nCountV[col] += 1;
}
}
}
for ( int row = 0; row < rules.size(); row++){
if (left[row] != -1){
if (pCountH[row] != left[row]){
return false ;
}
}
if (right[row] != -1){
if (nCountH[row] != right[row]){
return false ;
}
}
}
for ( int col = 0; col < rules[0].size(); col++){
if (top[col] != -1){
if (pCountV[col] != top[col]){
return false ;
}
}
if (bottom[col] != -1){
if (nCountV[col] != bottom[col]){
return false ;
}
}
// if (top[col] != -1 and pCountH[col] != top[col]) or (bottom[col] != -1 and nCountH[col] != bottom[col]) :
// return False
}
return true ;
} bool canPutPatternHorizontally(vector<vector< char >> &rules, int i, int j, string pat){
if ( j-1>=0 and rules[i][j-1] == pat[0]){
return false ;
}
else if (i-1>=0 and rules[i-1][j] == pat[0]){
return false ;
}
else if (i-1>=0 and rules[i-1][j+1] == pat[1]){
return false ;
}
else if (j+2 < rules[0].size() and rules[i][j+2] == pat[1]){
return false ;
}
return true ;
} bool canPutPatternVertically(vector<vector< char >> &rules, int i, int j, string pat){
if ( j-1>=0 and rules[i][j-1] == pat[0]){
return false ;
}
else if (i-1>=0 and rules[i-1][j] == pat[0]){
return false ;
}
else if (j+1 < rules[0].size() and rules[i][j+1] == pat[0]){
return false ;
}
return true ;
} void solveMagnets(vector<vector< char >> &rules, int i, int j){
// check the constraint before printing
if ( i == rules.size() and j == 0){
if (checkConstraints(rules)){
// Printing rules array.
cout << "[" ;
for ( int indxi = 0; indxi < rules.size(); indxi++){
cout << "[" ;
for ( int indxj = 0; indxj < rules[0].size(); indxj++){
cout << "'" << rules[indxi][indxj] << "', " ;
}
cout << "]" ;
}
cout << "]" ;
}
}
else if (j >= rules[0].size()){
solveMagnets(rules, i+1, 0);
}
// normal cases
else {
if (rules[i][j] == 'L' ){
// option 1 +-
if (canPutPatternHorizontally(rules,i,j, "+-" )){
rules[i][j] = '+' ;
rules[i][j+1] = '-' ;
solveMagnets(rules,i,j+2);
rules[i][j] = 'L' ;
rules[i][j+1] = 'R' ;
}
// option 2 -+
if (canPutPatternHorizontally(rules,i,j, "-+" )){
rules[i][j] = '-' ;
rules[i][j+1] = '+' ;
solveMagnets(rules,i,j+2);
rules[i][j] = 'L' ;
rules[i][j+1] = 'R' ;
}
// option 3 xx
if ((1 == 1) || canPutPatternHorizontally(rules,i,j, "xx" )){
rules[i][j] = 'x' ;
rules[i][j+1] = 'x' ;
solveMagnets(rules,i,j+2);
rules[i][j] = 'L' ;
rules[i][j+1] = 'R' ;
}
}
// vertical check
else if (rules[i][j] == 'T' ){
// option 1 +-
if (canPutPatternVertically(rules,i,j, "+-" )){
rules[i][j] = '+' ;
rules[i+1][j] = '-' ;
solveMagnets(rules,i,j+1);
rules[i][j] = 'T' ;
rules[i+1][j] = 'B' ;
}
// option 2 -+
if (canPutPatternVertically(rules,i,j, "-+" )){
rules[i][j] = '-' ;
rules[i+1][j] = '+' ;
solveMagnets(rules,i,j+1);
rules[i][j] = 'T' ;
rules[i+1][j] = 'B' ;
}
// option 3 xx
if ((1 == 1) or canPutPatternVertically(rules,i,j, "xx" )){
rules[i][j] = 'x' ;
rules[i+1][j] = 'x' ;
solveMagnets(rules,i,j+1);
rules[i][j] = 'T' ;
rules[i+1][j] = 'B' ;
}
}
else {
solveMagnets(rules,i,j+1);
}
}
} void doTheStuff(vector<vector< char >> &rules, int i, int j){
if (rules[i][j] == 'L' || rules[i][j] == 'R' ){
// option 1 +-
if (canPutPatternHorizontally(rules, i, j , "+-" )){
rules[i][j] = '+' ;
rules[i][j+1] = '-' ;
solveMagnets(rules,i,j);
}
// option 2 -+
// option 3 xx
}
} // Driver code int main(){
vector<vector< char >> rules = {
{ 'L' , 'R' , 'L' , 'R' , 'T' , 'T' },
{ 'L' , 'R' , 'L' , 'R' , 'B' , 'B' },
{ 'T' , 'T' , 'T' , 'T' , 'L' , 'R' },
{ 'B' , 'B' , 'B' , 'B' , 'T' , 'T' },
{ 'L' , 'R' , 'L' , 'R' , 'B' , 'B' }
};
solveMagnets(rules,0,0);
} // The code is contributed by Gautam goel. |
// java code implementation import java.util.*;
import java.lang.*;
import java.io.*;
import java.util.stream.*;
public class Main {
public static boolean canPutPatternHorizontally( char [][] rules, int i, int j, char [] pat){
if ( j- 1 >= 0 && rules[i][j- 1 ] == pat[ 0 ]){
return false ;
}
else if (i- 1 >= 0 && rules[i- 1 ][j] == pat[ 0 ]){
return false ;
}
else if (i- 1 >= 0 && rules[i- 1 ][j+ 1 ] == pat[ 1 ]){
return false ;
}
else if (j+ 2 < rules[ 0 ].length && rules[i][j+ 2 ] == pat[ 1 ]){
return false ;
}
return true ;
}
public static boolean checkConstraints( char [][] rules){
int M = 5 ;
int N = 6 ;
int [] top = { 1 , - 1 , - 1 , 2 , 1 , - 1 };
int [] bottom = { 2 , - 1 , - 1 , 2 , - 1 , 3 };
int [] left = { 2 , 3 , - 1 , - 1 , - 1 };
int [] right = {- 1 , - 1 , - 1 , 1 , - 1 };
int [] pCountH = new int [rules.length];
for ( int i= 0 ; i < rules.length; i++){
pCountH[i] = 0 ;
}
int [] nCountH = new int [rules.length];
for ( int i = 0 ; i < rules.length; i++){
nCountH[i] = 0 ;
}
for ( int row = 0 ; row < rules.length; row++){
for ( int col = 0 ; col < rules[ 0 ].length; col++){
char ch = rules[row][col];
if (ch == '+' ){
pCountH[row] += 1 ;
}
else if (ch == '-' ){
nCountH[row] += 1 ;
}
}
}
int [] pCountV = new int [rules[ 0 ].length];
for ( int i= 0 ; i < rules[ 0 ].length; i++){
pCountV[i] = 0 ;
}
int [] nCountV = new int [rules[ 0 ].length];
for ( int i = 0 ; i < rules[ 0 ].length; i++){
nCountV[i] = 0 ;
}
for ( int col = 0 ; col < rules[ 0 ].length; col++){
for ( int row = 0 ; row < rules.length; row++){
char ch = rules[row][col];
if (ch == '+' ){
pCountV[col] += 1 ;
}
else if (ch == '-' ){
nCountV[col] += 1 ;
}
}
}
for ( int row = 0 ; row < rules.length; row++){
if (left[row] != - 1 ){
if (pCountH[row] != left[row]){
return false ;
}
}
if (right[row] != - 1 ){
if (nCountH[row] != right[row]){
return false ;
}
}
}
for ( int col = 0 ; col < rules[ 0 ].length; col++){
if (top[col] != - 1 ){
if (pCountV[col] != top[col]){
return false ;
}
}
if (bottom[col] != - 1 ){
if (nCountV[col] != bottom[col]){
return false ;
}
}
// if (top[col] != -1 and pCountH[col] != top[col]) or (bottom[col] != -1 and nCountH[col] != bottom[col]) :
// return False
}
return true ;
}
public static boolean canPutPatternVertically( char [][] rules, int i, int j, char [] pat){
if ( j- 1 >= 0 && rules[i][j- 1 ] == pat[ 0 ]){
return false ;
}
else if (i- 1 >= 0 && rules[i- 1 ][j] == pat[ 0 ]){
return false ;
}
else if (j+ 1 < rules[ 0 ].length && rules[i][j+ 1 ] == pat[ 0 ]){
return false ;
}
return true ;
}
public static void solveMagnets( char [][] rules, int i, int j){
// check the constraint before printing
if ( i == rules.length && j == 0 ){
if (checkConstraints(rules)){
// Printing rules array.
System.out.print( "[" );
for ( int indxi = 0 ; indxi < rules.length; indxi++){
System.out.print( "[" );
for ( int indxj = 0 ; indxj < rules[ 0 ].length; indxj++){
System.out.print( "'" + rules[indxi][indxj] + "', " );
}
System.out.print( "]" );
}
System.out.print( "]" );
}
}
else if (j >= rules[ 0 ].length){
solveMagnets(rules, i+ 1 , 0 );
}
// normal cases
else {
if (rules[i][j] == 'L' ){
// option 1 +-
if (canPutPatternHorizontally(rules,i,j, "+-" .toCharArray()) == true ){
rules[i][j] = '+' ;
rules[i][j+ 1 ] = '-' ;
solveMagnets(rules,i,j+ 2 );
rules[i][j] = 'L' ;
rules[i][j+ 1 ] = 'R' ;
}
// option 2 -+
if (canPutPatternHorizontally(rules,i,j, "-+" .toCharArray()) == true ){
rules[i][j] = '-' ;
rules[i][j+ 1 ] = '+' ;
solveMagnets(rules,i,j+ 2 );
rules[i][j] = 'L' ;
rules[i][j+ 1 ] = 'R' ;
}
// option 3 xx
if (( 1 == 1 ) || canPutPatternHorizontally(rules,i,j, "xx" .toCharArray()) == true ){
rules[i][j] = 'x' ;
rules[i][j+ 1 ] = 'x' ;
solveMagnets(rules,i,j+ 2 );
rules[i][j] = 'L' ;
rules[i][j+ 1 ] = 'R' ;
}
}
// vertical check
else if (rules[i][j] == 'T' ){
// option 1 +-
if (canPutPatternVertically(rules,i,j, "+-" .toCharArray()) == true ){
rules[i][j] = '+' ;
rules[i+ 1 ][j] = '-' ;
solveMagnets(rules,i,j+ 1 );
rules[i][j] = 'T' ;
rules[i+ 1 ][j] = 'B' ;
}
// option 2 -+
if (canPutPatternVertically(rules,i,j, "-+" .toCharArray()) == true ){
rules[i][j] = '-' ;
rules[i+ 1 ][j] = '+' ;
solveMagnets(rules,i,j+ 1 );
rules[i][j] = 'T' ;
rules[i+ 1 ][j] = 'B' ;
}
// option 3 xx
if (( 1 == 1 ) || canPutPatternVertically(rules,i,j, "xx" .toCharArray()) == true ){
rules[i][j] = 'x' ;
rules[i+ 1 ][j] = 'x' ;
solveMagnets(rules,i,j+ 1 );
rules[i][j] = 'T' ;
rules[i+ 1 ][j] = 'B' ;
}
}
else {
solveMagnets(rules,i,j+ 1 );
}
}
}
public static void doTheStuff( char [][] rules, int i, int j){
if (rules[i][j] == 'L' || rules[i][j] == 'R' ){
// option 1 +-
if (canPutPatternHorizontally(rules, i, j , "+-" .toCharArray()) == true ){
rules[i][j] = '+' ;
rules[i][j+ 1 ] = '-' ;
solveMagnets(rules,i,j);
}
// option 2 -+
// option 3 xx
}
}
public static void main(String[] args) {
char [][] rules = {
{ 'L' , 'R' , 'L' , 'R' , 'T' , 'T' },
{ 'L' , 'R' , 'L' , 'R' , 'B' , 'B' },
{ 'T' , 'T' , 'T' , 'T' , 'L' , 'R' },
{ 'B' , 'B' , 'B' , 'B' , 'T' , 'T' },
{ 'L' , 'R' , 'L' , 'R' , 'B' , 'B' }
};
solveMagnets(rules, 0 , 0 );
}
} // The code is contributed by Nidhi goel. |
# Write Python3 code here M = 5
N = 6
top = [ 1 , - 1 , - 1 , 2 , 1 , - 1 ]
bottom = [ 2 , - 1 , - 1 , 2 , - 1 , 3 ]
left = [ 2 , 3 , - 1 , - 1 , - 1 ]
right = [ - 1 , - 1 , - 1 , 1 , - 1 ]
rules = [["L","R","L","R","T","T" ],
[ "L","R","L","R","B","B" ],
[ "T","T","T","T","L","R" ],
[ "B","B","B","B","T","T" ],
[ "L","R","L","R","B","B" ]];
def canPutPatternHorizontally(rules,i,j,pat):
if j - 1 > = 0 and rules[i][j - 1 ] = = pat[ 0 ]:
return False
elif i - 1 > = 0 and rules[i - 1 ][j] = = pat[ 0 ]:
return False
elif i - 1 > = 0 and rules[i - 1 ][j + 1 ] = = pat[ 1 ]:
return False
elif j + 2 < len (rules[ 0 ]) and rules[i][j + 2 ] = = pat[ 1 ]:
return False
return True
def canPutPatternVertically(rules,i,j,pat):
if j - 1 > = 0 and rules[i][j - 1 ] = = pat[ 0 ]:
return False
elif i - 1 > = 0 and rules[i - 1 ][j] = = pat[ 0 ]:
return False
elif j + 1 < len (rules[ 0 ]) and rules[i][j + 1 ] = = pat[ 0 ]:
return False
return True
def doTheStuff(rules,i,j):
if rules[i][j] = = "L" or rules[i][j] = = "R":
# option 1 +-
if canPutPatternHorizontally(rules,i,j," + - "):
rules[i][j] = " + "
rules[i][j + 1 ] = " - "
solveMagnets(rules,i,j)
# option 2 -+
# option 3 xx
def checkConstraints(rules):
pCountH = [ 0 for i in range ( len (rules))]
nCountH = [ 0 for i in range ( len (rules))]
for row in range ( len (rules)):
for col in range ( len (rules[ 0 ])):
ch = rules[row][col]
if ch = = " + ":
pCountH[row] + = 1
elif ch = = " - ":
nCountH[row] + = 1
pCountV = [ 0 for i in range ( len (rules[ 0 ]))]
nCountV = [ 0 for i in range ( len (rules[ 0 ]))]
for col in range ( len (rules[ 0 ])):
for row in range ( len (rules)):
ch = rules[row][col]
if ch = = " + ":
pCountV[col] + = 1
elif ch = = " - ":
nCountV[col] + = 1
for row in range ( len (rules)):
if left[row] ! = - 1 :
if pCountH[row] ! = left[row]:
return False
if right[row] ! = - 1 :
if nCountH[row] ! = right[row]:
return False
for col in range ( len (rules[ 0 ])):
if top[col] ! = - 1 :
if pCountV[col] ! = top[col]:
return False
if bottom[col] ! = - 1 :
if nCountV[col] ! = bottom[col]:
return False
#
# if (top[col] != -1 and pCountH[col] != top[col]) or (bottom[col] != -1 and nCountH[col] != bottom[col]) :
# return False
return True
def solveMagnets(rules,i,j):
if i = = len (rules) and j = = 0 :
# check the constraint before printing
if checkConstraints(rules):
print (rules)
elif j > = len (rules[ 0 ]):
solveMagnets(rules,i + 1 , 0 )
# normal cases
else :
if rules[i][j] = = "L":
# option 1 +-
if canPutPatternHorizontally(rules,i,j," + - "):
rules[i][j] = " + "
rules[i][j + 1 ] = " - "
solveMagnets(rules,i,j + 2 )
rules[i][j] = "L"
rules[i][j + 1 ] = "R"
# option 2 -+
if canPutPatternHorizontally(rules,i,j," - + "):
rules[i][j] = " - "
rules[i][j + 1 ] = " + "
solveMagnets(rules,i,j + 2 )
rules[i][j] = "L"
rules[i][j + 1 ] = "R"
# option 3 xx
if True or canPutPatternHorizontally(rules,i,j,"xx"):
rules[i][j] = "x"
rules[i][j + 1 ] = "x"
solveMagnets(rules,i,j + 2 )
rules[i][j] = "L"
rules[i][j + 1 ] = "R"
# vertical check
elif rules[i][j] = = "T":
# option 1 +-
if canPutPatternVertically(rules,i,j," + - "):
rules[i][j] = " + "
rules[i + 1 ][j] = " - "
solveMagnets(rules,i,j + 1 )
rules[i][j] = "T"
rules[i + 1 ][j] = "B"
# option 2 -+
if canPutPatternVertically(rules,i,j," - + "):
rules[i][j] = " - "
rules[i + 1 ][j] = " + "
solveMagnets(rules,i,j + 1 )
rules[i][j] = "T"
rules[i + 1 ][j] = "B"
# option 3 xx
if True or canPutPatternVertically(rules,i,j,"xx"):
rules[i][j] = "x"
rules[i + 1 ][j] = "x"
solveMagnets(rules,i,j + 1 )
rules[i][j] = "T"
rules[i + 1 ][j] = "B"
else :
solveMagnets(rules,i,j + 1 )
# Driver code solveMagnets(rules, 0 , 0 )
|
using System;
class Program
{ // Arrays to store constraints for each side
static int [] top = { 1, -1, -1, 2, 1, -1 };
static int [] bottom = { 2, -1, -1, 2, -1, 3 };
static int [] left = { 2, 3, -1, -1, -1 };
static int [] right = { -1, -1, -1, 1, -1 };
// Function to check if the current configuration satisfies the constraints
static bool CheckConstraints( char [][] rules)
{
int [] pCountH = new int [rules.Length];
int [] nCountH = new int [rules.Length];
// Count the number of '+' and '-' in each row
for ( int row = 0; row < rules.Length; row++)
{
for ( int col = 0; col < rules[0].Length; col++)
{
char ch = rules[row][col];
if (ch == '+' )
{
pCountH[row] += 1;
}
else if (ch == '-' )
{
nCountH[row] += 1;
}
}
}
int [] pCountV = new int [rules[0].Length];
int [] nCountV = new int [rules[0].Length];
// Count the number of '+' and '-' in each column
for ( int col = 0; col < rules[0].Length; col++)
{
for ( int row = 0; row < rules.Length; row++)
{
char ch = rules[row][col];
if (ch == '+' )
{
pCountV[col] += 1;
}
else if (ch == '-' )
{
nCountV[col] += 1;
}
}
}
// Check constraints for each side
for ( int row = 0; row < rules.Length; row++)
{
if (left[row] != -1)
{
if (pCountH[row] != left[row])
{
return false ;
}
}
if (right[row] != -1)
{
if (nCountH[row] != right[row])
{
return false ;
}
}
}
for ( int col = 0; col < rules[0].Length; col++)
{
if (top[col] != -1)
{
if (pCountV[col] != top[col])
{
return false ;
}
}
if (bottom[col] != -1)
{
if (nCountV[col] != bottom[col])
{
return false ;
}
}
}
return true ;
}
// Function to check if a horizontal pattern can be placed at the specified position
static bool CanPutPatternHorizontally( char [][] rules, int i, int j, string pat)
{
if (j - 1 >= 0 && rules[i][j - 1] == pat[0])
{
return false ;
}
else if (i - 1 >= 0 && rules[i - 1][j] == pat[0])
{
return false ;
}
else if (i - 1 >= 0 && rules[i - 1][j + 1] == pat[1])
{
return false ;
}
else if (j + 2 < rules[0].Length && rules[i][j + 2] == pat[1])
{
return false ;
}
return true ;
}
// Function to check if a vertical pattern can be placed at the specified position
static bool CanPutPatternVertically( char [][] rules, int i, int j, string pat)
{
if (j - 1 >= 0 && rules[i][j - 1] == pat[0])
{
return false ;
}
else if (i - 1 >= 0 && rules[i - 1][j] == pat[0])
{
return false ;
}
else if (j + 1 < rules[0].Length && rules[i][j + 1] == pat[1])
{
return false ;
}
return true ;
}
// Function to solve the magnet puzzle using backtracking
static void SolveMagnets( char [][] rules, int i, int j)
{
// If the entire grid is processed, check and print the solution if valid
if (i == rules.Length && j == 0)
{
if (CheckConstraints(rules))
{
Console.Write( "[" );
for ( int indxi = 0; indxi < rules.Length; indxi++)
{
Console.Write( "[" );
for ( int indxj = 0; indxj < rules[0].Length; indxj++)
{
char magnet = rules[indxi][indxj];
if (magnet == 'L' || magnet == 'R' || magnet == 'T' || magnet == 'B' )
{
Console.Write( "'x', " );
}
else
{
Console.Write($ "'{magnet}', " );
}
}
Console.Write( "]" );
}
Console.WriteLine( "]" );
}
}
// If the end of a row is reached, move to the next row
else if (j >= rules[0].Length)
{
SolveMagnets(rules, i + 1, 0);
}
else
{
// Check for placing horizontal patterns
if (rules[i][j] == 'L' )
{
if (CanPutPatternHorizontally(rules, i, j, "+-" ))
{
rules[i][j] = '+' ;
rules[i][j + 1] = '-' ;
SolveMagnets(rules, i, j + 2);
rules[i][j] = 'L' ;
rules[i][j + 1] = 'R' ;
}
if (CanPutPatternHorizontally(rules, i, j, "-+" ))
{
rules[i][j] = '-' ;
rules[i][j + 1] = '+' ;
SolveMagnets(rules, i, j + 2);
rules[i][j] = 'L' ;
rules[i][j + 1] = 'R' ;
}
if (CanPutPatternHorizontally(rules, i, j, "xx" ))
{
rules[i][j] = 'L' ;
rules[i][j + 1] = 'R' ;
SolveMagnets(rules, i, j + 2);
rules[i][j] = 'L' ;
rules[i][j + 1] = 'R' ;
}
}
// Check for placing vertical patterns
else if (rules[i][j] == 'T' )
{
if (CanPutPatternVertically(rules, i, j, "+-" ))
{
rules[i][j] = '+' ;
rules[i + 1][j] = '-' ;
SolveMagnets(rules, i, j + 1);
rules[i][j] = 'T' ;
rules[i + 1][j] = 'B' ;
}
if (CanPutPatternVertically(rules, i, j, "-+" ))
{
rules[i][j] = '-' ;
rules[i + 1][j] = '+' ;
SolveMagnets(rules, i, j + 1);
rules[i][j] = 'T' ;
rules[i + 1][j] = 'B' ;
}
if (CanPutPatternVertically(rules, i, j, "xx" ))
{
rules[i][j] = 'T' ;
rules[i + 1][j] = 'B' ;
SolveMagnets(rules, i, j + 1);
rules[i][j] = 'T' ;
rules[i + 1][j] = 'B' ;
}
}
// Move to the next cell
else
{
SolveMagnets(rules, i, j + 1);
}
}
}
static void Main()
{
// Initial configuration of magnets
char [][] rules = new char [][]
{
new char [] { 'L' , 'R' , 'L' , 'R' , 'T' , 'T' },
new char [] { 'L' , 'R' , 'L' , 'R' , 'B' , 'B' },
new char [] { 'T' , 'T' , 'T' , 'T' , 'L' , 'R' },
new char [] { 'B' , 'B' , 'B' , 'B' , 'T' , 'T' },
new char [] { 'L' , 'R' , 'L' , 'R' , 'B' , 'B' }
};
// Solve the magnet puzzle
SolveMagnets(rules, 0, 0);
}
} |
<script> // javascript code here function checkConstraints(rules){
let M = 5;
let N = 6;
let top = [ 1, -1, -1, 2, 1, -1 ];
let bottom = [2, -1, -1, 2, -1, 3 ];
let left = [2, 3, -1, -1, -1];
let right = [-1, -1, -1, 1, -1];
let pCountH = new Array(rules.length).fill(0);
let nCountH = new Array(rules.length).fill(0);
for (let row = 0; row < rules.length; row++){
for (let col = 0; col < rules[0].length; col++){
let ch = rules[row][col];
if (ch == '+' ){
pCountH[row] += 1;
}
else if (ch == '-' ){
nCountH[row] += 1;
}
}
}
let pCountV = new Array(rules[0].length).fill(0);
let nCountV = new Array(rules[0].length).fill(0);
for (let col = 0; col < rules[0].length; col++){
for (let row = 0; row < rules.length; row++){
let ch = rules[row][col];
if (ch == '+' ){
pCountV[col] += 1;
}
else if (ch == '-' ){
nCountV[col] += 1;
}
}
}
for (let row = 0; row < rules.length; row++){
if (left[row] != -1){
if (pCountH[row] != left[row]){
return false ;
}
}
if (right[row] != -1){
if (nCountH[row] != right[row]){
return false ;
}
}
}
for (let col = 0; col < rules[0].length; col++){
if (top[col] != -1){
if (pCountV[col] != top[col]){
return false ;
}
}
if (bottom[col] != -1){
if (nCountV[col] != bottom[col]){
return false ;
}
}
// if (top[col] != -1 and pCountH[col] != top[col]) or (bottom[col] != -1 and nCountH[col] != bottom[col]) :
// return False
}
return true ;
} function canPutPatternHorizontally(rules, i, j, pat){
if ( j-1>=0 && rules[i][j-1] == pat[0]){
return false ;
}
else if (i-1>=0 && rules[i-1][j] == pat[0]){
return false ;
}
else if (i-1>=0 && rules[i-1][j+1] == pat[1]){
return false ;
}
else if (j+2 < rules[0].length && rules[i][j+2] == pat[1]){
return false ;
}
return true ;
} function canPutPatternVertically(rules,i,j, pat){
if ( j-1>=0 && rules[i][j-1] == pat[0]){
return false ;
}
else if (i-1>=0 && rules[i-1][j] == pat[0]){
return false ;
}
else if (j+1 < rules[0].length && rules[i][j+1] == pat[0]){
return false ;
}
return true ;
} function solveMagnets(rules, i,j){
// check the constraint before printing
if ( i == rules.length && j == 0){
if (checkConstraints(rules)){
// Printing rules array.
console.log(rules);
}
}
else if (j >= rules[0].length){
solveMagnets(rules, i+1, 0);
}
// normal cases
else {
if (rules[i][j] == 'L' ){
// option 1 +-
if (canPutPatternHorizontally(rules,i,j, "+-" )){
rules[i][j] = '+' ;
rules[i][j+1] = '-' ;
solveMagnets(rules,i,j+2);
rules[i][j] = 'L' ;
rules[i][j+1] = 'R' ;
}
// option 2 -+
if (canPutPatternHorizontally(rules,i,j, "-+" )){
rules[i][j] = '-' ;
rules[i][j+1] = '+' ;
solveMagnets(rules,i,j+2);
rules[i][j] = 'L' ;
rules[i][j+1] = 'R' ;
}
// option 3 xx
if ((1 == 1) || canPutPatternHorizontally(rules,i,j, "xx" )){
rules[i][j] = 'x' ;
rules[i][j+1] = 'x' ;
solveMagnets(rules,i,j+2);
rules[i][j] = 'L' ;
rules[i][j+1] = 'R' ;
}
}
// vertical check
else if (rules[i][j] == 'T' ){
// option 1 +-
if (canPutPatternVertically(rules,i,j, "+-" )){
rules[i][j] = '+' ;
rules[i+1][j] = '-' ;
solveMagnets(rules,i,j+1);
rules[i][j] = 'T' ;
rules[i+1][j] = 'B' ;
}
// option 2 -+
if (canPutPatternVertically(rules,i,j, "-+" )){
rules[i][j] = '-' ;
rules[i+1][j] = '+' ;
solveMagnets(rules,i,j+1);
rules[i][j] = 'T' ;
rules[i+1][j] = 'B' ;
}
// option 3 xx
if ((1 == 1) || canPutPatternVertically(rules,i,j, "xx" )){
rules[i][j] = 'x' ;
rules[i+1][j] = 'x' ;
solveMagnets(rules,i,j+1);
rules[i][j] = 'T' ;
rules[i+1][j] = 'B' ;
}
}
else {
solveMagnets(rules,i,j+1);
}
}
} function doTheStuff(rules, i, j){
if (rules[i][j] == 'L' || rules[i][j] == 'R' ){
// option 1 +-
if (canPutPatternHorizontally(rules, i, j , "+-" )){
rules[i][j] = '+' ;
rules[i][j+1] = '-' ;
solveMagnets(rules,i,j);
}
// option 2 -+
// option 3 xx
}
} // Driver code let rules = [ [ 'L' , 'R' , 'L' , 'R' , 'T' , 'T' ],
[ 'L' , 'R' , 'L' , 'R' , 'B' , 'B' ],
[ 'T' , 'T' , 'T' , 'T' , 'L' , 'R' ],
[ 'B' , 'B' , 'B' , 'B' , 'T' , 'T' ],
[ 'L' , 'R' , 'L' , 'R' , 'B' , 'B' ]
]; solveMagnets(rules,0,0); // The code is contributed by Nidhi goel. </script> |
Output:
[['+', '-', '+', '-', 'x', '-', ]['-', '+', '-', '+', 'x', '+', ]['x', 'x', '+', '-', '+', '-', ]['x', 'x', '-', '+', 'x', '+', ]['-', '+', 'x', 'x', 'x', '-', ]]
Source :https://people.eecs.berkeley.edu/~hilfingr/programming-contest/f2012-contest.pdf