void main() {
int cuad_columna, cuad_fila, asteriscos, i;
cout << "En que posicion (x) deseas dibujar el cuadrado?: ";
cin >> cuad_columna;
cout << "En que posicion (y) deseas dibujar el cuadrado?: ";
cin >> cuad_fila;
cout << "Cuantos asteriscos deseas pintar por lado?: ";
cin >> asteriscos;
//Dibujo del cuadrado
//Primera linia horizontal
for(i=0; i<asteriscos ; i++) {
horizontal(asteriscos,cuad_fila,cuad_columna);
}
//Segunda linia horizontal
for(i=0; i<asteriscos ; i++) {
horizontal(asteriscos,cuad_fila+asteriscos,cuad_columna);
}
//Primera linia vertical
for(i=0; i<asteriscos ; i++) {
vertical(asteriscos,cuad_fila,cuad_columna);
}
//Segunda linia vertical
for(i=0; i<asteriscos ; i++) {
vertical(asteriscos+1,cuad_fila,cuad_columna+asteriscos);
}
cin >> cuad_fila;
}
int check()
{
int i,j;
for(i=0;i<size;i++)
for(j=0;j<size;j++)
{
if(j<=size-length && board[i][j]==duma[0])
{
horizontal(1,i,j);
if(sreshtano)
{
print();
return -1;
}
}
if(j>=length-1 && board[i][j]==duma[0])
{
horizontal(0,i,j);
if(sreshtano)
{
print();
return -1;
}
}
if(i>=length-1 && board[i][j]==duma[0])
{
vertical(0,i,j);
if(sreshtano)
{
print();
return -1;
}
}
if(i<=size-length && board[i][j]==duma[0])
{
vertical(1,i,j);
if(sreshtano)
{
print();
return -1;
}
}
if(board[i][j]==duma[0])
{
diagonal(i,j);
if(sreshtano)
{
print();
return -1;
}
}
}
return 0;
}
void WarpGrid::reset()
{
points_.clear();
points_.reserve(vertical() * horizontal());
for (size_t y = 0; y < vertical(); ++y)
for (size_t x = 0; x < horizontal();
++x) points_.emplace_back((getTexCoord(x, y) - QVector2D(0.5,
0.5)).toPointF());
hasChanged_ = true;
}
QVector2D WarpGrid::getWarpPointPos(int x, int y) const
{
int maxX = horizontal() - 1;
int maxY = vertical() - 1;
// here's the magic: extrapolate points beyond the edges
if (x < 0) {
return QVector2D(
2.0f * getWarpPointPos(0, y) - getWarpPointPos(0 - x, y));
}
if (y < 0) {
return QVector2D(
2.0f * getWarpPointPos(x, 0) - getWarpPointPos(x, 0 - y));
}
if (x > maxX) {
return QVector2D(2.0f * getWarpPointPos(maxX, y) - getWarpPointPos(
2 * maxX - x,
y));
}
if (y > maxY) {
return QVector2D(
2.0f * getWarpPointPos(x, maxY)
- getWarpPointPos(x, 2 * maxY - y));
}
return QVector2D(getPoint(x, y)->pos());
}
int judge(int x, int y)
{
int horizontal(int x, int y);
int vertical(int x, int y);
int minus_diagonal(int x, int y);
int plus_diagonal(int x, int y);
if (horizontal(x, y) == 1)
{
return 1;
}
if (vertical(x, y) == 1)
{
return 1;
}
if (minus_diagonal(x, y) == 1)
{
return 1;
}
if (plus_diagonal(x, y) == 1)
{
return 1;
}
return 0;
}
int main ()
{
int* input = malloc(20*20*sizeof(int));
int i, j;
int temp;
for (i = 0; i < 20; i++)
for(j = 0; j < 20; j++)
{
scanf("%d", &temp);
input[i*20+j] = temp;
}
for (i = 0; i < 20; i++)
{
for(j = 0; j < 20; j++)
{
printf("%2d ", input[i*20+j]);
}
printf("\n");
}
int a = horizontal(input, 20, 20);
int b = vertical(input, 20, 20);
int c = diagDown(input, 20, 20);
int d = diagUp(input, 20, 20);
int result = a;
if (result < b) result = b;
if (result < c) result = c;
if (result < d) result = d;
printf("HIGHEST PRODUCT %d\n", result);
return 0;
}
std::string Srs::codeString() const
{
if (!hasCode()) throw std::runtime_error("No SRS code found");
std::string s(authority() + ':' + horizontal());
if (hasVerticalCode()) s += '+' + vertical();
return s;
}
void ScrollBarView::layout_children(Canvas &canvas)
{
View::layout_children(canvas);
// Update the CSS properties.
auto track_geometry = impl->track->geometry();
if (impl->min_pos == impl->max_pos || impl->page_step == 0.0)
{
impl->thumb->style()->set("left: 0; top: 0; width: %1px; height: %2px", track_geometry.content_width, track_geometry.content_height);
}
else
{
double thumb_pos = impl->thumb_pos();
double thumb_length = impl->thumb_length();
if (vertical())
impl->thumb->style()->set("left: 0; top: %1px; width: %2px; height: %3px", (float)thumb_pos, track_geometry.content_width, (float)thumb_length);
else
impl->thumb->style()->set("left: %1px; top: 0; width: %2px; height: %3px", (float)thumb_pos, (float)thumb_length, track_geometry.content_height);
// Grip is visible only if there enough space.
impl->thumb_grip->set_hidden(thumb_length < cMinThumbSizeForShowGrip);
}
}
check()
{
horizontal(); //horcheck function call
vertical(); //vertical function call
diagonal(); //diagonal function call
return(d||e||f);
}
SimdVector3 GetRayTo(int x,int y)
{
float top = 1.f;
float bottom = -1.f;
float nearPlane = 1.f;
float tanFov = (top-bottom)*0.5f / nearPlane;
float fov = 2.0 * atanf (tanFov);
SimdVector3 rayFrom(eye[0],eye[1],eye[2]);
SimdVector3 rayForward = -rayFrom;
rayForward.normalize();
float farPlane = 600.f;
rayForward*= farPlane;
SimdVector3 rightOffset;
SimdVector3 vertical(0.f,1.f,0.f);
SimdVector3 hor;
hor = rayForward.cross(vertical);
hor.normalize();
vertical = hor.cross(rayForward);
vertical.normalize();
float tanfov = tanf(0.5f*fov);
hor *= 2.f * farPlane * tanfov;
vertical *= 2.f * farPlane * tanfov;
SimdVector3 rayToCenter = rayFrom + rayForward;
SimdVector3 dHor = hor * 1.f/float(glutScreenWidth);
SimdVector3 dVert = vertical * 1.f/float(glutScreenHeight);
SimdVector3 rayTo = rayToCenter - 0.5f * hor + 0.5f * vertical;
rayTo += x * dHor;
rayTo -= y * dVert;
return rayTo;
}
void ResourceCache::LoadExplosionResources(const TiXmlHandle& hndl)
{
const Size size = mAppConfig.GetCellSize();
const auto len = mAppConfig.GetExplosionLifetime();
ExplosionResource center(ExplosionType::Center);
center.SetFrames(len, LoadTextures(hndl, "Center", size));
ExplosionResource horizontal(ExplosionType::Horizontal);
horizontal.SetFrames(len, LoadTextures(hndl, "Horizontal", size));
ExplosionResource horizontal_leftend(ExplosionType::HorizontalLeftEnd);
horizontal_leftend.SetFrames(len, LoadTextures(hndl, "HorizontalLeftEnd", size));
ExplosionResource horizontal_rightend(ExplosionType::HorizontalRightEnd);
horizontal_rightend.SetFrames(len, LoadTextures(hndl, "HorizontalRightEnd", size));
ExplosionResource vertical(ExplosionType::Vertical);
vertical.SetFrames(len, LoadTextures(hndl, "Vertical", size));
ExplosionResource vertical_upend(ExplosionType::VerticalUpEnd);
vertical_upend.SetFrames(len, LoadTextures(hndl, "VerticalUpEnd", size));
ExplosionResource vertical_downend(ExplosionType::VerticalDownEnd);
vertical_downend.SetFrames(len, LoadTextures(hndl, "VerticalDownEnd", size));
mExplosionRes.insert({ center.GetType(), center });
mExplosionRes.insert({ horizontal.GetType(), horizontal });
mExplosionRes.insert({ horizontal_leftend.GetType(), horizontal_leftend });
mExplosionRes.insert({ horizontal_rightend.GetType(), horizontal_rightend });
mExplosionRes.insert({ vertical.GetType(), vertical });
mExplosionRes.insert({ vertical_upend.GetType(), vertical_upend });
mExplosionRes.insert({ vertical_downend.GetType(), vertical_downend });
}
bool Line::could_intercept(Line l) const
{
if (vertical() && l.vertical()) //edge-case for vertical lines
return collinear_to(l);
double am = slope(), bm = l.slope();
return (abs(am) != abs(bm) || collinear_to(l));
}
void BounceAnimation::randomizePositions() {
mutex.lock();
for (auto & pos : positions) {
pos.x = horizontal(random);
pos.y = vertical(random);
}
mutex.unlock();
}
Vect RayTracer::computeDirection(uint x, uint y) {
Point_2D p = computePoint(x, y);
Vect dx = (horizontal()).linearMult(2 * p.x - 1);
Vect dy = (vertical()).linearMult(2 * p.y - 1);
Vect dir = imageCenter + dx + dy;
// dir.normalize(); TODO: fix tests
return dir;
}
void Camera::cursorCtrl()//鼠标控制
{
int midX=640;
int midY=400;
POINT p;
GetCursorPos(&p);
rotateSpeed=2;
elevSpeed=0.1;
if(p.x>midX)
horizontal(false);
else if(p.x<midX)
horizontal(true);
if(p.y>midY)
vertical(false);
else if(p.y<midY)
vertical(true);
rotateSpeed=DEFUALT_ROTATE_SPEED;
elevSpeed=DEFAULT_ELEV_SPEED;
SetCursorPos(midX,midY);
}
double Tringle::dist (const Point* point1, const Point* point2, const Point& dot) const
{
double distTemp = abs(((point1->getX() - point2->getX())*dot.getX() + (point1->getY() - point2->getY())*dot.getY() + point1->getX()*point2->getY() - point2->getX()*point1->getY())) /
sqrt (pow(point2->getX() - point1->getX(), 2.0) + pow(point2->getY() - point1->getY(), 2.0));
Point tempPoint = vertical (point1, point2, &dot);
if (tempPoint.getX() >= point1->getX() && tempPoint.getX() <= point2->getX() && tempPoint.getY() >= point1->getY() && tempPoint.getY() <= point2->getY())
return distTemp;
double distTemp1 = side (point1, &dot);
double distTemp2 = side (point2, &dot);
return (distTemp1 < distTemp2 ? distTemp1 : distTemp2);
}
void LicensePlate::LPAlignment() {
Mat ROI = LPRedChannel.clone();
ImageEnhancement(ROI);
Mat temp;
ROI.copyTo(temp);
horizen_record = horizen(ROI,temp);
ROI = temp;
threshold(ROI, ROI, 0, 255, CV_THRESH_BINARY | CV_THRESH_OTSU);
// for other color license plate
int black=0, white = 0;
for(int i=15; i<ROI.rows-15; i++)
{
for(int j=20; j<ROI.cols-20; j++)
{
if(ROI.at<uchar>(i,j) == 0)
{
black++;
}
else{
white++;
}
}
}
//cout << "black: " << black << " white: " << white << endl;
if(black + 500 < white)
{
for(int i=0; i<ROI.rows; i++)
{
for(int j=0; j<ROI.cols; j++)
{
ROI.at<uchar>(i,j) = 255 - ROI.at<uchar>(i,j);
}
}
}
vector<int> aa;
vector<Rect> rr;
GetComponent(ROI, aa, rr);
DeleteSmallNonLPCompoent(ROI, aa, rr, 100);
//Rect place;
//place.x = 0;
//place.y = 0;
//place.width = int(100.0 / LP.rows * LP.cols);
//place.height = 100;
//ScanToCutHorizenFrame(ROI, place);
vertical_record = vertical_record = vertical(ROI,temp);
}
bool Line::collinear_to(Line l) const
{
// FOR INTERNAL USE ONLY - ASSUMES slope == l.slope
// same thing as a.y_at(0) == b.y_at(0), as:
// -y1m1 +x1 = -y2m2 +x2
// m1=m2=m, thus m(y2-y1)+x2-x1 = 0, y2-y1+(x2-x1)/m = 0/m = 0
if (vertical()) return (x1 == l.x1);
else if (horizontal()) return (y1 == l.y1);
else return (l.y1 - y1 + (l.x1 - x1)/slope() == 0);
}
bool WarpGrid::isReset() const
{
for (size_t y = 0; y < vertical(); ++y)
for (size_t x = 0; x < horizontal(); ++x)
{
if (QVector2D(getPoint(x,
y)->pos()) !=
(getTexCoord(x, y) - QVector2D(0.5, 0.5))) return false;
}
return true;
}
int rate(const Scaffold& s, int N, int color)
{
for (int i=1;i<=s.rows();i++)
{
for (int j=1;j<=s.cols();j++)
{
if (horizontal(s,N,i,j,color)||vertical(s,N,i,j,color)||updiag(s,N,i,j,color)||downdiag(s,N,i,j,color)) //check all the conditions of victory
return (s.rows()*s.cols() - s.numberEmpty()); //this will be useful for evaluating the depth
}
}
return 0;
}
static
int evaluate(char grid[SIZE][SIZE], Index2d pos, char player)
{
int rank = 0;
rank = max(rank, horizontal(grid, pos, player));
rank = max(rank, vertical(grid, pos, player));
rank = max(rank, diagonal(grid, pos, player));
rank = max(rank, anti_diagonal(grid, pos, player));
return rank;
}
void Fl_Scrollbar::draw()
{
if (damage()&FL_DAMAGE_ALL) draw_frame();
int X=0; int Y=0; int W=w(); int H=h(); box()->inset(X,Y,W,H);
int ix = X; int iy = Y; int iw = W; int ih = H;
char pushed_ = this==Fl::pushed() ? which_pushed : NOTHING;
char highlight_ = this==Fl::belowmouse() ? which_highlight : NOTHING;
// 1 = left/top 2 = right/bottom 5 = slider button
Fl_Flags f1 = 0, f2 = 0, f5 = 0;
if (!active_r())
{
f1 = f2 = f5 = FL_INACTIVE;
}
else
{
if (pushed_ == UP_ARROW) f1 = FL_VALUE|FL_HIGHLIGHT;
else if (highlight_ == UP_ARROW) f1 = FL_HIGHLIGHT;
if (pushed_ == DOWN_ARROW) f2 = FL_VALUE|FL_HIGHLIGHT;
else if (highlight_ == DOWN_ARROW) f2 = FL_HIGHLIGHT;
if (pushed_ == SLIDER) f5 = FL_VALUE|FL_HIGHLIGHT;
else if (highlight_ == SLIDER) f5 = FL_HIGHLIGHT;
}
if (vertical() && H >= 3*W)
{
if (damage()&FL_DAMAGE_ALL || last_ == UP_ARROW || highlight_ == UP_ARROW)
draw_glyph(FL_GLYPH_UP_BUTTON, X, Y, W, W, f1);
if (damage()&FL_DAMAGE_ALL || last_ ==DOWN_ARROW|| highlight_ ==DOWN_ARROW)
draw_glyph(FL_GLYPH_DOWN_BUTTON, X, Y+H-W, W, W, f2);
iy += W; ih -= 2*W;
} // horizontal:
else if (W >= 3*H)
{
if (damage()&FL_DAMAGE_ALL || last_ == UP_ARROW || highlight_ == UP_ARROW)
draw_glyph(FL_GLYPH_LEFT_BUTTON, X, Y, H, H, f1);
if (damage()&FL_DAMAGE_ALL || last_ ==DOWN_ARROW|| highlight_ ==DOWN_ARROW)
draw_glyph(FL_GLYPH_RIGHT_BUTTON, X+W-H, Y, H, H, f2);
ix += H; iw -= 2*H;
}
last_ = highlight_;
if (Fl_Slider::draw(ix, iy, iw, ih, f5, false))
{
fl_color(color());
fl_rectf(ix, iy, iw, ih);
fl_pop_clip();
}
}
void SliderView::layout_subviews(Canvas &canvas)
{
View::layout_subviews(canvas);
auto track_geometry = impl->track->geometry();
float track_length = vertical() ? track_geometry.content_box().get_height() : track_geometry.content_box().get_width();
float thumb_length = vertical() ? impl->thumb->get_preferred_height(canvas, track_geometry.content_box().get_width()) : impl->thumb->get_preferred_width(canvas);
float t = (float) (impl->_position - impl->_min_position) / (float) (impl->_max_position - impl->_min_position);
float thumb_pos = t * (track_length - thumb_length);
if (vertical())
{
impl->thumb->style()->set("top: %1px;", thumb_pos);
}
else
{
impl->thumb->style()->set("left: %1px;", thumb_pos);
}
}
/** fill the custom widget with current properties */
bool KstViewLegend::fillConfigWidget(QWidget *w, bool isNew) const {
ViewLegendWidget *widget = dynamic_cast<ViewLegendWidget*>(w);
if (!widget) {
return false;
}
KstBaseCurveList allCurves = kstObjectSubList<KstDataObject, KstBaseCurve>(KST::dataObjectList);
if (isNew) {
widget->_fontSize->setValue(0);
widget->_fontColor->setColor(KstSettings::globalSettings()->foregroundColor);
widget->_font->setCurrentFont(KstApp::inst()->defaultFont());
widget->_margin->setValue(5);
widget->_boxColors->setColor(KstSettings::globalSettings()->foregroundColor);
widget->_vertical->setChecked(true);
widget->_transparent->setChecked(false);
widget->_border->setValue(2);
widget->_title->setText("");
widget->TrackContents->setChecked(true);
for (KstBaseCurveList::ConstIterator it = allCurves.begin(); it != allCurves.end(); ++it) {
(*it)->readLock();
widget->AvailableCurveList->insertItem((*it)->tagName());
(*it)->unlock();
}
} else { // fill legend properties into widget
widget->TrackContents->setChecked(trackContents());
widget->_title->setText(title());
widget->_fontSize->setValue(int(fontSize()));
widget->_fontColor->setColor(foregroundColor());
widget->_font->setCurrentFont(fontName());
widget->_transparent->setChecked(transparent());
widget->_border->setValue(borderWidth());
widget->_boxColors->setColor(borderColor());
widget->_margin->setValue(_legendMargin);
widget->_vertical->setChecked(vertical());
for (KstBaseCurveList::ConstIterator it = _curves.begin(); it != _curves.end(); ++it) {
(*it)->readLock();
widget->DisplayedCurveList->insertItem((*it)->tagName());
(*it)->unlock();
}
for (KstBaseCurveList::ConstIterator it = allCurves.begin(); it != allCurves.end(); ++it) {
(*it)->readLock();
if (_curves.find(*it) == _curves.end()) {
widget->AvailableCurveList->insertItem((*it)->tagName());
}
(*it)->unlock();
}
}
return false;
}
static void first_pass(char pattern[9][9], char possibilities[9][9][9]) {
for (int x = 0; x <= 6; x = x + 3) {
for (int y = 0; y <= 6; y = y + 3) {
square(x,y, pattern, possibilities);
}
}
for (int x = 0; x < 9; x++) {
horizontal(x, pattern, possibilities);
}
for (int y = 0; y < 9; y++) {
vertical(y, pattern, possibilities);
}
}
unsigned long long products(std::vector<std::vector<int>> &matrix){
unsigned long long greatest = 0;
for(int row = 0; i<20;i++){
for(int col = 0; j<20; j++){
greatest = std::max(greatest, vertical(row, col, matrix));
greatest = std::max(greatest, horizontal(row, col, matrix));
greatest = std::max(greatest, fordiag(row, col, matrix));
greatest = std::max(greatest, backdiag(row, col, matrix));
}
}
return greatest;
}
short evaluate_black(struct board *board)
{
short key,oracle;
register x;
char **matrix;
short i,*bpos;
board->sp=0;
board->intgp.j=0;
board->intgp.k=0;
memset(board->sqused,0xff,(BOARDX+1)*(BOARDY+2)*sizeof(short));
for(i=0;i<GROUPS;i++)
{
if(threat_group(board,i,BLACK))
{
board->intgp.tgroups[i]=YES;
board->intgp.j++;
}
else board->intgp.tgroups[i]=NO;
if(threat_group(board,i,WHITE))
{
board->intgp.mygroups[i]=YES;
board->intgp.k++;
}
else board->intgp.mygroups[i]=NO;
}
claimeven(board);
baseinverse(board);
vertical(board);
aftereven(board);
lowinverse(board);
highinverse(board);
baseclaim(board);
before(board);
if(board->intgp.j==0) return YES;
if(board->sp==0) return NO;
matrix=(char **)allocate_matrix(board);
build_adjacency_matrix(matrix,board);
oracle=problem_solver(board,matrix,NO,NULL);
free_matrix(matrix,board);
return oracle;
}
// Blur an image, given a kernel and its size
Image_uc ApplyGaussBlur(const Image_uc& im, int radius, const std::vector<double>& kernel) {
Image_uc vertical(im.Height(), im.Width());
for (int i = 0; i < im.Height(); ++i) {
for (int j = 0; j < im.Width(); ++j) {
double acc = 0.0;
for (int k = 0; k < 2*radius+1; ++k) {
acc += kernel[k] * im(i + k - radius, j);
}
vertical(i, j) = (unsigned char)acc;
}
}
Image_uc horizontal(im.Height(), im.Width());
for (int i = 0; i < im.Height(); ++i) {
for (int j = 0; j < im.Width(); ++j) {
double acc = 0.0;
for (int k = 0; k < 2*radius+1; ++k) {
acc += kernel[k] * vertical(i, j + k - radius);
}
horizontal(i, j) = (unsigned char)acc;
}
}
return horizontal;
}
int main()
{
int dice1[6], dice2[6];
int i = 0, is_same = 0, j = 0;
for(i = 0; i < 6; i++){
scanf("%d", &dice1[i]);
printf("%d\t", dice1[i]);
}
printf("\n");
for(i = 0; i < 6; i++){
scanf("%d", &dice2[i]);
printf("%d\t", dice2[i]);
}
printf("\n");
for(j = 0; j < 4; j++){
vertical(dice1);
if(is_same == 0)
is_same = judge(dice1, dice2);
for(i = 0; i < 4; i++){
horizontal(dice1);
if(is_same == 0)
is_same = judge(dice1, dice2);
}
vertical(dice1);
for(i = 0; i < 4; i++){
clockwise(dice1);
if(is_same == 0)
is_same = judge(dice1, dice2);
}
}
if(is_same == 0)
printf("\nNO\n");
else
printf("\nYES\n");
return 0;
}
Peice verify(Board b){
for(unsigned y=0;y<Board::Y;++y){
auto h = horizontal(b,y);
if(h != Peice::EMPTY){
return h;
}
}
for(unsigned x=0;x<Board::X;++x){
auto h = vertical(b,x);
if(h != Peice::EMPTY){
return h;
}
}
auto d = diagonal(b);
return d;
}
