Desafio

Dados dois números inteiros Ae Bcomo entrada, você deve escrever um programa que produza se A>B, A==Bou A<B.

Os números inteiros estarão em qualquer faixa razoável suportada pelo seu idioma, que inclua pelo menos 256 valores.

Seu programa pode ser um programa completo ou uma função, recebendo entradas via STDIN ou argumentos de função.

Saídas

Se a A>Bsaída

A is greater than B

Se a A==Bsaída

A is equal to B

Se a A<Bsaída

A is less than B

Onde você substitui Ae Bpor seus valores inteiros.

Ganhando

O programa mais curto em bytes vence.

Entre os melhores

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*

Experimente online

Explicação:

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 bytes

A entrada deve ser separada por vírgula.

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

Labirinto , 180 152 149 bytes

<
?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.{!@

Editar: Dirigido para raspar 3 bytes reutilizando 10entre 101, 103e 108(os códigos de caracteres de e, ge l). A explicação abaixo não reflete isso, mas não é uma mudança substancial.

Explicação

Não há muito que possamos fazer no sentido de salvar bytes para imprimir as seqüências de caracteres; isso será apenas seções lineares longas. Portanto, o principal desafio no golfe é evitar grandes quantidades de espaço em branco desnecessário. Isso significa que queremos que as partes lineares "irradiem" da coluna mais à esquerda. Também podemos obter mais economias reutilizando o código que é impresso than B. Então, vamos ver o fluxo de controle aqui:

O programa inicia em um comando de rotação da grade <. Isso muda a linha atual ciclicamente para a esquerda com o IP, então obtemos o seguinte:

                                                     <
?.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.{!@

Agora, o IP está em uma célula isolada, portanto, ele executa o mesmo comando repetidamente, enquanto <viaja mais para a esquerda até ...

                    <
?.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.{!@

Nesse ponto, o IP tem algum lugar para ir e executa a primeira seção linear (a segunda linha) da direita para a esquerda. O que ele faz é ler A, copiar, imprimir. Consuma o caracter delimitador entre os números, imprima is(e espaços). Em seguida B, leia , copie-o e subtraia A-o no -.

Neste ponto, atingimos a primeira "bifurcação na estrada". Se a diferença ocorrer 0, o IP continuará avançando em direção ao ramo inferior. Esse ramo simplesmente imprime equal toe depois B.

Caso contrário, o IP vira à esquerda em direção aos dois no-ops "". Depois, há outro garfo. Se a diferença foi negativa, o IP vira outra esquerda em direção ao ramo superior longo. Esse ramo simplesmente imprime greater thane depois B.

Se a diferença foi positiva, o IP vira à direita na ramificação inferior, que é impressa less. Agora, queremos reutilizar o thando outro ramo. Mas, ao mesmo tempo, não queremos conectar os dois ramos mais tarde, porque precisaríamos de vários espaços desnecessários. Em vez disso, usamos algumas no-ops para alinhar o ramo inferior com o local onde thancomeça no ramo superior e, em seguida, começamos a manipular a fonte novamente com ^:

                    <
?.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 .{!@

Novamente, isso isola o IP, então ^é executado novamente e obtemos

                    <
?.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 .{!@

Agora o IP pode continuar se movendo para a direita e imprimindo thane Bconforme necessário.

JavaScript (ES6), 66 bytes

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

Define uma função anônima. Teste adicionando f=antes e chame-o comoalert(f(4, 5))

Infelizmente, não se pode economizar com o repetitivo "que".

Java, 114 113 bytes ou 74 72 67 se usamos a notação lambda

Agradecimentos a Kevin Cruijssen pela solução baseada no curry:

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

Solução pré-lambda antiga

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

como usuário hjk no comentário, se usamos lambda, podemos reduzir significativamente até 74 bytes.

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

R, 80 bytes

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

Pitão, 52 49 bytes

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

Julia, 69 66 bytes

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

Este usa interpolação de string para incorporar A, Be o ternário dentro de uma única cadeia.

Economizou 3 bytes graças a Glen O.

Perl, 64 63 bytes

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

62 bytes + 1 byte para -p. Recebe entrada de STDIN, com os dois números separados por um único espaço:

$ 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

Como funciona:

O <=>operador retorna -1, 0 ou 1, dependendo se o primeiro operando for menor que, igual a ou maior que o segundo. Convenientemente, o Perl permite subscritos negativos com matrizes e fatias, onde o último elemento está na posição -1, o penúltimo elemento está na posição -2 e assim por diante.

No código

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

usamos o valor de retorno <=>como o subscrito em uma fatia da lista para obter a sequência correspondente, onde $`é o primeiro número e $'o segundo.

Para evitar repetições than, xé usado como espaço reservado e substituído em uma segunda substituição no final.

Solução alternativa, 63 bytes

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

62 bytes + 1 byte para -p. Recebe entrada do STDIN, separada por espaço, exatamente como a primeira solução.

Como funciona:

Essa solução também usa uma fatia, mas tira vantagem do fato de que, diferentemente das fatias da lista, as fatias da matriz podem ser interpoladas em seqüências de caracteres (e o RHS de substituições). Isso nos permite soltar o /emodificador e as aspas no operador de substituição.

O verdadeiro truque está na fatia subscrita:

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

Para os diferentes valores de <=>, isso fornece:

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

Quando uma matriz ou fatia de matriz é interpolada em uma sequência, os elementos são automaticamente unidos por $"(por padrão, um único espaço).

Mouse , 79 bytes

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

Quando as strings são encontradas, elas são gravadas imediatamente em STDOUT, em vez de serem colocadas na pilha. A pilha pode conter apenas números inteiros.

Ungolfed:

? 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 bytes

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

Espera 2 números inteiros na pilha. Experimente online .

Como funciona:

• \.@.@- A e B já estão na pilha, e este pedaço de código faz o olhar pilha assim: ABBA. \troca os dois itens principais da pilha, .duplica o item superior e @gira os 3 itens principais ( 1 2 3-> 2 3 1).

• Em seguida, três itens são enviados para a pilha: o =sinal,, "equal to "e o bloco entre eles {}. A ifinstrução faz o seguinte: se o primeiro argumento é avaliado como verdadeiro, ele executa o primeiro bloco de código (o segundo argumento), caso contrário, o segundo bloco de código (o terceiro argumento). Portanto, se A e B são iguais, ele pressionará "igual a" na pilha. Se não forem iguais, ele executará o código entre o bloco. Observe que =os dois itens principais são exibidos na pilha; agora, a pilha se parece AB.

• Dentro do bloco, você vê pela primeira vez .@.@. Antes desses comandos, a pilha se parece ABe depois a pilha se parece BAAB. Os comandos são semelhantes aos mencionados acima.

• Depois, há outra ifdeclaração. Desta vez, verifica se A> B e, se verdadeiro, empurra "maior" na pilha. Senão, ele empurra "menos" na pilha. Depois de empurrar um desses dois, ele empurra "than" na pilha e concatena-o com a string empurrada anterior. >também exibe os dois itens principais da pilha; agora, a pilha se parece BA"string".

• Os próximos três comandos são: " is "\+. " is "coloca essa sequência na pilha (aparência da pilha BA"string"" is "), \troca os dois itens principais (aparência da pilha BA" is ""string") e +concatena os dois itens principais (aparência da pilha BA" is string").

• O último comando, @, gira os três itens da pilha, de modo que a pilha agora parece: A" is string"B. O GolfScript imprime automaticamente os valores da pilha no STDOUT quando o programa termina, para que você obtenha a saída desejada.

MATLAB, 105 bytes

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

Adicionada uma quebra de linha antes do sprintf, para facilitar a legibilidade. Ele funciona com e sem essa quebra de linha, portanto não é incluído na contagem de bytes. Deve pressionar enter entre os dois números de entrada.

Bash, 76

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

Fortran, 129

Aritmética Fortran se é perfeita para este desafio

Teste: ideone

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 bytes (economizados oito bytes graças ao Digital Trauma)

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

Teste (no 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

O uso de [ ]after p=greateré para impedir que o ||operador seja avaliado antes =na expressão ...&&p=greater||(($1<$2))... (a precedência do operador!).

A alternativa seria usar colchetes (($1>$2))&&p=greatere (($1<$2))&&p=less, mas os colchetes criam escopo interno para as variáveis, portanto p, permaneceriam inalterados.

Código de máquina IA-32 + linux, 107 bytes

Hexdump do código:

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

Devido a limitações de hardware, o código funciona com números no intervalo de 0 a 255.

Código fonte (pode ser montado com o 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

Este é um abuso grave da pilha! O código cria a mensagem de saída na pilha, do fim ao começo. Para escrever 4 bytes, ele usa uma única pushinstrução. Para escrever 1 byte, ele usa duas instruções:

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

Por sorte, a maioria dos fragmentos a serem escritos tem 4 bytes. Um deles ("gre" em "maior") é de 3 bytes; é tratado pressionando 4 bytes e removendo um depois:

inc %esp

A rotina que escreve números na forma decimal usa a aaminstrução para dividir axpor 10repetidamente. É vantajoso que calcule os dígitos da direita para a esquerda!

Como existem dois números para escrever, o código usa uma sub-rotina, chamada duas vezes. No entanto, como a sub-rotina grava os resultados na pilha, ela usa um registro para armazenar o endereço de retorno.

Código C que chama o código de máquina acima:

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;
}

Saída:

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

ShortScript , 98 bytes

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

Esta resposta não é competitiva, pois o ShortScript foi publicado após esse desafio.

Fourier , 147 74 bytes

Não competir porque a impressão de cordas é mais recente que esse desafio

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

Experimente no FourIDE!

Não sei por que eu não permiti a impressão antes ... Torna o código legível e é ótimo para jogar golfe

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 bytes

Um byte menor que a abordagem de Otomo.

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

Lua, 118 bytes

Eu não vejo respostas suficientes de Lua aqui, então ...

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

Ungolfed:

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 bytes

Eu amo como cmp()é realmente útil, mas foi removido no Python 3 .

Usando uma função anônima:

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

Não usando uma função (79 bytes):

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

JavaScript, 151 104 100 95 92 bytes

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

Consegui diminuir com a ajuda do 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}");}

Agradecemos a edc65 por salvar 13 bytes e a cell001uk por salvar 5 bytes usando as seqüências interpoladas do C # 6 !

rs , 105 bytes

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

O espaço em branco à direita e o anterior é muito importante!

Demonstração ao vivo e todos os casos de teste.

Pitão, 57 55 53 bytes

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

Isso basicamente faz:

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

Saved 2 bytes, graças à do @ Alexa. Sugestão de usar A, em vez de Je Ke outros 2 bytes, substituindo toda a adição mexer com uma subtração simples.

Demonstração ao vivo e casos de teste.

Versão de 55 bytes

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

Demonstração ao vivo e casos de teste.

Versão de 57 bytes:

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

Demonstração ao vivo e casos de teste.

O, 67 bytes

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

Demonstração ao vivo.

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 bytes

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

ainda mais curto com o Swift 2.0 ( 103 90 bytes)

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

Processando, 92 bytes

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