Linear Interpolation in TwinCAT - twincat
I'm trying to use FB_CTRL_LIN_INTERPOLATION, which exists in Controller Toolbox in TwinCAT3 as described in this link.
Unfortunately, the examples on the Infosys site are not practical; for example, there is no data type FLOAT on twincat3 at all; it can replace with REAL or LREAL in the next revision of the site!
By the way, here is my first attempt to implement the example.
The deceleration part is:
VAR
linInt:FB_CTRL_LIN_INTERPOLATION;
stParams : ST_CTRL_LIN_INTERPOLATION_PARAMS;
fIn : LREAL;
fManValue : LREAL;
bExtrapolate : BOOL;
eMode : E_CTRL_MODE;
fOut : LREAL;
bInIsGreaterThanMaxElement : BOOL;
bInIsLessThanMinElement : BOOL;
eState : E_CTRL_STATE;
eErrorId : E_CTRL_ERRORCODES;
bError : BOOL;
Data: ARRAY[1..6, 1..2] OF INT := [10, 15, 21, 22, 30, 40, 7, 10, 9, 2, 3, 6];
END_VAR
and the body part is :
stParams.pDataTable_ADR:=ADR(Data);
stParams.tCtrlCycleTime:=T#4S;
stParams.tTaskCycleTime:=T#2S;
stParams.nDataTable_SIZEOF:=SIZEOF(Data);
stParams.nDataTable_NumberOfRows:=6;
linInt(fIn:=fIn,
fManValue:=fManValue,
bExtrapolate:=bExtrapolate,
eMode:=emode,
fOut=>fOut,
bInIsGreaterThanMaxElement=>bInIsGreaterThanMaxElement,
bInIsGreaterThanMaxElement=>bInIsLessThanMinElement,
eState=>eState,
eErrorId=>eErrorId,
bError=>bError,
stParams:=stParams);
I do not have any idea what is the meaning of Size of the n x 2 array for the Description of nDataTable_SIZEOF so I used SIZEOF(Data) command to assign a value to it.
exactly I now wonder what the 24 is!
as shown in the following figure, there is an error with the table description.
any help would be appreciated if someone clears it to me what is the meaning of stparams with detail here and how I can handle this example completely.
Your data table needs to be "ARRAY[x..y, 1..2] OF FLOAT", not INT.
The FLOAT datatype is defined as an alias inside the library as a LREAL or REAL. See: InfoSys
I have no experience with TwinCAT, however implementing a linear interpolator shouldn't be too difficult.
Here's an example Function Block.
Assuming you have a data array, you can interpolate using the following formulae:
// find the interval of points x falls into. let `i` be the left point of that interval.
y := (x - data[i, 1]) / (data[i + 1, 1] - data[i, 1]) * (data[i + 1, 2] - data[i, 2]) + data[i, 2];
Related
Are there any restrictions with LUT: unbounded way in dimension
When trying to run the sample code below (similar to a look up table), it always generates the following error message: "The pure definition of Function 'out' calls function 'color' in an unbounded way in dimension 0". RDom r(0, 10, 0, 10); Func label, color, out; Var x,y,c; label(x,y) = 0; label(r.x,r.y) = 1; color(c) = 0; color(label(r.x,r.y)) = 255; out(x,y) = color(label(x,y)); out.realize(10,10); Before calling realize, I have tried to statically set bound, like below, without success. color.bound(c,0,10); label.bound(x,0,10).bound(y,0,10); out.bound(x,0,10).bound(y,0,10); I also looked at the histogram examples, but they are a bit different. Is this some kind of restrictions in Halide?
Halide prevents any out of bounds access (and decides what to compute) by analyzing the range of the values you pass as arguments to a Func. If those values are unbounded, it can't do that. The way to make them bounded is with clamp: out(x, y) = color(clamp(label(x, y), 0, 9)); In this case, the reason it's unbounded is that label has an update definition, which makes the analysis give up. If you wrote label like this instead: label(x, y) = select(x >= 0 && x < 10 && y >= 0 && y < 10, 1, 0); Then you wouldn't need the clamp.
Change array type: 8bit type to 6bit type
I have two types and two arrays of that types in file.ads type Ebit is mod 2**8; type Sbit is mod 2**6; type Data_Type is array (Positive range <>) of Ebit; type Changed_Data_Type is array (Positive range <>) of Sbit; and function: function ChangeDataType (D : in Data_Type) return Changed_Data_Type with Pre => D'Length rem 3 = 0 and D'Last < Positive'Last / 4, Post => ChangeDataType'Result'Length = 4 * (D'Length / 3) Ok i can understand all of this. For example we have arrays of: 65, 66, 65, 65, 66, 65 in 8bit values function should give to us 16, 20, 9, 1, 16, 20, 9, 1 in 6bit values. I dont know how i can build a 6bit table from 8 bit table. My idea of sollutions is for example taking bit by bit from type: fill all bites in 6bit type to 0 (propably default) if first bit (2**1) is 1 set bit (2**1) in 6bit type to 1; and do some iterations But i dont know how to do this, always is a problem with types. Is this good idea or i can do this with easier way? I spend last nigt to try write this but without success. Edit: I wrote some code, its working but i have problem with array initialization. function ChangeDataType (D: in Data_Type) return Changed_Data_Type is length: Natural := (4*(D'Length / 3)); ER: Changed_Data_type(length); Temp: Ebit; Temp1: Ebit; Temp2: Ebit; Actual: Ebit; n: Natural; k: Natural; begin n := 0; k := 0; Temp := 2#00000000#; Temp1 := 2#00000000#; Temp2 := 2#00000000#; Array_loop: for k in D'Range loop case n is when 0 => Actual := D(k); Temp1 := Actual / 2**2; ER(k) := Sbit(Temp1); Temp := Actual * ( 2**4); n := 2; when 2 => Actual := D(k); Temp1 := Actual / 2**4; Temp2 := Temp1 or Temp; ER(k) := Sbit(Temp2); Temp := Actual * ( 2**2); n := 4; when 4 => Actual := D(k); Temp1 := Actual / 2**6; Temp2 := Temp1 or Temp; ER(k) := Sbit(Temp2); n := 6; when 6 => Temp1 := Actual * ( 2**2); Temp2 := Actual / 2**2; ER(k) := Sbit(Temp2); n := 0; when others => n := 0; end case; end loop Array_Loop; return ER; end;
IF I understand what you're asking... it's that you want to re-pack the same 8-bit data into 6-bit values such that the "leftover" bits of the first EBit become the first bits (highest or lowest?) of the second Sbit. One way you can do this - at least for fixed size arrays, e.g. your 6 words * 8 bits, 8 words * 6 bits example, is by specifying the exact layout in memory for each array type, using packing, and representation aspects (or pragmas, before Ada-2012) which are nicely described here. I haven't tested the following, but it may serve as a starting point. type Ebit is mod 2**8; type Sbit is mod 2**6; for Ebit'Size use 8; for Sbit'Size use 6; type Data_Type is array (1 .. 6) of Ebit with Alignment => 0; -- this should pack tightly type Changed_Data_Type is array (1 .. 8) of Sbit with Alignment => 0; Then you can instantiate the generic Unchecked_Conversion function with the two array types, and use that function to convert from one array to the other. with Ada.Unchecked_Conversion; function Change_Type is new Ada.Unchecked_Conversion(Data_Type, Changed_Data_Type); declare Packed_Bytes : Changed_Data_Type := Change_Type(Original_Bytes); begin ... In terms of code generated, it's not slow, because Unchecked_Conversion doesn't do anything, except tell the compile-time type checking to look the other way. I view Unchecked_Conversion like the "I meant to do that" look my cat gives me after falling off the windowledge. Again... Alternatively, if you wish to avoid copying, you can declare Original_Bytes as aliased, and use a similar trick with access types and Unchecked_Access to overlay both arrays on the same memory (like a Union in C). I think this is what DarkestKhan calls "array overlays" in a comment below. See also section 3 of this rather dated page which describes the technique further. It notes the overlaid variable must not only be declared aliased but also volatile so that accesses to one view aren't optimised into registers, but reflect any changes made via the other view. Another approach to overlays is in the Ada Wikibook here. Now this may be vulnerable to endian-ness considerations, i.e. it may work on some platforms but not others. The second reference above gives an example of a record with exact bit-alignment of its members : we can at least take the Bit_Order aspect, as in with Alignment => 0, Bit_Order => Low_Order_First; for the arrays above... -- code stolen from "Rationale" ... see link above p.11 type RR is record Code: Opcode; R1: Register; R2: Register; end record with Alignment => 2, Bit_Order => High_Order_First; for RR use record Code at 0 range 0 .. 7; R1 at 1 range 0 .. 3; R2 at 1 range 4 .. 7; end record; One thing that's not clear to me is if there's a formulaic way to specify the exact layout of each element in an array, as is done in a record here - or even if there's a potential need to. If necessary, one workaround would be to replace the arrays above with records. But I'd love to see a better answer if there is one.
Sum of numbers with approximation and no repetition
For an app I'm working on, I need to process an array of numbers and return a new array such that the sum of the elements are as close as possible to a target sum. This is similar to the coin-counting problem, with two differences: Each element of the new array has to come from the input array (i.e. no repetition/duplication) The algorithm should stop when it finds an array whose sum falls within X of the target number (e.g., given [10, 12, 15, 23, 26], a target of 35, and a sigma of 5, a result of [10, 12, 15] (sum 37) is OK but a result of [15, 26] (sum 41) is not. I was considering the following algorithm (in pseudocode) but I doubt that this is the best way to do it. function (array, goal, sigma) var A = [] for each element E in array if (E + (sum of rest of A) < goal +/- sigma) A.push(E) return A For what it's worth, the language I'm using is Javascript. Any advice is much appreciated!
This is not intended as the best answer possible, just maybe something that will work well enough. All remarks/input is welcome. Also, this is taking into mind the answers from the comments, that the input is length of songs (usually 100 - 600), the length of the input array is between 5 to 50 and the goal is anywhere between 100 to 7200. The idea: Start with finding the average value of the input, and then work out a guess on the number of input values you're going to need. Lets say that comes out x. Order your input. Take the first x-1 values and substitute the smallest one with the any other to get to your goal (somewhere in the range). If none exist, find a number so you're still lower than the goal. Repeat step #3 using backtracking or something like that. Maybe limit the number of trials you're gonna spend there. x++ and go back to step #3.
I would use some kind of divide and conquer and a recursive implementation. Here is a prototype in Smalltalk
SequenceableCollection>>subsetOfSum: s plusOrMinus: d
"check if a singleton matches"
self do: [:v | (v between: s - d and: s + d) ifTrue: [^{v}]].
"nope, engage recursion with a smaller collection"
self keysAndValuesDo: [:i :v |
| sub |
sub := (self copyWithoutIndex: i) subsetOfSum: s-v plusOrMinus: d.
sub isNil ifFalse: [^sub copyWith: v]].
"none found"
^nil
Using like this:
#(10 12 15 23 26) subsetOfSum: 62 plusOrMinus: 3.
gives:
#(23 15 12 10)
With limited input this problem is good candidate for dynamic programming with time complexity O((Sum + Sigma) * ArrayLength) Delphi code: function FindCombination(const A: array of Integer; Sum, Sigma: Integer): string; var Sums: array of Integer; Value, idx: Integer; begin Result := ''; SetLength(Sums, Sum + Sigma + 1); //zero-initialized array Sums[0] := 1; //just non-zero for Value in A do begin idx := Sum + Sigma; while idx >= Value do begin if Sums[idx - Value] <> 0 then begin //(idx-Value) sum can be formed from array] Sums[idx] := Value; //value is included in this sum if idx >= Sum - Sigma then begin //bingo! while idx > 0 do begin //unwind and extract all values for this sum Result := Result + IntToStr(Sums[idx]) + ' '; idx := idx - Sums[idx]; end; Exit; end; end; Dec(idx); //idx-- end; end; end;
Here's one commented algorithm in JavaScript:
var arr = [9, 12, 20, 23, 26];
var target = 35;
var sigma = 5;
var n = arr.length;
// sort the numbers in ascending order
arr.sort(function(a,b){return a-b;});
// initialize the recursion
var stack = [[0,0,[]]];
while (stack[0] !== undefined){
var params = stack.pop();
var i = params[0]; // index
var s = params[1]; // sum so far
var r = params[2]; // accumulating list of numbers
// if the sum is within range, output sum
if (s >= target - sigma && s <= target + sigma){
console.log(r);
break;
// since the numbers are sorted, if the current
// number makes the sum too large, abandon this thread
} else if (s + arr[i] > target + sigma){
continue;
}
// there are still enough numbers left to skip this one
if (i < n - 1){
stack.push([i + 1,s,r]);
}
// there are still enough numbers left to add this one
if (i < n){
_r = r.slice();
_r.push(arr[i]);
stack.push([i + 1,s + arr[i],_r]);
}
}
/* [9,23] */
NIntegrate evaluates a clearly non-zero integral to be zero. The integrand is a set of data points morphed into a distribution
I have a list of data points that are to represent a probability distribution. I need to integrate over this distribution. However since I didn't have a function and I only had a set of data points, I came up with the following code to represent the probability distribution:
dList1 = Import["Z-1.txt", "Table"];
dList2 = Import["Z_over-1.txt", "Table"];
dDist[X_,sym_] := (
dList = 0;
If[sym,
dList = dList1;
,
dList = dList2;
];
val = 0;
If[Abs[X] < Pi,
i = 2;
While[dList[[i]][[1]] < X, i++];
width = dList[[i]][[1]] - dList[[i-1]][[1]];
difX = dList[[i]][[1]] - X;
difY = dList[[i]][[2]] - dList[[i-1]][[2]];
val = dList[[i-1]][[2]] + (1-(difX/width)) difY;
];
Return[val];
);
where the set of data points are in the text files.
Performing the following command:
Plot[dDist[x, True], {x, -1, 1}]
gives this:
Whereas, performing this:
NIntegrate[dDist[x, True], {x, -1, 1}]
evaluates to zero, along with this warning:
I have tried increasing MinRecursion to no avail. I'm not sure what to do and would be open to any suggestions, including modifying the dDist function.
Not having your data to play with, I'd suggest using the table(s) to create Piecewise functions separated at the disontinuities. NIntegrate should handle those with no problem.
A cool algorithm to check a Sudoku field?
Does anyone know a simple algorithm to check if a Sudoku-Configuration is valid? The simplest algorithm I came up with is (for a board of size n) in Pseudocode for each row for each number k in 1..n if k is not in the row (using another for-loop) return not-a-solution ..do the same for each column But I'm quite sure there must be a better (in the sense of more elegant) solution. Efficiency is quite unimportant.
You need to check for all the constraints of Sudoku : check the sum on each row check the sum on each column check for sum on each box check for duplicate numbers on each row check for duplicate numbers on each column check for duplicate numbers on each box that's 6 checks altogether.. using a brute force approach. Some sort of mathematical optimization can be used if you know the size of the board (ie 3x3 or 9x9) Edit: explanation for the sum constraint: Checking for the sum first (and stoping if the sum is not 45) is much faster (and simpler) than checking for duplicates. It provides an easy way of discarding a wrong solution.
Peter Norvig has a great article on solving sudoku puzzles (with python), https://norvig.com/sudoku.html Maybe it's too much for what you want to do, but it's a great read anyway
Check each row, column and box such that it contains the numbers 1-9 each, with no duplicates. Most answers here already discuss this. But how to do that efficiently? Answer: Use a loop like result=0; for each entry: result |= 1<<(value-1) return (result==511); Each number will set one bit of the result. If all 9 numbers are unique, the lowest 9 bits will be set. So the "check for duplicates" test is just a check that all 9 bits are set, which is the same as testing result==511. You need to do 27 of these checks.. one for each row, column, and box.
Just a thought: don't you need to also check the numbers in each 3x3 square? I'm trying to figure out if it is possible to have the rows and columns conditions satisfied without having a correct sudoku
This is my solution in Python, I'm glad to see it's the shortest one yet :) The code: def check(sud): zippedsud = zip(*sud) boxedsud=[] for li,line in enumerate(sud): for box in range(3): if not li % 3: boxedsud.append([]) # build a new box every 3 lines boxedsud[box + li/3*3].extend(line[box*3:box*3+3]) for li in range(9): if [x for x in [set(sud[li]), set(zippedsud[li]), set(boxedsud[li])] if x != set(range(1,10))]: return False return True And the execution: sudoku=[ [7, 5, 1, 8, 4, 3, 9, 2, 6], [8, 9, 3, 6, 2, 5, 1, 7, 4], [6, 4, 2, 1, 7, 9, 5, 8, 3], [4, 2, 5, 3, 1, 6, 7, 9, 8], [1, 7, 6, 9, 8, 2, 3, 4, 5], [9, 3, 8, 7, 5, 4, 6, 1, 2], [3, 6, 4, 2, 9, 7, 8, 5, 1], [2, 8, 9, 5, 3, 1, 4, 6, 7], [5, 1, 7, 4, 6, 8, 2, 3, 9]] print check(sudoku)
Create an array of booleans for every row, column, and square. The array's index represents the value that got placed into that row, column, or square. In other words, if you add a 5 to the second row, first column, you would set rows[2][5] to true, along with columns[1][5] and squares[4][5], to indicate that the row, column, and square now have a 5 value. Regardless of how your original board is being represented, this can be a simple and very fast way to check it for completeness and correctness. Simply take the numbers in the order that they appear on the board, and begin building this data structure. As you place numbers in the board, it becomes a O(1) operation to determine whether any values are being duplicated in a given row, column, or square. (You'll also want to check that each value is a legitimate number: if they give you a blank or a too-high number, you know that the board is not complete.) When you get to the end of the board, you'll know that all the values are correct, and there is no more checking required. Someone also pointed out that you can use any form of Set to do this. Arrays arranged in this manner are just a particularly lightweight and performant form of a Set that works well for a small, consecutive, fixed set of numbers. If you know the size of your board, you could also choose to do bit-masking, but that's probably a little overly tedious considering that efficiency isn't that big a deal to you.
Create cell sets, where each set contains 9 cells, and create sets for vertical columns, horizontal rows, and 3x3 squares. Then for each cell, simply identify the sets it's part of and analyze those.
You could extract all values in a set (row, column, box) into a list, sort it, then compare to '(1, 2, 3, 4, 5, 6, 7, 8, 9)
I did this once for a class project. I used a total of 27 sets to represent each row, column and box. I'd check the numbers as I added them to each set (each placement of a number causes the number to be added to 3 sets, a row, a column, and a box) to make sure the user only entered the digits 1-9. The only way a set could get filled is if it was properly filled with unique digits. If all 27 sets got filled, the puzzle was solved. Setting up the mappings from the user interface to the 27 sets was a bit tedious, but made the rest of the logic a breeze to implement.
It would be very interesting to check if: when the sum of each row/column/box equals n*(n+1)/2 and the product equals n! with n = number of rows or columns this suffices the rules of a sudoku. Because that would allow for an algorithm of O(n^2), summing and multiplying the correct cells. Looking at n = 9, the sums should be 45, the products 362880. You would do something like: for i = 0 to n-1 do boxsum[i] := 0; colsum[i] := 0; rowsum[i] := 0; boxprod[i] := 1; colprod[i] := 1; rowprod[i] := 1; end; for i = 0 to n-1 do for j = 0 to n-1 do box := (i div n^1/2) + (j div n^1/2)*n^1/2; boxsum[box] := boxsum[box] + cell[i,j]; boxprod[box] := boxprod[box] * cell[i,j]; colsum[i] := colsum[i] + cell[i,j]; colprod[i] := colprod[i] * cell[i,j]; rowsum[j] := colsum[j] + cell[i,j]; rowprod[j] := colprod[j] * cell[i,j]; end; end; for i = 0 to n-1 do if boxsum[i] <> 45 or colsum[i] <> 45 or rowsum[i] <> 45 or boxprod[i] <> 362880 or colprod[i] <> 362880 or rowprod[i] <> 362880 return false;
Some time ago, I wrote a sudoku checker that checks for duplicate number on each row, duplicate number on each column & duplicate number on each box. I would love it if someone could come up one with like a few lines of Linq code though.
char VerifySudoku(char grid[81])
{
for (char r = 0; r < 9; ++r)
{
unsigned int bigFlags = 0;
for (char c = 0; c < 9; ++c)
{
unsigned short buffer = r/3*3+c/3;
// check horizontally
bitFlags |= 1 << (27-grid[(r<<3)+r+c])
// check vertically
| 1 << (18-grid[(c<<3)+c+r])
// check subgrids
| 1 << (9-grid[(buffer<<3)+buffer+r%3*3+c%3]);
}
if (bitFlags != 0x7ffffff)
return 0; // invalid
}
return 1; // valid
}
if the sum and the multiplication of a row/col equals to the right number 45/362880
First, you would need to make a boolean, "correct". Then, make a for loop, as previously stated. The code for the loop and everything afterwards (in java) is as stated, where field is a 2D array with equal sides, col is another one with the same dimensions, and l is a 1D one:
for(int i=0; i<field.length(); i++){
for(int j=0; j<field[i].length; j++){
if(field[i][j]>9||field[i][j]<1){
checking=false;
break;
}
else{
col[field[i].length()-j][i]=field[i][j];
}
}
}
I don't know the exact algorithim to check the 3x3 boxes, but you should check all the rows in field and col with "/*array name goes here*/[i].contains(1)&&/*array name goes here*/[i].contains(2)" (continues until you reach the length of a row) inside another for loop.
def solution(board): for i in board: if sum(i) != 45: return "Incorrect" for i in range(9): temp2 = [] for x in range(9): temp2.append(board[i][x]) if sum(temp2) != 45: return "Incorrect" return "Correct" board = [] for i in range(9): inp = raw_input() temp = [int(i) for i in inp] board.append(temp) print solution(board)
Here's a nice readable approach in Python: from itertools import chain def valid(puzzle): def get_block(x,y): return chain(*[puzzle[i][3*x:3*x+3] for i in range(3*y, 3*y+3)]) rows = [set(row) for row in puzzle] columns = [set(column) for column in zip(*puzzle)] blocks = [set(get_block(x,y)) for x in range(0,3) for y in range(0,3)] return all(map(lambda s: s == set([1,2,3,4,5,6,7,8,9]), rows + columns + blocks)) Each 3x3 square is referred to as a block, and there are 9 of them in a 3x3 grid. It is assumed as the puzzle is input as a list of list, with each inner list being a row.
Let's say int sudoku[0..8,0..8] is the sudoku field.
bool CheckSudoku(int[,] sudoku)
{
int flag = 0;
// Check rows
for(int row = 0; row < 9; row++)
{
flag = 0;
for (int col = 0; col < 9; col++)
{
// edited : check range step (see comments)
if ((sudoku[row, col] < 1)||(sudoku[row, col] > 9))
{
return false;
}
// if n-th bit is set.. but you can use a bool array for readability
if ((flag & (1 << sudoku[row, col])) != 0)
{
return false;
}
// set the n-th bit
flag |= (1 << sudoku[row, col]);
}
}
// Check columns
for(int col= 0; col < 9; col++)
{
flag = 0;
for (int row = 0; row < 9; row++)
{
if ((flag & (1 << sudoku[row, col])) != 0)
{
return false;
}
flag |= (1 << sudoku[row, col]);
}
}
// Check 3x3 boxes
for(int box= 0; box < 9; box++)
{
flag = 0;
for (int ofs = 0; ofs < 9; ofs++)
{
int col = (box % 3) * 3;
int row = ((int)(box / 3)) * 3;
if ((flag & (1 << sudoku[row, col])) != 0)
{
return false;
}
flag |= (1 << sudoku[row, col]);
}
}
return true;
}
Let's assume that your board goes from 1 - n. We'll create a verification array, fill it and then verify it. grid [0-(n-1)][0-(n-1)]; //this is the input grid //each verification takes n^2 bits, so three verifications gives us 3n^2 boolean VArray (3*n*n) //make sure this is initialized to false for i = 0 to n for j = 0 to n /* each coordinate consists of three parts row/col/box start pos, index offset, val offset */ //to validate rows VArray( (0) + (j*n) + (grid[i][j]-1) ) = 1 //to validate cols VArray( (n*n) + (i*n) + (grid[i][j]-1) ) = 1 //to validate boxes VArray( (2*n*n) + (3*(floor (i/3)*n)+ floor(j/3)*n) + (grid[i][j]-1) ) = 1 next next if every array value is true then the solution is correct. I think that will do the trick, although i'm sure i made a couple of stupid mistakes in there. I might even have missed the boat entirely.
array = [1,2,3,4,5,6,7,8,9] sudoku = int [][] puzzle = 9 #9x9 columns = map [] units = map [] # box unit_l = 3 # box width/height check_puzzle() def strike_numbers(line, line_num, columns, units, unit_l): count = 0 for n in line: # check which unit we're in unit = ceil(n / unit_l) + ceil(line_num / unit_l) # this line is wrong - rushed if units[unit].contains(n): #is n in unit already? return columns, units, 1 units[unit].add(n) if columns[count].contains(n): #is n in column already? return columns, units, 1 columns[count].add(n) line.remove(n) #remove num from temp row return columns, units, line.length # was a number not eliminated? def check_puzzle(columns, sudoku, puzzle, array, units): for (i=0;i< puzzle;i++): columns, units, left_over = strike_numbers(sudoku[i], i, columns, units) # iterate through rows if (left_over > 0): return false Without thoroughly checking, off the top of my head, this should work (with a bit of debugging) while only looping twice. O(n^2) instead of O(3(n^2))
Here is paper by math professor J.F. Crook: A Pencil-and-Paper Algorithm for Solving Sudoku Puzzles This paper was published in April 2009 and it got lots of publicity as definite Sudoku solution (check google for "J.F.Crook Sudoku" ). Besides algorithm, there is also a mathematical proof that algorithm works (professor admitted that he does not find Sudoku very interesting, so he threw some math in paper to make it more fun).
I'd write an interface that has functions that receive the sudoku field and returns true/false if it's a solution. Then implement the constraints as single validation classes per constraint. To verify just iterate through all constraint classes and when all pass the sudoku is correct. To speedup put the ones that most likely fail to the front and stop in the first result that points to invalid field. Pretty generic pattern. ;-) You can of course enhance this to provide hints which field is presumably wrong and so on. First constraint, just check if all fields are filled out. (Simple loop) Second check if all numbers are in each block (nested loops) Third check for complete rows and columns (almost same procedure as above but different access scheme)
Here is mine in C. Only pass each square once.
int checkSudoku(int board[]) {
int i;
int check[13] = { 0 };
for (i = 0; i < 81; i++) {
if (i % 9 == 0) {
check[9] = 0;
if (i % 27 == 0) {
check[10] = 0;
check[11] = 0;
check[12] = 0;
}
}
if (check[i % 9] & (1 << board[i])) {
return 0;
}
check[i % 9] |= (1 << board[i]);
if (check[9] & (1 << board[i])) {
return 0;
}
check[9] |= (1 << board[i]);
if (i % 9 < 3) {
if (check[10] & (1 << board[i])) {
return 0;
}
check[10] |= (1 << board[i]);
} else if (i % 9 < 6) {
if (check[11] & (1 << board[i])) {
return 0;
}
check[11] |= (1 << board[i]);
} else {
if (check[12] & (1 << board[i])) {
return 0;
}
check[12] |= (1 << board[i]);
}
}
}
Here is what I just did for this:
boolean checkers=true;
String checking="";
if(a.length/3==1){}
else{
for(int l=1; l<a.length/3; l++){
for(int n=0;n<3*l;n++){
for(int lm=1; lm<a[n].length/3; lm++){
for(int m=0;m<3*l;m++){
System.out.print(" "+a[n][m]);
if(a[n][m]<=0){
System.out.print(" (Values must be positive!) ");
}
if(n==0){
if(m!=0){
checking+=", "+a[n][m];
}
else{
checking+=a[n][m];
}
}
else{
checking+=", "+a[n][m];
}
}
}
System.out.print(" "+checking);
System.out.println();
}
}
for (int i=1;i<=a.length*a[1].length;i++){
if(checking.contains(Integer.toString(i))){
}
else{
checkers=false;
}
}
}
checkers=checkCol(a);
if(checking.contains("-")&&!checking.contains("--")){
checkers=false;
}
System.out.println();
if(checkers==true){
System.out.println("This is correct! YAY!");
}
else{
System.out.println("Sorry, it's not right. :-(");
}
}
private static boolean checkCol(int[][]a){
boolean checkers=true;
int[][]col=new int[][]{{0,0,0},{0,0,0},{0,0,0}};
for(int i=0; i<a.length; i++){
for(int j=0; j<a[i].length; j++){
if(a[i][j]>9||a[i][j]<1){
checkers=false;
break;
}
else{
col[a[i].length-j][i]=a[i][j];
}
}
}
String alia="";
for(int i=0; i<col.length; i++){
for(int j=1; j<=col[i].length; j++){
alia=a[i].toString();
if(alia.contains(""+j)){
alia=col[i].toString();
if(alia.contains(""+j)){}
else{
checkers=false;
}
}
else{
checkers=false;
}
}
}
return checkers;
}
You can check if sudoku is solved, in these two similar ways: Check if the number is unique in each row, column and block. A naive solution would be to iterate trough every square and check if the number is unique in the row, column block that number occupies. But there is a better way. Sudoku is solved if every row, column and block contains a permutation of the numbers (1 trough 9) This only requires to check every row, column and block, instead of doing that for every number. A simple implementation would be to have a bitfield of numbers 1 trough 9 and remove them when you iterate the columns, rows and blocks. If you try to remove a missing number or if the field isn't empty when you finish then sudoku isn't correctly solved.
Here's a very concise version in Swift, that only uses an array of Ints to track the groups of 9 numbers, and only iterates over the sudoku once.
import UIKit
func check(_ sudoku:[[Int]]) -> Bool {
var groups = Array(repeating: 0, count: 27)
for x in 0...8 {
for y in 0...8 {
groups[x] += 1 << sudoku[x][y] // Column (group 0 - 8)
groups[y + 9] += 1 << sudoku[x][y] // Row (group 9 - 17)
groups[(x + y * 9) / 9 + 18] += 1 << sudoku[x][y] // Box (group 18 - 27)
}
}
return groups.filter{ $0 != 1022 }.count == 0
}
let sudoku = [
[7, 5, 1, 8, 4, 3, 9, 2, 6],
[8, 9, 3, 6, 2, 5, 1, 7, 4],
[6, 4, 2, 1, 7, 9, 5, 8, 3],
[4, 2, 5, 3, 1, 6, 7, 9, 8],
[1, 7, 6, 9, 8, 2, 3, 4, 5],
[9, 3, 8, 7, 5, 4, 6, 1, 2],
[3, 6, 4, 2, 9, 7, 8, 5, 1],
[2, 8, 9, 5, 3, 1, 4, 6, 7],
[5, 1, 7, 4, 6, 8, 2, 3, 9]
]
if check(sudoku) {
print("Pass")
} else {
print("Fail")
}
One minor optimization you can make is that you can check for duplicates in a row, column, or box in O(n) time rather than O(n^2): as you iterate through the set of numbers, you add each one to a hashset. Depending on the language, you may actually be able to use a true hashset, which is constant time lookup and insertion; then checking for duplicates can be done in the same step by seeing if the insertion was successful or not. It's a minor improvement in the code, but going from O(n^2) to O(n) is a significant optimization.