Défi

Étant donné deux entiers Aet Ben entrée, vous devez écrire un programme qui génère si A>B, A==Bou A<B.

Les entiers seront dans toute plage raisonnable prise en charge par votre langue qui comprend au moins 256 valeurs.

Votre programme peut être soit un programme complet soit une fonction, prenant des entrées via STDIN ou des arguments de fonction.

Les sorties

Si A>B sortie

A is greater than B

Si A==B sortie

A is equal to B

Si A<B sortie

A is less than B

Où vous remplacez Aet Bpour leurs valeurs entières.

Gagnant

Le programme le plus court en octets gagne.

Classement

var QUESTION_ID=55693,OVERRIDE_USER=8478;function answersUrl(e){return"http://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"http://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;

body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>

CJam, 47

q~_~-g"is
equal greater less
to than"N/Sf/f=*S*

Essayez-le en ligne

Explication:

q~     read and evaluate the input (array of 2 numbers)
_      duplicate the array
~-     dump one array on the stack and subtract the numbers
g      get signum (-1 for <, 0 for ==, 1 for >)
"…"    push that string
N/     split into lines
Sf/    split each line by space
f=     get the corresponding word (for the signum) from each line
*      join the array of 2 numbers by the array of words
        it effectively inserts the words between the numbers
S*     join everything with spaces

Python 2, 95 94 76 octets

L'entrée doit être séparée par des virgules.

A,B=input();print A,'is',['equal to','greater than','less than'][cmp(A,B)],B

Labyrinthe , 180 152 149 octets

<
?01.23.511.501.23};,!:?
:
= ;3.114.101.97.116.101.114.32.116.104.97.110.32.{!@
-""
; ;8.101.115:..""""""""""""^
1
.113.117.97.108.32.116.111.32.{!@

Edit: Géré pour raser 3 octets en réutilisant 10entre 101, 103et 108(les codes de caractères de e, get l). L'explication ci-dessous ne reflète pas cela, mais ce n'est pas un changement substantiel.

Explication

Il n'y a pas grand-chose que nous puissions faire pour économiser des octets pour l'impression des chaînes, ce ne seront que de longues sections linéaires. Le principal défi du golf est donc d'éviter de grandes quantités d'espaces blancs inutiles. Cela signifie que nous voulons que les parties linéaires "rayonnent" à partir de la colonne la plus à gauche. Nous pouvons également réaliser des économies supplémentaires en réutilisant le code qui imprimethan B . Regardons donc le flux de contrôle ici:

Le programme démarre sur une commande de rotation de grille < . Cela déplace la ligne actuelle de manière cyclique vers la gauche avec l'IP dessus, donc nous obtenons ceci:

                                                     <
?.23.511.501.23};,!:?
:
= ;103.114.101.97.116.101.114.32.116.104.97.110.32.{!@
-""
1 ;108.101.115:..""""""""""""^
0
1.113.117.97.108.32.116.111.32.{!@

Maintenant, l'IP est sur une cellule isolée, il exécute donc la même commande encore et encore pendant que le < voyage continue vers la gauche jusqu'à ...

                    <
?.23.511.501.23};,!:?
:
= ;103.114.101.97.116.101.114.32.116.104.97.110.32.{!@
-""
1 ;108.101.115:..""""""""""""^
0
1.113.117.97.108.32.116.111.32.{!@

À ce stade, l'IP a quelque part où aller et exécute la première section linéaire (la deuxième ligne) de droite à gauche. Ce qu'il fait, c'est lire A, copier, imprimer. Consommez le caractère délimitant entre les nombres, les caractères imprimés is(et les espaces). Puis lireB , copiez-le et soustrayez- Ale- .

À ce stade, nous avons frappé la première "bifurcation sur la route". Si la différence s'est produite 0, l'IP continue d'avancer tout droit vers la branche inférieure. Cette branche imprime simplementequal to et ensuite B.

Sinon, l'IP prend à gauche vers les deux no-ops "". Ensuite, il y a une autre fourchette. Si la différence était négative, l'IP prend une autre à gauche vers la longue branche supérieure. Cette branche s'imprime simplement greater thanet ensuite B.

Si la différence était positive, l'IP prend à droite sur la branche inférieure, qui s'imprime less. Maintenant, nous voulons réutiliser le thande l'autre branche. Mais en même temps, nous ne voulons pas connecter les deux branches plus tard, car nous aurions besoin de tout un tas d'espaces inutiles. Au lieu de cela, nous utilisons quelques no-ops pour aligner la branche inférieure avec l'endroit où thancommence la branche supérieure, puis recommençons à manipuler la source avec ^:

                    <
?.23.511.501.23};,!:?
:                            .
= ;103.114.101.97.116.101.114 32.116.104.97.110.32.{!@
-""                          ^
1 ;108.101.115:..""""""""""""
0                            2
1.113.117.97.108.32.116.111.3 .{!@

Encore une fois, cela isole l'IP, donc ^est à nouveau exécuté et nous obtenons

                    <
?.23.511.501.23};,!:?        .
:
= ;103.114.101.97.116.101.114^32.116.104.97.110.32.{!@
-""
1 ;108.101.115:..""""""""""""2
0
1.113.117.97.108.32.116.111.3 .{!@

Maintenant, l'IP peut continuer à se déplacer vers la droite et imprimer thanet Bselon les besoins.

JavaScript (ES6), 66 octets

(a,b)=>a+` is ${a<b?"less than":a>b?"greater than":"equal to"} `+b

Définit une fonction anonyme. Testez en ajoutant f=avant, et appelez-le commealert(f(4, 5))

Pas d'économies à tirer du "que" répétitif, malheureusement.

Java, 114 113 octets ou 74 72 67 si nous avons utilisé la notation lambda

Merci à Kevin Cruijssen pour la solution basée sur le curry:

a->b->a+" is "+(a==b?"equal to ":(a>b?"greater":"less")+" than ")+b

Ancienne solution pré lambda

public void c(int a,int b){System.out.print(a+" is "+(a==b?"equal to ":(a>b?"greater":"less")+" than ")+b);}

en tant que commentaire de l'utilisateur hjk dans le commentaire, si nous avons utilisé lambda, nous pouvons le faire de manière significative jusqu'à 74 octets.

(a,b)->a+" is "+(a==b?"equal to ":(a>b?"greater":"less")+" than ")+b;

R, 80 octets

function(A,B)cat(A,"is",c("less than","equal to","greater than")[2+sign(A-B)],B)

Pyth, 52 49 octets

jdm@cd)._-FQcj"
is
equal greater less
to than
"Qb

Julia, 69 66 octets

f(A,B)="$A is $(A>B?"greater than":A<B?"less than":"equal to") $B"

Cela utilise l'interpolation de chaîne pour incorporer A, Bet le ternaire à l'intérieur d'une seule chaîne.

Enregistré 3 octets grâce à Glen O.

Perl, 64 63 octets

#!/usr/bin/perl -p
s/ /" is ".("equal to ",greaterx,lessx)[$`<=>$']/e;s/x/ than /

62 octets + 1 octet pour -p. Prend l'entrée de STDIN, avec les deux nombres séparés par un seul espace:

$ echo 1 2 | ./cmp
1 is less than 2
$ echo 42 -17 | ./cmp
42 is greater than -17
$ echo 123456789 123456789 | ./cmp
123456789 is equal to 123456789

Comment ça marche:

le <=> opérateur renvoie -1, 0 ou 1 selon que le premier opérande est inférieur, égal ou supérieur au second. De manière pratique, Perl autorise les indices négatifs avec des tableaux et des tranches, où le dernier élément est à la position -1, l'avant-dernier élément est à la position -2, etc.

Dans le code

("equal to ",greaterx,lessx)[$`<=>$']

nous utilisons la valeur de retour de <=>comme indice dans une tranche de liste pour obtenir la chaîne correspondante, où $`est le premier nombre et$' le second.

Pour éviter de répéter than, xest utilisé comme espace réservé et remplacé dans une deuxième substitution à la fin.

Solution alternative, 63 octets

#!/usr/bin/perl -p
@a=(equal,greater,than,to,less);s/ / is @a[$i=$`<=>$',!$i+2] /

62 octets + 1 octet pour -p. Prend l'entrée séparée par l'espace de STDIN comme la première solution.

Comment ça marche:

Cette solution utilise également une tranche, mais tire parti du fait que contrairement aux tranches de liste, les tranches de tableau peuvent être interpolées en chaînes (et le RHS des substitutions). Cela nous permet de supprimer le /emodificateur et les guillemets dans l'opérateur de substitution.

Le vrai truc est dans l'indice de tranche:

@a[$i=$`<=>$',!$i+2]

Pour les différentes valeurs de <=>, cela donne:

$i  !$i+2  $a[$i]  $a[!$i+2]
----------------------------
-1    2     less      than
 0    3     equal     to
 1    2     greater   than

Lorsqu'un tableau ou une tranche de tableau est interpolé dans une chaîne, les éléments sont automatiquement joints par $"(par défaut, un seul espace).

Souris , 79 octets

?A:?B:A.!" is "A.B.<["less than"]A.B.>["greater than"]A.B.=["equal to"]" "B.!$

Lorsque des chaînes sont rencontrées, elles sont immédiatement écrites dans STDOUT plutôt que d'être placées sur la pile. La pile ne peut contenir que des entiers.

Non golfé:

? A:                            ~ Read an integer A from STDIN
? B:                            ~ Read an integer B from STDIN
A. !                            ~ Write A to STDOUT
" is "
A. B. < [ "less than" ]         ~ If A < B
A. B. > [ "greater than" ]      ~ If A > B
A. B. = [ "equal to" ]          ~ If A == B
" "
B. !                            ~ Write B to STDOUT
$                               ~ End of program

GolfScript, 61 octets

\.@.@="equal to "{.@.@>"greater""less"if" than "+}if" is "\+@

Attend 2 entiers sur la pile. Essayez-le en ligne .

Comment ça marche:

• \.@.@- A et B sont déjà sur la pile, et ce morceau de code rend le regard de la pile comme ceci: ABBA. \échange les deux éléments supérieurs de la pile, .duplique l'élément supérieur et @fait pivoter les 3 éléments supérieurs ( 1 2 3-> 2 3 1).

• Ensuite, trois éléments sont poussés dans la pile: le =signe "equal to ", et le bloc entre les deux {}. L' ifinstruction fait ceci: si le premier argument est évalué à vrai, il exécute le premier bloc de code (le deuxième argument), sinon, le deuxième bloc de code (le troisième argument). Donc, si A et B sont égaux, cela poussera "égal à" sur la pile. S'ils ne sont pas égaux, il exécutera le code entre le bloc. Notez que =les deux éléments supérieurs sortent de la pile, alors maintenant la pile ressemble AB.

• À l'intérieur du bloc, vous voyez d'abord .@.@. Avant ces commandes, la pile ressemble AB, et après, la pile ressemble BAAB. Les commandes sont similaires à celles mentionnées ci-dessus.

• Ensuite, il y a une autre ifdéclaration. Cette fois, il vérifie si A> B, et si c'est vrai, il pousse "plus" sur la pile. Sinon, il pousse "moins" sur la pile. Après avoir poussé l'un de ces deux, il poussera "que" sur la pile et le concaténera avec la chaîne poussée précédente. >fait également apparaître les deux éléments supérieurs de la pile, alors maintenant, la pile ressemble BA"string".

• Les trois prochaines commandes sont: " is "\+. " is "pousse cette chaîne sur la pile (la pile ressemble BA"string"" is "), \échange les deux premiers éléments (la pile ressemble BA" is ""string") et +concatène les deux premiers éléments (la pile ressemble BA" is string").

• La dernière commande, @, tourne les trois éléments de la pile, de sorte que la pile ressemble maintenant à : A" is string"B. GolfScript imprime automatiquement les valeurs de pile sur STDOUT une fois le programme terminé, vous obtenez donc la sortie souhaitée.

MATLAB, 105 octets

x=input('');y=input('');t={'less than','greater than','equal to'};
sprintf('%i is %s %i',x,t{(x>=y)+(x==y)+1},y)

Ajout d'un saut de ligne avant le sprintf, pour faciliter la lisibilité. Il fonctionne à la fois avec et sans ce saut de ligne, il n'est donc pas inclus dans le nombre d'octets. Doit appuyer sur Entrée entre les deux numéros d'entrée.

Bash, 76

a=(less\ than equal\ to greater\ than)
echo $1 is ${a[($1>$2)-($1<$2)+1]} $2

Fortran, 129

Arithmétique Fortran si est parfaite pour ce défi

Test: idéone

read(*,*)i,j
if(i-j)1,2,3
1 print*,i," is less than",j
stop
2 print*,j," is equal to",j
stop
3 print*,i," is greater than",j
end

Bash, 94 86 octets (économisé huit octets grâce à Digital Trauma)

p=equal;q=than;(($1>$2))&&p=greater&&[ ]||(($1<$2))&&p=less||q=to;echo $1 is $p $q $2

Test (sous Linux):

echo 'p=equal;q=than;(($1>$2))&&p=greater&&[ ]||(($1<$2))&&p=less||q=to;echo $1 is $p $q $2' > cmp.sh
chmod +x cmp.sh
./cmp.sh 10 12
10 is less than 12

L'utilisation de l' [ ]after p=greaterest d'empêcher l' ||opérateur d'être évalué avant= dans l'expression ...&&p=greater||(($1<$2))... (la priorité de l'opérateur!).

L'alternative serait d'utiliser des crochets autour de (($1>$2))&&p=greateret (($1<$2))&&p=less, mais les crochets créent une portée interne pour les variables, donc pne seraient pas modifiés.

Code machine IA-32 + Linux, 107 octets

Hexdump du code:

60 89 e5 89 d0 e8 51 00 00 00 4c c6 04 24 20 38
d1 74 20 68 74 68 61 6e 4c c6 04 24 20 72 0d 68
61 74 65 72 68 20 67 72 65 44 eb 11 68 6c 65 73
73 eb 0a 68 6c 20 74 6f 68 65 71 75 61 68 20 69
73 20 88 c8 e8 12 00 00 00 89 ea 29 e2 89 e1 31
db 43 8d 43 03 cd 80 89 ec 61 c3 5b d4 0a 4c 04
30 88 04 24 c1 e8 08 75 f3 ff e3

En raison des limitations matérielles, le code fonctionne avec des nombres compris entre 0 et 255.

Code source (peut être assemblé avec gcc):

    .globl print_it
    .text
    .align 16
print_it:
    pushal;
    mov %esp, %ebp; // save esp (stack pointer)
    mov %edx, %eax; // put second number in al
    call prepend;   // convert al to string

    dec %esp;       // write ...
    movb $' ', (%esp); // ... a space
    cmp %dl, %cl;   // compare the numbers
    je equal;       // if equal, goto there

    push $0x6e616874; // write "than"
    dec %esp;       // write ...
    movb $' ', (%esp); // ... a space
    jb less;        // if below, goto there

greater:
    push $0x72657461; // write "ater"
    push $0x65726720; // write " gre"
    inc %esp;         // remove a space
    jmp finish;     // bypass the code for "less than"

less:
    push $0x7373656c; // write "less"
    jmp finish;     // bypass the code for "equal"

equal:
    push $0x6f74206c; // write "l to"
    push $0x61757165; // write "equa"

finish:
    push $0x20736920; // write " is "

    mov %cl, %al;   // put first number in al
    call prepend;   // convert al to string

    mov %ebp, %edx; // calculate the length ...
    sub %esp, %edx; // ... of the output message
    mov %esp, %ecx; // address of the message
    xor %ebx, %ebx; // set ebx to ...
    inc %ebx;       // ... 1 (i.e. stdout)
    lea 3(%ebx), %eax; // set eax=4 (syscall "write")
    int $0x80;      // do the system call
    mov %ebp, %esp; // restore the stack pointer
    popal;          // restore other registers
    ret;            // return

prepend:            // writes al converted to string
    pop %ebx;       // remove return address from the stack
appendloop:
    aam;            // calculate a digit in al, rest in ah
    dec %esp;
    add $'0', %al;  // convert the digit to ASCII
    mov %al, (%esp);// write the digit
    shr $8, %eax;   // replace al by ah; check if zero
    jnz appendloop; // nonzero? repeat
    jmp *%ebx;      // return

C'est un sérieux abus de la pile! Le code crée le message de sortie sur la pile, de la fin au début. Pour écrire 4 octets, il utilise une seule pushinstruction. Pour écrire 1 octet, il utilise deux instructions:

dec %esp
mov %al, (%esp);

Par chance, la plupart des fragments à écrire font 4 octets. L'un d'eux ("gre" dans "supérieur") fait 3 octets; il est géré en poussant 4 octets et en supprimant un après:

inc %esp

La routine qui écrit des nombres sous forme décimale utilise l' aaminstruction pour diviser axpar à 10plusieurs reprises. Il est avantageux qu'il calcule les chiffres de droite à gauche!

Puisqu'il y a deux nombres à écrire, le code utilise un sous-programme, qui est appelé deux fois. Cependant, étant donné que le sous-programme écrit les résultats sur la pile, il utilise un registre pour contenir l'adresse de retour.

Code C qui appelle le code machine ci-dessus:

include <stdio.h>

void print_it(int, int) __attribute__((fastcall));

int main()
{
    print_it(90, 102);
    puts("");
    print_it(78, 0);
    puts("");
    print_it(222, 222);
    puts("");
    return 0;
}

Sortie:

90 is less than 102
78 is greater than 0
222 is equal to 222

ShortScript , 98 octets

←Α
←Β
↑Γαis
↔α>β→γgreater thanβ
↔α<β→γless thanβ
↔α|β→γequal toβ

Cette réponse n'est pas en concurrence, car ShortScript a été publié après ce défi.

Fourier , 147 74 octets

Pas de concurrence car l'impression de chaînes est plus récente que ce défi

I~AoI~B` is `<A{1}{`greater than`}A<B{1}{`less than`}A{B}{`equal to`}` `Bo

Essayez-le sur FourIDE!

Je ne sais pas pourquoi je n'ai pas autorisé l'impression avant ... Cela rend le code lisible et est idéal pour le golf

C, 155 136 127 83 bytes

f(a,b){printf("%d is %s %d\n",a,a>b?"greater than":a<b?"less than":"equal to",b);}

Haskell, 87 octets

Un octet plus court que l'approche d'Otomo.

a?b=show a++" is "++["less than ","equal to ","greater than "]!!(1+signum(a-b))++show b

Lua, 118 octets

Je ne vois pas assez de réponses de Lua ici, alors ...

function f(a,b)print(a>b and a.." is greater than "..b or a==b and a.." is equal to "..b or a.." is less than "..b)end

Non golfé:

function f(a,b)
    print(a>b and a.." is greater than "..b or a==b and a.." is equal to "..b or a.." is less than "..b)
end

Python 2, 78 octets

J'adore la façon dont il cmp()est vraiment utile, mais il a été supprimé en Python 3 .

Utilisation d'une fonction anonyme:

lambda a,b:`a`+' is '+['equal to ','greater than ','less than '][cmp(a,b)]+`b`

Ne pas utiliser de fonction (79 octets):

a,b=input();print a,'is %s'%['equal to','greater than','less than'][cmp(a,b)],b

JavaScript, 151104100 95 92 octets

a+=prompt()
b+=prompt()
alert(a+" is "+(a>b?"greater than ":a<b?"lesser than ":"equal to ")+b)

J'ai réussi à raccourcir avec l'aide d'edc65

C# 6, 113 103 100 95 bytes

void C(int a,int b){System.Console.Write($"{a} is {a-b:greater than;less than;equal to} {b}");}

Thanks to edc65 for saving 13 bytes and to cell001uk for saving 5 bytes using C# 6's interpolated strings!

rs, 105 bytes

(\d+) (\d+)/\1 is (_)^^(\1) (_)^^(\2) \2
 (_+) \1_+/ less than
 (_+) \1 / equal to 
_+ _+/greater than

The trailing and preceding whitespace is very important!

Live demo and all test cases.

Pyth, 57 55 53 bytes

AQjd[G"is"@c"equal to
greater than
less than"b._-GHH)

This basically does:

["less than", "greater than", "equal to"][sign_of(A-B)]

Saved 2 bytes thanks to @AlexA.'s suggestion of using A instead of J and K and another 2 bytes by replacing the whole addition mess with a simpler subtraction.

Live demo and test cases.

55-byte version

AQjd[G"is"@c"less than
greater than
equal to"b+gGHqGHH)

Live demo and test cases.

57-byte version:

jd[JhQ"is"@c"less than
greater than
equal to"b+gJKeQqJKK)

Live demo and test cases.

O, 67 bytes

jJ" is ""greater than""less than""equal to"JjK-.e\1<+{@}d;;' K++++p

Live demo.

SWI-Prolog, 94 bytes

a(A,B):-(((A>B,C=greater;A<B,C=less),D=than);C=equal,D=to),writef("%t is %t %t %t",[A,C,D,B]).

Swift, 105 92 byte

func c(a:Int, b:Int){println("A is",(a==b ?"equal to":(a<b ?"less":"greater")," than"),"B")}

even shorter with Swift 2.0 (103 90 byte)

func c(a:Int, b:Int){print("A is",(a==b ?"equal to":(a<b ?"less":"greater")," than"),"B")}

Processing, 92 bytes

void c(int a,int b){print(a+" is "+(a>b?"greater than ":a<b?"lesser than ":"equal to ")+b);}