Determine if a string is collapsible: Difference between revisions

{{trans|Kotlin}}

V cs = ‘’

V last = Char("\0")

print(‘original : length = ’s.len‘, string = <<<’s‘>>>’)

print(‘collapsed : length = ’c.len‘, string = <<<’c‘>>>’)

{{out}}

=={{header|8080 Assembly}}==

puts: equ 9

org 100h

db 'and they think it',39,'s hell. $'

str5: db ' '

{{out}}

=={{header|Action!}}==

BYTE i,j

CHAR c

Test("I never give 'em hell, I just tell the truth, and they think it's hell. ")

Test(" --- Harry S Truman ")

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Determine_if_a_string_is_collapsible.png Screenshot from Atari 8-bit computer]

=={{header|Ada}}==

procedure Test_Collapsible is

procedure Collapse (S : in String) is

Collapse (" --- Harry S Truman ");

end Test_Collapsible;

{{out}}

=={{header|ALGOL 68}}==

# returns a collapsed version of s #

# i.e. s with adjacent duplicate characters removed #

OD

END

{{out}}

<pre>

{{works with|Dyalog APL}}

⍝ Collapse a string

collapse←{(1,¯1↓⍵≠1⌽⍵)/⍵}

⍝ Collapse each string and display it as specified

↑collapse display¨ strs

{{out}}

=={{header|Arturo}}==

{::}

{:"If I were two-faced, would I be wearing this one?" --- Abraham Lincoln :}

loop lines 'line ->

{{out}}

=={{header|AutoHotkey}}==

for i, ch in StrSplit(str){

if (ch <> prev)

}

return "original string:`t" StrLen(str) " characters`t«««" str "»»»`nresultant string:`t" StrLen(res) " characters`t«««" res "»»»"

, """If I were two-faced, would I be wearing this one?"" --- Abraham Lincoln "

, "..1111111111111111111111111111111111111111111111111111111111111117777888"

for i, v in data

MsgBox % := collapsible_string(v)

Outputs:<pre>-----------------------------------------

original string: 0 characters «««»»»

=={{header|AWK}}==

# syntax: GAWK -f DETERMINE_IF_A_STRING_IS_COLLAPSIBLE.AWK

BEGIN {

printf("new: %2d <<<%s>>>\n\n",length(new_str),new_str)

}

{{out}}

<pre>

=={{header|BaCon}}==

DATA "\"If I were two-faced, would I be wearing this one?\" --- Abraham Lincoln "

DATA "..1111111111111111111111111111111111111111111111111111111111111117777888"

NEXT

PRINT ">>> - length: ", found

{{out}}

<pre><<<>>> - length: 0

=={{header|BASIC}}==

20 FOR A% = 1 TO N%

30 READ I$: GOSUB 100

430 DATA "..1111111111111111111111111111111111111111111111111111111111111117777888"

440 DATA "I never give 'em hell, I just tell the truth, and they think it's hell. "

{{out}}

=={{header|BCPL}}==

// Collapse a string

show("I never give 'em hell, I just tell the truth, and they think it's hell. ")

show(" --- Harry S Truman ")

{{out}}

<pre>0: <<<>>>

The base function is very simple: Keep adjacent unequal characters, make sure first character is always preserved.

>{

"I never give 'em hell, I just tell the truth, and they think it's hell. "

" --- Harry S Truman "

╵ ┌─

╵ 80 "<<<The better the 4-wheel drive, the further you'll be from help when ya get stuck!>>>"

17 "<<< - Hary S Truman >>>"

┘

=={{header|Bracmat}}==

= previous

. str

$ "I never give 'em hell, I just tell the truth, and they think it's hell. "

& testcolapse

'''Output'''

<pre>«««»»» 0

Identical implementation as in [[Determine_if_a_string_is_squeezable]], as both tasks are very similar. The Lincoln quote contains backslashes to accommodate the double quotes via the command line. strcmpi is not part of the C Standard Library, thus comment out the definition in the code if testing on a system where it is already included.

#include<string.h>

#include<stdlib.h>

return 0;

}

Output :

<pre>

=={{header|C sharp|C#}}==

using static System.Linq.Enumerable;

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());

{{out}}

<pre>

=={{header|C++}}==

The solution is a straightforward application of the standard library function "unique".

#include <iostream>

#include <algorithm>

test(" --- Harry S Truman ");

return 0;

{{out}}

=={{header|Clojure}}==

(defn collapse [s]

(let [runs (partition-by identity s)]

(str (format "Input: <<<%s>>> (len %d)\n" s (count s))

(format "becomes: <<<%s>>> (len %d)\n" out (count out)))))

{{out}}

=={{header|CLU}}==

collapse = proc (s: string) returns (string)

out: array[char] := array[char]$[]

show(ex)

end

{{out}}

<pre>0 <<<>>>

=={{header|Cowgol}}==

include "strings.coh";

show(strings[i]);

i := i + 1;

{{out}}

=={{header|D}}==

void collapsible(string s) {

collapsible(`I never give 'em hell, I just tell the truth, and they think it's hell. `);

collapsible(` --- Harry S Truman `);

{{out}}

<pre>old: <<<>>>, length = 0

{{libheader| System.SysUtils}}

{{Trans|D}}

program Determine_if_a_string_is_collapsible;

collapsible(' --- Harry S Truman ');

readln;

=={{header|F_Sharp|F#}}==

// 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.

collapse " --- Harry S Truman "

collapse "withoutConsecutivelyRepeatedCharacters"

{{out}}

<pre>

=={{header|Factor}}==

IN: rosetta-code.string-collapse

} [ show-collapse ] each ;

{{out}}

(Using some extra test cases from the Go entry.)

=={{header|FreeBASIC}}==

{{trans|BASIC}}

Data ""

Data "'If I were two-faced, would I be wearing this one?' --- Abraham Lincoln "

Next j

Sleep

{{out}}

<pre>

=={{header|Frink}}==

lines = ["",

for line = lines

{{out}}

<pre>

=={{header|Go}}==

import "fmt"

fmt.Printf("collapsed: length = %2d, string = «««%s»»»\n\n", clen, cs)

}

{{out}}

=={{header|Groovy}}==

{{trans|Java}}

static void main(String[] args) {

for ( String s : [

return sb.toString()

}

{{out}}

<pre>old: 0 <<<>>>

=={{header|Haskell}}==

import Data.Maybe (catMaybes)

import Control.Monad (guard)

main =

mapM_ (\(a, b) -> printf "old: %3d «««%s»»»\nnew: %3d «««%s»»»\n\n" (length a) a (length b) b)

{{out}}

<pre>

Note that we can also directly define a predicate, and a rewrite, in terms of ''Data.List group'',

isCollapsible :: String -> Bool

collapsed :: String -> String

or, without imports, in terms of pattern matching:

isCollapsible [] = False

isCollapsible [_] = False

collapsed (h:t@(x:_))

| h == x = collapsed t

=={{header|J}}==

=={{header|Java}}==

// Title: Determine if a string is collapsible

}

{{out}}

=={{header|JavaScript}}==

String.prototype.collapse = function() {

let str = this;

console.log(`«««${col}»»» (${col.length})`);

}

{{out}} <pre>

=={{header|jq}}==

Here we can use the Unix-like `uniq` function defined on (JSON) arrays to define `collapse` on (JSON) strings:

# Output: a stream

def uniq: foreach .[] as $x ({x:nan, y:.[0]}; {x:$x, y:.x}; select(.x != .y) | .x);

The program for the given task can now be written in three lines:

"Original: \(Guillemets) has length \(length)",

(collapse | "Collapsed \(Guillemets) has length \(length)")

Using the following invocation on the five "raw" (i.e. unquoted) strings yields the results as shown:

jq -Rrf program.jq raw.txt

Collapsed «««»»» has length 0

Original: «««"If I were two-faced, would I be wearing this one?" --- Abraham Lincoln »»» 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

=={{header|Julia}}==

"",

""""If I were two-faced, would I be wearing this one?" --- Abraham Lincoln """,

testcollapse(teststrings)

<pre>

«««»»» (length 0)

</pre>

==== Condensed version: ====

"",

""""If I were two-faced, would I be wearing this one?" --- Abraham Lincoln """,

println("«««$s»»» (length $n)\n collapses to:\n«««$t»»» (length $(length(t))).\n")

end

=={{header|Kotlin}}==

{{trans|Go}}

val cs = StringBuilder()

var last: Char = 0.toChar()

println()

}

{{out}}

<pre>original : length = 0, string = «««»»»

=={{header|Ksh}}==

#!/bin/ksh

print ${#strings[i]} "${Guillemet[0]}${strings[i]}${Guillemet[1]}"

print ${#str} "${Guillemet[0]}${str}${Guillemet[1]}\n"

{{out}}<pre>0 «««»»»

0 «««»»»

=={{header|Lua}}==

{{trans|C#}}

local ns = ""

local last = nil

end

{{out}}

<pre>old: 0 <<<>>>

=={{header|Mathematica}} / {{header|Wolfram Language}}==

StringCollapse[s_String] := FixedPoint[StringReplace[y_ ~~ y_ :> y], s]

strings = {"",

,

{s, strings}

{{out}}

<pre>«««»»»

=={{header|MATLAB}} / {{header|Octave}}==

function r = collapse(s)

ix=find((s(1:end-1)==s(2:end))+1;

collapse('║ --- Harry S Truman ║', 'r')

{{out}}

=={{header|Modula-2}}==

FROM InOut IMPORT WriteString, WriteCard, WriteLn;

FROM Strings IMPORT Length;

Task("I never give 'em hell, I just tell the truth, and they think it's hell. ");

Task(" --- Harry S Truman ");

{{out}}

<pre> 0 <<<>>>

* On the Interface Pane, in the Command Center, type "demo" and hit enter.

to-report split [ string ]

;; utility reporter to split a string into a list

demo-collapse

end

{{out}}

=={{header|Nim}}==

proc collapse(s: string) =

for s in Strings:

{{out}}

=={{header|Perl}}==

use warnings;

use utf8;

printf "\nLength: %2d <<<%s>>>\nCollapsible: %s\nLength: %2d <<<%s>>>\n",

length($_), $_, $_ ne $squish ? 'True' : 'False', length($squish), $squish

{{out}}

<pre>Length: 0 <<<>>>

If you don't have builtins/punique.e to hand, you may want to take a quick look at squeeze() in

[[https://rosettacode.org/wiki/Determine_if_a_string_is_squeezable#Phix]], but obviously w/o ch.

<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: #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>

{{out}}

<pre>

=={{header|PHP}}==

function collapseString($string) {

echo 'Collapse : string is not collapsing...', PHP_EOL, PHP_EOL;

}

{{out}}

The <code>COLLAPSE</code> procedure compares bytes and would be fine with any 8-bit input.

BDOS: PROCEDURE (FN, ARG); DECLARE FN BYTE, ARG ADDRESS; GO TO 5; END BDOS;

EXIT: PROCEDURE; CALL BDOS(0,0); END EXIT;

CALL EXIT;

EOF

{{out}}

<pre>0 <<<>>>

=={{header|Prolog}}==

collapse_( [A], [A] ).

collapse_( [A,A|T], R ) :- collapse_( [A|T], R ).

string_chars( Str, Chars ),

collapse_( Chars, Result ),

{{out}}

<pre>

=={{header|PureBasic}}==

DataSection

STR1:

*p_data+StringByteLength(PeekS(*p_data))+2

Wend

{{out}}

<pre>Before collapse: «««»»» (length: 0)

=={{header|Python}}==

def collapser(txt):

this = "Collapsed"

sqz = collapser(txt)

{{out}}

and for the missing predicate, foregrounded in the task title, and already forgotten in the listing of tests:

from operator import eq

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre>[False, True, True, True, True, True, True, True, True, False]</pre>

=={{header|Quackery}}==

witheach

[ 2dup = iff

$ "..1111111111111111111111111111111111111111111111111111111111111117777888" task

$ "I never give 'em hell, I just tell the truth, and they think it's hell. " task

{{out}}

=={{header|R}}==

str_iterable <- strsplit(string, "")[[1]]

}

{{out}}

=={{header|Racket}}==

(define (collapse text)

(string-length text) text

(string-length collapsed) collapsed))))

{{out}}

<pre>Original (size 0): «««»»»

Technically, the task is asking for a boolean. "Determine if a string is collapsible" is answerable with True/False, so return a boolean as well.

my $squish = .comb.squish.join;

printf "\nLength: %2d <<<%s>>>\nCollapsible: %s\nLength: %2d <<<%s>>>\n",

AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA

STRINGS

{{out}}

<pre>Length: 0 <<<>>>

=={{header|REXX}}==

@.= /*define a default for the @. array. */

parse arg x /*obtain optional argument from the CL.*/

$= $ || _ /*append the character, it's different.*/

end /*j*/

{{out|output|text=&nbsp; when using the internal default inputs:}}

<pre>

=={{header|Ring}}==

load "stdlib.ring"

see "done..." + nl

Output:

<pre>

=={{header|Ruby}}==

This is built in since at least a decade under the method name 'squeeze'. squeeze(" ") would only squeeze spaces.

'"If I were two-faced, would I be wearing this one?" --- Abraham Lincoln ',

"..1111111111111111111111111111111111111111111111111111111111111117777888",

puts

end

{{out}}

<pre>«««»»» (size 0)

=={{header|Rust}}==

let mut output = String::new();

let mut chars = val.chars().peekable();

println!();

}

{{out}}

<pre>

===Pure imperative programming 😃===

/**Collapse a string (if possible)*/

{{out}}

<pre>ORIGINAL : length = 0, string = «««»»»

=={{header|Sidef}}==

str.gsub(/(.)\1+/, {|s1| s1 })

}

say "«««#{str}»»» (length: #{str.len})"

say "«««#{ssq}»»» (length: #{ssq.len})\n"

{{out}}

<pre style="font-size: 80%">

=={{header|Smalltalk}}==

{{works with|Smalltalk/X}}

'The better the 4-wheel drive, the further you''ll be from help when ya get stuck!'

'headmistressship'

showCR:( eachWord,'(length:',eachWord size,')' );

showCR:( shortened,'(length:',shortened size,')' ).

{{out}}

<pre>The better the 4-wheel drive, the further you'll be from help when ya get stuck!(length:80)

=={{header|Swift}}==

"",

#""If I were two-faced, would I be wearing this one?" --- Abraham Lincoln "#,

for (original, collapsed) in zip(strings, collapsedStrings) {

print (String(format: "%03d «%@»\n%03d «%@»\n", original.count, original, collapsed.count, collapsed))

{{out}}

=={{header|Tcl}}==

Please note the ;# ' comments, there appears to be a syntax hightlighting bug with RC

{}

{"If I were two-faced, would I be wearing this one?" --- Abraham Lincoln }

puts ----------------------

}

{{out}}

<pre>

=={{header|Visual Basic .NET}}==

{{trans|C#}}

Function Collapse(s As String) As String

End Sub

{{out}}

<pre>old: 0 «««»»»

=={{header|VBA}}==

Function :

Dim i As Long, strOut As String

If Len(strIn) > 0 Then

End If

Collapse = strOut

To Call :

Dim S As String

S = vbNullString

Debug.Print "String : <<<" & S & ">>>", "Lenght : " & Len(S)

Debug.Print "Collapsed : <<<" & Collapse(S) & ">>>", "Lenght : " & Len(Collapse(S))

{{out}}

<pre>String : <<<>>> Lenght : 0

=={{header|Vlang}}==

{{trans|Go}}

// unicode code points (not normalized).

fn collapse(s string) (string, int, int) {

println("collapsed: length = ${clen:2}, string = «««$cs»»»\n")

}

{{out}}

{{trans|Go}}

{{libheader|Wren-fmt}}

// Returns collapsed string, original and new lengths in

System.print("original : length = %(Fmt.d(2, r[1])), string = «««%(s)»»»")

System.print("collapsed: length = %(Fmt.d(2, r[2])), string = «««%(r[0])»»»\n")

{{out}}

=={{header|XPL0}}==

char C, I, J, Last;

Text(0, "<<<"); Text(0, C); Text(0, ">>> "); IntOut(0, J); CrLf(0);

];

{{out}}

=={{header|zkl}}==

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

0'^

"If I were two-faced, would I be wearing this one?" --- Abraham Lincoln

_,cstr:=collapsible(s);

println("After: %3d >>>%s<<<\n".fmt(cstr.len(),cstr));

{{out}}

<pre>