divide(nodeptr one,nodeptr two,nodeptr ans){
int i=0;
while(1){
if(greater(one,two)==3)
{
i=i+1;
break;
}
else{
if(greater(one,two)==2)
{
break;
}
else
{
i++;
subtract(one,two,ans);
stripLeadingZeros(ans->next);
one=ans;
}
}
}
nodeptr tmp=NULL;
tmp=malloc(sizeof(nodeptr));
tmp->next=NULL;
tmp->data=i;
ans->next=tmp;
}
int sink(BinaryHeap *self, int pos) {
int k = pos;
int last = len(self) - 1;
while (k * 2 < last) {
PyObject *item = get(self, k);
int childIndex = k * 2;
PyObject *child = get(self, k * 2);
if (k * 2 + 1 < last) {
PyObject *child2 = get(self, k * 2 + 1);
if (greater(child2, child)) {
childIndex++;
child = child2;
}
}
if (greater(child, item)) {
exchange(self, k, childIndex);
} else {
break;
}
k = childIndex;
}
return k;
}
void ColumnVector<T>::getPermutation(bool reverse, size_t limit, int nan_direction_hint, IColumn::Permutation & res) const
{
size_t s = data.size();
res.resize(s);
for (size_t i = 0; i < s; ++i)
res[i] = i;
if (limit >= s)
limit = 0;
if (limit)
{
if (reverse)
std::partial_sort(res.begin(), res.begin() + limit, res.end(), greater(*this, nan_direction_hint));
else
std::partial_sort(res.begin(), res.begin() + limit, res.end(), less(*this, nan_direction_hint));
}
else
{
if (reverse)
std::sort(res.begin(), res.end(), greater(*this, nan_direction_hint));
else
std::sort(res.begin(), res.end(), less(*this, nan_direction_hint));
}
}
bool isBST(node* Node, int left_limit,int right_limit)
{
// the node's value must be greater than its
// left child
if(!greater(Node->value,Node->left->value))
return false;
// the node's value must be smaller than its
// right child
if(!greater(Node->right->value,Node-> value))
return false;
// the node's value must be lie between it's
// left and right limit
if(!between(Node->value,left_limit,right_limit))
return false;
// to the left child pass the node's left limit as
// as left limit and node's value as right limit
isBST(Node-> left,left_limit,Node->value);
// to the right child pass the node's value as left limit
// and node's right limit as right limit
isBST(Node-> right,Node->value,right_limit);
}
void sink(min_pq m, int n) {
while (2 * n <= m->num) {
int j = 2 * n;
if (j < m->num && greater(m, j, j + 1)) j++;
if (!greater(m, n, j)) break;
swap(m, n, j);
n = j;
}
}
int main(void)
{
int a, b;
scanf("%d %d", &a, &b);
printf("%d is greater than %d.\n", greater(a, b), -greater(-a, -b));
return 0;
}
void testPtrs(void)
{
#ifndef __SDCC_pic16
#if defined (__SDCC_MODEL_HUGE)
char __code * cp2 = (char __code *)0x0002;
void (* fp2)(void) = (void (*)(void))0x0002;
ASSERT (eq(cp2, fp2));
ASSERT (smaller(fpE, fpF));
#endif
ASSERT (xp0 == NULL);
ASSERT (ip0 == NULL);
ASSERT (pp0 == NULL);
ASSERT (cp0 == NULL);
ASSERT (fp0 == NULL);
ASSERT (gp0 == NULL);
ASSERT (xp1 != NULL);
ASSERT (ip1 != NULL);
ASSERT (pp1 != NULL);
ASSERT (cp1 != NULL);
ASSERT (fp1 != NULL);
ASSERT (gp2 != NULL);
ASSERT (eq(xp0, ip0));
ASSERT (eq(xp0, pp0));
ASSERT (eq(xp0, cp0));
ASSERT (eq(xp0, fp0));
ASSERT (eq(xp0, gp0));
#if defined(__SDCC_mcs51) || defined(__SDCC_ds390)
ASSERT (neq(xp1, ip1));
ASSERT (neq(xp1, pp1));
ASSERT (neq(xp1, cp1));
ASSERT (neq(xp1, fp1));
ASSERT (neq(xp1, gp2));
ASSERT (smaller(xp1, ip1) || greater(xp1, ip1));
ASSERT (smaller(xp1, pp1) || greater(xp1, pp1));
ASSERT (smaller(xp1, cp1) || greater(xp1, cp1));
ASSERT (smaller(xp1, fp1) || greater(xp1, fp1));
ASSERT (smaller(xp1, gp2) || greater(xp1, gp2));
ASSERT (!smaller(xp0, ip0) && !greater(xp0, ip0));
ASSERT (!smaller(xp0, pp0) && !greater(xp0, pp0));
ASSERT (!smaller(xp0, cp0) && !greater(xp0, cp0));
ASSERT (!smaller(xp0, fp0) && !greater(xp0, fp0));
ASSERT (!smaller(xp0, gp0) && !greater(xp0, gp0));
#endif
ASSERT (eq(cp1, fp1));
ASSERT (smaller(pp1, gp2));
#endif
}
static void MinHeapify(heap *h)
{
int i, left, right;
assert(h);
for (i=h->size/2;i>0;i--) {
left = (2*i), right = (2*i+1);
if (greater(h->data[i-1], h->data[left-1]))
swap(&h->data[i-1], &h->data[left-1]);
if ((0==h->size%2)&&(i==h->size/2))
continue;/*skip complete binary tree empty right node*/
if (greater(h->data[i-1], h->data[right-1]))
swap(&h->data[i-1], &h->data[right-1]);
}
}
vector<int> maxNumber(vector<int>& nums1, vector<int>& nums2, int k) {
vector<int> ans(k, 0);
for (int i = max(0, k - (int)nums2.size()); i <= min(k, (int)nums1.size()); i++) {
vector<int> res1 = get_max_sub_array(nums1, i);
vector<int> res2 = get_max_sub_array(nums2, k - i);
vector<int> res(k, 0);
int pos1 = 0, pos2 = 0, tpos = 0;
while (pos1 < res1.size() || pos2 < res2.size()) {
res[tpos++] = greater(res1, pos1, res2, pos2) ? res1[pos1++] : res2[pos2++];
}
if (!greater(ans, 0, res, 0))
ans = res;
}
return ans;
}
/* don't feed list with sentinal characters
* works for positive lists only
*/
slist *greater(slist *a, slist *b)
{
if (a == NULL && b == NULL) /* lists of same length */
return (NULL);
if (a == NULL)
return (b);
if (b == NULL)
return (a);
slist *ret = greater(a->next, b->next);
if (ret == NULL) {
if (a->data == b->data)
return (NULL);
else
return ((a->data > b->data) ? a : b);
} else if (ret == a->next) {
return (a);
} else if (ret == b->next) {
return (b);
} else {
/* error */
}
}
// (Trivialer) Sortieralgorithmus, der
// keinen direkten Datenzugriff braucht, sondern
// Interfacemethodes swap() und greater() benutzt.
void sort(void) {
for (int i=0; i < N; i++)
for (int j=i+1; j < N; j++) {
if (greater(i, j))
swap(i, j);
}
}
bignum multiply (bignum x, bignum y) {
bignum z, zero;
int len = x.len + y.len;
zero.len = 1;
zero.num = calloc(len, sizeof(int));
zero.num[0] = 0;
z.len = 1;
z.num = calloc(len, sizeof(int));
z.num[0] = 0;
while (greater(y, zero)) {
if (mod_int(y, 2) == 1)
z = plus(z, x);
x = mul_int(x, 2);
y = div_int(y, 2);
}
free(zero.num);
if (z.len == len)
return z;
else {
bignum m;
m.len = z.len;
m.num = calloc(m.len, sizeof(int));
memcpy(m.num, z.num, m.len * sizeof(int));
free(z.num);
return m;
}
}
static inline void apply(Box& box, Point const& source)
{
typedef typename strategy::compare::detail::select_strategy
<
StrategyLess, 1, Point, Dimension
>::type less_type;
typedef typename strategy::compare::detail::select_strategy
<
StrategyGreater, -1, Point, Dimension
>::type greater_type;
typedef typename select_coordinate_type<Point, Box>::type coordinate_type;
less_type less;
greater_type greater;
coordinate_type const coord = get<Dimension>(source);
if (less(coord, get<min_corner, Dimension>(box)))
{
set<min_corner, Dimension>(box, coord);
}
if (greater(coord, get<max_corner, Dimension>(box)))
{
set<max_corner, Dimension>(box, coord);
}
point_loop
<
StrategyLess, StrategyGreater,
Dimension + 1, DimensionCount
>::apply(box, source);
}
void sortprog(int *A, int l, int r) {
int diff=0;
int is_sorted = 0;
#ifdef DEBUG
printf("[odd-even before] ");
for(int i=l; i<=r; i++)printf("%d ", A[i]);
printf("\n");
#endif
while(is_sorted!=3){
is_sorted |= (1<<diff);
#pragma omp parallel for
for(int i=l+diff; i<r; i+=2){
if(greater(A[i], A[i+1])){
exch(A[i], A[i+1]);
is_sorted &= ~(1<<diff);
}
}
#ifdef DEBUG
printf("[odd-even after] ");
for(int i=l; i<=r; i++)printf("%d ", A[i]);
printf("\n");
#endif
}
}
void Heapify(PQ h, int i) {
int l, r, largest;
l = LEFT(i);
r = RIGHT(i);
if (l < h->heapsize && greater(h->array[l], h->array[i]))
largest = l;
else
largest = i;
if (r<h->heapsize && greater(h->array[r], h->array[largest]))
largest = r;
if (largest != i) {
swap(h, i, largest);
Heapify(h, largest);
}
return;
}
int main()
{
bool suite,compare;
int i,j;
for(i=1;i<=4;i++)
{
for(j=1;j<=13;j++)
{
a[i][j]=i*j;
}
}
card1=a[2][3];
card2=a[3][8];
suite=sameSuite(card1,card2);
compare=greater(card1,card2);
if(suite^0)
{
printf("same suite\n");
}
else
{
printf("different suite\n");
}
return 0;
}
bigInt multiplyBigInt(bigInt a, bigInt b){
bigInt product("0");
bigInt greater("0");
bigInt lesser("0");
if (b.num.size() > a.num.size()){ // Find vector with most elements
greater = b;
lesser = a;
}
else{
greater = a;
lesser = b;
}
product.num.resize(a.num.size() + b.num.size()); // Get the magnitude of the product
product.bigIntInit();
int k = 0;
for (unsigned long i = 0; i < lesser.num.size(); i++){ // By hand style multiplacation
for (unsigned long j = 0; j < greater.num.size(); j++){
product.num[j + k] += greater.num[j] * lesser.num[i];
}
k++;
}
product.cleanCarries();
if (a.isNegative != b.isNegative){
product.isNegative = 1;
}
return product;
}
int MAX(treeNode * ptr, int alpha, int beta){
if(ptr->numChildren == 0){
return evalState(ptr->board);
}
int v = -1000;
for (int i = 0; i < ptr->numChildren; i++){
v = greater(v, MIN(ptr->children[i], alpha, beta));
if (v >= beta){
ptr->evalVal = v;
return v;
}
alpha = greater(alpha, v);
}
ptr->evalVal = v;
return v;
}
void sort(void) { // Template of sort
for (int i=0; i < N; i++) // algorithm
for (int j=i+1; j < N; j++) {
if (greater(i, j))
swap(i, j);
}
}
void sort( void** items, int N, bool ( *greater )( void *l, void *r ) )
{
if ( N <= 0 )
return;
unsigned int n = ( unsigned int ) N, i = n / 2, parent, child;
void *t = NULL;
for ( ;; )
{
if ( i > 0 )
{
i--;
t = items[i];
}
else
{
n--;
if ( n == 0 ) return;
t = items[n];
items[n] = items[0];
}
parent = i;
child = i * 2 + 1;
while ( child < n )
{
if ( child + 1 < n && greater( items[child + 1], items[child] ) )
{
child++;
}
if ( greater( items[child], t ) )
{
items[parent] = items[child];
parent = child;
child = parent * 2 + 1;
}
else
{
break;
}
}
items[parent] = t;
}
}
void siftdown(int pos, pqueue* pq)
{
int j;
while (!is_leaf(pos, pq))
{
j = left_child(pos, pq);
if ( (j < (pq->n-1)) && (greater(pq->elems[j+1], pq->elems[j])) )
j++; /* j is now index of child with greater value */
if ( !greater(pq->elems[j], pq->elems[pos]) )
return;
swap(pos, j, pq);
pos = j; /* Move down */
}
}
void encode_comparator(B_Cell in_a, B_Cell in_b, B_Cell out_a, B_Cell out_b, int &nv_var, vector<vector<int>>&E) {
int bga = greater(in_b, in_a, nv_var, E);
var_eq_if(out_a, bga, in_b, in_a, nv_var, E);
var_eq_if(out_b, bga, in_a, in_b, nv_var, E);
}
static void
swim (PQueue *queue, guint index)
{
while (index > 1 && greater (queue, index/2, index))
{
swap (queue, index, index/2);
index = index/2;
}
}
/**
\brief Return true if l is maximal in the clause, given a substitution s.
s(l) is considered maximal if there is no literal l' in the clause such s(l') is greater
than s(l).
*/
bool clause::is_maximal(order & o, literal const & l, unsigned offset, substitution * s) const {
unsigned num_lits = get_num_literals();
for (unsigned i = 0; i < num_lits; i++) {
literal const & l_prime = m_lits[i];
if (l != l_prime && greater(o, l_prime, l, offset, s))
return false;
}
return true;
}
vector<int> merge(const vector<int>& nums1, const vector<int>& nums2) {
vector<int> result;
for (int i = 0, j = 0; i < nums1.size() || j < nums2.size(); ) {
if (greater(nums1, i, nums2, j))
result.push_back(nums1[i++]);
else
result.push_back(nums2[j++]);
}
return result;
}
/**
\brief Return true if s >_{lpo} t_i forall children t_i of t.
*/
bool lpo::dominates_args(expr_offset s, expr_offset t, unsigned depth) {
SASSERT(is_app(t.get_expr()));
unsigned num_args = to_app(t.get_expr())->get_num_args();
unsigned off = t.get_offset();
for (unsigned i = 0; i < num_args; i++) {
expr * t_i = to_app(t.get_expr())->get_arg(i);
if (!greater(s, expr_offset(t_i, off), depth+1))
return false;
}
return true;
}
void pq_insert(vertex* v, pqueue* pq)
{
int curr = pq->n++;
pq->elems[curr] = v; /* Start at end of heap */
/* Now sift up until curr's parent's key > curr's key */
while ((curr!=0) && greater(pq->elems[curr], pq->elems[parent(curr,pq)]) )
{
swap(curr, parent(curr, pq), pq);
curr = parent(curr, pq);
}
}
bool changeToConquer(const Table& table, const SoldierData& friendly) {
auto range = arrayRange(table);
return std::all_of(
range.begin(), range.end(), [&table, &friendly](Point p) {
const auto& soldier = table[p];
if (soldier && soldier->enemy) {
return greater(soldier->soldier, friendly.soldier);
} else {
return true;
}
});
}
static void
sink (PQueue *queue, guint index)
{
guint j, size;
size = queue->size;
while (2 * index <= size)
{
j = 2 * index;
if ((j < size) && (greater(queue, j, j+1)))
j++;
if (!greater (queue, index, j))
break;
swap (queue, index, j);
index = j;
}
}
int BreakableMesh::mergePolygons(std::vector<int> &polys) {
if(polys.size()==1){
return polys[0];
}
SimplePolygonMerger merger;
Polygon merged = merger.mergePolygons(polys, points.getList(), *this);
std::sort(polys.begin(), polys.end(), greater());
this->polygons[polys.back()] = merged;
return replacePolygonsForMerged(polys);
}
