Herausforderung

Bei zwei Ganzzahlen Aund Bals Eingabe müssen Sie ein Programm schreiben, das if A>B, A==Bor ausgibt A<B.

Die Ganzzahlen liegen in einem angemessenen Bereich, der von Ihrer Sprache unterstützt wird und mindestens 256 Werte enthält.

Ihr Programm kann entweder ein vollständiges Programm oder eine Funktion sein, die über STDIN oder Funktionsargumente eingegeben wird.

Ausgänge

Wenn A>Bausgegeben

A is greater than B

Wenn A==Bausgegeben

A is equal to B

Wenn A<Bausgegeben

A is less than B

Wo Sie ersetzen Aund Bfür ihre ganzzahligen Werte.

Gewinnen

Das kürzeste Programm in Bytes gewinnt.

Bestenliste

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*

Probieren Sie es online aus

Erläuterung:

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

Die Eingabe muss durch Kommas getrennt sein.

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

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

Bearbeiten: Es ist gelungen, 3 Bytes zu sparen , indem 10zwischen 101, 103und 108(die Zeichencodes von e, gund l) wiederverwendet wurden . Die folgende Erklärung spiegelt dies nicht wider, ist jedoch keine wesentliche Änderung.

Erläuterung

Wir können nicht viel tun, um Bytes für das Drucken der Zeichenfolgen zu sparen, das sind nur lange lineare Abschnitte. Die größte Herausforderung beim Golfen besteht also darin, große Mengen unnötiger Leerzeichen zu vermeiden. Das heißt, wir möchten, dass die linearen Teile aus der äußersten linken Spalte "herausstrahlen". Durch die Wiederverwendung des gedruckten Codes können wir noch mehr Einsparungen erzielen than B. Schauen wir uns also den Kontrollfluss hier an:

Das Programm startet mit einem Gitterrotationsbefehl <. Dies verschiebt die aktuelle Zeile zyklisch mit der IP nach links.

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

Jetzt befindet sich die IP in einer isolierten Zelle und führt denselben Befehl immer wieder aus, während sich die IP <weiter nach links bewegt, bis ...

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

Zu diesem Zeitpunkt muss die IP irgendwo hin und führt den ersten linearen Abschnitt (die zweite Reihe) von rechts nach links aus. Was es tut, ist zu lesen A, zu kopieren, zu drucken. Verbrauchen Sie das Trennzeichen zwischen den Zahlen, dem Druck is(und den Leerzeichen). Dann lesen B, kopieren Sie sie und ziehen Avon ihm an der -.

Zu diesem Zeitpunkt haben wir die erste "Weggabelung" getroffen. Wenn sich die Differenz ergibt 0, bewegt sich die IP immer geradeaus in Richtung des untersten Zweigs. Dieser Zweig druckt einfach equal tound dann B.

Andernfalls biegt die IP nach links in Richtung der beiden No-Ops ab "". Dann gibt es noch eine Gabelung. Wenn die Differenz negativ war, nimmt die IP eine weitere Linke in Richtung des langen oberen Zweigs. Dieser Zweig druckt einfach greater thanund dann B.

Wenn die Differenz positiv war, nimmt die IP einen Rechtsanschlag auf den unteren Zweig, der gedruckt wird less. Jetzt wollen wir die thanaus dem anderen Zweig wiederverwenden . Gleichzeitig wollen wir die beiden Niederlassungen aber später nicht verbinden, weil wir eine ganze Reihe unnötiger Leerzeichen benötigen würden. Stattdessen verwenden wir einige No-Ops, um den unteren Zweig an der Stelle auszurichten, thanan der der obere Zweig beginnt, und beginnen dann erneut mit der Bearbeitung der Quelle ^:

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

Auch diesmal wird die IP isoliert, also ^erneut ausgeführt und wir bekommen

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

Jetzt kann die IP weiter nach rechts gehen thanund Bnach Bedarf drucken .

JavaScript (ES6), 66 Byte

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

Definiert eine anonyme Funktion. Testen f=Sie, indem Sie davor hinzufügen , und nennen Sie es wiealert(f(4, 5))

Leider sind durch das wiederholte "als" keine Einsparungen zu erzielen.

Java, 114 113 Bytes oder 74 72 67, wenn wir die Lambda-Notation verwenden

Vielen Dank an Kevin Cruijssen für die Currying-basierte Lösung:

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

Alte Pre-Lambda-Lösung

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

als benutzer hjk bedeutung im kommentar, wenn wir lambda verwenden, können wir bis zu 74 bytes deutlich machen.

(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"

Diese verwendet String Interpolation einzubetten A, Bund das ternäre in einem einzigen String.

3 Bytes gespart dank Glen O.

Perl, 64 63 Bytes

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

62 Bytes + 1 Byte für -p. Nimmt Eingaben von STDIN entgegen, wobei die beiden Zahlen durch ein einzelnes Leerzeichen getrennt sind:

$ 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

Wie es funktioniert:

Der <=>Operator gibt -1, 0 oder 1 zurück, je nachdem, ob der erste Operand kleiner, gleich oder größer als der zweite ist. Praktischerweise erlaubt Perl negative Indizes mit Arrays und Slices, wobei sich das letzte Element an Position -1 befindet, das vorletzte Element an Position -2 und so weiter.

Im Code

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

Wir verwenden den Rückgabewert von <=>als Index in einem Listenabschnitt, um die entsprechende Zeichenfolge abzurufen, wobei $`die erste und $'die zweite Zahl ist.

Um Wiederholungen zu vermeiden than, xwird als Platzhalter verwendet und am Ende in einer zweiten Ersetzung ersetzt.

Alternative Lösung, 63 Bytes

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

62 Bytes + 1 Byte für -p. Übernimmt die durch Leerzeichen getrennte Eingabe von STDIN wie bei der ersten Lösung.

Wie es funktioniert:

Diese Lösung verwendet auch ein Slice, nutzt jedoch die Tatsache, dass im Gegensatz zu Listen-Slices Array-Slices in Strings (und die RHS von Substitutionen) interpoliert werden können. Auf diese Weise können Sie den /eModifikator und die Anführungszeichen im Substitutionsoperator löschen.

Der wahre Trick steckt im Slice-Index:

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

Für die verschiedenen Werte von <=>ergibt dies:

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

Wenn ein Array oder ein Array-Slice in eine Zeichenfolge interpoliert wird, werden die Elemente automatisch durch $"(standardmäßig ein einzelnes Leerzeichen) verbunden.

Maus , 79 Bytes

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

Wenn Zeichenfolgen gefunden werden, werden sie sofort in STDOUT geschrieben und nicht auf den Stapel gelegt. Der Stapel kann nur ganze Zahlen enthalten.

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 "\+@

Erwartet 2 Ganzzahlen auf dem Stapel. Probieren Sie es online aus .

Wie es funktioniert:

• \.@.@- A und B sind bereits auf dem Stapel, und dieser Code Stück macht den Stapel sieht wie folgt aus : ABBA. \Vertauscht die beiden obersten Elemente auf dem Stapel, .dupliziert das oberste Element und @dreht die drei obersten Elemente ( 1 2 3-> 2 3 1).

• Dann werden drei Elemente auf den Stapel gelegt: das =Zeichen "equal to "und der Block dazwischen {}. Die ifAnweisung führt Folgendes aus: Wenn das erste Argument true ergibt, wird der erste Codeblock (das zweite Argument) ausgeführt, andernfalls der zweite Codeblock (das dritte Argument). Wenn also A und B gleich sind, wird "gleich" auf dem Stapel gedrückt. Wenn sie nicht gleich sind, wird der Code zwischen den Blöcken ausgeführt. Beachten Sie, dass =die beiden obersten Elemente aus dem Stapel entfernt werden, sodass der Stapel jetzt wie folgt aussieht AB.

• Im Inneren des Blocks sehen Sie zuerst .@.@. Vor diesen Befehlen sieht der Stapel so aus ABund danach sieht der Stapel so aus BAAB. Die Befehle sind ähnlich wie die oben genannten.

• Dann gibt es noch eine andere ifAussage. Dieses Mal wird geprüft, ob A> B ist, und wenn dies der Fall ist, wird der Stack auf "größer" gesetzt. Sonst drückt es "weniger" auf den Stapel. Nachdem Sie eine dieser beiden Optionen gedrückt haben, wird "than" auf den Stapel verschoben und mit der vorherigen geschobenen Zeichenfolge verkettet. >Außerdem werden die beiden obersten Elemente des Stapels geöffnet, sodass der Stapel jetzt wie folgt aussieht BA"string".

• Die nächsten drei Befehle sind: " is "\+. " is "Schiebt diese Zeichenfolge auf den Stapel (Stapel sieht aus wie BA"string"" is "), \vertauscht die beiden obersten Elemente (Stapel sieht aus wie BA" is ""string") und +verkettet die beiden obersten Elemente (Stapel sieht aus wie BA" is string").

• Der letzte Befehl, @dreht sich die drei Stapel Elemente, so dass nun der Stapel wie folgt aussieht: A" is string"B. GolfScript druckt die Stapelwerte automatisch auf STDOUT, sobald das Programm beendet ist, und Sie erhalten die gewünschte Ausgabe.

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)

Es wurde ein Zeilenumbruch vor dem Sprint hinzugefügt, um die Lesbarkeit zu verbessern. Es funktioniert sowohl mit als auch ohne diesen Zeilenumbruch, daher ist es nicht in der Byteanzahl enthalten. Muss die Eingabetaste zwischen den beiden Eingabenummern drücken.

Bash, 76

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

Fortran, 129

Fortran Arithmetik ist perfekt für diese Herausforderung

Test: 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 (8 Bytes dank Digital Trauma eingespart)

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

Test (unter 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

Die Verwendung von [ ]after p=greatersoll verhindern, dass der ||Operator vor =dem Ausdruck ausgewertet wird ...&&p=greater||(($1<$2))... (Operator-Priorität!).

Die Alternative wäre die Verwendung von Klammern um (($1>$2))&&p=greaterund (($1<$2))&&p=less, aber Klammern bieten inneren Spielraum für Variablen und pwürden daher unverändert bleiben.

IA-32 Maschinencode + Linux, 107 Bytes

Hexdump des Codes:

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

Aufgrund von Hardwareeinschränkungen funktioniert der Code mit Zahlen im Bereich von 0 bis 255.

Quellcode (kann mit gcc zusammengestellt werden):

    .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

Dies ist ein schwerwiegender Missbrauch des Stapels! Der Code erstellt die Ausgabenachricht vom Ende bis zum Anfang auf dem Stapel. Zum Schreiben von 4 Bytes wird eine einzelne pushAnweisung verwendet. Zum Schreiben von 1 Byte werden zwei Anweisungen verwendet:

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

Glücklicherweise sind die meisten zu schreibenden Fragmente 4 Bytes. Einer von ihnen ("gre" in "größer") ist 3 Bytes; Es wird durch Drücken von 4 Bytes und anschließendes Entfernen eines Bytes gehandhabt:

inc %esp

Die Routine, die Zahlen in Dezimalform schreibt, verwendet den aamBefehl, um wiederholt axdurch zu teilen 10. Es ist vorteilhaft, dass es die Ziffern von rechts nach links berechnet!

Da zwei Zahlen zu schreiben sind, verwendet der Code eine Unterroutine, die zweimal aufgerufen wird. Da die Subroutine jedoch die Ergebnisse auf den Stapel schreibt, verwendet sie ein Register, um die Rücksprungadresse zu speichern.

C-Code, der den obigen Maschinencode aufruft:

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

Ausgabe:

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β

Diese Antwort ist nicht konkurrierend, da ShortScript nach dieser Herausforderung veröffentlicht wurde.

Fourier , 147 74 Bytes

Wettbewerbsverbot, da das Drucken von Zeichenfolgen neuer ist als diese Herausforderung

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

Probieren Sie es auf FourIDE!

Keine Ahnung, warum ich das Drucken vorher nicht zugelassen habe ... Es macht den Code lesbar und eignet sich hervorragend zum Golfen

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

Ein Byte kürzer als Otomos Ansatz.

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

Lua, 118 Bytes

Ich sehe hier nicht genug Antworten von Lua, also ...

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

Ich mag, wie cmp()nützlich es ist, aber es wurde in Python 3 entfernt .

Verwenden einer anonymen Funktion:

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

Keine Funktion verwenden (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)

Ich habe es geschafft, mit Hilfe von edc65 zu verkürzen

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

Danke an edc65 für das Speichern von 13 Bytes und an cell001uk für das Speichern von 5 Bytes unter Verwendung der interpolierten Strings von C # 6 !

rs , 105 bytes

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

Das nachfolgende und vorangestellte Leerzeichen ist sehr wichtig!

Live-Demo und alle Testfälle.

Pyth, 57 55 53 Bytes

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

Dies macht im Grunde:

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

2 Bytes gespart dank des Vorschlags von @ AlexA., AAnstelle von Jund Kweitere 2 Bytes zu verwenden, indem der gesamte Additionsfehler durch eine einfachere Subtraktion ersetzt wurde.

Live-Demo und Testfälle.

55-Byte-Version

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

Live-Demo und Testfälle.

57-Byte-Version:

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

Live-Demo und Testfälle.

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

noch kürzer mit 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")}

Verarbeitung, 92 Bytes

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