Reto

Dados dos enteros Ay Bcomo entrada, debe escribir un programa que genere si A>B, A==Bo A<B.

Los enteros estarán en cualquier rango razonable admitido por su idioma que incluya al menos 256 valores.

Su programa puede ser un programa completo o una función, tomando entrada a través de STDIN o argumentos de función.

Salidas

Si A>Bsalida

A is greater than B

Si A==Bsalida

A is equal to B

Si A<Bsalida

A is less than B

Donde reemplazas Ay Bpor sus valores enteros.

Victorioso

El programa más corto en bytes gana.

Tabla de clasificación

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*

Pruébalo en línea

Explicación:

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

La entrada debe estar separada por comas.

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

Laberinto , 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: Managed afeitarse 3 bytes mediante la reutilización de 10entre 101, 103y 108(los códigos de caracteres dee , gy l). La explicación a continuación no refleja esto, pero no es un cambio sustancial.

Explicación

No hay mucho que podamos hacer para ahorrar bytes para imprimir las cadenas, solo serán largas secciones lineales. Por lo tanto, el principal desafío en el golf es evitar grandes cantidades de espacios en blanco innecesarios. Eso significa que queremos que las partes lineales se "irradien" desde la columna más a la izquierda. También podemos obtener más ahorros reutilizando el código que imprimethan B . Así que echemos un vistazo al flujo de control aquí:

El programa comienza en un comando de rotación de cuadrícula <. Esto desplaza la fila actual cíclicamente a la izquierda con la IP, así que obtenemos esto:

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

Ahora la IP está en una celda aislada, por lo que ejecuta el mismo comando una y otra vez mientras <viaja más a la izquierda hasta ...

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

En este punto, la IP tiene un lugar adonde ir y ejecuta la primera sección lineal (la segunda fila) de derecha a izquierda. Lo que hace es leer A, copiar, imprimir. Consume el carácter delimitador entre los números, imprimir is(y espacios). Luego lea B, cópielo y reste Aen el -.

En este punto llegamos al primer "tenedor en el camino". Si la diferencia cede 0, la IP sigue avanzando hacia la rama inferior. Esa rama simplemente imprime equal toy luego B.

De lo contrario, la IP gira a la izquierda hacia los dos no-ops "". Luego hay otro tenedor. Si la diferencia fue negativa, la IP toma otra izquierda hacia la rama superior larga. Esa rama simplemente imprime greater thany luego B.

Si la diferencia fue positiva, la IP gira a la derecha en la rama inferior, que imprime less. Ahora queremos reutilizar el thande la otra rama. Pero al mismo tiempo no queremos conectar las dos ramas más adelante, porque necesitaríamos un montón de espacios innecesarios. En su lugar, usamos algunos no-ops para alinear la rama inferior con donde thancomienza en la rama superior y luego comenzamos a manipular la fuente nuevamente con ^:

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

De nuevo, esto aísla la IP, por lo que ^se ejecuta nuevamente y obtenemos

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

Ahora la IP puede continuar moviéndose hacia la derecha e imprimir thany Bsegún sea necesario.

JavaScript (ES6), 66 bytes

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

Define una función anónima. Pruebe agregando f=antes y llámelo comoalert(f(4, 5))

Desafortunadamente, no se pueden obtener ahorros del "que" repetitivo.

Java, 114 113 Bytes o 74 72 67 si usamos la notación lambda

Gracias a Kevin Cruijssen por la solución basada en curry:

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

Antigua solución pre lambda

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

como comentario del usuario hjk en el comentario, si usamos lambda podemos hacerlo significativamente hasta 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)

Pyth, 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 sistema utiliza la interpolación de cadenas para incrustar A, By el ternario dentro de una única cadena.

Guardado 3 bytes gracias 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. Toma información de STDIN, con los dos números separados por un solo espacio:

$ 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

Cómo funciona:

los <=> operador devuelve -1, 0 o 1 dependiendo de si el primer operando es menor, igual o mayor que el segundo. Convenientemente, Perl permite subíndices negativos con matrices y sectores, donde el último elemento está en la posición -1, el penúltimo elemento está en la posición -2, y así sucesivamente.

En el codigo

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

Usamos el valor de retorno de <=>como el subíndice en un segmento de lista para obtener la cadena correspondiente, donde$` es el primer número y $'es el segundo.

Para evitar la repetición than, xse utiliza como marcador de posición y se reemplaza en una segunda sustitución al final.

Solución 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 . Toma entradas separadas por espacios de STDIN como la primera solución.

Cómo funciona:

Esta solución también utiliza un sector, pero aprovecha el hecho de que, a diferencia de los sectores de la lista, los sectores de la matriz se pueden interpolar en cadenas (y el RHS de las sustituciones). Esto nos permite soltar el/e modificador y las comillas en el operador de sustitución.

El verdadero truco está en el subíndice de corte:

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

Para los diferentes valores de <=>, esto da:

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

Cuando una matriz o segmento de matriz se interpola en una cadena, los elementos se unen automáticamente $"(de forma predeterminada, un solo espacio).

Ratón , 79 bytes

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

Cuando se encuentran cadenas, se escriben inmediatamente en STDOUT en lugar de colocarse en la pila. La pila solo puede contener enteros.

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

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

Espera 2 enteros en la pila. Pruébalo en línea .

Cómo funciona:

• \.@.@- A y B ya están en la pila, y esta pieza de código hace que el aspecto pila como esto: ABBA. \intercambia los dos elementos superiores de la pila, .duplica el elemento superior y @gira los 3 elementos superiores (1 2 3 -> 2 3 1).

• Luego, se empujan tres elementos a la pila: el =signo "equal to ", y el bloque entre ellos {}. La ifdeclaración hace esto: si el primer argumento se evalúa como verdadero, ejecuta el primer bloque de código (el segundo argumento), de lo contrario, el segundo bloque de código (el tercer argumento). Entonces, si A y B son iguales, presionará "igual a" en la pila. Si no son iguales, ejecutará el código entre el bloque. Tenga en cuenta que= saca los dos elementos principales de la pila, por lo que ahora se ve la pila AB.

• Dentro del bloque, primero ves .@.@. Antes de estos comandos, se ve la pila AB, y después, se ve la pila BAAB. Los comandos son similares a los mencionados anteriormente.

• Entonces, hay otra ifdeclaración. Esta vez, comprueba si A> B, y si es cierto, empuja "mayor" en la pila. De lo contrario, empuja "menos" en la pila. Después de presionar uno de estos dos, presionará "que" en la pila y lo concatenará con la cadena anterior.>también muestra los dos elementos principales de la pila, por lo que ahora se ve la pila BA"string".

• Los siguientes tres comandos son los siguientes: " is "\+. " is "empuja esa cadena en la pila (la pila parece BA"string"" is "), \intercambia los dos elementos superiores (la pila parece BA" is ""string") y +concatena los dos elementos superiores (la pila pareceBA" is string" ).

• El último comando, @, gira los tres elementos de la pila, por lo que la pila ahora se ve así: A" is string"B. GolfScript imprime automáticamente los valores de la pila en STDOUT una vez que el programa termina, para que obtenga el resultado deseado.

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)

Se agregó un salto de línea antes de sprintf, para facilitar la lectura. Funciona con y sin este salto de línea, por lo que no se incluye en el recuento de bytes. Debe presionar enter entre los dos 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

Fortran aritmética si es perfecta para este desafío

Prueba: 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 (ahorró ocho bytes gracias a Digital Trauma)

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

Prueba (en 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

El uso de [ ]after p=greateres para evitar que el ||operador sea evaluado antes =en la expresión...&&p=greater||(($1<$2))... (¡la precedencia del operador!).

La alternativa sería usar corchetes (($1>$2))&&p=greatery (($1<$2))&&p=less, pero los corchetes hacen un alcance interno para las variables, por plo que no se alterarían.

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

Hexdump del 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

Debido a limitaciones de hardware, el código funciona con números en el rango 0 ... 255.

Código fuente (se puede ensamblar con 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

¡Esto es un abuso grave de la pila! El código construye el mensaje de salida en la pila, desde el final hasta el principio. Para escribir 4 bytes, utiliza una sola pushinstrucción. Para escribir 1 byte, utiliza dos instrucciones:

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

Por suerte, la mayoría de los fragmentos a escribir son de 4 bytes. Uno de ellos ("gre" en "mayor") es de 3 bytes; se maneja presionando 4 bytes y eliminando uno después:

inc %esp

La rutina que escribe números en forma decimal usa la aaminstrucción para dividir axpor 10repetidamente. ¡Es ventajoso que calcule los dígitos de derecha a izquierda!

Como hay dos números para escribir, el código usa una subrutina, que se llama dos veces. Sin embargo, debido a que la subrutina escribe los resultados en la pila, utiliza un registro para contener la dirección de retorno.

Código C que llama al código de máquina anterior:

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

Salida:

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 respuesta no es competitiva, ya que ShortScript se publicó después de este desafío.

Fourier , 147 74 bytes

No competir porque la impresión de cadenas es más nueva que este desafío

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

Pruébalo en FourIDE!

No sé por qué no permití imprimir antes ... Hace que el código sea legible y es ideal para jugar al 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 bytes

Un byte más corto que el enfoque de Otomo.

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

Lua, 118 bytes

No veo suficientes respuestas de Lua aquí, así que ...

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

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

Me encanta cómo cmp()es realmente útil, pero se eliminó en Python 3 .

Usando una función anónima:

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

No utiliza una función (79 bytes):

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

JavaScript, 151104100 95 92 bytes

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

Logré acortar con la ayuda de 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}");}

¡Gracias a edc65 por guardar 13 bytes y a cell001uk por guardar 5 bytes usando las cadenas interpoladas de C # 6 !

rs , 105 bytes

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

¡El espacio en blanco final y anterior es muy importante!

Demostración en vivo y todos los casos de prueba.

Pyth, 57 55 53 bytes

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

Esto básicamente hace:

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

Ahorró 2 bytes gracias a la sugerencia de @ AlexA. de usar A En lugar de Jy Ky otros 2 bytes mediante la sustitución de todo el lío además con una resta simple.

Demostración en vivo y casos de prueba.

Versión de 55 bytes

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

Demostración en vivo y casos de prueba.

Versión de 57 bytes:

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

Demostración en vivo y casos de prueba.

O, 67 bytes

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

Demo en 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")}

aún más corto con 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")}

Procesando, 92 bytes

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