Data commit

Task/Determine-if-a-string-is-collapsible/00-META.yaml

@@ -0,0 +1,2 @@
+---
+from: http://rosettacode.org/wiki/Determine_if_a_string_is_collapsible

Task/Determine-if-a-string-is-collapsible/00-TASK.txt

@@ -0,0 +1,80 @@
+Determine if a character string is   ''collapsible''.
+
+And if so,   collapse the string   (by removing   ''immediately repeated''   characters).
+
+
+
+If a character string has   ''immediately repeated''   character(s),   the repeated characters are to be
+deleted (removed), &nbsp; but not the primary (1<sup>st</sup>) character(s).
+
+
+An &nbsp; ''immediately repeated'' &nbsp; character is any character that is &nbsp; <u>immediately</u> &nbsp; followed by an
+identical character (or characters). &nbsp; Another word choice could've been &nbsp; ''duplicated character'', &nbsp; but that
+might have ruled out &nbsp; (to some readers) &nbsp; triplicated characters &nbsp; ··· &nbsp; or more.
+
+
+{This Rosetta Code task was inspired by a newly introduced &nbsp; (as of around November 2019) &nbsp; '''PL/I''' &nbsp; BIF: &nbsp; '''collapse'''.}
+
+
+;Examples:
+In the following character string:
+
+
+ <big><big> The bet<u>t</u>er the 4-whe<u>e</u>l drive, the further you'l<u>l</u> be from help when ya get stuck! </big></big>
+
+
+Only the 2<sup>nd</sup> &nbsp; '''t''', &nbsp; '''e''', and &nbsp; '''l''' &nbsp; are repeated characters, &nbsp; indicated
+by underscores (above), &nbsp; even though they (those characters) appear elsewhere in the character string.
+
+
+
+So, after ''collapsing'' the string, the result would be:
+
+ <big><big> The beter the 4-whel drive, the further you'l be from help when ya get stuck! </big></big>
+
+
+
+
+Another example:
+In the following character string:
+
+ <big><big> headmistres<u>ss</u>hip </big></big>
+
+
+The "collapsed" string would be:
+
+ <big><big> headmistreship </big></big>
+
+
+
+;Task:
+Write a subroutine/function/procedure/routine··· &nbsp; to
+locate &nbsp; ''repeated'' &nbsp; characters and &nbsp; ''collapse'' &nbsp; (delete) &nbsp; them from the character
+string. &nbsp; The character string can be processed from either direction.
+
+
+Show all output here, on this page:
+:* &nbsp; the &nbsp; original string and its length
+:* &nbsp; the       resultant string and its length
+:* &nbsp; the above strings should be "bracketed" with &nbsp; '''<<<''' &nbsp; and &nbsp; '''>>>''' &nbsp; (to delineate blanks)
+;* &nbsp; «««Guillemets may be used instead for "bracketing" for the more artistic programmers, &nbsp; shown used here»»»
+<!--         Guillemots shouldn't be used as they stink.    !-->
+
+
+
+Use (at least) the following five strings, &nbsp; all strings are length seventy-two (characters, including blanks), &nbsp; except
+the 1<sup>st</sup> string:
+
+  string
+  number
+         ╔╗
+    1    ║╚═══════════════════════════════════════════════════════════════════════╗   ◄■■■■■■  a null string  (length zero)
+    2    ║"If I were two-faced, would I be wearing this one?" --- Abraham Lincoln ║
+    3    ║..1111111111111111111111111111111111111111111111111111111111111117777888║
+    4    ║I never give 'em hell, I just tell the truth, and they think it's hell. ║
+    5    ║                                                    --- Harry S Truman  ║   ◄■■■■■■  has many repeated blanks
+         ╚════════════════════════════════════════════════════════════════════════╝
+
+{{Template:Strings}}
+<br><br>
+

Task/Determine-if-a-string-is-collapsible/11l/determine-if-a-string-is-collapsible.11l

@@ -0,0 +1,25 @@
+F collapse(s)
+   V cs = ‘’
+   V last = Char("\0")
+   L(c) s
+      I c != last
+         cs ‘’= c
+         last = c
+   R cs
+
+V strings = [
+   ‘’,
+   ‘"If I were two-faced, would I be wearing this one?" --- Abraham Lincoln ’,
+   ‘..1111111111111111111111111111111111111111111111111111111111111117777888’,
+   ‘I never give 'em hell, I just tell the truth, and they think it's hell. ’,
+   ‘                                                   ---  Harry S Truman  ’,
+   ‘The better the 4-wheel drive, the further you'll be from help when ya get stuck!’,
+   ‘headmistressship’,
+   ‘aardvark’
+]
+
+L(s) strings
+   V c = collapse(s)
+   print(‘original  : length = ’s.len‘, string = <<<’s‘>>>’)
+   print(‘collapsed : length = ’c.len‘, string = <<<’c‘>>>’)
+   print()

Task/Determine-if-a-string-is-collapsible/8080-Assembly/determine-if-a-string-is-collapsible.8080

@@ -0,0 +1,101 @@
+bdos:	equ	5
+puts:	equ	9
+	org	100h
+	jmp	main
+	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+	;;;	Collapse the $-terminated string at [HL]
+colaps:	mov	b,m	; B = last character seen
+	inx	h	; First character never collapses
+	mov	d,h	; DE = output pointer
+	mov	e,l
+	mov	a,b	; Empty string?
+	cpi	'$'
+	rz		; Then do nothing
+cloop:	mov	a,m	; Get character
+	inx	h	; Advance pointer
+	cmp	b	; Same as last one?
+	jz	cloop	; Then keep scanning
+	mov	b,a	; Otherwise, it is a new one
+	stax	d	; Store it,
+	inx	d	; and increment output pointer.
+	cpi	'$'	; Reached the end?
+	jnz	cloop	; If not, next character
+	ret
+	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+	;;;	Code to print the output in the required format
+main:	lxi	h,strs	; List of string pointers
+loop:	mov	e,m	; DE = string pointer
+	inx	h
+	mov	d,m
+	inx	h
+	mov	a,e	; If zero, end
+	ora	d
+	rz
+	push	h	; Keep the list pointer
+	push	d	; Keep the string pointer
+	call	brstr	; Print original string in brackets
+	pop	h	; Retrieve string pointer
+	push	h
+	call	colaps	; Collapse the string
+	pop	d	; Retrieve string pointer
+	call	brstr	; Print the collapsed string in brackets
+	pop	h	; Retrieve the list pointer
+	jmp	loop	; Next string
+	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+	;;;	Print string at DE in brackets with length
+brstr:	push	d	; Store string pointer
+	mvi	c,puts	; Print opening brackets
+	lxi	d,open
+	call	bdos
+	pop	d	; Print original string
+	push	d
+	mvi	c,puts
+	call	bdos
+	mvi	c,puts	; Print closing brackets
+	lxi	d,close
+	call	bdos
+	pop	h
+	call	strlen	; Find string length
+	mov	a,b
+	jmp	prnum	; Print string length
+	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+	;;;	Figure out the length of a string (max 255)
+strlen:	mvi	b,0	; Counter
+	mvi	a,'$'	; Terminator
+sloop:	cmp	m	; Reached the end yet?
+	rz		; If so, stop
+	inr	b	; If not, increment counter,
+	inx	h	; and pointer,
+	jmp	sloop	; and check next byte.
+	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+	;;;	Print number in A as decimal
+prnum:	lxi	d,num	; End of number string
+prdgt:	mvi	b,-1	; Quotient
+ploop:	inr	b	; Increment quotient
+	sui	10	; Subtract 10
+	jnc	ploop	; Subtract until negative
+	adi	'0'+10	; Make ASCII digit
+	dcx	d	; Store in number string
+	stax	d
+	mov	a,b	; If more digits,
+	ana	a
+	jnz	prdgt	; find next digit
+	mvi	c,puts	; When done, print string
+	jmp	bdos
+	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+	;;;	Formatting strings
+open:	db	'<<<$'
+close:	db	'>>> $'
+	db	'***'
+num:	db	13,10,'$'
+	;;;	Input strings
+strs:	dw	str1,str2,str3,str4,str5,0
+str1:	db	'$'	; Empty string
+str2:	db	'"If I were two-faced, would I be wearing '
+	db	'this one?" --- Abraham Lincoln $'
+str3:	db	'..111111111111111111111111111111111111111'
+	db	'1111111111111111111111117777888$'
+str4:	db	'I never give ',39,'em hell, I just tell the truth, '
+	db	'and they think it',39,'s hell. $'
+str5:	db	'                                              '
+	db	'      --- Harry S Truman  $'

Task/Determine-if-a-string-is-collapsible/ALGOL-68/determine-if-a-string-is-collapsible.alg

@@ -0,0 +1,32 @@
+BEGIN
+    # returns a collapsed version of s                                    #
+    #         i.e. s with adjacent duplicate characters removed           #
+    PROC collapse = ( STRING s )STRING:
+        IF s = ""
+        THEN ""   # empty string                                          #
+        ELSE      # non-empty string                                      #
+            [ LWB s : UPB s ]CHAR result;
+            INT     r pos   := LWB result;
+            result[ r pos ] := s[ LWB s ];
+            FOR s pos FROM LWB s + 1 TO UPB s DO
+                IF result[ r pos ] /= s[ s pos ] THEN
+                   r pos +:= 1;
+                   result[ r pos ] := s[ s pos ]
+                FI
+            OD;
+            result[ LWB result : r pos ]
+        FI # callapse # ;
+    # task test cases                                                     #
+    []STRING tests = ( ""
+                     , """If I were two-faced, would I be wearing this one?"" --- Abraham Lincoln "
+                     , "..1111111111111111111111111111111111111111111111111111111111111117777888"
+                     , "I never give 'em hell, I just tell the truth, and they think it's hell. "
+                     , "                                                    --- Harry S Truman  "
+                     );
+    FOR t pos FROM LWB tests TO UPB tests DO
+        STRING s = tests[ t pos ];
+        STRING c = collapse( s );
+        print( ( "       <<<", s, ">>> (length ", whole( ( UPB s + 1 ) - LWB s, 0 ), ")", newline ) );
+        print( ( "result <<<", c, ">>> (length ", whole( ( UPB c + 1 ) - LWB c, 0 ), ")", newline ) )
+    OD
+END

Task/Determine-if-a-string-is-collapsible/APL/determine-if-a-string-is-collapsible.apl

@@ -0,0 +1,27 @@
+task←{
+   ⍝ Collapse a string
+   collapse←{(1,¯1↓⍵≠1⌽⍵)/⍵}
+
+   ⍝ Given a function ⍺⍺, display a string in brackets,
+   ⍝ along with its length, and do the same for the result
+   ⍝ of applying ⍺⍺ to the string.
+   display←{
+      bracket←{(⍕⍴⍵),' «««',⍵,'»»»'}
+      ↑(⊂bracket ⍵),(⊂bracket ⍺⍺ ⍵)
+   }
+
+   ⍝ Strings from the task
+   s1←''
+   s2←'"If I were two-faced, would I be wearing this one?"'
+   s2,←' --- Abraham Lincoln '
+   s3←'..1111111111111111111111111111111111111111111111111'
+   s3,←'111111111111117777888'
+   s4←'I never give ''em hell, I just tell the truth, '
+   s4,←'and they think it''s hell. '
+   s5←'                                             '
+   s5,←'       --- Harry S Truman  '
+   strs←s1 s2 s3 s4 s5
+
+   ⍝ Collapse each string and display it as specified
+   ↑collapse display¨ strs
+}

Task/Determine-if-a-string-is-collapsible/AWK/determine-if-a-string-is-collapsible.awk

@@ -0,0 +1,30 @@
+# syntax: GAWK -f DETERMINE_IF_A_STRING_IS_COLLAPSIBLE.AWK
+BEGIN {
+    for (i=1; i<=9; i++) {
+      for (j=1; j<=i; j++) {
+        arr[0] = arr[0] i
+      }
+    }
+    arr[++n] = ""
+    arr[++n] = "\"If I were two-faced, would I be wearing this one?\" --- Abraham Lincoln "
+    arr[++n] = "..1111111111111111111111111111111111111111111111111111111111111117777888"
+    arr[++n] = "I never give 'em hell, I just tell the truth, and they think it's hell. "
+    arr[++n] = "                                                    --- Harry S Truman  "
+    arr[++n] = "The better the 4-wheel drive, the further you'll be from help when ya get stuck!"
+    arr[++n] = "headmistressship"
+    for (i=0; i<=n; i++) {
+      main(arr[i])
+    }
+    exit(0)
+}
+function main(str,  c,i,new_str,prev_c) {
+    for (i=1; i<=length(str); i++) {
+      c = substr(str,i,1)
+      if (prev_c != c) {
+        prev_c = c
+        new_str = new_str c
+      }
+    }
+    printf("old: %2d <<<%s>>>\n",length(str),str)
+    printf("new: %2d <<<%s>>>\n\n",length(new_str),new_str)
+}

Task/Determine-if-a-string-is-collapsible/Action-/determine-if-a-string-is-collapsible.action

@@ -0,0 +1,38 @@
+PROC Collapse(CHAR ARRAY in,out)
+  BYTE i,j
+  CHAR c
+
+  j=1 c=0
+  FOR i=1 TO in(0)
+  DO
+    IF in(i)#c THEN
+      c=in(i)
+      out(j)=c
+      j==+1
+    FI
+  OD
+  out(0)=j-1
+RETURN
+
+PROC Test(CHAR ARRAY s)
+  CHAR ARRAY c(100)
+  BYTE CH=$02FC ;Internal hardware value for last key pressed
+
+  Collapse(s,c)
+  PrintF("<<<%S>>> (len=%B)%E",s,s(0))
+  PrintF("<<<%S>>> (len=%B)%E",c,c(0))
+  PutE()
+  PrintE("Press any key to continue")
+  PutE()
+
+  DO UNTIL CH#$FF OD
+  CH=$FF
+RETURN
+
+PROC Main()
+  Test("")
+  Test("""If I were two-faced, would I be wearing this one?"" --- Abraham Lincoln ")
+  Test("..1111111111111111111111111111111111111111111111111111111111111117777888")
+  Test("I never give 'em hell, I just tell the truth, and they think it's hell. ")
+  Test("                                                    --- Harry S Truman  ")
+RETURN

Task/Determine-if-a-string-is-collapsible/Ada/determine-if-a-string-is-collapsible.ada

@@ -0,0 +1,22 @@
+with Ada.Text_IO; use Ada.Text_IO;
+procedure Test_Collapsible is
+   procedure Collapse (S : in String) is
+      Res : String (1 .. S'Length);
+      Len : Natural := 0;
+   begin
+      Put_Line ("Input  = <<<" & S & ">>>, length =" & S'Length'Image);
+      for I in S'Range loop
+         if Len = 0 or else S(I) /= Res(Len) then
+            Len := Len + 1;
+            Res(Len) := S(I);
+         end if;
+      end loop;
+      Put_Line ("Output = <<<" & Res (1 .. Len) & ">>>, length =" & Len'Image);
+   end Collapse;
+begin
+   Collapse ("");
+   Collapse ("""If I were two-faced, would I be wearing this one?"" --- Abraham Lincoln ");
+   Collapse ("..1111111111111111111111111111111111111111111111111111111111111117777888");
+   Collapse ("I never give 'em hell, I just tell the truth, and they think it's hell. ");
+   Collapse ("                                                    --- Harry S Truman  ");
+end Test_Collapsible;

Task/Determine-if-a-string-is-collapsible/Arturo/determine-if-a-string-is-collapsible.arturo

@@ -0,0 +1,10 @@
+lines: [
+    {::}
+    {:"If I were two-faced, would I be wearing this one?" --- Abraham Lincoln :}
+    {:..1111111111111111111111111111111111111111111111111111111111111117777888:}
+    {:I never give 'em hell, I just tell the truth, and they think it's hell. :}
+    {:                                                    --- Harry S Truman  :}
+]
+
+loop lines 'line ->
+    print squeeze line

Task/Determine-if-a-string-is-collapsible/AutoHotkey/determine-if-a-string-is-collapsible-1.ahk

@@ -0,0 +1,8 @@
+collapsible_string(str){
+	for i, ch in StrSplit(str){
+		if (ch <> prev)
+			res .= ch
+		prev := ch
+	}
+	return "original string:`t" StrLen(str) " characters`t«««" str "»»»`nresultant string:`t" StrLen(res) " characters`t«««" res "»»»"
+}

Task/Determine-if-a-string-is-collapsible/AutoHotkey/determine-if-a-string-is-collapsible-2.ahk

@@ -0,0 +1,8 @@
+data := [""
+	, """If I were two-faced, would I be wearing this one?"" --- Abraham Lincoln "
+	, "..1111111111111111111111111111111111111111111111111111111111111117777888"
+	, "I never give 'em hell, I just tell the truth, and they think it's hell. "
+	, "                                                    --- Harry S Truman  "]
+for i, v in data
+	MsgBox % := collapsible_string(v)
+return

Task/Determine-if-a-string-is-collapsible/BASIC/determine-if-a-string-is-collapsible.basic

@@ -0,0 +1,26 @@
+10 READ N%
+20 FOR A% = 1 TO N%
+30 READ I$: GOSUB 100
+40 PRINT LEN(I$); "<<<"; I$; ">>>"
+50 PRINT LEN(O$); "<<<"; O$; ">>>"
+55 PRINT
+60 NEXT
+70 END
+100 REM Collapse I$ into O$
+105 IF I$="" THEN O$=I$: RETURN
+110 O$=SPACE$(LEN(I$))
+120 P$=LEFT$(I$,1)
+130 MID$(O$,1,1)=P$
+140 O%=2
+150 FOR I%=2 TO LEN(I$)
+160 C$=MID$(I$,I%,1)
+170 IF P$<>C$ THEN MID$(O$,O%,1)=C$: O%=O%+1: P$=C$
+180 NEXT
+190 O$=LEFT$(O$,O%-1)
+200 RETURN
+400 DATA 5: REM There are 5 strings
+410 DATA ""
+420 DATA "'If I were two-faced, would I be wearing this one?' --- Abraham Lincoln "
+430 DATA "..1111111111111111111111111111111111111111111111111111111111111117777888"
+440 DATA "I never give 'em hell, I just tell the truth, and they think it's hell. "
+450 DATA "                                                    --- Harry S Truman  "

Task/Determine-if-a-string-is-collapsible/BCPL/determine-if-a-string-is-collapsible.bcpl

@@ -0,0 +1,33 @@
+get "libhdr"
+
+// Collapse a string
+let collapse(in, out) = valof
+$(  let o = 0
+    for i = 1 to in%0
+        unless i>1 & in%i = in%(i-1)
+        $(  o := o + 1
+            out%o := in%i
+        $)
+    out%0 := o
+    resultis out
+$)
+
+// Print string with brackets and length
+let brackets(s) be
+    writef("%N: <<<%S>>>*N", s%0, s)
+
+// Print original and collapsed version
+let show(s) be
+$(  let v = vec 1+255/BYTESPERWORD
+    brackets(s)
+    brackets(collapse(s, v))
+    wrch('*N')
+$)
+
+let start() be
+$(  show("")
+    show("*"If I were two-faced, would I be wearing this one?*" --- Abraham Lincoln ")
+    show("..1111111111111111111111111111111111111111111111111111111111111111111788")
+    show("I never give 'em hell, I just tell the truth, and they think it's hell. ")
+    show("                                                     --- Harry S Truman ")
+$)

Task/Determine-if-a-string-is-collapsible/BQN/determine-if-a-string-is-collapsible-1.bqn

@@ -0,0 +1,14 @@
+Collapse←(≠↑1∾1↓≠⟜»)⊸/
+
+>{
+  c←Collapse 𝕩
+  ⟨⟨≠𝕩 ⋄ "<<<"∾𝕩∾">>>"⟩≍⟨≠c ⋄ "<<<"∾c∾">>>"⟩⟩
+}¨⟨
+  "The better the 4-wheel drive, the further you'll be from help when ya get stuck!"
+  "headmistressship"
+  ""
+  """If I were two-faced, would I be wearing this one?"" --- Abraham Lincoln "
+  "..1111111111111111111111111111111111111111111111111111111111111117777888"
+  "I never give 'em hell, I just tell the truth, and they think it's hell. "
+  "                                                    --- Harry S Truman  "
+⟩

Task/Determine-if-a-string-is-collapsible/BQN/determine-if-a-string-is-collapsible-2.bqn

@@ -0,0 +1,30 @@
+┌─
+╵ ┌─
+  ╵ 80 "<<<The better the 4-wheel drive, the further you'll be from help when ya get stuck!>>>"
+    77 "<<<The beter the 4-whel drive, the further you'l be from help when ya get stuck!>>>"
+                                                                                                ┘
+  ┌─
+  ╵ 16 "<<<headmistressship>>>"
+    14 "<<<headmistreship>>>"
+                                ┘
+  ┌─
+  ╵ 0 "<<<>>>"
+    0 "<<<>>>"
+               ┘
+  ┌─
+  ╵ 72 "<<<""If I were two-faced, would I be wearing this one?"" --- Abraham Lincoln >>>"
+    70 "<<<""If I were two-faced, would I be wearing this one?"" - Abraham Lincoln >>>"
+                                                                                          ┘
+  ┌─
+  ╵ 72 "<<<..1111111111111111111111111111111111111111111111111111111111111117777888>>>"
+    4  "<<<.178>>>"
+                                                                                        ┘
+  ┌─
+  ╵ 72 "<<<I never give 'em hell, I just tell the truth, and they think it's hell. >>>"
+    69 "<<<I never give 'em hel, I just tel the truth, and they think it's hel. >>>"
+                                                                                        ┘
+  ┌─
+  ╵ 72 "<<<                                                    --- Harry S Truman  >>>"
+    17 "<<< - Hary S Truman >>>"
+                                                                                        ┘
+                                                                                                  ┘

Task/Determine-if-a-string-is-collapsible/BaCon/determine-if-a-string-is-collapsible.bacon

@@ -0,0 +1,21 @@
+DATA ""
+DATA "\"If I were two-faced, would I be wearing this one?\" --- Abraham Lincoln "
+DATA "..1111111111111111111111111111111111111111111111111111111111111117777888"
+DATA "I never give 'em hell, I just tell the truth, and they think it's hell. "
+DATA "                                                    --- Harry S Truman  "
+DATA "The better the 4-wheel drive, the further you'll be from help when ya get stuck!"
+DATA "headmistressship"
+
+DOTIMES 7
+    READ x$
+    found = 0
+    PRINT "<<<", x$, ">>> - length: ", LEN(x$)
+    PRINT "<<<";
+    FOR y = 1 TO LEN(x$)
+        IF MID$(x$, y, 1) <> MID$(x$, y+1, 1) THEN
+            PRINT MID$(x$, y, 1);
+            INCR found
+        ENDIF
+    NEXT
+    PRINT ">>> - length: ", found
+DONE

Task/Determine-if-a-string-is-collapsible/Bracmat/determine-if-a-string-is-collapsible.bracmat

@@ -0,0 +1,29 @@
+  ( colapse
+  =   previous
+    .   str
+      $ ( vap
+        $ ( (
+            =
+              .   !arg:!previous&
+                | !arg:?previous
+            )
+          . !arg
+          )
+        )
+  )
+& ( testcolapse
+  =   len
+    .   (len=.@(!arg:? [?arg)&!arg)
+      & out$(str$(««« !arg "»»» " len$!arg))
+      & colapse$!arg:?arg
+      & out$(str$(««« !arg "»»» " len$!arg))
+  )
+& testcolapse$
+&   testcolapse
+  $ "\"If I were two-faced, would I be wearing this one?\" --- Abraham Lincoln "
+&   testcolapse
+  $ "..1111111111111111111111111111111111111111111111111111111111111117777888"
+&   testcolapse
+  $ "I never give 'em hell, I just tell the truth, and they think it's hell. "
+&   testcolapse
+  $ "                                                    --- Harry S Truman  "

Task/Determine-if-a-string-is-collapsible/C++/determine-if-a-string-is-collapsible.cpp

@@ -0,0 +1,26 @@
+#include <string>
+#include <iostream>
+#include <algorithm>
+
+template<typename char_type>
+std::basic_string<char_type> collapse(std::basic_string<char_type> str) {
+    auto i = std::unique(str.begin(), str.end());
+    str.erase(i, str.end());
+    return str;
+}
+
+void test(const std::string& str) {
+    std::cout << "original string: <<<" << str << ">>>, length = " << str.length() << '\n';
+    std::string collapsed(collapse(str));
+    std::cout << "result string: <<<" << collapsed << ">>>, length = " << collapsed.length() << '\n';
+    std::cout << '\n';
+}
+
+int main(int argc, char** argv) {
+    test("");
+    test("\"If I were two-faced, would I be wearing this one?\" --- Abraham Lincoln ");
+    test("..1111111111111111111111111111111111111111111111111111111111111117777888");
+    test("I never give 'em hell, I just tell the truth, and they think it's hell. ");
+    test("                                                    --- Harry S Truman  ");
+    return 0;
+}

Task/Determine-if-a-string-is-collapsible/C-sharp/determine-if-a-string-is-collapsible.cs

@@ -0,0 +1,26 @@
+using System;
+using static System.Linq.Enumerable;
+
+public class Program
+{
+    static void Main()
+    {
+        string[] input = {
+            "",
+            "The better the 4-wheel drive, the further you'll be from help when ya get stuck!",
+            "headmistressship",
+            "\"If I were two-faced, would I be wearing this one?\" --- Abraham Lincoln ",
+            "..1111111111111111111111111111111111111111111111111111111111111117777888",
+            "I never give 'em hell, I just tell the truth, and they think it's hell. ",
+            "                                                    --- Harry S Truman  "
+        };
+        foreach (string s in input) {
+            Console.WriteLine($"old: {s.Length} «««{s}»»»");
+            string c = Collapse(s);
+            Console.WriteLine($"new: {c.Length} «««{c}»»»");
+        }
+    }
+
+    static string Collapse(string s) => string.IsNullOrEmpty(s) ? "" :
+        s[0] + new string(Range(1, s.Length - 1).Where(i => s[i] != s[i - 1]).Select(i => s[i]).ToArray());
+}

Task/Determine-if-a-string-is-collapsible/C/determine-if-a-string-is-collapsible.c

@@ -0,0 +1,170 @@
+#include<string.h>
+#include<stdlib.h>
+#include<stdio.h>
+
+#define COLLAPSE 0
+#define SQUEEZE 1
+
+typedef struct charList{
+    char c;
+    struct charList *next;
+} charList;
+
+/*
+Implementing strcmpi, the case insensitive string comparator, as it is not part of the C Standard Library.
+
+Comment this out if testing on a compiler where it is already defined.
+*/
+
+int strcmpi(char* str1,char* str2){
+    int len1 = strlen(str1), len2 = strlen(str2), i;
+
+    if(len1!=len2){
+        return 1;
+    }
+
+    else{
+        for(i=0;i<len1;i++){
+            if((str1[i]>='A'&&str1[i]<='Z')&&(str2[i]>='a'&&str2[i]<='z')&&(str2[i]-65!=str1[i]))
+                return 1;
+            else if((str2[i]>='A'&&str2[i]<='Z')&&(str1[i]>='a'&&str1[i]<='z')&&(str1[i]-65!=str2[i]))
+                return 1;
+            else if(str1[i]!=str2[i])
+                return 1;
+        }
+    }
+
+    return 0;
+}
+
+charList *strToCharList(char* str){
+    int len = strlen(str),i;
+
+    charList *list, *iterator, *nextChar;
+
+    list = (charList*)malloc(sizeof(charList));
+    list->c = str[0];
+    list->next = NULL;
+
+    iterator = list;
+
+    for(i=1;i<len;i++){
+        nextChar = (charList*)malloc(sizeof(charList));
+        nextChar->c = str[i];
+        nextChar->next = NULL;
+
+        iterator->next = nextChar;
+        iterator = nextChar;
+    }
+
+    return list;
+}
+
+char* charListToString(charList* list){
+    charList* iterator = list;
+    int count = 0,i;
+    char* str;
+
+    while(iterator!=NULL){
+        count++;
+        iterator = iterator->next;
+    }
+
+    str = (char*)malloc((count+1)*sizeof(char));
+    iterator = list;
+
+    for(i=0;i<count;i++){
+        str[i] = iterator->c;
+        iterator = iterator->next;
+    }
+
+    free(list);
+    str[i] = '\0';
+
+    return str;
+}
+
+char* processString(char str[100],int operation, char squeezeChar){
+    charList *strList = strToCharList(str),*iterator = strList, *scout;
+
+    if(operation==SQUEEZE){
+        while(iterator!=NULL){
+            if(iterator->c==squeezeChar){
+                scout = iterator->next;
+
+                while(scout!=NULL && scout->c==squeezeChar){
+                        iterator->next = scout->next;
+                        scout->next = NULL;
+                        free(scout);
+                        scout = iterator->next;
+                }
+            }
+            iterator = iterator->next;
+        }
+    }
+
+    else{
+        while(iterator!=NULL && iterator->next!=NULL){
+            if(iterator->c == (iterator->next)->c){
+                scout = iterator->next;
+                squeezeChar = iterator->c;
+
+                while(scout!=NULL && scout->c==squeezeChar){
+                        iterator->next = scout->next;
+                        scout->next = NULL;
+                        free(scout);
+                        scout = iterator->next;
+                }
+            }
+            iterator = iterator->next;
+        }
+    }
+
+    return charListToString(strList);
+}
+
+void printResults(char originalString[100], char finalString[100], int operation, char squeezeChar){
+    if(operation==SQUEEZE){
+        printf("Specified Operation : SQUEEZE\nTarget Character : %c",squeezeChar);
+    }
+
+    else
+        printf("Specified Operation : COLLAPSE");
+
+    printf("\nOriginal %c%c%c%s%c%c%c\nLength : %d",174,174,174,originalString,175,175,175,(int)strlen(originalString));
+    printf("\nFinal    %c%c%c%s%c%c%c\nLength : %d\n",174,174,174,finalString,175,175,175,(int)strlen(finalString));
+}
+
+int main(int argc, char** argv){
+    int operation;
+    char squeezeChar;
+
+    if(argc<3||argc>4){
+        printf("Usage : %s <SQUEEZE|COLLAPSE> <String to be processed> <Character to be squeezed, if operation is SQUEEZE>\n",argv[0]);
+        return 0;
+    }
+
+    if(strcmpi(argv[1],"SQUEEZE")==0 && argc!=4){
+        scanf("Please enter characted to be squeezed : %c",&squeezeChar);
+        operation = SQUEEZE;
+    }
+
+    else if(argc==4){
+        operation = SQUEEZE;
+        squeezeChar = argv[3][0];
+    }
+
+    else if(strcmpi(argv[1],"COLLAPSE")==0){
+        operation = COLLAPSE;
+    }
+
+    if(strlen(argv[2])<2){
+        printResults(argv[2],argv[2],operation,squeezeChar);
+    }
+
+    else{
+        printResults(argv[2],processString(argv[2],operation,squeezeChar),operation,squeezeChar);
+    }
+
+    return 0;
+}

Task/Determine-if-a-string-is-collapsible/CLU/determine-if-a-string-is-collapsible.clu

@@ -0,0 +1,44 @@
+% Collapse a string
+collapse = proc (s: string) returns (string)
+    out: array[char] := array[char]$[]
+    last: char := '\000'
+
+    for c: char in string$chars(s) do
+        if c ~= last then
+            last := c
+            array[char]$addh(out,c)
+        end
+    end
+    return (string$ac2s(out))
+end collapse
+
+% Show a string in brackets, with its length
+brackets = proc (s: string)
+    stream$putl(stream$primary_output(),
+                    int$unparse(string$size(s))
+                 || " <<<"
+                 || s
+                 || ">>>")
+end brackets
+
+% Show a string and its collapsed version, and the corresponding lengths
+show = proc (s: string)
+    brackets(s)
+    brackets(collapse(s))
+    stream$putl(stream$primary_output(), "")
+end show
+
+% Try the examples from the task description
+start_up = proc ()
+    examples: array[string] := array[string]$[
+        "",
+        "\"If I were two-faced, would I be wearing this one?\" --- Abraham Lincoln ",
+        "..1111111111111111111111111111111111111111111111111111111111111117777888",
+        "I never give 'em hell, I just tell the truth, and they think it's hell. ",
+        "                                                    --- Harry S Truman  "
+    ]
+
+    for ex: string in array[string]$elements(examples) do
+        show(ex)
+    end
+end start_up

Task/Determine-if-a-string-is-collapsible/Clojure/determine-if-a-string-is-collapsible.clj

@@ -0,0 +1,8 @@
+(defn collapse [s]
+  (let [runs (partition-by identity s)]
+    (apply str (map first runs))))
+
+(defn run-test [s]
+  (let [out (collapse s)]
+    (str (format "Input: <<<%s>>> (len %d)\n" s (count s))
+         (format "becomes: <<<%s>>> (len %d)\n" out (count out)))))

Task/Determine-if-a-string-is-collapsible/Cowgol/determine-if-a-string-is-collapsible.cowgol

@@ -0,0 +1,52 @@
+include "cowgol.coh";
+include "strings.coh";
+
+# Collapse the string at in, and store the result in the given buffer
+sub collapse(in: [uint8], out: [uint8]) is
+    var ch := [in];
+    in := @next in;
+    loop
+        if ch == 0 then
+            [out] := 0;
+            return;
+        elseif [in] != ch then
+            [out] := ch;
+            out := @next out;
+            ch := [in];
+        end if;
+        in := @next in;
+    end loop;
+end sub;
+
+# Given a string, collapse it and print all required output
+sub show(str: [uint8]) is
+    sub bracket_length(str: [uint8]) is
+        print_i32(StrLen(str) as uint32);
+        print(" <<<");
+        print(str);
+        print(">>>");
+        print_nl();
+    end sub;
+
+    var buf: uint8[256];
+    collapse(str, &buf[0]);
+    bracket_length(str);
+    bracket_length(&buf[0]);
+    print_nl();
+end sub;
+
+# Strings from the task
+var strings: [uint8][] := {
+"",
+"\"If I were two-faced, would I be wearing this one?\" --- Abraham Lincoln ",
+"..1111111111111111111111111111111111111111111111111111111111111117777888",
+"I never give 'em hell, I just tell the truth, and they think it's hell. ",
+"                                                    --- Harry S Truman  "
+};
+
+# Collapse and print each string
+var i: @indexof strings := 0;
+while i < @sizeof strings loop
+    show(strings[i]);
+    i := i + 1;
+end loop;

Task/Determine-if-a-string-is-collapsible/D/determine-if-a-string-is-collapsible.d

@@ -0,0 +1,27 @@
+import std.stdio;
+
+void collapsible(string s) {
+    writeln("old: <<<", s, ">>>, length = ", s.length);
+
+    write("new: <<<");
+    char last = '\0';
+    int len = 0;
+    foreach (c; s) {
+        if (c != last) {
+            write(c);
+            len++;
+        }
+        last = c;
+    }
+    writeln(">>>, length = ", len);
+
+    writeln;
+}
+
+void main() {
+    collapsible(``);
+    collapsible(`"If I were two-faced, would I be wearing this one?" --- Abraham Lincoln `);
+    collapsible(`..1111111111111111111111111111111111111111111111111111111111111117777888`);
+    collapsible(`I never give 'em hell, I just tell the truth, and they think it's hell. `);
+    collapsible(`                                                    --- Harry S Truman  `);
+}

Task/Determine-if-a-string-is-collapsible/Delphi/determine-if-a-string-is-collapsible.delphi

@@ -0,0 +1,36 @@
+program Determine_if_a_string_is_collapsible;
+
+{$APPTYPE CONSOLE}
+
+uses
+  System.SysUtils;
+
+procedure collapsible(s: string);
+var
+  c, last: char;
+  len: Integer;
+begin
+  writeln('old: <<<', s, '>>>, length = ', s.length);
+  write('new: <<<');
+  last := #0;
+  len := 0;
+  for c in s do
+  begin
+    if c <> last then
+    begin
+      write(c);
+      inc(len);
+    end;
+    last := c;
+  end;
+  writeln('>>>, length = ', len, #10);
+end;
+
+begin
+  collapsible('');
+  collapsible('"If I were two-faced, would I be wearing this one?" --- Abraham Lincoln ');
+  collapsible('..1111111111111111111111111111111111111111111111111111111111111117777888');
+  collapsible('I never give ''em hell, I just tell the truth, and they think it''s hell. ');
+  collapsible('                                                    --- Harry S Truman  ');
+  readln;
+end.

Task/Determine-if-a-string-is-collapsible/F-Sharp/determine-if-a-string-is-collapsible.fs

@@ -0,0 +1,17 @@
+// Collapse a String. Nigel Galloway: June 9th., 2020
+//As per the task description a function which 'determines if a character string is collapsible' by testing if any consecutive characters are the same.
+let isCollapsible n=n|>Seq.pairwise|>Seq.tryFind(fun(n,g)->n=g)
+//As per the task description a function which 'if the string is collapsable, collapses the string (by removing immediately repeated characters).
+let collapse n=match isCollapsible n with
+                Some _->let i=Seq.head n
+                        let fN=let mutable g=i in (fun n->if n=g then false else g<-n; true)
+                        let g=System.String([|yield i;yield! Seq.tail n|>Seq.filter fN|])
+                        printfn "<<<%s>>> (length %d) colapses to <<<%s>>> (length %d)" n n.Length g g.Length
+               |     _->printfn "<<<%s>>> (length %d) does not colapse" n n.Length
+
+collapse ""
+collapse "\"If I were two-faced, would I be wearing this one?\" --- Abraham Lincoln "
+collapse "..1111111111111111111111111111111111111111111111111111111111111117777888"
+collapse "I never give 'em hell, I just tell the truth, and they think it's hell. "
+collapse "                                                    --- Harry S Truman  "
+collapse "withoutConsecutivelyRepeatedCharacters"

Task/Determine-if-a-string-is-collapsible/Factor/determine-if-a-string-is-collapsible.factor

@@ -0,0 +1,29 @@
+USING: formatting io kernel sbufs sequences strings ;
+IN: rosetta-code.string-collapse
+
+: (collapse) ( str -- str )
+    unclip-slice 1string >sbuf
+    [ over last over = [ drop ] [ suffix! ] if ] reduce >string ;
+
+: collapse ( str -- str ) [ "" ] [ (collapse) ] if-empty ;
+
+: .str ( str -- ) dup length "«««%s»»» (length %d)\n" printf ;
+
+: show-collapse ( str -- )
+    [ "Before collapse: " write .str ]
+    [ "After  collapse: " write collapse .str ] bi nl ;
+
+: collapse-demo ( -- )
+    {
+        ""
+        "\"If I were two-faced, would I be wearing this one?\" --- Abraham Lincoln "
+        "..1111111111111111111111111111111111111111111111111111111111111117777888"
+        "I never give 'em hell, I just tell the truth, and they think it's hell. "
+        "                                                   ---  Harry S Truman  "
+        "The better the 4-wheel drive, the further you'll be from help when ya get stuck!"
+        "headmistressship"
+        "aardvark"
+        "😍😀🙌💃😍😍😍🙌"
+    } [ show-collapse ] each ;
+
+MAIN: collapse-demo

Task/Determine-if-a-string-is-collapsible/FreeBASIC/determine-if-a-string-is-collapsible.basic

@@ -0,0 +1,30 @@
+Const numCad = 5
+Data ""
+Data "'If I were two-faced, would I be wearing this one?' --- Abraham Lincoln "
+Data "..1111111111111111111111111111111111111111111111111111111111111117777888"
+Data "I never give 'em hell, I just tell the truth, and they think it's hell. "
+Data "                                                    --- Harry S Truman  "
+
+Dim Shared As String cadIN, cadOUT
+
+Sub Collapse
+    Dim As String a, b
+    If cadIN = "" Then cadOUT = cadIN: Exit Sub
+    cadOUT = Space(Len(cadIN))
+    a = Left(cadIN,1)
+    Mid(cadOUT,1,1) = a
+    Dim As Integer txtOUT = 2
+    For i As Integer = 2 To Len(cadIN)
+        b = Mid(cadIN,i,1)
+        If a <> b Then Mid(cadOUT,txtOUT,1) = b: txtOUT += 1: a = b
+    Next i
+    cadOUT = Left(cadOUT,txtOUT-1)
+End Sub
+
+For j As Integer = 1 To numCad
+    Read cadIN
+    Collapse
+    Print " <<<"; cadIN; ">>> (longitud "; Len(cadIN); _
+    !")\n    se pliega a:\n <<<"; cadOUT; ">>> (longitud "; Len(cadOUT); !")\n"
+Next j
+Sleep

Task/Determine-if-a-string-is-collapsible/Frink/determine-if-a-string-is-collapsible.frink

@@ -0,0 +1,10 @@
+collapse[str] := str =~ %s/(.)\1+/$1/g
+
+lines = ["",
+         """"If I were two-faced, would I be wearing this one?" --- Abraham Lincoln """,
+"..1111111111111111111111111111111111111111111111111111111111111117777888",
+"I never give 'em hell, I just tell the truth, and they think it's hell. ",
+"                                                    --- Harry S Truman  "]
+
+for line = lines
+   println[collapse[line]]

Task/Determine-if-a-string-is-collapsible/FutureBasic/determine-if-a-string-is-collapsible.basic

@@ -0,0 +1,41 @@
+local fn CollapseString( inString as CFStringRef ) as CFStringRef
+  CFMutableStringRef outString = fn MutableStringWithCapacity(0)
+  long index
+  unichar prevChar = 0, currChar
+
+  for index = 0 to len(inString) - 1
+    currChar = fn StringCharacterAtIndex( inString, index )
+    if ( currChar != prevChar ) then MutableStringAppendFormat( outString, @"%C", currChar )
+    prevChar = currChar
+  next
+end fn = outString
+
+window 1, @"Collapse String", (0,0,600,300)
+
+CFStringRef string, collapsedString
+
+string = @""
+collapsedString = fn CollapseString( string )
+printf @"<<<%@>>> %ld\n<<<%@>>> %ld\n",string,len(string),collapsedString,len(collapsedString)
+
+string = @"\"If I were two-faced, would I be wearing this one?\" --- Abraham Lincoln "
+collapsedString = fn CollapseString( string )
+printf@"<<<%@>>> %ld\n<<<%@>>> %ld\n",string,len(string),collapsedString,len(collapsedString)
+
+string = @"..1111111111111111111111111111111111111111111111111111111111111117777888"
+collapsedString = fn CollapseString( string )
+printf@"<<<%@>>> %ld\n<<<%@>>> %ld\n",string,len(string),collapsedString,len(collapsedString)
+
+string = @"I never give 'em hell, I just tell the truth, and they think it's hell. "
+collapsedString = fn CollapseString( string )
+printf@"<<<%@>>> %ld\n<<<%@>>> %ld\n",string,len(string),collapsedString,len(collapsedString)
+
+string = @"                                                    --- Harry S Truman  "
+collapsedString = fn CollapseString( string )
+printf@"<<<%@>>> %ld\n<<<%@>>> %ld\n",string,len(string),collapsedString,len(collapsedString)
+
+string = @"\"AAAAAll that glitters is not goldDDDD.\" - William Shakespeare"
+collapsedString = fn CollapseString( string )
+printf@"<<<%@>>> %ld\n<<<%@>>> %ld\n",string,len(string),collapsedString,len(collapsedString)
+
+HandleEvents

Task/Determine-if-a-string-is-collapsible/Go/determine-if-a-string-is-collapsible.go

@@ -0,0 +1,40 @@
+package main
+
+import "fmt"
+
+// Returns collapsed string, original and new lengths in
+// unicode code points (not normalized).
+func collapse(s string) (string, int, int) {
+    r := []rune(s)
+    le, del := len(r), 0
+    for i := le - 2; i >= 0; i-- {
+        if r[i] == r[i+1] {
+            copy(r[i:], r[i+1:])
+            del++
+        }
+    }
+    if del == 0 {
+        return s, le, le
+    }
+    r = r[:le-del]
+    return string(r), le, len(r)
+}
+
+func main() {
+    strings:= []string {
+        "",
+        `"If I were two-faced, would I be wearing this one?" --- Abraham Lincoln `,
+        "..1111111111111111111111111111111111111111111111111111111111111117777888",
+        "I never give 'em hell, I just tell the truth, and they think it's hell. ",
+        "                                                   ---  Harry S Truman  ",
+        "The better the 4-wheel drive, the further you'll be from help when ya get stuck!",
+        "headmistressship",
+        "aardvark",
+        "😍😀🙌💃😍😍😍🙌",
+    }
+    for _, s := range strings {
+        cs, olen, clen := collapse(s)
+        fmt.Printf("original : length = %2d, string = «««%s»»»\n", olen, s)
+        fmt.Printf("collapsed: length = %2d, string = «««%s»»»\n\n", clen, cs)
+    }
+}

Task/Determine-if-a-string-is-collapsible/Groovy/determine-if-a-string-is-collapsible.groovy

@@ -0,0 +1,26 @@
+class StringCollapsible {
+    static void main(String[] args) {
+        for ( String s : [
+                "",
+                "\"If I were two-faced, would I be wearing this one?\" --- Abraham Lincoln ",
+                "..1111111111111111111111111111111111111111111111111111111111111117777888",
+                "I never give 'em hell, I just tell the truth, and they think it's hell. ",
+                "                                                    --- Harry S Truman  ",
+                "122333444455555666666777777788888888999999999",
+                "The better the 4-wheel drive, the further you'll be from help when ya get stuck!",
+                "headmistressship"]) {
+            String result = collapse(s)
+            System.out.printf("old:  %2d <<<%s>>>%nnew:  %2d <<<%s>>>%n%n", s.length(), s, result.length(), result)
+        }
+    }
+
+    private static String collapse(String input) {
+        StringBuilder sb = new StringBuilder()
+        for ( int i = 0 ; i < input.length() ; i++ ) {
+            if ( i == 0 || input.charAt(i-1) != input.charAt(i) ) {
+                sb.append(input.charAt(i))
+            }
+        }
+        return sb.toString()
+    }
+}

Task/Determine-if-a-string-is-collapsible/Haskell/determine-if-a-string-is-collapsible-1.hs

@@ -0,0 +1,22 @@
+import Text.Printf (printf)
+import Data.Maybe (catMaybes)
+import Control.Monad (guard)
+
+input :: [String]
+input = [ ""
+        , "The better the 4-wheel drive, the further you'll be from help when ya get stuck!"
+        , "headmistressship"
+        , "\"If I were two-faced, would I be wearing this one?\" --- Abraham Lincoln "
+        , "..1111111111111111111111111111111111111111111111111111111111111117777888"
+        , "I never give 'em hell, I just tell the truth, and they think it's hell. "
+        , "                                                    --- Harry S Truman  "
+        , "😍😀🙌💃😍😍😍🙌"
+        ]
+
+collapse :: Eq a => [a] -> [a]
+collapse = catMaybes . (\xs -> zipWith (\a b -> guard (a /= b) >> a) (Nothing : xs) (xs <> [Nothing])) . map Just
+
+main :: IO ()
+main =
+  mapM_ (\(a, b) -> printf "old: %3d «««%s»»»\nnew: %3d «««%s»»»\n\n" (length a) a (length b) b)
+  $ ((,) <*> collapse) <$> input

Task/Determine-if-a-string-is-collapsible/Haskell/determine-if-a-string-is-collapsible-2.hs

@@ -0,0 +1,7 @@
+import Data.List (group)
+
+isCollapsible :: String -> Bool
+isCollapsible = any ((1 <) . length) . group
+
+collapsed :: String -> String
+collapsed = map head . group

Task/Determine-if-a-string-is-collapsible/Haskell/determine-if-a-string-is-collapsible-3.hs

@@ -0,0 +1,11 @@
+isCollapsible :: String -> Bool
+isCollapsible [] = False
+isCollapsible [_] = False
+isCollapsible (h:t@(x:_)) = h == x || isCollapsible t
+
+collapsed :: String -> String
+collapsed [] = []
+collapsed [x] = [x]
+collapsed (h:t@(x:_))
+  | h == x = collapsed t
+  | otherwise = h : collapsed t

Task/Determine-if-a-string-is-collapsible/Java/determine-if-a-string-is-collapsible.java

@@ -0,0 +1,30 @@
+//  Title:  Determine if a string is collapsible
+
+public class StringCollapsible {
+
+    public static void main(String[] args) {
+        for ( String s : new String[] {
+              "",
+              "\"If I were two-faced, would I be wearing this one?\" --- Abraham Lincoln ",
+              "..1111111111111111111111111111111111111111111111111111111111111117777888",
+              "I never give 'em hell, I just tell the truth, and they think it's hell. ",
+              "                                                    --- Harry S Truman  ",
+              "122333444455555666666777777788888888999999999",
+              "The better the 4-wheel drive, the further you'll be from help when ya get stuck!",
+              "headmistressship"}) {
+            String result = collapse(s);
+            System.out.printf("old:  %2d <<<%s>>>%nnew:  %2d <<<%s>>>%n%n", s.length(), s, result.length(), result);
+        }
+    }
+
+    private static String collapse(String in) {
+        StringBuilder sb = new StringBuilder();
+        for ( int i = 0 ; i < in.length() ; i++ ) {
+            if ( i == 0 || in.charAt(i-1) != in.charAt(i) ) {
+                sb.append(in.charAt(i));
+            }
+        }
+        return sb.toString();
+    }
+
+}

Task/Determine-if-a-string-is-collapsible/JavaScript/determine-if-a-string-is-collapsible.js

@@ -0,0 +1,21 @@
+String.prototype.collapse = function() {
+  let str = this;
+  for (let i = 0; i < str.length; i++) {
+    while (str[i] == str[i+1]) str = str.substr(0,i) + str.substr(i+1);
+  }
+  return str;
+}
+
+// testing
+let strings = [
+  '',
+  '"If I were two-faced, would I be wearing this one?" --- Abraham Lincoln ',
+  '..1111111111111111111111111111111111111111111111111111111111111117777888',
+  `I never give 'em hell, I just tell the truth, and they think it's hell. `,
+  '                                                    --- Harry S Truman  '
+];
+for (let i = 0; i < strings.length; i++) {
+  let str = strings[i], col = str.collapse();
+  console.log(`«««${str}»»» (${str.length})`);
+  console.log(`«««${col}»»» (${col.length})`);
+}

Task/Determine-if-a-string-is-collapsible/Jq/determine-if-a-string-is-collapsible-1.jq

@@ -0,0 +1,5 @@
+# Input: an array
+# Output: a stream
+def uniq: foreach .[] as $x ({x:nan, y:.[0]}; {x:$x, y:.x}; select(.x != .y) | .x);
+
+def collapse: explode | [uniq] | implode;

Task/Determine-if-a-string-is-collapsible/Jq/determine-if-a-string-is-collapsible-2.jq

@@ -0,0 +1,4 @@
+def Guillemets: "«««\(.)»»»";
+
+"Original: \(Guillemets) has length \(length)",
+(collapse | "Collapsed \(Guillemets) has length \(length)")

Task/Determine-if-a-string-is-collapsible/Jq/determine-if-a-string-is-collapsible-3.jq

@@ -0,0 +1,10 @@
+Original: «««»»» has length 0
+Collapsed «««»»» has length 0
+Original: «««"If I were two-faced, would I be wearing this one?" --- Abraham Lincoln »»» has length 72
+Collapsed «««"If I were two-faced, would I be wearing this one?" - Abraham Lincoln »»» has length 70
+Original: «««..1111111111111111111111111111111111111111111111111111111111111117777888»»» has length 72
+Collapsed «««.178»»» has length 4
+Original: «««I never give 'em hell, I just tell the truth, and they think it's hell. »»» has length 72
+Collapsed «««I never give 'em hel, I just tel the truth, and they think it's hel. »»» has length 69
+Original: «««                                                    --- Harry S Truman  »»» has length 72
+Collapsed ««« - Hary S Truman »»» has length 17

Task/Determine-if-a-string-is-collapsible/Julia/determine-if-a-string-is-collapsible-1.julia

@@ -0,0 +1,30 @@
+const teststrings = [
+    "",
+    """"If I were two-faced, would I be wearing this one?" --- Abraham Lincoln """,
+    "..1111111111111111111111111111111111111111111111111111111111111117777888",
+    """I never give 'em hell, I just tell the truth, and they think it's hell. """,
+    "                                                    --- Harry S Truman  "]
+
+function collapse(s)
+    len = length(s)
+    if len < 2
+        return s, len, s, len
+    end
+    result = last = s[1]
+    for c in s[2:end]
+        if c != last
+            last = c
+            result *= c
+        end
+    end
+    return s, len, result, length(result)
+end
+
+function testcollapse(arr)
+    for s in arr
+        (s1, len1, s2, len2) = collapse(s)
+        println("«««$s1»»» (length $len1)\n    collapses to:\n«««$s2»»» (length $len2).\n")
+    end
+end
+
+testcollapse(teststrings)

Task/Determine-if-a-string-is-collapsible/Julia/determine-if-a-string-is-collapsible-2.julia

@@ -0,0 +1,13 @@
+const teststrings = [
+    "",
+    """"If I were two-faced, would I be wearing this one?" --- Abraham Lincoln """,
+    "..1111111111111111111111111111111111111111111111111111111111111117777888",
+    """I never give 'em hell, I just tell the truth, and they think it's hell. """,
+    "                                                    --- Harry S Truman  "]
+
+collapse(s) = (t = isempty(s) ? "" : s[1:1]; for c in s if c != t[end] t *= c end; end; t)
+
+for s in teststrings
+    n, t = length(s), collapse(s)
+    println("«««$s»»» (length $n)\n    collapses to:\n«««$t»»» (length $(length(t))).\n")
+end

Task/Determine-if-a-string-is-collapsible/Kotlin/determine-if-a-string-is-collapsible.kotlin

@@ -0,0 +1,30 @@
+fun collapse(s: String): String {
+    val cs = StringBuilder()
+    var last: Char = 0.toChar()
+    for (c in s) {
+        if (c != last) {
+            cs.append(c)
+            last = c
+        }
+    }
+    return cs.toString()
+}
+
+fun main() {
+    val strings = arrayOf(
+        "",
+        "\"If I were two-faced, would I be wearing this one?\" --- Abraham Lincoln ",
+        "..1111111111111111111111111111111111111111111111111111111111111117777888",
+        "I never give 'em hell, I just tell the truth, and they think it's hell. ",
+        "                                                   ---  Harry S Truman  ",
+        "The better the 4-wheel drive, the further you'll be from help when ya get stuck!",
+        "headmistressship",
+        "aardvark"
+    )
+    for (s in strings) {
+        val c = collapse(s)
+        println("original : length = ${s.length}, string = «««$s»»»")
+        println("collapsed : length = ${c.length}, string = «««$c»»»")
+        println()
+    }
+}

Task/Determine-if-a-string-is-collapsible/Ksh/determine-if-a-string-is-collapsible.ksh

@@ -0,0 +1,42 @@
+#!/bin/ksh
+
+# Determine if a string is collapsible (repeated letters)
+
+#	# Variables:
+#
+typeset -a strings
+strings[0]=""
+strings[1]='"If I were two-faced, would I be wearing this one?" --- Abraham Lincoln'
+strings[2]="..1111111111111111111111111111111111111111111111111111111111111117777888"
+strings[3]="I never give 'em hell, I just tell the truth, and they think it's hell."
+strings[4]="                                                    --- Harry S Truman"
+
+typeset -a Guillemet=( "«««" "»»»" )
+
+#	# Functions:
+#
+#	# Function _collapse(str) - return colapsed version of str
+#
+function _collapse {
+	typeset _str ; _str="$1"
+	typeset _i _buff ; integer _i
+
+	for ((_i=1; _i<${#_str}; _i++)); do
+		if [[ "${_str:$((_i-1)):1}" == "${_str:${_i}:1}" ]]; then
+			continue
+		else
+			_buff+=${_str:$((_i-1)):1}
+		fi
+	done
+	[[ "${_str:$((_i-1)):1}" != "${_str:${_i}:1}" ]] && _buff+=${_str:$((_i-1)):1}
+	echo "${_buff}"
+}
+
+ ######
+# main #
+ ######
+for ((i=0; i<${#strings[*]}; i++)); do
+	str=$(_collapse "${strings[i]}")
+	print ${#strings[i]} "${Guillemet[0]}${strings[i]}${Guillemet[1]}"
+	print ${#str} "${Guillemet[0]}${str}${Guillemet[1]}\n"
+done

Task/Determine-if-a-string-is-collapsible/Lua/determine-if-a-string-is-collapsible.lua

@@ -0,0 +1,34 @@
+function collapse(s)
+    local ns = ""
+    local last = nil
+    for c in s:gmatch"." do
+        if last then
+            if last ~= c then
+                ns = ns .. c
+            end
+            last = c
+        else
+            ns = ns .. c
+            last = c
+        end
+    end
+    return ns
+end
+
+function test(s)
+    print("old: " .. s:len() .. " <<<" .. s .. ">>>")
+    local a = collapse(s)
+    print("new: " .. a:len() .. " <<<" .. a .. ">>>")
+end
+
+function main()
+    test("")
+    test("The better the 4-wheel drive, the further you'll be from help when ya get stuck!")
+    test("headmistressship")
+    test("\"If I were two-faced, would I be wearing this one?\" --- Abraham Lincoln ")
+    test("..1111111111111111111111111111111111111111111111111111111111111117777888")
+    test("I never give 'em hell, I just tell the truth, and they think it's hell. ")
+    test("                                                    --- Harry S Truman  ")
+end
+
+main()

Task/Determine-if-a-string-is-collapsible/MATLAB/determine-if-a-string-is-collapsible.m

@@ -0,0 +1,20 @@
+function r = collapse(s)
+  ix=find((s(1:end-1)==s(2:end))+1;
+  r=s;
+  r(ix)=[];
+
+  fprintf(1,'Input:  <<<%s>>>  length: %d\n',s,length(s));
+  fprintf(1,'Output: <<<%s>>>  length: %d\n',r,length(r));
+  fprintf(1,'Character to be squeezed: "%s"\n',c);
+
+end
+
+
+collapse('', ' ')
+collapse('║╚═══════════════════════════════════════════════════════════════════════╗', '-')
+collapse('║"If I were two-faced, would I be wearing this one?" --- Abraham Lincoln ║', '7')
+collapse('║..1111111111111111111111111111111111111111111111111111111111111117777888║', '.')
+collapse('║I never give ''em hell, I just tell the truth, and they think it''s hell. ║', '.')
+collapse('║                                                    --- Harry S Truman  ║', '.')
+collapse('║                                                    --- Harry S Truman  ║', '-')
+collapse('║                                                    --- Harry S Truman  ║', 'r')

Task/Determine-if-a-string-is-collapsible/Mathematica/determine-if-a-string-is-collapsible.math

@@ -0,0 +1,15 @@
+ClearAll[StringCollapse]
+StringCollapse[s_String] := FixedPoint[StringReplace[y_ ~~ y_ :> y], s]
+strings = {"",
+"\"If I were two-faced, would I be wearing this one?\" --- Abraham Lincoln ",
+"..1111111111111111111111111111111111111111111111111111111111111117777888",
+"I never give 'em hell, I just tell the truth, and they think it's hell. ",
+"                                                    --- Harry S Truman  "};
+Do[
+ Print["«««" <> s <> "»»»"];
+ Print["Length = ", StringLength[s]];
+ Print["«««" <> StringCollapse[s] <> "»»»"];
+ Print["Length = ", StringLength[StringCollapse[s]]]
+ ,
+ {s, strings}
+ ]

Task/Determine-if-a-string-is-collapsible/Miranda/determine-if-a-string-is-collapsible.miranda

@@ -0,0 +1,26 @@
+main :: [sys_message]
+main = [Stdout (lay (map test tests))]
+
+tests :: [[char]]
+tests
+= [
+  "",
+  "\"If I were two-faced, would I be wearing this one?\" --- Abraham Lincoln ",
+  "..1111111111111111111111111111111111111111111111111111111111111111111788",
+  "I never give 'em hell, I just tell the truth, and they think it's hell. ",
+  "                                                     --- Harry S Truman "
+  ]
+
+test :: [char]->[char]
+test s = lay [before, after]
+         where before = disp s
+               after  = disp (collapse s)
+
+disp :: [char]->[char]
+disp s = show (#s) ++ ": <<<" ++ s ++ ">>>"
+
+collapse :: [*]->[*]
+collapse []       = []
+collapse [x]      = [x]
+collapse (x:y:xs) = collapse (y:xs),   if x=y
+                  = x:collapse (y:xs), otherwise

Task/Determine-if-a-string-is-collapsible/Modula-2/determine-if-a-string-is-collapsible.mod2

@@ -0,0 +1,45 @@
+MODULE StrCollapse;
+FROM InOut IMPORT WriteString, WriteCard, WriteLn;
+FROM Strings IMPORT Length;
+
+(* Collapse a string *)
+PROCEDURE Collapse(in: ARRAY OF CHAR; VAR out: ARRAY OF CHAR);
+    VAR i, o: CARDINAL;
+BEGIN
+    i := 0;
+    o := 0;
+    WHILE (i < HIGH(in)) AND (in[i] # CHR(0)) DO
+        IF (o = 0) OR (out[o-1] # in[i]) THEN
+            out[o] := in[i];
+            INC(o);
+        END;
+        INC(i);
+    END;
+    out[o] := CHR(0);
+END Collapse;
+
+(* Display a string and collapse it as stated in the task *)
+PROCEDURE Task(s: ARRAY OF CHAR);
+    VAR buf: ARRAY [0..127] OF CHAR;
+    PROCEDURE LengthAndBrackets(s: ARRAY OF CHAR);
+    BEGIN
+        WriteCard(Length(s), 2);
+        WriteString(" <<<");
+        WriteString(s);
+        WriteString(">>>");
+        WriteLn();
+    END LengthAndBrackets;
+BEGIN
+    LengthAndBrackets(s);
+    Collapse(s, buf);
+    LengthAndBrackets(buf);
+    WriteLn();
+END Task;
+
+BEGIN
+    Task("");
+    Task('"If I were two-faced, would I be wearing this one?" --- Abraham Lincoln ');
+    Task("..1111111111111111111111111111111111111111111111111111111111111117777888");
+    Task("I never give 'em hell, I just tell the truth, and they think it's hell. ");
+    Task("                                                    --- Harry S Truman  ");
+END StrCollapse.

Task/Determine-if-a-string-is-collapsible/NetLogo/determine-if-a-string-is-collapsible.netlogo

@@ -0,0 +1,34 @@
+to-report split [ string ]
+  ;; utility reporter to split a string into a list
+  report n-values length string [ [ n ] -> item n string ]
+end
+
+to-report collapse [ string ]
+  ;; reporter that actually does the collapse function
+  ifelse ( string = "" )
+  [ report "" ]
+  [ report reduce [ [ a b ] -> (word a ifelse-value last a != b [ b ] [ "" ] ) ] split string ]
+end
+
+to-report format [ string ]
+  ;; reporter to format the output as required
+  report ( word "<<<" string ">>> " length string )
+end
+
+to demo-collapse [ string ]
+  ;; procedure to display the required output
+  output-print format string
+  output-print format collapse string
+end
+
+to demo
+  ;; procedure to perform the test cases
+  foreach
+  [ ""
+    "\"If I were two-faced, would I be wearing this one?\" --- Abraham Lincoln "
+    "..1111111111111111111111111111111111111111111111111111111111111117777888"
+    "I never give 'em hell, I just tell the truth, and they think it's hell. "
+    "                                                    --- Harry S Truman  "
+  ]
+  demo-collapse
+end

Task/Determine-if-a-string-is-collapsible/Nim/determine-if-a-string-is-collapsible.nim

@@ -0,0 +1,28 @@
+import unicode, strformat
+
+proc collapse(s: string) =
+  let original = s.toRunes
+  echo fmt"Original:  length = {original.len}, string = «««{s}»»»"
+  var previous = Rune(0)
+  var collapsed: seq[Rune]
+  for rune in original:
+    if rune != previous:
+      collapsed.add(rune)
+      previous = rune
+  echo fmt"Collapsed: length = {collapsed.len}, string = «««{collapsed}»»»"
+  echo ""
+
+
+const Strings = ["",
+        "\"If I were two-faced, would I be wearing this one?\" --- Abraham Lincoln ",
+        "..1111111111111111111111111111111111111111111111111111111111111117777888",
+        "I never give 'em hell, I just tell the truth, and they think it's hell. ",
+        "                                                   ---  Harry S Truman  ",
+        "The better the 4-wheel drive, the further you'll be from help when ya get stuck!",
+        "headmistressship",
+        "aardvark",
+        "😍😀🙌💃😍😍😍🙌",]
+
+
+for s in Strings:
+  s.collapse()

Task/Determine-if-a-string-is-collapsible/PHP/determine-if-a-string-is-collapsible.php

@@ -0,0 +1,42 @@
+<?php
+
+function collapseString($string) {
+    $previousChar = null;
+    $collapse = '';
+    $charArray = preg_split('//u', $string, -1, PREG_SPLIT_NO_EMPTY);
+    for ($i = 0 ; $i < count($charArray) ; $i++) {
+        $currentChar = $charArray[$i];
+        if ($previousChar !== $currentChar) {
+            $collapse .= $charArray[$i];
+        }
+        $previousChar = $currentChar;
+    }
+    return $collapse;
+}
+
+function isCollapsible($string) {
+    return ($string !== collapseString($string));
+}
+
+$strings = array(
+    '',
+    'another non colapsing string',
+    '"If I were two-faced, would I be wearing this one?" --- Abraham Lincoln ',
+    '..1111111111111111111111111111111111111111111111111111111111111117777888',
+    "I never give 'em hell, I just tell the truth, and they think it's hell. ",
+    '                                                    --- Harry S Truman  ',
+    '0112223333444445555556666666777777778888888889999999999',
+    "The better the 4-wheel drive, the further you'll be from help when ya get stuck!",
+    'headmistressship',
+    "😍😀🙌💃😍😍😍🙌",
+);
+
+foreach ($strings as $original) {
+    echo 'Original : <<<', $original, '>>> (len=', mb_strlen($original), ')', PHP_EOL;
+    if (isCollapsible($original)) {
+        $collapse = collapseString($original);
+        echo 'Collapse : <<<', $collapse, '>>> (len=', mb_strlen($collapse), ')', PHP_EOL, PHP_EOL;
+    } else {
+        echo 'Collapse : string is not collapsing...', PHP_EOL, PHP_EOL;
+    }
+}

Task/Determine-if-a-string-is-collapsible/PL-M/determine-if-a-string-is-collapsible.plm

@@ -0,0 +1,79 @@
+100H:
+BDOS: PROCEDURE (FN, ARG); DECLARE FN BYTE, ARG ADDRESS; GO TO 5; END BDOS;
+EXIT: PROCEDURE; CALL BDOS(0,0); END EXIT;
+PRINT: PROCEDURE (S); DECLARE S ADDRESS; CALL BDOS(9, S); END PRINT;
+
+/* PRINT NUMBER */
+PRINT$NUMBER: PROCEDURE (N);
+    DECLARE S (6) BYTE INITIAL ('.....$');
+    DECLARE (N, P) ADDRESS, C BASED P BYTE;
+    P = .S(5);
+DIGIT:
+    P = P - 1;
+    C = N MOD 10 + '0';
+    N = N / 10;
+    IF N > 0 THEN GO TO DIGIT;
+    CALL PRINT(P);
+END PRINT$NUMBER;
+
+/* STRING LENGTH */
+STR$LEN: PROCEDURE (STR) ADDRESS;
+    DECLARE (STR, I) ADDRESS, S BASED STR BYTE;
+    I = 0;
+    DO WHILE S(I) <> '$';
+        I = I + 1;
+    END;
+    RETURN I;
+END STR$LEN;
+
+/* COLLAPSE */
+COLLAPSE: PROCEDURE (IN, OUT);
+    DECLARE (IN, OUT) ADDRESS, (I BASED IN, O BASED OUT, C) BYTE;
+    C = I;
+    DO WHILE C <> '$';
+        IN = IN + 1;
+        IF I <> C THEN DO;
+            O = C;
+            OUT = OUT + 1;
+            C = I;
+        END;
+    END;
+    O = '$';
+END COLLAPSE;
+
+/* PRINT STRING AND LENGTH WITH BRACKETS */
+PRINT$BRACKETS: PROCEDURE (S);
+    DECLARE S ADDRESS;
+    CALL PRINT$NUMBER(STR$LEN(S));
+    CALL PRINT(.' <<<$');
+    CALL PRINT(S);
+    CALL PRINT(.('>>>',13,10,'$'));
+END PRINT$BRACKETS;
+
+/* GIVEN A STRING, PRINT IT AND ITS COLLAPSED FORM */
+SHOW: PROCEDURE (S);
+    DECLARE S ADDRESS, BUFFER (256) BYTE;
+    CALL COLLAPSE(S, .BUFFER);
+    CALL PRINT$BRACKETS(S);
+    CALL PRINT$BRACKETS(.BUFFER);
+    CALL PRINT(.(13,10,'$'));
+END SHOW;
+
+/* STRINGS FROM THE TASK */
+DECLARE X (5) ADDRESS;
+X(0)=.'$';
+X(1)=.('''IF I WERE TWO-FACED, WOULD I BE WEARING ',
+       'THIS ONE.'' --- ABRAHAM LINCOLN $');
+X(2)=.('..111111111111111111111111111111111111111',
+       '1111111111111111111111117777888$');
+X(3)=.('I NEVER GIVE ''EM HELL, I JUST TELL THE TR',
+       'UTH, AND THEY THINK IT''S HELL. $');
+X(4)=.('                                         ',
+       '            --- HARRY S TRUMAN $');
+
+DECLARE I BYTE;
+DO I=0 TO LAST(X);
+    CALL SHOW(X(I));
+END;
+CALL EXIT;
+EOF

Task/Determine-if-a-string-is-collapsible/Perl/determine-if-a-string-is-collapsible.pl

@@ -0,0 +1,22 @@
+use strict;
+use warnings;
+use utf8;
+binmode STDOUT, ":utf8";
+
+my @lines = split "\n", <<~'STRINGS';
+
+    "If I were two-faced, would I be wearing this one?" --- Abraham Lincoln
+    ..1111111111111111111111111111111111111111111111111111111111111117777888
+    I never give 'em hell, I just tell the truth, and they think it's hell.
+                                                        --- Harry S Truman
+    The American people have a right to know if their president is a crook.
+                                                        --- Richard Nixon
+    AАΑAАΑAАΑAАΑAАΑAАΑAАΑAАΑAАΑAАΑAАΑAАΑAАΑAАΑAАΑAАΑAАΑAАΑAАΑAАΑAАΑAАΑAАΑAАΑ
+    AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+    STRINGS
+
+for (@lines) {
+    my $squish = s/(.)\1+/$1/gr;
+    printf "\nLength: %2d <<<%s>>>\nCollapsible: %s\nLength: %2d <<<%s>>>\n",
+      length($_), $_, $_ ne $squish ? 'True' : 'False', length($squish), $squish
+}

Task/Determine-if-a-string-is-collapsible/Phix/determine-if-a-string-is-collapsible.phix

@@ -0,0 +1,34 @@
+(phixonline)-->
+ <span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
+ <span style="color: #008080;">constant</span> <span style="color: #000000;">tests</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{</span><span style="color: #008000;">""</span><span style="color: #0000FF;">,</span>
+                   <span style="color: #008000;">`"If I were two-faced, would I be wearing this one?" --- Abraham Lincoln `</span><span style="color: #0000FF;">,</span>
+                   <span style="color: #008000;">"..1111111111111111111111111111111111111111111111111111111111111117777888"</span><span style="color: #0000FF;">,</span>
+                   <span style="color: #008000;">"I never give 'em hell, I just tell the truth, and they think it's hell. "</span><span style="color: #0000FF;">,</span>
+                   <span style="color: #008000;">"                                                    --- Harry S Truman  "</span><span style="color: #0000FF;">},</span>
+          <span style="color: #000000;">fmt</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">"""		
+ length %2d  input: &lt;&lt;&lt;%s&gt;&gt;&gt;
+ length %2d output: &lt;&lt;&lt;%s&gt;&gt;&gt;
+ """</span>
+ <span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">tests</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">do</span>
+     <span style="color: #004080;">string</span> <span style="color: #000000;">ti</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">tests</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">],</span> <span style="color: #000000;">ci</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">unique</span><span style="color: #0000FF;">(</span><span style="color: #000000;">ti</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">"PRESORTED"</span><span style="color: #0000FF;">)</span>
+     <span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">fmt</span><span style="color: #0000FF;">,{</span><span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">ti</span><span style="color: #0000FF;">),</span><span style="color: #000000;">ti</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">ci</span><span style="color: #0000FF;">),</span><span style="color: #000000;">ci</span><span style="color: #0000FF;">})</span>
+ <span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
+
+ <span style="color: #008080;">function</span> <span style="color: #000000;">collapsible</span><span style="color: #0000FF;">(</span><span style="color: #004080;">string</span> <span style="color: #000000;">t</span><span style="color: #0000FF;">)</span>
+ <span style="color: #000080;font-style:italic;">--  sequence utf32 = utf8_to_utf32(t) -- maybe
+ --  for i=2 to length(utf32) do       --  """
+ --      if utf32[i]=utf32[i-1] then   --  """</span>
+     <span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">2</span> <span style="color: #008080;">to</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">t</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">do</span>
+         <span style="color: #008080;">if</span> <span style="color: #000000;">t</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">]=</span><span style="color: #000000;">t</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">-</span><span style="color: #000000;">1</span><span style="color: #0000FF;">]</span> <span style="color: #008080;">then</span>
+             <span style="color: #008080;">return</span> <span style="color: #004600;">true</span>
+         <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
+     <span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
+     <span style="color: #008080;">return</span> <span style="color: #004600;">false</span>
+ <span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
+
+ <span style="color: #7060A8;">puts</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"\nAs predicate: "</span><span style="color: #0000FF;">)</span>
+ <span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">tests</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">do</span>
+     <span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%t "</span><span style="color: #0000FF;">,</span><span style="color: #000000;">collapsible</span><span style="color: #0000FF;">(</span><span style="color: #000000;">tests</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">]))</span>
+ <span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
+ <span style="color: #7060A8;">puts</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"\n"</span><span style="color: #0000FF;">)</span>
+<!--

Task/Determine-if-a-string-is-collapsible/Prolog/determine-if-a-string-is-collapsible.pro

@@ -0,0 +1,9 @@
+collapse_( [], [] ).
+collapse_( [A], [A] ).
+collapse_( [A,A|T], R ) :- collapse_( [A|T], R ).
+collapse_( [A,B|T], [A|R] ) :- dif( A, B ), collapse_( [B|T], R ).
+
+collapse( Str, Collapsed ) :-
+    string_chars( Str, Chars ),
+    collapse_( Chars, Result ),
+    string_chars( Collapsed, Result ).

Task/Determine-if-a-string-is-collapsible/PureBasic/determine-if-a-string-is-collapsible.basic

@@ -0,0 +1,36 @@
+EnableExplicit
+DataSection
+  STR1:
+  Data.s ""
+  STR2:
+  Data.s "'If I were two-faced, would I be wearing this one?' --- Abraham Lincoln "
+  STR3:
+  Data.s "..1111111111111111111111111111111111111111111111111111111111111117777888"
+  STR4:
+  Data.s "I never give 'em hell, I just tell the truth, and they think it's hell. "
+  STR5:
+  Data.s "                                                    --- Harry S Truman  "
+EndDataSection
+
+Procedure.s collapse(txt$)
+  Define *c.Character=@txt$, last.c=0, result$
+  While *c\c
+    If *c\c<>last
+      result$+Chr(*c\c)
+      last=*c\c
+    EndIf
+    *c+SizeOf(Character)
+  Wend
+  ProcedureReturn result$
+EndProcedure
+
+OpenConsole("")
+Define *p_data=?STR1, buf$
+While *p_data<=?STR4+StringByteLength(PeekS(?STR4))+2
+  buf$=PeekS(*p_data)
+  PrintN("Before collapse: «««"+buf$+"»»» (length: "+Str(Len(buf$))+")")
+  buf$=collapse(PeekS(*p_data))
+  PrintN("After  collapse: «««"+buf$+~"»»» (length: "+Str(Len(buf$))+~")\n")
+  *p_data+StringByteLength(PeekS(*p_data))+2
+Wend
+Input()

Task/Determine-if-a-string-is-collapsible/Python/determine-if-a-string-is-collapsible-1.py

@@ -0,0 +1,23 @@
+from itertools import groupby
+
+def collapser(txt):
+    return ''.join(item for item, grp in groupby(txt))
+
+if __name__ == '__main__':
+    strings = [
+            "",
+            '"If I were two-faced, would I be wearing this one?" --- Abraham Lincoln ',
+            "..1111111111111111111111111111111111111111111111111111111111111117777888",
+            "I never give 'em hell, I just tell the truth, and they think it's hell. ",
+            "                                                   ---  Harry S Truman  ",
+            "The better the 4-wheel drive, the further you'll be from help when ya get stuck!",
+            "headmistressship",
+            "aardvark",
+            "😍😀🙌💃😍😍😍🙌",
+            ]
+    for txt in strings:
+        this = "Original"
+        print(f"\n{this:14} Size: {len(txt)} «««{txt}»»»" )
+        this = "Collapsed"
+        sqz = collapser(txt)
+        print(f"{this:>14} Size: {len(sqz)} «««{sqz}»»»" )

Task/Determine-if-a-string-is-collapsible/Python/determine-if-a-string-is-collapsible-2.py

@@ -0,0 +1,39 @@
+'''Determining if a string is collapsible'''
+
+from operator import eq
+
+
+# isCollapsible :: String -> Bool
+def isCollapsible(s):
+    '''True if s contains any consecutively
+       repeated characters.
+    '''
+    return False if 2 > len(s) else (
+        any(map(eq, s, s[1:]))
+    )
+
+
+# ------------------------- TEST --------------------------
+# main :: IO ()
+def main():
+    '''Determining whether each string is collapsible'''
+    xs = [
+        "",
+        '"If I were two-faced, would I be wearing this one?" --- Abraham Lincoln ',
+        "..1111111111111111111111111111111111111111111111111111111111111117777888",
+        "I never give 'em hell, I just tell the truth, and they think it's hell. ",
+        "                                                   ---  Harry S Truman  ",
+        "The better the 4-wheel drive, the further you'll be from help when ya get stuck!",
+        "headmistressship",
+        "aardvark",
+        "😍😀🙌💃😍😍😍🙌",
+        "abcdefghijklmnopqrstuvwxyz"
+    ]
+    print([
+        isCollapsible(x) for x in xs
+    ])
+
+
+# MAIN ---
+if __name__ == '__main__':
+    main()

Task/Determine-if-a-string-is-collapsible/Quackery/determine-if-a-string-is-collapsible.quackery

@@ -0,0 +1,35 @@
+  [ false -1 rot
+    witheach
+      [ 2dup = iff
+          [ drop dip not
+            conclude ]
+        else nip ]
+    drop ]                       is collapsible ( $ --> b )
+
+  [ [] -1 rot
+    witheach
+      [ 2dup = iff drop
+        else
+          [ nip dup dip join ] ]
+    drop ]                       is collapse    ( $ --> $ )
+
+  [ dup collapsible iff
+      [ dup collapse
+        swap 2 ]
+    else
+      [ say "(Not collapsible.)" cr
+        1 ]
+    times
+      [ say "<<<"
+        dup echo$
+        say ">>>" cr
+        say "   Length: "
+        size echo
+        say " characters" cr cr ]
+    cr ]                         is task     ( $ -->   )
+
+$ "" task
+$ '"If I were two-faced, would I be wearing this one?" --- Abraham Lincoln ' task
+$ "..1111111111111111111111111111111111111111111111111111111111111117777888" task
+$ "I never give 'em hell, I just tell the truth, and they think it's hell. " task
+$ "                                                    --- Harry S Truman  " task

Task/Determine-if-a-string-is-collapsible/R/determine-if-a-string-is-collapsible.r

@@ -0,0 +1,41 @@
+collapse_string <- function(string){
+
+    str_iterable <- strsplit(string, "")[[1]]
+
+    message(paste0("Original String: ", "<<<", string, ">>>\n",
+                   "Length: ", length(str_iterable)))
+
+    detect <- rep(TRUE, length(str_iterable))
+
+
+    for(i in 2:length(str_iterable)){
+
+      if(length(str_iterable)==0) break
+
+      if(str_iterable[i] == str_iterable[i-1])
+
+        detect[i] <- FALSE
+    }
+
+    collapsed_string <- paste(str_iterable[detect],collapse = "")
+
+    message(paste0("Collapsed string: ", "<<<",collapsed_string, ">>>\n",
+                   "Length: ", length(str_iterable[detect])), "\n")
+
+}
+
+test_strings <- c(
+  "",
+  "'If I were two-faced, would I be wearing this one?' --- Abraham Lincoln ",
+  "..1111111111111111111111111111111111111111111111111111111111111117777888",
+  "I never give 'em hell, I just tell the truth, and they think it's hell. ",
+  "                                                    --- Harry S Truman  ",
+  "The better the 4-wheel drive, the further you'll be from help when ya get stuck!",
+  "headmistressship",
+  "aardvark",
+  "Ciao Mamma, guarda come mi diverto!!"
+)
+
+for(test in test_strings){
+  collapse_string(test)
+}

Task/Determine-if-a-string-is-collapsible/REXX/determine-if-a-string-is-collapsible.rexx

@@ -0,0 +1,29 @@
+/*REXX program "collapses" all immediately repeated characters in a string (or strings).*/
+@.=                                              /*define a default for the  @.  array. */
+parse arg x                                      /*obtain optional argument from the CL.*/
+if x\=''  then      @.1= x                       /*if user specified an arg, use that.  */
+          else do;  @.1=
+                    @.2= '"If I were two-faced, would I be wearing this one?" --- Abraham Lincoln '
+                    @.3=  ..1111111111111111111111111111111111111111111111111111111111111117777888
+                    @.4= "I never give 'em hell, I just tell the truth, and they think it's hell. "
+                    @.5= '                                                   ---  Harry S Truman  '
+               end
+
+     do j=1;    L= length(@.j)                   /*obtain the length of an array element*/
+     say copies('═', 105)                        /*show a separator line between outputs*/
+     if j>1  &  L==0     then leave              /*if arg is null and  J>1, then leave. */
+     new= collapse(@.j)
+     say 'string' word("isn't is",1+collapsible) 'collapsible' /*display semaphore value*/
+     say '    length='right(L, 3)     "   input=«««"  ||  @.j  ||  '»»»'
+       w= length(new)
+     say '    length='right(w, 3)     "  output=«««"  ||  new  ||  '»»»'
+     end   /*j*/
+exit                                             /*stick a fork in it,  we're all done. */
+/*──────────────────────────────────────────────────────────────────────────────────────*/
+collapse: procedure expose collapsible; parse arg y 1 $ 2  /*get the arg; get 1st char. */
+            do k=2  to length(y)                 /*traipse through almost all the chars.*/
+            _= substr(y, k, 1)                   /*pick a character from  Y  (1st arg). */
+            if _==right($, 1)  then iterate      /*Is this the same character?  Skip it.*/
+            $= $ || _                            /*append the character, it's different.*/
+            end   /*j*/
+          collapsible= y\==$;       return $     /*set boolean to  true  if collapsible.*/

Task/Determine-if-a-string-is-collapsible/Racket/determine-if-a-string-is-collapsible.rkt

@@ -0,0 +1,27 @@
+#lang racket
+
+(define (collapse text)
+  (if (< (string-length text) 2)
+      text
+      (string-append
+       (if (equal? (substring text 0 1) (substring text 1 2))
+           "" (substring text 0 1))
+       (collapse (substring text 1)))))
+
+; Test cases
+(define tcs
+  '(""
+    "\"If I were two-faced, would I be wearing this one?\" --- Abraham Lincoln "
+    "..1111111111111111111111111111111111111111111111111111111111111117777888"
+    "I never give 'em hell, I just tell the truth, and they think it's hell. "
+    "                                                   ---  Harry S Truman  "
+    "The better the 4-wheel drive, the further you'll be from help when ya get stuck!"
+    "headmistressship"
+    "aardvark"
+    "😍😀🙌💃😍😍😍🙌"))
+
+(for ([text tcs])
+  (let ([collapsed (collapse text)])
+    (display (format "Original  (size ~a): «««~a»»»\nCollapsed (size ~a): «««~a»»»\n\n"
+                     (string-length text) text
+                     (string-length collapsed) collapsed))))

Task/Determine-if-a-string-is-collapsible/Raku/determine-if-a-string-is-collapsible.raku

@@ -0,0 +1,17 @@
+map {
+    my $squish = .comb.squish.join;
+    printf "\nLength: %2d <<<%s>>>\nCollapsible: %s\nLength: %2d <<<%s>>>\n",
+      .chars, $_, .chars != $squish.chars, $squish.chars, $squish
+}, lines
+
+q:to/STRINGS/;
+
+    "If I were two-faced, would I be wearing this one?" --- Abraham Lincoln
+    ..1111111111111111111111111111111111111111111111111111111111111117777888
+    I never give 'em hell, I just tell the truth, and they think it's hell.
+                                                        --- Harry S Truman
+    The American people have a right to know if their president is a crook.
+                                                        --- Richard Nixon
+    AАΑAАΑAАΑAАΑAАΑAАΑAАΑAАΑAАΑAАΑAАΑAАΑAАΑAАΑAАΑAАΑAАΑAАΑAАΑAАΑAАΑAАΑAАΑAАΑ
+    AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
+    STRINGS

Task/Determine-if-a-string-is-collapsible/Ring/determine-if-a-string-is-collapsible.ring

@@ -0,0 +1,26 @@
+load "stdlib.ring"
+
+see "working..." + nl + nl
+str = ["The better the 4-wheel drive, the further you'll be from help when ya get stuck!",
+       "I never give 'em hell, I just tell the truth, and they think it's hell.",
+       "..1111111111111111111111111111111111111111111111111111111111111117777888"]
+strsave = str
+for n = 1 to len(str)
+    for m = 1 to len(str[n])-1
+        if substr(str[n],m,1) = substr(str[n],m+1,1)
+           str[n] = left(str[n],m) + right(str[n],len(str[n])-m-1)
+           for p = len(str[n]) to 2 step -1
+               if substr(str[n],p,1) = substr(str[n],p-1,1)
+                  str[n] = left(str[n],p-1) + right(str[n],len(str[n])-p)
+               ok
+           next
+        ok
+     next
+next
+
+for n = 1 to len(str)
+    see "" + len(strsave[n]) + "«««" + strsave[n] + "»»»" + nl
+    see "" + len(str[n]) + "«««" + str[n] + "»»»" + nl + nl
+next
+
+see "done..." + nl

Task/Determine-if-a-string-is-collapsible/Ruby/determine-if-a-string-is-collapsible.rb

@@ -0,0 +1,16 @@
+strings = ["",
+        '"If I were two-faced, would I be wearing this one?" --- Abraham Lincoln ',
+        "..1111111111111111111111111111111111111111111111111111111111111117777888",
+        "I never give 'em hell, I just tell the truth, and they think it's hell. ",
+        "                                                   ---  Harry S Truman  ",
+        "The better the 4-wheel drive, the further you'll be from help when ya get stuck!",
+        "headmistressship",
+        "aardvark",
+        "😍😀🙌💃😍😍😍🙌",]
+
+strings.each do |str|
+  puts "«««#{str}»»» (size #{str.size})"
+  ssq = str.squeeze
+  puts "«««#{ssq}»»» (size #{ssq.size})"
+  puts
+end

Task/Determine-if-a-string-is-collapsible/Rust/determine-if-a-string-is-collapsible.rust

@@ -0,0 +1,39 @@
+fn collapse_string(val: &str) -> String {
+    let mut output = String::new();
+    let mut chars = val.chars().peekable();
+
+    while let Some(c) = chars.next() {
+        while let Some(&b) = chars.peek() {
+            if b == c {
+                chars.next();
+            } else {
+                break;
+            }
+        }
+
+        output.push(c);
+    }
+
+    output
+}
+
+fn main() {
+    let tests = [
+        "122333444455555666666777777788888888999999999",
+        "",
+        "\"If I were two-faced, would I be wearing this one?\" --- Abraham Lincoln ",
+        "..1111111111111111111111111111111111111111111111111111111111111117777888",
+        "I never give 'em hell, I just tell the truth, and they think it's hell. ",
+        "                                                    --- Harry S Truman  ",
+        "The better the 4-wheel drive, the further you'll be from help when ya get stuck!",
+        "headmistressship",
+    ];
+
+    for s in &tests {
+        println!("Old: {:>3} <<<{}>>>", s.len(), s);
+        let collapsed = collapse_string(s);
+        println!("New: {:>3} <<<{}>>>", collapsed.len(), collapsed);
+
+        println!();
+    }
+}

Task/Determine-if-a-string-is-collapsible/Scala/determine-if-a-string-is-collapsible.scala

@@ -0,0 +1,54 @@
+object CollapsibleString {
+
+  /**Collapse a string (if possible)*/
+  def collapseString (s : String) : String = {
+    var res = s
+    var isOver = false
+    var i = 0
+    if(res.size == 0) res
+    else while(!isOver){
+      if(res(i) == res(i+1)){
+        res = res.take(i) ++ res.drop(i+1)
+        i-=1
+      }
+      i+=1
+      if(i==res.size-1) isOver = true
+    }
+    res
+  }
+
+  /**Check if a string is collapsible*/
+  def isCollapsible (s : String) : Boolean = collapseString(s).length != s.length
+
+  /**Display results as asked in the task*/
+  def reportResults (s : String) : String = {
+    val sCollapsed = collapseString(s)
+    val originalRes = "ORIGINAL  : length = " + s.length() + ", string = «««" + s + "»»»"
+    val collapsedRes = "COLLAPSED : length = " + sCollapsed.length() + ", string = «««" + sCollapsed + "»»»"
+    //In order to avoid useless computations, the function isCollapsible isn't called
+    if(s.length != sCollapsed.length) originalRes + "\n" + collapsedRes + "\n" + "This string IS collapsible !"
+    else originalRes + "\n" + collapsedRes + "\n" + "This string is NOT collapsible !"
+  }
+
+
+
+  def main(args: Array[String]): Unit = {
+    println(reportResults(""))
+    println("------------")
+    println(reportResults("\"If I were two-faced, would I be wearing this one?\" --- Abraham Lincoln "))
+    println("------------")
+    println(reportResults("..1111111111111111111111111111111111111111111111111111111111111117777888"))
+    println("------------")
+    println(reportResults("I never give 'em hell, I just tell the truth, and they think it's hell. "))
+    println("------------")
+    println(reportResults("                                                    --- Harry S Truman  "))
+    println("------------")
+    println(reportResults("The better the 4-wheel drive, the further you'll be from help when ya get stuck!"))
+    println("------------")
+    println(reportResults("headmistressship"))
+    println("------------")
+    println(reportResults("aardvark"))
+  }
+
+
+}

Task/Determine-if-a-string-is-collapsible/Sed/determine-if-a-string-is-collapsible.sed

@@ -0,0 +1,8 @@
+h
+s/.*/<<<&>>>/
+x
+s/\(.\)\1*/\1/g
+s/.*/<<<&>>>/
+H
+s/.*//
+G

Task/Determine-if-a-string-is-collapsible/Sidef/determine-if-a-string-is-collapsible.sidef

@@ -0,0 +1,19 @@
+func squeeze(str) {
+    str.gsub(/(.)\1+/, {|s1| s1 })
+}
+
+var strings = ["",
+        '"If I were two-faced, would I be wearing this one?" --- Abraham Lincoln ',
+        "..1111111111111111111111111111111111111111111111111111111111111117777888",
+        "I never give 'em hell, I just tell the truth, and they think it's hell. ",
+        "                                                   ---  Harry S Truman  ",
+        "The better the 4-wheel drive, the further you'll be from help when ya get stuck!",
+        "headmistressship",
+        "aardvark",
+        "😍😀🙌💃😍😍😍🙌"]
+
+strings.each {|str|
+    var ssq = squeeze(str)
+    say "«««#{str}»»» (length: #{str.len})"
+    say "«««#{ssq}»»» (length: #{ssq.len})\n"
+}

Task/Determine-if-a-string-is-collapsible/Smalltalk/determine-if-a-string-is-collapsible.st

@@ -0,0 +1,19 @@
+#(
+  'The better the 4-wheel drive, the further you''ll be from help when ya get stuck!'
+  'headmistressship'
+  'aardvark'
+  '😍😀🙌💃😍😍😍🙌'
+) do:[:eachWord |
+  |shortened|
+
+  shortened :=
+    String streamContents:[:out |
+        eachWord inject:nil into:[:prev :this |
+            prev ~= this ifTrue:[out nextPut:this].
+            this
+        ]
+    ].
+  Transcript
+    showCR:( eachWord,'(length:',eachWord size,')' );
+    showCR:( shortened,'(length:',shortened size,')' ).
+]

Task/Determine-if-a-string-is-collapsible/Swift/determine-if-a-string-is-collapsible.swift

@@ -0,0 +1,17 @@
+let strings = [
+	"",
+	#""If I were two-faced, would I be wearing this one?" --- Abraham Lincoln "#,
+	"..1111111111111111111111111111111111111111111111111111111111111117777888",
+	"I never give 'em hell, I just tell the truth, and they think it's hell. ",
+	"                                                   ---  Harry S Truman  ",
+	"The better the 4-wheel drive, the further you'll be from help when ya get stuck!",
+	"headmistressship",
+	"aardvark",
+	"😍😀🙌💃😍😍😍🙌"
+]
+
+let collapsedStrings = strings.map { $0.replacingOccurrences( of: #"(.)\1*"#, with: "$1", options: .regularExpression)}
+
+for (original, collapsed) in zip(strings, collapsedStrings) {
+	print (String(format: "%03d «%@»\n%03d «%@»\n", original.count, original, collapsed.count, collapsed))
+}

Task/Determine-if-a-string-is-collapsible/Tcl/determine-if-a-string-is-collapsible.tcl

@@ -0,0 +1,19 @@
+set test {
+    {}
+    {"If I were two-faced, would I be wearing this one?" --- Abraham Lincoln }
+    {..1111111111111111111111111111111111111111111111111111111111111117777888}
+    {I never give 'em hell, I just tell the truth, and they think it's hell. } ;# '
+    {                                                    --- Harry S Truman  }
+    {The better the 4-wheel drive, the further you'll be from help when ya get stuck!} ;# '
+    {headmistressship}
+}
+
+foreach {str} $test {
+    # Uses regexp lookbehind to detect repeated characters
+    set sub [regsub -all {(.)(\1+)} $str {\1}]
+
+    # Output
+    puts [format "Original (length %3d): %s" [string length $str] $str]
+    puts [format "Subbed   (length %3d): %s" [string length $sub] $sub]
+    puts ----------------------
+}

Task/Determine-if-a-string-is-collapsible/V-(Vlang)/determine-if-a-string-is-collapsible.v

@@ -0,0 +1,36 @@
+// Returns collapsed string, original and new lengths in
+// unicode code points (not normalized).
+fn collapse(s string) (string, int, int) {
+    mut r := s.runes()
+    le, mut del := r.len, 0
+    for i := le - 2; i >= 0; i-- {
+        if r[i] == r[i+1] {
+            r.delete(i)
+            del++
+        }
+    }
+    if del == 0 {
+        return s, le, le
+    }
+    r = r[..le-del]
+    return r.string(), le, r.len
+}
+
+fn main() {
+    strings:= [
+        "",
+        '"If I were two-faced, would I be wearing this one?" --- Abraham Lincoln ',
+        "..1111111111111111111111111111111111111111111111111111111111111117777888",
+        "I never give 'em hell, I just tell the truth, and they think it's hell. ",
+        "                                                   ---  Harry S Truman  ",
+        "The better the 4-wheel drive, the further you'll be from help when ya get stuck!",
+        "headmistressship",
+        "aardvark",
+        "😍😀🙌💃😍😍😍🙌",
+	]
+    for s in strings {
+        cs, olen, clen := collapse(s)
+        println("original : length = ${olen:2}, string = «««$s»»»")
+        println("collapsed: length = ${clen:2}, string = «««$cs»»»\n")
+    }
+}

Task/Determine-if-a-string-is-collapsible/VBA/determine-if-a-string-is-collapsible-1.vba

@@ -0,0 +1,12 @@
+Function Collapse(strIn As String) As String
+Dim i As Long, strOut As String
+    If Len(strIn) > 0 Then
+        strOut = Mid$(strIn, 1, 1)
+        For i = 2 To Len(strIn)
+            If Mid$(strIn, i, 1) <> Mid$(strIn, i - 1, 1) Then
+                strOut = strOut & Mid$(strIn, i, 1)
+            End If
+        Next i
+    End If
+    Collapse = strOut
+End Function

Task/Determine-if-a-string-is-collapsible/VBA/determine-if-a-string-is-collapsible-2.vba

@@ -0,0 +1,18 @@
+Sub CallCollapse()
+Dim S As String
+    S = vbNullString
+    Debug.Print "String : <<<" & S & ">>>", "Lenght : " & Len(S)
+    Debug.Print "Collapsed : <<<" & Collapse(S) & ">>>", "Lenght : " & Len(Collapse(S))
+    S = """If I were two-faced, would I be wearing this one?"" --- Abraham Lincoln "
+    Debug.Print "String : <<<" & S & ">>>", "Lenght : " & Len(S)
+    Debug.Print "Collapsed : <<<" & Collapse(S) & ">>>", "Lenght : " & Len(Collapse(S))
+    S = "..1111111111111111111111111111111111111111111111111111111111111117777888"
+    Debug.Print "String : <<<" & S & ">>>", "Lenght : " & Len(S)
+    Debug.Print "Collapsed : <<<" & Collapse(S) & ">>>", "Lenght : " & Len(Collapse(S))
+    S = "I never give 'em hell, I just tell the truth, and they think it's hell. "
+    Debug.Print "String : <<<" & S & ">>>", "Lenght : " & Len(S)
+    Debug.Print "Collapsed : <<<" & Collapse(S) & ">>>", "Lenght : " & Len(Collapse(S))
+    S = "                                                    --- Harry S Truman  "
+    Debug.Print "String : <<<" & S & ">>>", "Lenght : " & Len(S)
+    Debug.Print "Collapsed : <<<" & Collapse(S) & ">>>", "Lenght : " & Len(Collapse(S))
+End Sub

Task/Determine-if-a-string-is-collapsible/Visual-Basic-.NET/determine-if-a-string-is-collapsible.vb

@@ -0,0 +1,27 @@
+Module Module1
+
+    Function Collapse(s As String) As String
+        If String.IsNullOrEmpty(s) Then
+            Return ""
+        End If
+        Return s(0) + New String(Enumerable.Range(1, s.Length - 1).Where(Function(i) s(i) <> s(i - 1)).Select(Function(i) s(i)).ToArray)
+    End Function
+
+    Sub Main()
+        Dim input() = {
+             "",
+            "The better the 4-wheel drive, the further you'll be from help when ya get stuck!",
+            "headmistressship",
+            ControlChars.Quote + "If I were two-faced, would I be wearing this one?" + ControlChars.Quote + " --- Abraham Lincoln ",
+            "..1111111111111111111111111111111111111111111111111111111111111117777888",
+            "I never give 'em hell, I just tell the truth, and they think it's hell. ",
+            "                                                    --- Harry S Truman  "
+           }
+        For Each s In input
+            Console.WriteLine($"old: {s.Length} «««{s}»»»")
+            Dim c = Collapse(s)
+            Console.WriteLine($"new: {c.Length} «««{c}»»»")
+        Next
+    End Sub
+
+End Module

Task/Determine-if-a-string-is-collapsible/Wren/determine-if-a-string-is-collapsible.wren

@@ -0,0 +1,32 @@
+import "/fmt" for Fmt
+
+// Returns collapsed string, original and new lengths in
+// unicode code points (not normalized).
+var collapse = Fn.new { |s|
+    var c = s.codePoints.toList
+    var le = c.count
+    if (le < 2) return [s, le, le]
+    for (i in le-2..0) {
+        if (c[i] == c[i+1]) c.removeAt(i)
+    }
+    var cc = c.reduce("") { |acc, cp| acc + String.fromCodePoint(cp) }
+    return [cc, le, cc.count]
+}
+
+var strings = [
+    "",
+    "\"If I were two-faced, would I be wearing this one?\" --- Abraham Lincoln ",
+    "..1111111111111111111111111111111111111111111111111111111111111117777888",
+    "I never give 'em hell, I just tell the truth, and they think it's hell. ",
+    "                                                   ---  Harry S Truman  ",
+    "The better the 4-wheel drive, the further you'll be from help when ya get stuck!",
+    "headmistressship",
+    "aardvark",
+    "😍😀🙌💃😍😍😍🙌"
+]
+
+for (s in strings) {
+    var r = collapse.call(s)
+    System.print("original : length = %(Fmt.d(2, r[1])), string = «««%(s)»»»")
+    System.print("collapsed: length = %(Fmt.d(2, r[2])), string = «««%(r[0])»»»\n")
+}

Task/Determine-if-a-string-is-collapsible/XPL0/determine-if-a-string-is-collapsible.xpl0

@@ -0,0 +1,30 @@
+string 0;
+char C, I, J, Last;
+
+proc Collapse(S);       \Eliminate immediately repeated characters from string
+char S;
+[I:= 0;  J:= 0;  Last:= -1;
+loop [if S(I) # Last then
+        [C(J):= S(I);
+        if S(I) = 0 then quit;
+        J:= J+1;
+        ];
+     Last:= S(I);
+     I:= I+1;
+     ];
+];
+
+int String, K;
+[String:= [
+    "",
+    "^"If I were two-faced, would I be wearing this one?^" --- Abraham Lincoln ",
+    "..1111111111111111111111111111111111111111111111111111111111111117777888",
+    "I never give 'em hell, I just tell the truth, and they think it's hell. ",
+    "                                                    --- Harry S Truman  "];
+C:= Reserve(79+1);      \space for collapsed string
+for K:= 0 to 4 do
+    [Collapse(String(K));
+    Text(0, "<<<");  Text(0, String(K));  Text(0, ">>> ");  IntOut(0, I);  CrLf(0);
+    Text(0, "<<<");  Text(0, C);  Text(0, ">>> ");  IntOut(0, J);  CrLf(0);
+    ];
+]

Task/Determine-if-a-string-is-collapsible/Zkl/determine-if-a-string-is-collapsible-1.zkl

@@ -0,0 +1,6 @@
+fcn collapsible(str){			// no Unicode
+   sink:=Sink(String);
+   str.reduce('wrap(c1,c2){ if(c1!=c2) sink.write(c2); c2 },"");  // prime with \0
+   cstr:=sink.close();
+   return(str.len()!=cstr.len(), cstr);
+}

Task/Determine-if-a-string-is-collapsible/Zkl/determine-if-a-string-is-collapsible-2.zkl

@@ -0,0 +1,19 @@
+strings:=
+0'^
+"If I were two-faced, would I be wearing this one?" --- Abraham Lincoln
+..1111111111111111111111111111111111111111111111111111111111111117777888
+I never give 'em hell, I just tell the truth, and they think it's hell.
+                                                    --- Harry S Truman
+The American people have a right to know if their president is a crook.
+                                                    --- Richard Nixon
+The better the 4-wheel drive, the further you'll be from help when ya get stuck!
+headmistressship
+aardvark^
+.split("\n");
+#<<<
+
+foreach s in (strings){
+   println("Before: %3d >>>%s<<<".fmt(s.len(),s));
+   _,cstr:=collapsible(s);
+   println("After:  %3d >>>%s<<<\n".fmt(cstr.len(),cstr));
+}