Compare length of two strings

From Rosetta Code
Task
Compare length of two strings
You are encouraged to solve this task according to the task description, using any language you may know.

Basic Data Operation
This is a basic data operation. It represents a fundamental action on a basic data type.

You may see other such operations in the Basic Data Operations category, or:

Integer Operations
Arithmetic | Comparison

Boolean Operations
Bitwise | Logical

String Operations
Concatenation | Interpolation | Comparison | Matching

Memory Operations
Pointers & references | Addresses

Task

Given two strings of different length, determine which string is longer or shorter. Print both strings and their length, one on each line. Print the longer one first.

Measure the length of your string in terms of bytes or characters, as appropriate for your language. If your language doesn't have an operator for measuring the length of a string, note it.

Extra credit

Given more than two strings:
list = ["abcd","123456789","abcdef","1234567"]
Show the strings in descending length order.

Other tasks related to string operations:
Metrics
Counting
Remove/replace
Anagrams/Derangements/shuffling
Find/Search/Determine
Formatting
Song lyrics/poems/Mad Libs/phrases
Tokenize
Sequences



AArch64 Assembly

Works with: as version Raspberry Pi 3B version Buster 64 bits
or android 64 bits with application Termux
/* ARM assembly AARCH64 Raspberry PI 3B */
/*  program complength64.s   */ 

/************************************/
/* Constantes                       */
/************************************/
/* for this file see task include a file in language AArch64 assembly */
.include "../includeConstantesARM64.inc" 

/************************************/
/* structures                       */
/************************************/
   .struct  0
list_string:                             // string address
    .struct  list_string + 8 
list_length:                             // string length
    .struct  list_length + 8 
list_end:
/*********************************/
/* Initialized data              */
/*********************************/
.data
szMessResult:       .asciz "@ length : @\n"
szCarriageReturn:   .asciz "\n"
szLibSort:          .asciz "\nAfter sort\n"
szString1:          .asciz "abcd"
szString2:          .asciz "123456789"
szString3:          .asciz "abcdef"
szString4:          .asciz "1234567"

.align 4
tabStrings:        .quad szString1           // string address array
                   .quad 0
                   .quad szString2
                   .quad 0
                   .quad szString3
                   .quad 0  
                   .quad szString4
                   .quad 0
.equ NBTABSTRINGS, (. - tabStrings) / list_end  // compute items number
/*********************************/
/* UnInitialized data            */
/*********************************/
.bss
sZoneConv:        .skip 24
/*********************************/
/*  code section                 */
/*********************************/
.text
.global main 
main:                                 // entry of program 
    ldr x4,qAdrtabStrings             // string array address
    mov x5,#0                         // indice
    mov x6,#list_end                  // structure size
1:                                    // item loop
    madd x3,x5,x6,x4                   // compute item address 
    ldr x0,[x3,#list_string]          // load string address
    bl stringRoutine                  // length string compute
    str x0,[x3,#list_length]          // store result in array
    add x5,x5,#1                         // increment indice
    cmp x5,#NBTABSTRINGS              // end ?
    blt 1b                            // no -> loop
    
    mov x0,x4                         // string array address
    mov x1,#0                         // first item
    mov x2,#NBTABSTRINGS              // item number
    bl insertionSort                  // sort
    
    ldr x0,qAdrszLibSort
    bl affichageMess
    mov x0,x4                         // string array address
    mov x5,#0                         // indice
    mov x6,#list_end
2:                                    // item loop
    madd x3,x5,x6,x4
    ldr x0,[x3,#list_string]
    bl stringRoutine                  // use same routine for display result after sort
    add x5,x5,#1
    cmp x5,#NBTABSTRINGS              // end ?
    blt 2b                            // no -> loop

100:                                  // standard end of the program 
    mov x0, #0                        // return code
    mov x8,EXIT 
    svc #0                            // perform the system call
 
qAdrszCarriageReturn:     .quad szCarriageReturn
qAdrszMessResult:         .quad szMessResult
qAdrsZoneConv:            .quad sZoneConv
qAdrtabStrings:           .quad tabStrings
qAdrszLibSort:            .quad szLibSort
/***************************************************/
/*      string exec               */
/***************************************************/
// x0 contains string address
// x0 return length
stringRoutine:
    stp x1,lr,[sp,-16]!         // save  registers 
    stp x2,x3,[sp,-16]!         // save  registers 
    mov x3,x0                   // save string address          
    mov x1,x0
    ldr x0,qAdrszMessResult
    bl strInsertAtCharInc       // insert string in result message
    mov x2,x0                   // save new message address
    mov x0,x3                   // restaur string address
    bl stringlength             // compute length
    mov x3,x0
    ldr x1,qAdrsZoneConv
    bl conversion10             // call decimal conversion
    mov x0,x2
    ldr x1,qAdrsZoneConv        // insert conversion in message
    bl strInsertAtCharInc
    bl affichageMess            // display result message
    mov x0,x3
100:
    ldp x2,x3,[sp],16           // restaur  registers 
    ldp x1,lr,[sp],16           // restaur  registers
    ret 
/***************************************************/
/*     compute string length               */
/***************************************************/
// x0 contains string address
stringlength:
    stp x1,lr,[sp,-16]!         // save  registers 
    stp x2,x3,[sp,-16]!         // save  registers 
    mov x1,#-1                  // init counter
1:                              // loop 
    add x1,x1,#1                   // increment counter
    ldrb w2,[x0,x1]             // load byte string
    cmp w2,#0                   // zero final ?
    bne 1b                      // no -> loop
    mov x0,x1                   // return length
100:
    ldp x2,x3,[sp],16           // restaur  registers 
    ldp x1,lr,[sp],16           // restaur  registers
    ret 

/******************************************************************/
/*         insertion sort                                              */ 
/******************************************************************/
/* x0 contains the address of table */
/* x1 contains the first element    */
/* x2 contains the number of element */
insertionSort:
    stp x1,lr,[sp,-16]!                // save  registers 
    stp x2,x3,[sp,-16]!                // save  registers 
    stp x4,x5,[sp,-16]!                // save  registers
    stp x6,x7,[sp,-16]!                // save  registers
    stp x8,x9,[sp,-16]!                // save  registers
    stp x10,x11,[sp,-16]!              // save  registers
    mov x6,x0
    mov x7,#list_end
    add x3,x1,#1                       // start index i
1:                                     // start loop
    madd x8,x7,x3,x6
    ldr x10,[x8,#list_length]          // load value A[i]
    ldr x0,[x8,#list_string]           // load string address A[i]
    sub x5,x3,#1                       // index j
2:
    madd x9,x7,x5,x6
    ldr x4,[x9,#list_length]           // load value A[j]
    cmp x4,x10                         // compare value
    bge 3f
    add x5,x5,#1                          // increment index j
    madd x8,x7,x5,x6
    str x4,[x8,#list_length]           // store value A[j+1]
    ldr x4,[x9,#list_string]           // load string address 
    str x4,[x8,#list_string]           // store string address
    subs x5,x5,#2                         // j = i - 1
    cmp x5,x1                          // compare with first item
    bge 2b                             // loop if j >= first item
3:
    add x5,x5,#1                          // increment index j
    madd x9,x7,x5,x6
    str x10,[x9,#list_length]          // store value A[i] in A[j+1]
    str x0,[x9,#list_string]           // and store string address
    add x3,x3,#1                          // increment index i
    cmp x3,x2                          // end ?
    blt 1b                             // no -> loop

100:
    ldp x10,x11,[sp],16                // restaur  registers
    ldp x8,x9,[sp],16                  // restaur  registers
    ldp x6,x7,[sp],16                  // restaur  registers
    ldp x4,x5,[sp],16                  // restaur  registers
    ldp x2,x3,[sp],16                  // restaur  registers 
    ldp x1,lr,[sp],16                  // restaur  registers
    ret 

/***************************************************/
/*      ROUTINES INCLUDE                           */
/***************************************************/
/* for this file see task include a file in language AArch64 assembly */
.include "../includeARM64.inc"
abcd length : 4
123456789 length : 9
abcdef length : 6
1234567 length : 7

After sort
123456789 length : 9
1234567 length : 7
abcdef length : 6
abcd length : 4

Ada

with ada.command_line, ada.containers.indefinite_vectors, ada.text_io;
procedure compare_lengths is
   package string_vector is new ada.containers.indefinite_vectors
     (index_type => Positive, element_type => String);

   function "<" (left, right : String) return Boolean is
   begin
      return left'length > right'length;
   end "<";

   package string_vector_sorting is new string_vector.generic_sorting;
   list : string_vector.Vector;
begin
   for i in 1 .. ada.command_line.argument_count loop
      list.append (ada.command_line.argument (i));
   end loop;
   string_vector_sorting.sort (list);
   for elem of list loop
      ada.text_io.put_line (elem'length'image & ": " & elem);
   end loop;
end compare_lengths;
Output:

./compare_lengths Like sands through the hourglass these are the days of our lives

 9: hourglass
 7: through
 5: lives
 5: sands
 5: these
 4: days
 4: Like
 3: are
 3: our
 3: the
 3: the
 2: of

ALGOL 68

Algol 68 does not have an in-built "LENGTH" operator, it does have operators LWB and UPB which return the lower bound and upper bound of an array and as strings are arrays of characters, LENGTH can easily be constructed from these.
In most Algol 68 implementations such as Algol 68G and Rutgers Algol 68, the CHAR type is an 8-bit byte.

BEGIN # compare string lengths #
    # returns the length of s using the builtin UPB and LWB operators #
    OP LENGTH = ( STRING s )INT: ( UPB s + 1 ) - LWB s;
    # prints s and its length #
    PROC print string = ( STRING s )VOID:
         print( ( """", s, """ has length: ", whole( LENGTH s, 0 ), " bytes.", newline ) );
    STRING shorter     = "short";
    STRING not shorter = "longer";
    IF LENGTH shorter >  LENGTH not shorter THEN print string( shorter ) FI;
    print string( not shorter );
    IF LENGTH shorter <= LENGTH not shorter THEN print string( shorter ) FI
END
Output:
"longer" has length: 6 bytes.
"short" has length: 5 bytes.

APL

For a good intro to APL, see APL2 At A Glance

      sv  'defg' 'hijklm' 'abc' 'abcd'
      (¨sv[sv]),[0.5]sv[sv]
 6  hijklm 
 4  defg   
 4  abcd   
 3  abc

ARM Assembly

Works with: as version Raspberry Pi
or android 32 bits with application Termux
/* ARM assembly Raspberry PI  or android 32 bits */
/*  program complength.s   */ 

/* REMARK 1 : this program use routines in a include file 
   see task Include a file language arm assembly 
   for the routine affichageMess conversion10 
   see at end of this program the instruction include */

/* for constantes see task include a file in arm assembly */
/************************************/
/* Constantes                       */
/************************************/
.include "../constantes.inc"
/************************************/
/* structures                       */
/************************************/
   .struct  0
list_string:                             @ string address
    .struct  list_string + 4 
list_length:                             @ string length
    .struct  list_length + 4 
list_end:
/*********************************/
/* Initialized data              */
/*********************************/
.data
szMessResult:       .asciz "@ length : @\n"
szCarriageReturn:   .asciz "\n"
szLibSort:          .asciz "\nAfter sort\n"
szString1:          .asciz "abcd"
szString2:          .asciz "123456789"
szString3:          .asciz "abcdef"
szString4:          .asciz "1234567"

.align 4
tabStrings:        .int szString1           @ string address array
                   .int 0
                   .int szString2
                   .int 0
                   .int szString3
                   .int 0  
                   .int szString4
                   .int 0
.equ NBTABSTRINGS, (. - tabStrings) / list_end  @ compute items number
/*********************************/
/* UnInitialized data            */
/*********************************/
.bss
sZoneConv:        .skip 24
/*********************************/
/*  code section                 */
/*********************************/
.text
.global main 
main:                                 @ entry of program 
    ldr r4,iAdrtabStrings             @ string array address
    mov r5,#0                         @ indice
    mov r6,#list_end                  @ structure size
1:                                    @ item loop
    mla r3,r5,r6,r4                   @ compute item address 
    ldr r0,[r3,#list_string]          @ load string address
    bl stringRoutine                  @ length string compute
    str r0,[r3,#list_length]          @ store result in array
    add r5,#1                         @ increment indice
    cmp r5,#NBTABSTRINGS              @ end ?
    blt 1b                            @ no -> loop
    
    mov r0,r4                         @ string array address
    mov r1,#0                         @ first item
    mov r2,#NBTABSTRINGS              @ item number
    bl insertionSort                  @ sort
    
    ldr r0,iAdrszLibSort
    bl affichageMess
    mov r0,r4                         @ string array address
    mov r5,#0                         @ indice
    mov r6,#list_end
2:                                    @ item loop
    mla r3,r5,r6,r4
    ldr r0,[r3,#list_string]
    bl stringRoutine                  @ use same routine for display result after sort
    add r5,#1
    cmp r5,#NBTABSTRINGS              @ end ?
    blt 2b                            @ no -> loop

100:                                  @ standard end of the program 
    mov r0, #0                        @ return code
    mov r7, #EXIT                     @ request to exit program
    svc #0                            @ perform the system call
 
iAdrszCarriageReturn:     .int szCarriageReturn
iAdrszMessResult:         .int szMessResult
iAdrsZoneConv:            .int sZoneConv
iAdrtabStrings:           .int tabStrings
iAdrszLibSort:            .int szLibSort
/***************************************************/
/*      string exec               */
/***************************************************/
// r0 contains string address
// r0 return length
stringRoutine:
    push {r1-r3,lr}             @ save  registers 
    mov r3,r0                   @ save string address          
    mov r1,r0
    ldr r0,iAdrszMessResult
    bl strInsertAtCharInc       @ insert string in result message
    mov r2,r0                   @ save new message address
    mov r0,r3                   @ restaur string address
    bl stringlength             @ compute length
    mov r3,r0
    ldr r1,iAdrsZoneConv
    bl conversion10             @ call decimal conversion
    mov r0,r2
    ldr r1,iAdrsZoneConv        @ insert conversion in message
    bl strInsertAtCharInc
    bl affichageMess            @ display result message
    mov r0,r3
100:
    pop {r1-r3,pc}              @ restaur registers
/***************************************************/
/*     compute string length               */
/***************************************************/
// r0 contains string address
stringlength:
    push {r1-r2,lr}             @ save  registers 
    mov r1,#-1                  @ init counter
1:                              @ loop 
    add r1,#1                   @ increment counter
    ldrb r2,[r0,r1]             @ load byte string
    cmp r2,#0                   @ zero final ?
    bne 1b                      @ no -> loop
    mov r0,r1                   @ return length
100:
    pop {r1-r2,pc}              @ restaur registers
/******************************************************************/
/*         insertion sort                                              */ 
/******************************************************************/
/* r0 contains the address of table */
/* r1 contains the first element    */
/* r2 contains the number of element */
insertionSort:
    push {r1-r10,lr}                    @ save registers
    mov r6,r0
    mov r7,#list_end
    add r3,r1,#1                       @ start index i
1:                                     @ start loop
    mla r8,r7,r3,r6
    ldr r10,[r8,#list_length]          @ load value A[i]
    ldr r0,[r8,#list_string]           @ load string address A[i]
    sub r5,r3,#1                       @ index j
2:
    mla r9,r7,r5,r6
    ldr r4,[r9,#list_length]           @ load value A[j]
    cmp r4,r10                         @ compare value
    bge 3f
    add r5,#1                          @ increment index j
    mla r8,r7,r5,r6
    str r4,[r8,#list_length]           @ store value A[j+1]
    ldr r4,[r9,#list_string]           @ load string address 
    str r4,[r8,#list_string]           @ store string address
    subs r5,#2                         @ j = i - 1
    cmp r5,r1                          @ compare with first item
    bge 2b                             @ loop if j >= first item
3:
    add r5,#1                          @ increment index j
    mla r9,r7,r5,r6
    str r10,[r9,#list_length]          @ store value A[i] in A[j+1]
    str r0,[r9,#list_string]           @ and store string address
    add r3,#1                          @ increment index i
    cmp r3,r2                          @ end ?
    blt 1b                             @ no -> loop

100:
    pop {r1-r10,lr}
    bx lr

/***************************************************/
/*      ROUTINES INCLUDE                           */
/***************************************************/
.include "../affichage.inc"
abcd length : 4
123456789 length : 9
abcdef length : 6
1234567 length : 7

After sort
123456789 length : 9
1234567 length : 7
abcdef length : 6
abcd length : 4

Arturo

sortByLength: function [strs][
    map sort.descending.by:'v 
        map strs 'str -> #[s: str, v: size str] 
        'z -> z\s
]

A: "I am string"
B: "I am string too"

sA: size A
sB: size B

if? sA < sB ->
    print ["string ->" A "(" sA ") is smaller than string ->" B "(" sB ")"]
else [
    if? sA > sB ->
        print ["string ->" A "(" sA ") is larger than string ->" B "(" sB ")"]
    else ->
        print ["string ->" A "(" sA ") and string ->" B "(" sB ") are of equal length"]
]

print ["sorted strings (by length):" sortByLength ["abcd" "123456789" "abcdef" "1234567"]]
Output:
string -> I am string ( 11 ) is smaller than string -> I am string too ( 15 ) 
sorted strings (by length): [123456789 1234567 abcdef abcd]

Asymptote

string A, B, t = '\t';

void comp(string A, string B) {
    if (length(A) >= length(B)) {
        write(A+t, length(A));
        write(B+t, length(B));
    } else {
        write(B+t, length(B));
        write(A+t, length(A));
    }
}

comp("abcd", "123456789");
Output:
123456789	9
abcd	4

AutoHotkey

list := ["abcd","123456789","abcdef","1234567"]

sorted := []
for i, s in list
    sorted[0-StrLen(s), s] := s
for l, obj in sorted
{
    i := A_Index
    for s, v in obj
    {
        if (i = 1)
            result .= """" s """ has length " 0-l " and is the longest string.`n"
        else if (i < sorted.Count())
            result .= """"s """ has length " 0-l " and is neither the longest nor the shortest string.`n"
        else
            result .= """"s """ has length " 0-l " and is the shorted string.`n"
    }
}
MsgBox % result
Output:
"123456789" has length 9 and is the longest string.
"1234567" has length 7 and is neither the longest nor the shortest string.
"abcdef" has length 6 and is neither the longest nor the shortest string.
"abcd" has length 4 and is the shorted string.

AWK

# syntax: GAWK -f COMPARE_LENGTH_OF_TWO_STRINGS.AWK
BEGIN {
    main("abcd","123456789")
    main("longer","short")
    main("hello","world")
    exit(0)
}
function main(Sa,Sb,  La,Lb) {
    La = length(Sa)
    Lb = length(Sb)
    if (La > Lb) {
      printf("a>b\n%3d %s\n%3d %s\n\n",La,Sa,Lb,Sb)
    }
    else if (La < Lb) {
      printf("a<b\n%3d %s\n%3d %s\n\n",Lb,Sb,La,Sa)
    }
    else {
      printf("a=b\n%3d %s\n%3d %s\n\n",Lb,Sb,La,Sa)
    }
}
Output:
a<b
  9 123456789
  4 abcd

a>b
  6 longer
  5 short

a=b
  5 world
  5 hello

BASIC

Applesoft BASIC

Printing CHR$(14) does nothing by default in Applesoft BASIC. Commodore BASIC appends spaces to numbers, but otherwise the Compare_length_of_two_strings#Commodore_BASIC code works the same in Applesoft BASIC.

Output:
*** (1) TWO STRINGS ***
LONGER STRING (13)
SHORT STRING (12)


*** (2) MORE THAN 2 STRINGS***
SHE DOESN'T STUDY GERMAN ON MONDAY (34)
EVERY CHILD LIKES AN ICE CREAM (30)
THE COURSE STARTS NEXT SUNDAY (29)
DOES SHE LIVE IN PARIS? (23)
SHE SWIMS EVERY MORNING (23)
THE EARTH IS SPHERICAL (22)
WE SEE THEM EVERY WEEK (22)
HE DOESN'T TEACH MATH (21)
CATS HATE WATER (15)
I LIKE TEA (10)

Commodore BASIC

Works with: Applesoft BASIC
Works with: Commodore BASIC version 2.0
Works with: Commodore BASIC version 3.5
0 REM ROSETTACODE.ORG
1 REM COMPARE LENGTH OF TWO STRINGS
2 REM GIVEN TWO STRINGS OF DIFFERENT 
3 REM LENGTH, DETERMINE WHICH STRING IS
4 REM LONGER OR SHORTER. 
5 REM PRINT BOTH STRINGS AND THEIR 
6 REM LENGTH, ONE ON EACH LINE. PRINT 
7 REM THE LONGER ONE FIRST.
8 REM  
9 REM ********************************
10 REM
20 REM PRINT CHR$(14): REM CHANGE TO LOWER/UPPER CASE CHAR SET
30 GOSUB 200: REM 1 - COMPARE LENGTH OF 2 STRINGS
40 GOSUB 300: REM 2- MORE THAN 2 STRINGS
50 END
200 PRINT"*** (1) TWO STRINGS ***"
210 A$ = "SHORT STRING"
220 B$ = "LONGER STRING"
230 A = LEN(A$)
240 B = LEN(B$)
250 IF A>B THEN PRINT A$;" (";A;")": PRINT B$;" (";B;")"
260 IF A<=B THEN PRINT B$;" (";B;")": PRINT A$;" (";A;")"
270 PRINT: PRINT
280 RETURN
300 PRINT"*** (2) MORE THAN 2 STRINGS***"
310 DIM C$(100)
320 N = 0
330 READ A$
340   IF A$ = "$$$" THEN 400
350   N = N+1
360   C$(N) = A$ 
370   IF N = 100 THEN 400
380   GOTO 330
390 REM SORT THE STRINGS
400 FOR J=1 TO N-1  
410   FOR I=1 TO N-J
420     IF LEN(C$(I)) < LEN(C$(I+1)) THEN A$=C$(I): C$(I)=C$(I+1): C$(I+1)=A$
430   NEXT
440 NEXT
450 REM PRINT OUT THE STRINGS
460 FOR I=1 TO N
470   PRINT C$(I);" (";LEN(C$(I));")"
480 NEXT
490 PRINT: PRINT
500 RETURN
1000 DATA "DOES SHE LIVE IN PARIS?"
1010 DATA "HE DOESN'T TEACH MATH"
1020 DATA "CATS HATE WATER"
1030 DATA "SHE DOESN'T STUDY GERMAN ON MONDAY"
1040 DATA "EVERY CHILD LIKES AN ICE CREAM"
1050 DATA "THE EARTH IS SPHERICAL"
1060 DATA "THE COURSE STARTS NEXT SUNDAY"
1070 DATA "SHE SWIMS EVERY MORNING"
1080 DATA "I LIKE TEA"
1090 DATA "WE SEE THEM EVERY WEEK"
1100 DATA "$$$"
Output:
*** (1) TWO STRINGS ***
LONGER STRING ( 13 )
SHORT STRING ( 12 )


*** (2) MORE THAN 2 STRINGS***
SHE DOESN'T STUDY GERMAN ON MONDAY ( 34
)
EVERY CHILD LIKES AN ICE CREAM ( 30 )
THE COURSE STARTS NEXT SUNDAY ( 29 )
DOES SHE LIVE IN PARIS? ( 23 )
SHE SWIMS EVERY MORNING ( 23 )
THE EARTH IS SPHERICAL ( 22 )
WE SEE THEM EVERY WEEK ( 22 )
HE DOESN'T TEACH MATH ( 21 )
CATS HATE WATER ( 15 )
I LIKE TEA ( 10 )

BASIC256

subroutine comp(A$, B$)
    if length(A$) >= length(B$) then 
        print A$, length(A$)
        print B$, length(B$)
    else
        print B$, length(B$)
        print A$, length(A$)
    end if
end subroutine

call comp("abcd", "123456789")

Chipmunk Basic

Works with: Chipmunk Basic version 3.6.4

The True BASIC solution works without any changes.

Gambas

Public Sub Main() 
  
  Compare("abcd", "123456789")
  
End

Sub Compare(A As String, B As String) 

  If Len(A) >= Len(B) Then  
    Print A, Len(A) 
    Print B, Len(B) 
  Else 
    Print B, Len(B) 
    Print A, Len(A) 
  End If 

End Sub

GW-BASIC

Works with: BASICA
Works with: QBasic version 1.1
Works with: QuickBasic version 4.5
Works with: True BASIC
10 'SAVE "SSTRING",A
20 ' Length of a group of strings
30 OPTION BASE 1
40 DIM SSTRING$(10)
50 I=0: J=1
60 ' Begin of program cycle
70 CLS
80 PRINT "This program shows the length of up to 10 captured strings."
90 PRINT "Enter an empty string to finish anytime."
100 PRINT
110 ' Do
120   PRINT "Capture the string";STR$(J);": ";
130   INPUT "", SSTRING$(J)
140   IF SSTRING$(J)="" THEN 180  ' Exit Do
150   IF J>1 THEN GOSUB 280 ' Autosort
160   J = J + 1
170 IF J < 11 THEN 110 ' Loop
180 ' Show results
190 CLS
200 J = J - 1
210 IF J<1 THEN PRINT "You entered no strings.": GOTO 260
220 PRINT "You entered";J;"strings. Lengths are as follows:"
230 FOR I=1 TO J
240   PRINT USING "##. &: ## chars."; I;SSTRING$(I);LEN(SSTRING$(I))
250 NEXT I
260 PRINT: PRINT "End of program execution."
270 END
280 ' Autosort subroutine
290   I=J
300   WHILE I>1
310     IF LEN(SSTRING$(I)) > LEN(SSTRING$(I-1)) THEN SWAP SSTRING$(I), SSTRING$(I-1)
320     I=I-1
330   WEND
340 RETURN
Output:

The user enters a list of up to 10 strings

This program shows the length of up to 10 captured strings.
Enter an empty string to finish anytime.

Capture the string 1: abcd
Capture the string 2: 123456789
Capture the string 3: abcdef
Capture the string 4: 1234567
Capture the string 5: 

You entered 4 strings. Lengths are as follows:
 1. 123456789:  9 chars.
 2. 1234567:  7 chars.
 3. abcdef:  6 chars.
 4. abcd:  4 chars.

End of program execution.

MSX Basic

Works with: MSX BASIC version any
Works with: Applesoft BASIC
Works with: BASICA
Works with: Chipmunk Basic
Works with: Just BASIC
Works with: PC-BASIC version any
Works with: QBasic
Works with: True BASIC
Translation of: True BASIC
100 LET A$ = "abcd"
110 LET B$ = "123456789"
120 GOSUB 140
130 END
140 REM SUB comp(A$, B$)
150   IF LEN(A$) >= LEN(B$) THEN PRINT A$,LEN(A$) : PRINT B$,LEN(B$)
180   IF LEN(A$) < LEN(B$) THEN PRINT B$,LEN(B$) : PRINT A$,LEN(A$)
220 RETURN

PureBasic

Procedure comp(A.s, B.s)
  If Len(A) >= Len(B)
    PrintN(A + #TAB$ + Str(Len(A)))
    PrintN(B + #TAB$ + Str(Len(B)))
  Else
    PrintN(B + #TAB$ + Str(Len(B)))
    PrintN(A + #TAB$ + Str(Len(A)))
  EndIf
EndProcedure

OpenConsole()
comp("abcd", "123456789")
Input()
CloseConsole()

QBasic

Works with: QBasic version 1.1
Works with: QuickBasic version 4.5
Works with: Chipmunk Basic
Works with: True BASIC
SUB comp(A$, B$)
    IF LEN(A$) >= LEN(B$) THEN
       PRINT A$, LEN(A$)
       PRINT B$, LEN(B$)
    ELSE
       PRINT B$, LEN(B$)
       PRINT A$, LEN(A$)
    END IF
END SUB

CALL comp("abcd", "123456789")
END

Run BASIC

sub comp A$, B$
    if len(A$) >= len(B$) then 
        print A$; chr$(9); len(A$)
        print B$; chr$(9); len(B$)
    else
        print B$; chr$(9); len(B$)
        print A$; chr$(9); len(A$)
    end if
end sub

call comp "abcd", "123456789"

SmallBASIC

func compfun(x, y)
    if(len(x) == len(y))
        return 0
    elseif(len(x) > len(y))
        return -1
    else
        return 1
    endif
end

list = ["abcd","123456789","abcdef","1234567"]

sort list use compfun(x, y)

for s in list
    print s, len(s)
next


True BASIC

Works with: QBasic
Works with: Chipmunk Basic
SUB comp(A$, B$)
    IF LEN(A$) >= LEN(B$) THEN
       PRINT A$, LEN(A$)
       PRINT B$, LEN(B$)
    ELSE
       PRINT B$, LEN(B$)
       PRINT A$, LEN(A$)
    END IF
END SUB

CALL comp("abcd", "123456789")
END
Output:
Igual que la entrada de FreeBASIC.

XBasic

Works with: Windows XBasic
PROGRAM	"Compare length of two strings"
VERSION	"0.0000"

DECLARE FUNCTION  Entry ()
DECLARE FUNCTION  comp (A$, B$)


FUNCTION  Entry ()
    comp("abcd", "123456789")
END FUNCTION

FUNCTION comp (A$, B$)
    IF LEN(A$) >= LEN(B$) THEN
       PRINT A$, LEN(A$)
       PRINT B$, LEN(B$)
    ELSE
       PRINT B$, LEN(B$)
       PRINT A$, LEN(A$)
    END IF
END FUNCTION
END PROGRAM

Yabasic

sub comp(A$, B$)
    if len(A$) >= len(B$) then 
        print A$, chr$(9), len(A$)
        print B$, chr$(9), len(B$)
    else
        print B$, chr$(9), len(B$)
        print A$, chr$(9), len(A$)
    end if
end sub

comp("abcd", "123456789")

FreeBASIC

sub comp( A as string, B as string )
    if len(A)>=len(B) then 
        print A, len(A)
        print B, len(B)
    else
        print B, len(B)
        print A, len(A)
    end if
end sub

comp( "abcd", "123456789" )
Output:
123456789      9
abcd           4

BQN

BQN's grade functions(similar to APL) produces the indices to sort an array. We grade the lengths, then use those to arrange the strings correctly.

Compare  >·(⍒⊑¨)⊏≠¨

•Show Compare "hello", "person"
•Show Compare "abcd", "123456789", "abcdef", "1234567"
┌─            
╵ 6 "person"  
  5 "hello"   
             ┘
┌─               
╵ 9 "123456789"  
  7 "1234567"    
  6 "abcdef"     
  4 "abcd"       
                ┘

C

Works with: C11
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int cmp(const int* a, const int* b)
{
    return *b - *a; // reverse sort!
}

void compareAndReportStringsLength(const char* strings[], const int n)
{
    if (n > 0)
    {
        char* has_length = "has length";
        char* predicate_max = "and is the longest string";
        char* predicate_min = "and is the shortest string";
        char* predicate_ave = "and is neither the longest nor the shortest string";

        int* si = malloc(2 * n * sizeof(int));
        if (si != NULL)
        {
            for (int i = 0; i < n; i++)
            {
                si[2 * i] = strlen(strings[i]);
                si[2 * i + 1] = i;
            }
            qsort(si, n, 2 * sizeof(int), cmp);

            int max = si[0];
            int min = si[2 * (n - 1)];

            for (int i = 0; i < n; i++)
            {
                int length = si[2 * i];
                char* string = strings[si[2 * i + 1]];
                char* predicate;
                if (length == max)
                    predicate = predicate_max;
                else if (length == min)
                    predicate = predicate_min;
                else
                    predicate = predicate_ave;
                printf("\"%s\" %s %d %s\n",
                    string, has_length, length, predicate);
            }

            free(si);
        }
        else
        {
            fputs("unable allocate memory buffer", stderr);
        }
    }
}

int main(int argc, char* argv[])
{
    char* list[] = { "abcd", "123456789", "abcdef", "1234567" };

    compareAndReportStringsLength(list, 4);

    return EXIT_SUCCESS;
}
Output:
"123456789" has length 9 and is the longest string
"1234567" has length 7 and is neither the longest nor the shortest string
"abcdef" has length 6 and is neither the longest nor the shortest string
"abcd" has length 4 and is the shortest string

C++

#include <iostream>
#include <algorithm>
#include <string>
#include <list>

using namespace std;

bool cmp(const string& a, const string& b)
{
    return b.length() < a.length(); // reverse sort!
}

void compareAndReportStringsLength(list<string> listOfStrings)
{
    if (!listOfStrings.empty())
    {
        char Q = '"';
        string has_length(" has length ");
        string predicate_max(" and is the longest string");
        string predicate_min(" and is the shortest string");
        string predicate_ave(" and is neither the longest nor the shortest string");

        list<string> ls(listOfStrings); // clone to avoid side-effects
        ls.sort(cmp);
        int max = ls.front().length();
        int min = ls.back().length();

        for (list<string>::iterator s = ls.begin(); s != ls.end(); s++)
        {
            int length = s->length();
            string* predicate;
            if (length == max)
                predicate = &predicate_max;
            else if (length == min)
                predicate = &predicate_min;
            else
                predicate = &predicate_ave;

            cout << Q << *s << Q << has_length << length << *predicate << endl;
        }
    }
}

int main(int argc, char* argv[])
{
    list<string> listOfStrings{ "abcd", "123456789", "abcdef", "1234567" };
    compareAndReportStringsLength(listOfStrings);

    return EXIT_SUCCESS;
}
Output:
"123456789" has length 9 and is the longest string
"1234567" has length 7 and is neither the longest nor the shortest string
"abcdef" has length 6 and is neither the longest nor the shortest string
"abcd" has length 4 and is the shortest string

C#

Works with: C# version 10+
void WriteSorted(string[] strings)
{
	var sorted = strings.OrderByDescending(x => x.Length);
	foreach(var s in sorted) Console.WriteLine($"{s.Length}: {s}");
}
WriteSorted(new string[] { "abcd", "123456789", "abcdef", "1234567" });
Output:
9: 123456789
7: 1234567
6: abcdef
4: abcd

CFEngine

bundle agent __main__
{
  vars:
      "strings" slist => { "abcd", "123456789", "abcdef", "1234567" };

      "sorted[$(with)]"
        string => "$(strings)",
        with => string_length( "$(strings)" );

      "sort_idx" slist => reverse( sort( getindices( "sorted" ), lex ) );

  reports:
      "'$(sorted[$(sort_idx)])' is $(sort_idx) characters in length.";
}
Output:
R: '123456789' is 9 characters in length.
R: '1234567' is 7 characters in length.
R: 'abcdef' is 6 characters in length.
R: 'abcd' is 4 characters in length.

Common Lisp

(defun sort-and-print-strings (strings)
  (dolist (s (sort (copy-list strings) #'> :key #'length))
    (format t "~A ~A~%" (length s) s)))

(sort-and-print-strings '("Lisp" "stands" "for" "List" "Processing"))
Output:
10 Processing
6 stands
4 Lisp
4 List
3 for

Delphi

Works with: Delphi version 6.0

Uses the Standard Delphi component TList compile the list of pointers to the strings and then sort them using a custom sort comparison.

var SA1: array [0..1] of string = ('Very Long String','short string');
var SA2: array [0..11] of string = ('Like','sands','through','the','hourglass',
				   'these','are','the','days','of','our','lives');

function Compare(P1,P2: pointer): integer;
{Compare for quick sort}
begin
Result:=Length(PString(P2)^)-Length(PString(P1)^);
end;


procedure ShowStringLengths(SA: array of string; Memo: TMemo);
{Sort strings by length and display string and length}
var List: TList;
var I: integer;
var S: string;
begin
List:=TList.Create;
try
for I:=0 to High(SA) do
 List.Add(@SA[I]);
List.Sort(Compare);
for I:=0 to List.Count-1 do
	begin
	S:=PString(List[I])^;
	Memo.Lines.Add(IntToStr(Length(S))+': '+S);
	end;
finally List.Free; end;
end;


procedure SortedStringLists(Memo: TMemo);
{Test two different string arrays}
begin
Memo.Lines.Add('Two word test: ');
Memo.Lines.Add('');
ShowStringLengths(SA1,Memo);
Memo.Lines.Add('');
Memo.Lines.Add('Twelve word test: ');
Memo.Lines.Add('');
ShowStringLengths(SA2,Memo);
end;
Output:
Two word test: 

16: Very Long String
12: short string

Twelve word test: 

9: hourglass
7: through
5: lives
5: these
5: sands
4: days
4: Like
3: our
3: are
3: the
3: the
2: of


EasyLang

proc scmp a$ b$ . .
   if len a$ < len b$
      swap a$ b$
   .
   print a$ & " - " & len a$
   print b$ & " - " & len b$
   print ""
.
scmp "Easy" "Language"
scmp "Rosetta" "Code"

Emacs Lisp

(defun sort-list-by-string-length (list-of-strings)
  "Order LIST-OF-STRINGS from longest to shortest."
    (sort list-of-strings 'longer-string))  ; sort by "longer-string" function below

(defun longer-string (string-1 string-2)
  "Test if STRING-1 is longer than STRING-2."
  (> (length string-1) (length string-2)))  ; is STRING-1 longer than STRING-2?
Output:

(sort-list-by-string-length '("abcd" "123456789" "abcdef" "1234567"))

("123456789" "1234567" "abcdef" "abcd")

EMal

List list = text["abcd","123456789","abcdef","1234567", "Привет, мир"]
^|this solves the task doing the comparison by using the diamond operator|^
fun comparator = int by text a, text b do return b.length <> a.length end
List sorted = list.sort(comparator)
writeLine("text".padEnd(15, " ") + "units".padStart(6, " ") + "bytes".padStart(6, " "))
for each text value in sorted
  writeLine(value.padEnd(15, " ") + 
    (text!value.length).padStart(6, " ") + 
	^|conversion from text to blob uses utf8 encoding|^
    (text!(blob!value).length).padStart(6, " "))
end
Output:
text            units bytes
Привет, мир        11    20
123456789           9     9
1234567             7     7
abcdef              6     6
abcd                4     4

Factor

Works with: Factor version 0.99 2022-04-03
USING: formatting io kernel qw sequences sorting ;

: .length ( str -- ) dup length "%u has length %d\n" printf ;

"I am a string" "I am a string too"
[ longer .length ] [ shorter .length ] 2bi nl

qw{ abcd 123456789 abcdef 1234567 } dup [ length ] inv-sort-with
"%u sorted by descending length:\n%u\n" printf
Output:
"I am a string too" has length 17
"I am a string" has length 13

{ "abcd" "123456789" "abcdef" "1234567" } sorted by descending length:
{ "123456789" "1234567" "abcdef" "abcd" }

Forth

Works with: gforth version 0.7.3

Traditionally, Forth strings are "counted strings" (as opposed to null-terminated strings like C). So, there is no need to search the length, we just need to swap strings if necessary before printing.

: say dup . ." : " type ;
: comp-strings
  2 pick over
  > if 2swap then
  cr say cr say cr
;
Output:
s" shortest string" s" longest string" comp-strings

15 : shortest string 14 : longest string

ok

s" longest string" s" shortest string" comp-strings 15 : shortest string 14 : longest string

ok

Fortran

Normally would use an external library for sorting, but to remain self-contained, created (a very inefficient) sort_int() procedure.

program demo_sort_indexed
implicit none

   call print_sorted_by_length( [character(len=20) :: "shorter","longer"] )
   call print_sorted_by_length( [character(len=20) :: "abcd","123456789","abcdef","1234567"] )
   call print_sorted_by_length( [character(len=20) :: 'the','quick','brown','fox','jumps','over','the','lazy','dog'])

contains

subroutine print_sorted_by_length(list)
character(len=*) :: list(:)
integer :: i

   list(sort_int(len_trim(list)))=list ! sort by length from small to large
   write(*,'(i9,1x,a)')(len_trim(list(i)), list(i),i=size(list),1,-1)! print from last to first
   write(*,*)

end subroutine print_sorted_by_length

function sort_int(input) result(counts) ! **very** inefficient mini index sort 
integer :: input(:), counts(size(input)), i
   counts=[(count(input(i) > input)+count(input(i) == input(:i)),i=1, size(input) )]
end function sort_int

end program demo_sort_indexed
Output:
        7 shorter             
        6 longer              

        9 123456789           
        7 1234567             
        6 abcdef              
        4 abcd                

        5 jumps               
        5 brown               
        5 quick               
        4 lazy                
        4 over                
        3 dog                 
        3 the                 
        3 fox                 
        3 the                 

FutureBasic

local fn MyArraySortFunction( obj1 as CFTypeRef, obj2 as CFTypeRef, context as ptr ) as NSComparisonResult
  NSComparisonResult result = NSOrderedDescending
  if len(obj1) >= len(obj2) then result = NSOrderedAscending
end fn = result

void local fn DoIt
  CFStringRef string1 = @"abcd", string2 = @"abcdef", s

  if len(string1) >= len(string2)
    print string1,len(string1)
    print string2,len(string2)
  else
    print string2,len(string2)
    print string1,len(string1)
  end if

  print
  text ,,,,, 85

  CFArrayRef strings = @[@"abcd",@"123456789",@"abcdef",@"1234567"]
  strings = fn ArraySortedArrayUsingFunction( strings, @fn MyArraySortFunction, NULL )
  for s in strings
    print s,len(s)
  next
end fn

window 1

fn DoIt

HandleEvents

Output:

abcdef  6
abcd    4

123456789  9
1234567    7
abcdef     6
abcd       4

Go

Works with: Go version 1.8+
package main

import (
	"fmt"
	"os"
	"sort"
)

func main() {
	// If no command-line arguments are specified when running the program, use example data
	if len(os.Args) == 1 {
		compareStrings("abcd", "123456789", "abcdef", "1234567")
	} else {
		// First argument, os.Args[0], is program name. Command-line arguments start from 1
		strings := os.Args[1:]
		compareStrings(strings...)
	}
}

// Variadic function that takes any number of string arguments for comparison
func compareStrings(strings ...string) {
	// "strings" slice is sorted in place
	// sort.SliceStable keeps strings in their original order when elements are of equal length (unlike sort.Slice)
	sort.SliceStable(strings, func(i, j int) bool {
		return len(strings[i]) > len(strings[j])
	})

	for _, s := range strings {
		fmt.Printf("%d: %s\n", len(s), s)
	}
}

sort.SliceStable takes comparison function "less" as a second argument. As long as the function satisfies Interface type's Less method you can use it for comparison, see SliceStable

comparisonFunction := func(i, j int) bool {
	return len(strings[i]) > len(strings[j])
}

sort.SliceStable(strings, comparisonFunction)
Output:

.\main.exe

9: 123456789
7: 1234567
6: abcdef
4: abcd

.\main.exe The quick brown fox jumps over the lazy dog

5: quick
5: brown
5: jumps
4: over
4: lazy
3: The
3: fox
3: the
3: dog

Harbour

We can, easily, realize this task with Harbour, utilizing its strong array-handling set of functions.

 

PROCEDURE Main()
	LOCAL s1 := "The long string"
	LOCAL s2 := "The short string"
	LOCAL a  := { s1, s2 }
	LOCAL s3

	? s3 := "Here is how you can print the longer string first using Harbour language"
	?
	? "-------------------------------------------"
	PrintTheLongerFirst( a )
	
	a := hb_ATokens( s3, " " )
	? "-------------------------------------------"
	PrintTheLongerFirst( a )
	? "-------------------------------------------"	
	RETURN

FUNCTION PrintTheLongerFirst( a )
	LOCAL n, tmp
	a := ASort( a,,, {|x,y| Len(x) > Len(y) } )
	n:= Len( a[1] )
	AEval( a, { |e| tmp := n-Len(e), Qout( e,  Space(tmp) + ;
	            hb_strFormat( "(length = %d chars)", Len(e) ) ) } )
	RETURN NIL

Output:

Here is how you can print the longer string first using Harbour language
-------------------------------------------
The short string (length = 16 chars)
The long string  (length = 15 chars)
-------------------------------------------
language (length = 8 chars)
Harbour  (length = 7 chars)
longer   (length = 6 chars)
string   (length = 6 chars)
print    (length = 5 chars)
first    (length = 5 chars)
using    (length = 5 chars)
Here     (length = 4 chars)
how      (length = 3 chars)
you      (length = 3 chars)
can      (length = 3 chars)
the      (length = 3 chars)
is       (length = 2 chars)
-------------------------------------------

Haskell

Using native String type:

task s1 s2 = do
  let strs = if length s1 > length s2 then [s1, s2] else [s2, s1]
  mapM_ (\s -> putStrLn $ show (length s) ++ "\t" ++ show s) strs
λ> task "short string" "longer string"
13	"longer string"
12	"short string"

λ> Data.List.sortOn length ["abcd","123456789","abcdef","1234567"]
["abcd","abcdef","1234567","123456789"]

Data.List.sortOn (negate . length) ["abcd","123456789","abcdef","1234567"]
["123456789","1234567","abcdef","abcd"]

or more practically useful Text:

import qualified Data.Text as T

taskT s1 s2 = do
  let strs = if T.length s1 > T.length s2 then [s1, s2] else [s2, s1]
  mapM_ (\s -> putStrLn $ show (T.length s) ++ "\t" ++ show s) strs
λ> :set -XOverloadedStrings
λ> taskT "short string" "longer string"
13	"longer string"
12	"short string"

J

   NB. solution
chars=: 9&u:@>
longestFirst=: \: #@chars
lengthAndString=: ([:":@,.#@chars),.' ',.chars

   NB. `Haruno-umi Hinemosu-Notari Notarikana'
   NB. Spring ocean ; Swaying gently ; All day long.

   lengthAndString longestFirst '春の海';'ひねもすのたり';'のたりかな'
7 ひねもすのたり
5 のたりかな    
3 春の海        
   lengthAndString longestFirst '1234567';'abcd';'123456789';'abcdef'
9 123456789
7 1234567  
6 abcdef   
4 abcd

Java

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
void printCompare(String stringA, String stringB) {
    if (stringA.length() > stringB.length()) {
        System.out.printf("%d %s%n", stringA.length(), stringA);
        System.out.printf("%d %s%n", stringB.length(), stringB);
    } else {
        System.out.printf("%d %s%n", stringB.length(), stringB);
        System.out.printf("%d %s%n", stringA.length(), stringA);
    }
}

void printDescending(String... strings) {
    List<String> list = new ArrayList<>(List.of(strings));
    list.sort(Comparator.comparingInt(String::length).reversed());
    for (String string : list)
        System.out.printf("%d %s%n", string.length(), string);
}
4 abcd
3 abc
9 123456789
7 1234567
6 abcdef
4 abcd


An alternate demonstration

Works with: Java version 11
Works with: Java version 17
package stringlensort;

import java.io.PrintStream;
import java.util.Arrays;
import java.util.Comparator;

public class ReportStringLengths {

    public static void main(String[] args) {
        String[] list = {"abcd", "123456789", "abcdef", "1234567"};
        String[] strings = args.length > 0 ? args : list;

        compareAndReportStringsLength(strings);
    }

    /**
     * Compare and report strings length to System.out.
     * 
     * @param strings an array of strings
     */    
    public static void compareAndReportStringsLength(String[] strings) {
        compareAndReportStringsLength(strings, System.out);
    }

    /**
     * Compare and report strings length.
     * 
     * @param strings an array of strings
     * @param stream the output stream to write results
     */
    public static void compareAndReportStringsLength(String[] strings, PrintStream stream) {
        if (strings.length > 0) {
            strings = strings.clone();
            final String QUOTE = "\"";
            Arrays.sort(strings, Comparator.comparing(String::length));
            int min = strings[0].length();
            int max = strings[strings.length - 1].length();
            for (int i = strings.length - 1; i >= 0; i--) {
                int length = strings[i].length();
                String predicate;
                if (length == max) {
                    predicate = "is the longest string";
                } else if (length == min) {
                    predicate = "is the shortest string";
                } else {
                    predicate = "is neither the longest nor the shortest string";
                }
                //@todo: StringBuilder may be faster
                stream.println(QUOTE + strings[i] + QUOTE + " has length " + length
                        + " and " + predicate);
            }
        }
    }
}
Output:
"123456789" has length 9 and is the longest string
"1234567" has length 7 and is neither the longest nor the shortest string
"abcdef" has length 6 and is neither the longest nor the shortest string
"abcd" has length 4 and is the shortest string

JavaScript

JavaScript (ECMA Script) file stringlensort.js.

/**
 * Compare and report strings lengths.
 * 
 * @param {Element} input - a TextArea DOM element with input
 * @param {Element} output - a TextArea DOM element for output
 */
function compareStringsLength(input, output) {

  // Safe defaults.
  //
  output.value = "";
  let output_lines = [];

  // Split input into an array of lines.
  //
  let strings = input.value.split(/\r\n|\r|\n/g);

  // Is strings array empty?
  //
  if (strings && strings.length > 0) {

    // Remove leading and trailing spaces.
    //
    for (let i = 0; i < strings.length; i++)
      strings[i] = strings[i].trim();

    // Sort by lengths.
    //
    strings.sort((a, b) => a.length - b.length);

    // Remove empty strings.
    //
    while (strings[0] == "")
      strings.shift();

    // Check if any strings remain.
    //
    if (strings && strings.length > 0) {

      // Get min and max length of strings.
      //
      const min = strings[0].length;
      const max = strings[strings.length - 1].length;

      // Build output verses - longest strings first.
      //
      for (let i = strings.length - 1; i >= 0; i--) {
        let length = strings[i].length;
        let predicate;
        if (length == max) {
          predicate = "is the longest string";
        } else if (length == min) {
          predicate = "is the shortest string";
        } else {
          predicate = "is neither the longest nor the shortest string";
        }
        output_lines.push(`"${strings[i]}" has length ${length} and ${predicate}\n`);
      }

      // Send all lines from output_lines array to an TextArea control.
      //
      output.value = output_lines.join('');
    }
  }
}

document.getElementById("input").value = "abcd\n123456789\nabcdef\n1234567";
compareStringsLength(input, output);

HTML file (with embeded CSS) to run the script.

<html>

<head>
  <style>
    div {
      margin-top: 4ch;
      margin-bottom: 4ch;
    }

    label {
      display: block;
      margin-bottom: 1ch;
    }

    textarea {
      display: block;
    }

    input {
      display: block;
      margin-top: 4ch;
      margin-bottom: 4ch;
    }
  </style>
</head>

<body>
  <main>
    <form>
      <div>
        <label for="input">Input:
        </label>
        <textarea rows="20" cols="80" id="input"></textarea>
      </div>
      <input type="button" value="press to compare strings" onclick="compareStringsLength(input, output);">
      </input>
      <div>
        <label for="output">Output:
        </label>
        <textarea rows="20" cols="80" id="output"></textarea>
      </div>
    </form>
  </main>
  <script src="stringlensort.js"></script>
</body>

</html>
Output:
"123456789" has length 9 and is the longest string
"1234567" has length 7 and is neither the longest nor the shortest string
"abcdef" has length 6 and is neither the longest nor the shortest string
"abcd" has length 4 and is the shortest string

Julia

Per the Julia docs, a String in Julia is a sequence of characters encoded as UTF-8. Most string methods in Julia actually accept an AbstractString, which is the supertype of strings in Julia regardless of the encoding, including the default UTF-8.

The Char data type in Julia is a 32-bit, potentially Unicode data type, so that if we enumerate a String as a Char array, we get a series of 32-bit characters:

s = "niño"
println("Position  Char Bytes\n==============================")
for (i, c) in enumerate(s)
    println("$i          $c     $(sizeof(c))")
end
Output:
Position  Char Bytes
==============================
1          n     4
2          i     4
3          ñ     4
4          o     4

However, if we index into the string, the index into the string will function as if the string was an ordinary C string, that is, an array of unsigned 8-bit integers. If the index attempts to index within a character of size greater than one byte, an error is thrown for bad indexing. This can be demonstrated by casting the above string to codeunits:

println("Position  Codeunit Bytes\n==============================")
for (i, c) in enumerate(codeunits(s))
    println("$i            $(string(c, base=16))     $(sizeof(c))")
end
Output:
Position  Codeunit Bytes
==============================
1            6e     1
2            69     1
3            c3     1
4            b1     1
5            6f     1

Note that the length of "niño" as a String is 4 characters, and the length of "niño" as codeunits (ie, 8 bit bytes) is 5. Indexing into the 4th position results in an error:

julia> s[4]
ERROR: StringIndexError: invalid index [4], valid nearby indices [3]=>'ñ', [5]=>'o'

So, whether a string is longer or shorter depends on the encoding, as below:

length("ñññ") < length("nnnn")  # true, and the usual meaning of length of a String

length(codeunits("ñññ")) > length(codeunits("nnnn"))  # true as well

jq

Works with: jq

Works with gojq, the Go implementation of jq

def s1: "longer";
def s2: "shorter😀";

[s1,s2]
| sort_by(length)
| reverse[]
| "\"\(.)\" has length (codepoints) \(length) and utf8 byte length \(utf8bytelength)."
Output:
"shorter😀" has length (codepoints) 8 and utf8 byte length 11.
"longer" has length (codepoints) 6 and utf8 byte length 6.

Kotlin

fun main() {
    printTwoStrings("a short string", "a fairly long string")
    printStringsInDescendingLengthOrder(listOf("abcd", "123456789", "abcdef", "1234567"))
}

fun printTwoStrings(a: String, b: String) {
    val (shorter, longer) = if (a.length < b.length) Pair(a, b) else Pair(b, a)
    println("%3d: %s".format(longer.length, longer))
    println("%3d: %s".format(shorter.length, shorter))
}

fun printStringsInDescendingLengthOrder(strings: Collection<String>) {
    strings.sortedByDescending(String::length).forEach {
        println("%3d: %s".format(it.length, it))
    }
}
Output:
 20: a fairly long string
 14: a short string
  9: 123456789
  7: 1234567
  6: abcdef
  4: abcd

Lambdatalk

Lambdatalk comes with primitives working on words, [W.equal?, W.length, ...], on sentences, [S.empty?, S.first, S.rest, ...] and pairs, [P.new, P.left, P.right, ...].

Using these primitives we define 2 helper functions, [L.new, L.disp], to build and display a list according to a chosen format.

{def L.new
 {lambda {:s}
  {if {S.empty? {S.rest :s}}
   then {P.new {S.first :s} nil}
   else {P.new {S.first :s} {L.new {S.rest :s}}}}}}
-> L.new 

{def L.disp
 {lambda {:l}
  {if {W.equal? :l nil}
   then 
   else {br} {W.length {P.left :l}} : {P.left :l}
        {L.disp {P.right :l}}}}}
-> L.disp

For instance

{def B {L.new abcd 123456789 abcdef 1234567}}
-> B

{L.disp {B}}
-> 
 4 : abcd 
 9 : 123456789 
 6 : abcdef 
 7 : 1234567

Then we define the L.sort function waiting for a predicate function and a list.

{def L.sort
 {lambda {:filter :l} 
  {if {W.equal? :l nil} 
   then nil 
   else {L.insert {P.left :l} :filter
                  {L.sort :filter {P.right :l}}}}}}
-> L.sort

{def L.insert
 {lambda {:x :filter :l} 
  {if {W.equal? :l nil} 
   then {P.new :x nil} 
   else {if {:filter :x {P.left :l}} 
   then {P.new :x :l} 
   else {P.new {P.left :l}
              {L.insert :x :filter {P.right :l}}}}}}}
-> L.insert

Using the following predicate function (which could be anonymous) testing the length of 2 words

{def filter
 {lambda {:a :b}
  {> {W.length :a} {W.length :b}}}}
-> filter

we display the B list sorted according to the length of its elements.

{L.disp {L.sort filter {B}}}
-> 
 9 : 123456789 
 7 : 1234567 
 6 : abcdef 
 4 : abcd

Note that in lambdatalk words (and numbers) don't need to be quoted.

Lua

function test(list)
  table.sort(list, function(a,b) return #a > #b end)
  for _,s in ipairs(list) do print(#s, s) end
end
test{"abcd", "123456789", "abcdef", "1234567"}
Output:
9       123456789
7       1234567
6       abcdef
4       abcd

Mathematica / Wolfram Language

list = {"abcd", "123456789", "abcdef", "1234567"};
Reverse@SortBy[list, StringLength] // TableForm
Output:

123456789 1234567 abcdef abcd

MiniScript

// Simple version
print "Simple version:"
s2 = "This is the first string."
s1 = "This is string number two."

if s1.len > s2.len then 
	print s1.len + ": " + s1
	print s2.len + ": " + s2
else
	print s2.len + ": " + s2
	print s1.len + ": " + s1
end if

// Extra credit. More than 2 strings
strings = ["qwerty", "abc", "#FFFFFFFF", "255,255,255,255", "3.14159"]
pairs = []
for string in strings
	pairs.push([string, string.len])
end for
// sort by index descending
pairs.sort(1, false)
print
print "Extra credit:"
for pair in pairs
	print pair[1] + ": " + pair[0]
end for
Output:
Simple version:
26: This is string number two.
25: This is the first string.

Extra credit:
15: 255,255,255,255
9: #FFFFFFFF
7: 3.14159
6: qwerty
3: abc

Nim

In Nim, a character (char) is represented on a byte. A string is a sequence of characters with a length. For interoperability reason, an extra null is added at the end of the characters. A string is supposed to be encoded in UTF-8, but this is not enforced. The function len returns the length of the string i.e. its number of characters (without the extra null).

If we want to manage a string as a Unicode sequence of code points, we have to use the module unicode. We can convert a string in a sequence of runes, each rune being a unicode UTF-32 value. The length of this sequence is the number of code points.

import strformat, unicode

const
  S1 = "marche"
  S2 = "marché"

echo &"“{S2}”, byte length = {S2.len}, code points: {S2.toRunes.len}"
echo &"“{S1}”, byte length = {S1.len}, code points: {S1.toRunes.len}"
Output:
“marché”, byte length = 7, code points: 6
“marche”, byte length = 6, code points: 6

OCaml

let () =
  ["abcd"; "123456789"; "abcdef"; "1234567"]
  |> List.rev_map (fun s -> String.length s, s)
  |> List.sort (Fun.flip compare)
  |> List.iter (fun (l, s) -> Printf.printf "%u %s\n" l s)
Output:
9 123456789
7 1234567
6 abcdef
4 abcd

Pascal

Works with: Extended Pascal
program compareLengthOfStrings(output);

const
	specimenA = 'RosettaCode';
	specimenB = 'Pascal';
	specimenC = 'Foobar';
	specimenD = 'Pascalish';

type
	specimen = (A, B, C, D);
	specimens = set of specimen value [];

const
	specimenMinimum = A;
	specimenMaximum = D;

var
	{ the explicit range min..max serves as a safeguard to update max const }
	list: array[specimenMinimum..specimenMaximum] of string(24)
		value [A: specimenA; B: specimenB; C: specimenC; D: specimenD];
	lengthRelationship: array[specimen] of specimens;

procedure analyzeLengths;
var
	left, right: specimen;
begin
	for left := specimenMinimum to specimenMaximum do
	begin
		for right := specimenMinimum to specimenMaximum do
		begin
			if length(list[left]) < length(list[right]) then
			begin
				lengthRelationship[right] := lengthRelationship[right] + [right]
			end
		end
	end
end;

procedure printSortedByLengths;
var
	i: ord(specimenMinimum)..ord(specimenMaximum);
	s: specimen;
begin
	{ first the string longer than all other strings }
	{ lastly print the string not longer than any other string }
	for i := ord(specimenMaximum) downto ord(specimenMinimum) do
	begin
		{ for demonstration purposes: iterate over a set }
		for s in [specimenMinimum..specimenMaximum] do
		begin
			{ card returns the cardinality ("population count") }
			if card(lengthRelationship[s]) = i then
			begin
				writeLn(length(list[s]):8, ' ', list[s])
			end
		end
	end
end;

begin
	analyzeLengths;
	printSortedByLengths
end.
Output:
      11 RosettaCode
       9 Pascalish
       6 Pascal
       6 Foobar

PascalABC.NET

begin
  var (s1,s2) := ('Bye','Hello');
  if s1.Length < s2.Length then
    Swap(s1,s2);
  Println(s1,s1.Length);
  Println(s2,s2.Length);
  Println;
  var strArr := |'wolf','cat','crocodile','tiger'|;
  strArr.OrderByDescending(s -> s.Length).PrintLines(s -> $'{s,9} - {s.Length}');
end.
Output:
Hello 5
Bye 3

crocodile - 9
    tiger - 5
     wolf - 4
      cat - 3

Perl

#!/usr/bin/perl

use strict; # https://rosettacode.org/wiki/Compare_length_of_two_strings
use warnings;

for ( 'shorter thelonger', 'abcd 123456789 abcdef 1234567' )
  {
  print "\nfor strings => $_\n";
  printf "length %d: %s\n", length(), $_
    for sort { length $b <=> length $a } split;
  }
Output:

for strings => shorter thelonger
length 9: thelonger
length 7: shorter

for strings => abcd 123456789 abcdef 1234567
length 9: 123456789
length 7: 1234567
length 6: abcdef
length 4: abcd

Phix

Lengths are in bytes, for codepoints use length(utf8_to_utf32()) or similar.

with javascript_semantics
sequence list = {"abcd","123456789","abcdef","1234567"},
         lens = apply(list,length),
         tags = reverse(custom_sort(lens,tagset(length(lens))))
papply(true,printf,{1,{"%s (length %d)\n"},columnize({extract(list,tags),extract(lens,tags)})})
Output:
123456789 (length 9)
1234567 (length 7)
abcdef (length 6)
abcd (length 4)

Phixmonti

/# Rosetta Code problem: http://rosettacode.org/wiki/Compare_length_of_two_strings
by Galileo, 10/2022 #/

include ..\Utilitys.pmt

def getlen len swap 2 tolist enddef

( "abcd" "123456789" "abcdef" "1234567" ) getid getlen map

sort reverse lprint
Output:
[9, "123456789"][7, "1234567"][6, "abcdef"][4, "abcd"]
=== Press any key to exit ===

PHP

<?php


function retrieveStrings()
{
    if (isset($_POST['input'])) {
        $strings = explode("\n", $_POST['input']);
    } else {
        $strings = ['abcd', '123456789', 'abcdef', '1234567'];
    }
    return $strings;
}


function setInput()
{
    echo join("\n", retrieveStrings());
}


function setOutput()
{
    $strings = retrieveStrings();

    // Remove empty strings
    //
    $strings = array_map('trim', $strings);
    $strings = array_filter($strings);

    if (!empty($strings)) {
        usort($strings, function ($a, $b) {
            return strlen($b) - strlen($a);
        });
        $max_len = strlen($strings[0]);
        $min_len = strlen($strings[count($strings) - 1]);
        foreach ($strings as $s) {
            $length = strlen($s);
            if ($length == $max_len) {
                $predicate = "is the longest string";
            } elseif ($length == $min_len) {
                $predicate = "is the shortest string";
            } else {
                $predicate = "is neither the longest nor the shortest string";
            }
            echo "$s has length $length and $predicate\n";
        }
    }
}

?>


<!DOCTYPE html>
<html lang="en">

<head>
    <style>
        div {
            margin-top: 4ch;
            margin-bottom: 4ch;
        }

        label {
            display: block;
            margin-bottom: 1ch;
        }

        textarea {
            display: block;
        }

        input {
            display: block;
            margin-top: 4ch;
            margin-bottom: 4ch;
        }
    </style>
</head>


<body>
    <main>
        <form action=<?php echo $_SERVER['SCRIPT_NAME'] ?> method="post" accept-charset="utf-8">
            <div>
                <label for="input">Input:
                </label>
                <textarea rows='20' cols='80' name='input'><?php setInput(); ?></textarea>
                </label>
            </div>
            <input type="submit" value="press to compare strings">
            </input>
            <div>
                <label for="Output">Output:
                </label>
                <textarea rows='20' cols='80' name='output'><?php setOutput(); ?></textarea>
            </div>
        </form>
    </main>
</body>

</html>

PL/I

   declare (S1, S2) character (20) varying; /* 11 Aug 2022 */
   get (S1, S2);
   if length(S1) > length(S2) then
      put (length(S1), S1);
   else
      put (length(S2), S2);

Python

Naive solution

Works with: Python version 3.8
A = 'I am string'
B = 'I am string too'

if len(A) > len(B):
    print('"' + A + '"', 'has length', len(A), 'and is the longest of the two strings')
    print('"' + B + '"', 'has length', len(B), 'and is the shortest of the two strings')
elif len(A) < len(B):
    print('"' + B + '"', 'has length', len(B), 'and is the longest of the two strings')
    print('"' + A + '"', 'has length', len(A), 'and is the shortest of the two strings')
else:
    print('"' + A + '"', 'has length', len(A), 'and it is as long as the second string')
    print('"' + B + '"', 'has length', len(B), 'and it is as long as the second string')
Output:
"I am string too" has length 15 and is the longest of the two strings
"I am string" has length 11 and is the shortest of the two strings

Advanced solution

Works with: Python version 3.8

The solution below has some imperfection. When the longest strings of characters are of equal length, instead of describing them as "one of the longest" they are described as "the longest". This works similarly for the shortest strings. Also, if all strings (in this case where there is only one) have the same length it is not printed that they are the shortest strings. Of course, this could be improved.

"""
An example code for the task "Compare length of two strings" (Rosseta Code).

This example code can handle not only strings, but any objects.
"""


def _(message):
    """Translate: an placeholder for i18n and l10n gettext or similar."""
    return message


def compare_and_report_length(*objects, sorted_=True, reverse=True):
    """
    For objects given as parameters it prints which of them are the longest.

    So if the parameters are strings, then the strings are printed, their
    lengths and classification as the longest, shortest or average length.

    Note that for N > 0 such objects (e.g., strings, bytes, lists) it is
    possible that exactly M > 0 of them will be of the maximum length, K > 0 of
    them will be of the minimum length. In particular, it is possible that all
    objects will be exactly the same length. So we assume that if an object has
    both the maximum and minimum length, it is referred to as a string with the
    maximum length.

    Args:
        *objects (object): Any objects with defined length.
        sorted_ (bool, optional): If sorted_ is False then objects are not
                sorted. Defaults to True.
        reverse (bool, optional): If reverse is True and sorted_ is True
                objects are sorted in the descending order. If reverse is False
                and sorted_ is True objects are sorted in the ascending order.
                Defaults to True.

    Returns:
        None.
    """
    lengths = list(map(len, objects))
    max_length = max(lengths)
    min_length = min(lengths)
    lengths_and_objects = zip(lengths, objects)

    # Longer phrases make translations into other natural languages easier.
    #
    has_length = _('has length')
    if all(isinstance(obj, str) for obj in objects):
        predicate_max = _('and is the longest string')
        predicate_min = _('and is the shortest string')
        predicate_ave = _('and is neither the longest nor the shortest string')
    else:
        predicate_max = _('and is the longest object')
        predicate_min = _('and is the shortest object')
        predicate_ave = _('and is neither the longest nor the shortest object')

    if sorted_:
        lengths_and_objects = sorted(lengths_and_objects, reverse=reverse)

    for length, obj in lengths_and_objects:
        if length == max_length:
            predicate = predicate_max
        elif length == min_length:
            predicate = predicate_min
        else:
            predicate = predicate_ave
        print(obj, has_length, length, predicate)


A = 'I am string'
B = 'I am string too'
LIST = ["abcd", "123456789", "abcdef", "1234567"]


print('Two strings')
print()
compare_and_report_length(A, B)
print()

print('A list of strings')
print()
compare_and_report_length(*LIST)
print()
Output:
Two strings

"I am string too" has length 15 and is the longest string
"I am string" has length 11 and is the shortest string

A list of strings

"123456789" has length 9 and is the longest string
"1234567" has length 7 and is neither the longest nor the shortest string
"abcdef" has length 6 and is neither the longest nor the shortest string
"abcd" has length 4 and is the shortest string

QB64

Dim Words(1 To 4) As String
Dim Lengths As Integer, Index As Integer, Position As Integer, Done As String, Index2 As Integer
' inititialization
Words(1) = "abcd"
Words(2) = "123456789"
Words(3) = "abcdef"
Words(4) = "1234567"

Print " Word         Length"
For Index2 = 1 To 4 Step 1
    Lengths = 0
    Position = 0
    For Index = 1 To 4 Step 1
        If Lengths < Len(Words(Index)) And InStr(Done, Words(Index) + " ") = 0 Then
            Lengths = Len(Words(Index))
            Position = Index
        End If
    Next Index
    Done = Done + Words(Position) + " /@/"
    Print Words(Position), Len(Words(Position))
Next Index2

Quackery

  $ "A short string of"
  $ "A slightly longer string of"
   
  2dup size dip size > if swap 
  dup echo$ sp size echo say " characters." cr
  dup echo$ sp size echo say " characters." cr cr

  '  [ $ "From troubles of the world I turn to ducks,"
       $ "Beautiful comical things"
       $ "Sleeping or curled"
       $ "Their heads beneath white wings"
       $ "By water cool,"
       $ "Or finding curious things"
       $ "To eat in various mucks"
       $ "Beneath the pool," ] 
   []  swap witheach [ do nested join ]
 
  sortwith [ size dip size < ]
  witheach [ echo$ cr ]
Output:
A slightly longer string of 27 characters.
A short string of 17 characters.

From troubles of the world I turn to ducks,
Their heads beneath white wings
Or finding curious things
Beautiful comical things
To eat in various mucks
Sleeping or curled
Beneath the pool,
By water cool,

Racket

#lang racket

(define strings '("abcd" "123456789" "abcdef" "1234567"))

(for ([i (sort strings > #:key string-length)])
  (printf "'~a' is length ~a~n" i (string-length i)))
Output:
'123456789' is length 9
'1234567' is length 7
'abcdef' is length 6
'abcd' is length 4

Raku

So... In what way does this task differ significantly from String length? Other than being horribly under specified?

In the modern world, string "length" is pretty much a useless measurement, especially in the absence of a specified encoding; hence Raku not even having an operator: "length" for strings.

say 'Strings (👨‍👩‍👧‍👦, 🤔🇺🇸, BOGUS!) sorted: "longest" first:';
say "$_: characters:{.chars},  Unicode code points:{.codes},  UTF-8 bytes:{.encode('UTF8').bytes},  UTF-16 bytes:{.encode('UTF16').bytes}" for <👨‍👩‍👧‍👦 BOGUS! 🤔🇺🇸>.sort: -*.chars;
Output:
Strings (👨‍👩‍👧‍👦, 🤔🇺🇸, BOGUS!) sorted: "longest" first:
BOGUS!: characters:6,  Unicode code points:6,  UTF-8 bytes:6,  UTF-16 bytes:12
🤔🇺🇸: characters:2,  Unicode code points:3,  UTF-8 bytes:12,  UTF-16 bytes:12
👨‍👩‍👧‍👦: characters:1,  Unicode code points:7,  UTF-8 bytes:25,  UTF-16 bytes:22

REXX

/* REXX */
list = '"abcd","123456789","abcdef","1234567"'
Do i=1 By 1 While list>''
  Parse Var list s.i ',' list
  s.i=strip(s.i,,'"')
  End
n=i-1
Do While n>1
  max=0
  Do i=1 To n
    If length(s.i)>max Then Do
      k=i
      max=length(s.i)
      End
    End
  Call o s.k
  If k<n Then
    s.k=s.n
  n=n-1
  End
Call o s.1
Exit
o:
Say length(arg(1)) arg(1)
Return
Output:
9 123456789
7 1234567
6 abcdef
4 abcd

Ring

Two strings

see "working..." + nl

list = ["abcd","123456789"]
if len(list[1]) > len(list[2])
   first = list[1]
   second = list[2]
else
   first = list[2]
   second = list[1]
ok

see "Compare length of two strings:" + nl
see "" + first + " len = " + len(first) + nl + second + " len = " + len(second) + nl
see "done..." + nl
Output:
working...
Compare length of two strings:
123456789 len = 9
abcd len = 4
done...

More than two strings

see "working..." + nl

lenList = []
list = ["abcd","123456789","abcdef","1234567"]
for n = 1 to len(list)
    len = len(list[n])
    add(lenList,[len,n])
next

lenList = sort(lenList,1)
lenList = reverse(lenList)

see "Compare length of strings in descending order:" + nl
for n = 1 to len(lenList)
    see "" + list[lenList[n][2]] + " len = " + lenList[n][1] + nl
next
see "done..." + nl
Output:
working...
Compare length of strings in descending order:
123456789 len = 9
1234567 len = 7
abcdef len = 6
abcd len = 4
done...

RPL

Works with: Halcyon Calc version 4.2.7
Code Comments
  ≪ " [" OVER SIZE →STR "]" + + + 
≫ 'FormatString' STO

≪ 
  IF OVER SIZE OVER SIZE > THEN SWAP END
  FormatString SWAP FormatString
 ≫ 'SRT2S' STO

≪ 
    LIST→ → len 
    ≪ len 1 FOR n 
           1 n 1 - START 
              IF OVER SIZE OVER SIZE < 
              THEN SWAP END 
              n ROLLD 
           NEXT 
           n ROLLD   
       -1 STEP
       1 len START len ROLL FormatString NEXT
≫  ≫ 'SRTLS' STO
( "string"  -- "string [length]"  )


( "s1" "s2"  -- "s1 [l1]" "s2 [l2]" )
Swap strings if necessary
Format strings


( { strings } -- { strings } )
Push list in the stack
Use selection sort algorithm (favouring code size to execution time)
 
 




Format each string in the stack

The following lines of code deliver what is required:

"AB" "ABCD" STR2S
{ "ABC" "AB" "ABCD" } SRTLS
Output:
5:    "ABCD [4]"
4:      "AB [2]"
3:    "ABCD [4]"
2:     "ABC [3]"
1:      "AB [2]"

Ruby

a, b = "Given two strings", "of different length"
[a,b].sort_by{|s| - s.size }.each{|s| puts s + " (size: #{s.size})"}

list = ["abcd","123456789","abcdef","1234567"]
puts list.sort_by{|s|- s.size}
Output:
of different length (size: 19)
Given two strings (size: 17)
123456789
1234567
abcdef
abcd

Rust

fn compare_and_report<T: ToString>(string1: T, string2: T) -> String {
    let strings = [string1.to_string(), string2.to_string()];
    let difference = strings[0].len() as i32 - strings[1].len() as i32;
    if difference == 0 { // equal
        format!("\"{}\" and \"{}\" are of equal length, {}", strings[0], strings[1], strings[0].len())
    } else if difference > 1 { // string1 > string2
        format!("\"{}\" has length {} and is the longest\n\"{}\" has length {} and is the shortest", strings[0], strings[0].len(), strings[1], strings[1].len())
    } else { // string2 > string1
        format!("\"{}\" has length {} and is the longest\n\"{}\" has length {} and is the shortest", strings[1], strings[1].len(), strings[0], strings[0].len())
    }
}

fn main() {
    println!("{}", compare_and_report("a", "b"));
    println!("\n{}", compare_and_report("cd", "e"));
    println!("\n{}", compare_and_report("f", "gh"));
}
Output:
"a" and "a" are of equal length, 1

"d" has length 1 and is the longest  
"bc" has length 2 and is the shortest

"fg" has length 2 and is the longest 
"e" has length 1 and is the shortest

Scala

Translation of: Java
object Example extends App {
  val strings = Array("abcd", "123456789", "abcdef", "1234567")
  compareAndReportStringsLength(strings)

  def compareAndReportStringsLength(strings: Array[String]): Unit = {
    if (strings.nonEmpty) {
      val Q = '"'
      val hasLength = " has length "
      val predicateMax = " and is the longest string"
      val predicateMin = " and is the shortest string"
      val predicateAve = " and is neither the longest nor the shortest string"

      val sortedStrings = strings.sortBy(-_.length)
      val maxLength = sortedStrings.head.length
      val minLength = sortedStrings.last.length

      sortedStrings.foreach { str =>
        val length = str.length
        val predicate = length match {
          case `maxLength` => predicateMax
          case `minLength` => predicateMin
          case _           => predicateAve
        }
        println(s"$Q$str$Q$hasLength$length$predicate")
      }
    }
  }
}
Output:
"123456789" has length 9 and is the longest string
"1234567" has length 7 and is neither the longest nor the shortest string
"abcdef" has length 6 and is neither the longest nor the shortest string
"abcd" has length 4 and is the shortest string

Swift

Swift provides a simple count property to find how many syntactic characters are in any given String. When counting bytes Swift supports Unicode codepoints.

In this example we use the sorted and forEach methods from the Sequence protocol to first sort our list into a new Array and then print each item in order. String interpolation is used to print the details of each item.

Here we use anonymous argument names with the sorted closure and a named argument with the forEach to illustrate how to use either style.

 let list = ["abcd", "abcd🤦‍♂️", "123456789", "abcdef", "1234567"]
 list.sorted { $0.count > $1.count }.forEach { string in
     print("\(string) has \(string.count) characters")
 }
Output:
123456789 has 9 characters
1234567 has 7 characters
abcdef has 6 characters
abcd🤦‍♂️ has 5 characters
abcd has 4 characters

V (Vlang)

// Compare lenth of two strings, in V
// Tectonics: v run compare-length-of-two-strings.v
module main

// starts here
pub fn main() {
    mut strs := ["abcd","123456789"]
    println("Given: $strs")
    strs.sort_by_len()
    for i := strs.len-1; i >= 0; i-- {
        println("${strs[i]}: with length ${strs[i].len}")
    }

    // more than 2 strings. note = vs :=, := for definition, = for assignment
    strs = ["abcd","123456789","abcdef","1234567"]
    println("\nGiven: $strs")
    strs.sort_by_len()
    for i := strs.len-1; i >= 0; i-- {
        println("${strs[i]}: with length ${strs[i].len}")
    }
}
Output:
prompt$ v run compare-length-of-two-strings.v
Given: ['abcd', '123456789']
123456789: with length 9
abcd: with length 4

Given: ['abcd', '123456789', 'abcdef', '1234567']
123456789: with length 9
1234567: with length 7
abcdef: with length 6
abcd: with length 4

Wren

Library: Wren-upc

In Wren a string (i.e. an object of the String class) is an immutable sequence of bytes which is usually interpreted as UTF-8 but does not have to be.

With regard to string length, the String.count method returns the number of 'codepoints' in the string. If the string contains bytes which are invalid UTF-8, each such byte adds one to the count.

To find the number of bytes one can use String.bytes.count.

Unicode grapheme clusters, where what appears to be a single 'character' may in fact be an amalgam of several codepoints, are not directly supported by Wren but it is possible to measure the length in grapheme clusters of a string (i.e. the number of user perceived characters) using the Graphemes.clusterCount method of the Wren-upc module.

import "./upc" for Graphemes

var printCounts = Fn.new { |s1, s2, c1, c2|
   var l1 = (c1 > c2) ? [s1, c1] : [s2, c2]
   var l2 = (c1 > c2) ? [s2, c2] : [s1, c1]
   System.print(  "%(l1[0]) : length %(l1[1])")
   System.print(  "%(l2[0]) : length %(l2[1])\n")
}

var codepointCounts = Fn.new { |s1, s2|
   var c1 = s1.count
   var c2 = s2.count
   System.print("Comparison by codepoints:")
   printCounts.call(s1, s2, c1, c2)
}

var byteCounts = Fn.new { |s1, s2|
   var c1 = s1.bytes.count
   var c2 = s2.bytes.count
   System.print("Comparison by bytes:")
   printCounts.call(s1, s2, c1, c2)
}

var graphemeCounts = Fn.new { |s1, s2|
   var c1 = Graphemes.clusterCount(s1)
   var c2 = Graphemes.clusterCount(s2)
   System.print("Comparison by grapheme clusters:")
   printCounts.call(s1, s2, c1, c2)
}

for (pair in [ ["nino", "niño"], ["👨‍👩‍👧‍👦", "🤔🇺🇸"] ]) {
    codepointCounts.call(pair[0], pair[1])
    byteCounts.call(pair[0], pair[1])
    graphemeCounts.call(pair[0], pair[1])
}

var list = ["abcd", "123456789", "abcdef", "1234567"]
System.write("Sorting in descending order by length in codepoints:\n%(list) -> ")
list.sort { |a, b| a.count > b.count }
System.print(list)
Output:
Comparison by codepoints:
niño : length 4
nino : length 4

Comparison by bytes:
niño : length 5
nino : length 4

Comparison by grapheme clusters:
niño : length 4
nino : length 4

Comparison by codepoints:
👨‍👩‍👧‍👦 : length 7
🤔🇺🇸 : length 3

Comparison by bytes:
👨‍👩‍👧‍👦 : length 25
🤔🇺🇸 : length 12

Comparison by grapheme clusters:
🤔🇺🇸 : length 2
👨‍👩‍👧‍👦 : length 1

Sorting in descending order by length in codepoints:
[abcd, 123456789, abcdef, 1234567] -> [123456789, 1234567, abcdef, abcd]

XPL0

string 0;               \use zero-terminated string convention

func    StrLen(A);      \Return number of characters in an ASCIIZ string
char    A;
int     I;
for I:= 0 to -1>>1 do
        if A(I) = 0 then return I;

char    List;
int     M, N, SN, Len, Max;
[List:= ["abcd","123456789","abcdef","1234567"];
for M:= 0 to 3 do
    [Max:= 0;
    for N:= 0 to 3 do
        [Len:= StrLen(@List(N,0));
        if Len > Max then [Max:= Len;  SN:= N];
        ];
    Text(0, @List(SN,0));
    Text(0, " length is ");  IntOut(0, StrLen(@List(SN,0)));  CrLf(0);
    List(SN, 0):= 0;    \truncate largest string
    ];
]
Output:
123456789 length is 9
1234567 length is 7
abcdef length is 6
abcd length is 4

Z80 Assembly

Terminator equ 0      ;null terminator
PrintChar equ &BB5A   ;Amstrad CPC BIOS call, prints accumulator to screen as an ASCII character.

        org &8000

	ld hl,String1
	ld de,String2
	call CompareStringLengths
	
	jp nc, Print_HL_First
		ex de,hl
Print_HL_First:
	push bc
		push hl
			call PrintString
		pop hl
		push hl
			ld a,' '
			call PrintChar
			call getStringLength
			ld a,b
			call ShowHex_NoLeadingZeroes
			call NewLine
		pop hl
	pop bc
	
	ex de,hl
	push bc
		push hl
			call PrintString
		pop hl
		push hl
			ld a,' '
			call PrintChar
			call getStringLength
			ld a,b
			call ShowHex_NoLeadingZeroes
			call NewLine
		pop hl
	pop bc	
ReturnToBasic:
	RET

String1:
	byte "Hello",Terminator
String2:
	byte "Goodbye",Terminator

;;;;;; RELEVANT SUBROUTINES - PRINTSTRING AND NEWLINE CREATED BY KEITH S. OF CHIBIAKUMAS
CompareStringLengths:
	;HL = string 1
	;DE = string 2
	;CLOBBERS A,B,C
	push hl
	push de
	ex de,hl
	call GetStringLength
	ld b,c
	
	ex de,hl
	call GetStringLength
	ld a,b
	cp c
	pop de
	pop hl
	ret
	;returns carry set if HL < DE, zero set if equal, zero & carry clear if HL >= DE
	;returns len(DE) in C, and len(HL) in B.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
GetStringLength:
		ld b,0
loop_getStringLength:
		ld a,(hl)
		cp Terminator
		ret z
		inc hl
		inc b
		jr loop_getStringLength
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
NewLine:
	push af
	ld a,13		;Carriage return
	call PrintChar
	ld a,10		;Line Feed 
	call PrintChar
	pop af
	ret
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
PrintString:
	ld a,(hl)	
	cp Terminator
	ret z
	inc hl
	call PrintChar
	jr PrintString
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
ShowHex_NoLeadingZeroes:
;useful for printing values where leading zeroes don't make sense,
; 	such as money etc.
	push af
		and %11110000
		ifdef gbz80      ;game boy 
			swap a
		else             ;zilog z80
			rrca
			rrca
			rrca
			rrca
		endif
		or a
		call nz,PrintHexChar
		;if top nibble of A is zero, don't print it.
	pop af
	and %00001111
	or a
	ret z	;if bottom nibble of A is zero, don't print it!
	jp PrintHexChar
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
PrintHexChar:
	or a	  ;Clear Carry Flag
	daa
	add a,&F0
	adc a,&40 ;This sequence converts a 4-bit hex digit to its ASCII equivalent.
	jp PrintChar
Output:
Goodbye 7
Hello 5