Free generate sudoku software for linux

B::Generate is a Perl module which you can create your own op trees.


SYNOPSIS

use B::Generate;
# Do nothing, slowly.
CHECK {
my $null = new B::OP("null",0);
my $enter = new B::OP("enter",0);
my $cop = new B::COP(0, "hiya", 0);
my $leave = new B::LISTOP("leave", 0, $enter, $null);
$leave->children(3);
$enter->sibling($cop);
$enter->next($cop);
$cop->sibling($null);
$null->next($leave);
$cop->next($leave);

# Tell Perl where to find our tree.
B::main_root($leave);
B::main_start($enter);
}

WARNING

This module will create segmentation faults if you dont know how to use it properly. Further warning: sometimes I dont know how to use it properly.

There are lots of other methods and utility functions, but they are not documented here. This is deliberate, rather than just through laziness. You are expected to have read the Perl and XS sources to this module before attempting to do anything with it.
Patches welcome.

Malcolm Beatties B module allows you to examine the Perl op tree at runtime, in Perl space; its the basis of the Perl compiler. But what it doesnt let you do is manipulate that op tree: it wont let you create new ops, or modify old ones. Now you can.
Well, if youre intimately familiar with Perls internals, you can.

B::Generate turns Bs accessor methods into get-set methods. Hence, instead of merely saying

$op2 = $op->next;

you can now say

$op->next($op2);

to set the next op in the chain. It also adds constructor methods to create new ops. This is where it gets really hairy.

new B::OP ( type, flags )
new B::UNOP ( type, flags, first )
new B::BINOP ( type, flags, first, last )
new B::LOGOP ( type, flags, first, other )
new B::LISTOP ( type, flags, first, last )
new B::COP ( flags, name, first )

In all of the above constructors, type is either a numeric value representing the op type (62 is the addition operator, for instance) or the name of the op. ("add")
(Incidentally, if you know about custom ops and have registed them properly with the interpreter, you can create custom ops by name: new B::OP("mycustomop",0), or whatever.)

first, last and other are ops to be attached to the current op; these should be B::OP objects. If you havent created the ops yet, dont worry; give a false value, and fill them in later:

$x = new B::UNOP("negate", 0, undef);
# ... create some more ops ...
$x->first($y);

In addition, one may create a new nextstate operator with

newstate B::op ( flags, label, op)

in the same manner as B::COP::new - this will also, however, add the lineseq op.
Finally, you can set the main root and the starting op by passing ops to the B::main_root and B::main_start functions.

This module can obviously be used for all sorts of fun purposes. The best one will be in conjuction with source filters; have your source filter parse an input file in a foreign language, create an op tree for it and get Perl to execute it. Then email me and tell me how you did it. And why.

Data::Generate allows you to create various types of synthetic data by parsing "regex-like" data creation rules.

This module generates data by parsing given text statements (data creation rules). These statements are flexible and powerful regex-like way to control the production of synthetic data. Think about a program that instead of selecting data which matches a regex filter expression, produces it. For example, from the rule [a-c], the generator would produce the array a,b,c. The module works as following:

Specify data creation rules.
my $generator= Data::Generate::parse(VC(24) [0-9][2-3]);
At this step first you define one kind of output datatype (for ex. VC(24)= "output is a string with max length 24") and then with the rest of the expression define what it should look like. If parsing is successful a Data Generator object is instantiated.

Get data
my $Data= $generator->get_unique_data(10);
To really get the data, users must call the get_unique_data method by indicating the desired number of output values. The generator returns the values contained in an array reference. Please remark that output format is fixed according to the data type.

Generate Numly Copyright is a Firefox extension that registers documents and blogs for Numly copyright. Numly Numbers are unique identifiers of electronic media and recognized worldwide by electronic publishing companies and electronic content providers. Numly Numbers are simple and quick to generate and serve as branded identifier for individuals or companies authoring or distributing electronic content and media.

php Sudoku is a Web-based sudoku game that includes 200,000 sudoku puzzles. It can be easily used on any Web site.

The project does not require MySQL or any other database.

Python Sudoku is a text and graphical program (gtk interface) to create or resolve sudokus. Python Sudoku can also print a sudoku (1 or 4 sudokus in each page) and write a image (png, jpeg, etc) with a sudoku.

Sudoku, sometimes spelled Su Doku, is a placement puzzle, also known as Number Place in the United States.

The aim of the puzzle is to enter a numeral from 1 through 9 in each cell of a grid, most frequently a 9 x 9 grid made up of 3 x 3 subgrids (called "regions"), starting with various numerals given in some cells (the "givens").

Each row, column and region must contain only one instance of each numeral. Completing the puzzle requires patience and logical ability.

Its grid layout is reminiscent of other newspaper puzzles like crosswords and chess problems. Sudoku initially became popular in Japan in 1986 and attained international popularity in 2005.

Games::Sudoku::General is a Perl module that can solve sudoku-like puzzles.

SYNOPSIS

$su = Games::Sudoku::General->new ();
print $su->problem(<<less