Determine if a string is collapsible: Difference between revisions

╚════════════════════════════════════════════════════════════════════════╝

 

 

 

 

 

=={{header|Ada}}==

procedure Test_Collapsible is

procedure Collapse (S : in String) is

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

end Test_Collapsible;

 

{{out}}

Input = <<< --- Harry S Truman >>>, length = 72

Output = <<< - Hary S Truman >>>, length = 17</pre>

 

=={{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>

new: 14 <<<headmistreship>>>

</pre>

 

=={{header|C}}==

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>

</pre>

 

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

becomes: <<< - Hary S Truman >>> (len 17)

</pre>

 

=={{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

old: <<< --- Harry S Truman >>>, length = 72

new: <<< - Hary S Truman >>>, length = 17</pre>

 

=={{header|Factor}}==

IN: rosetta-code.string-collapse

 

} [ show-collapse ] each ;

 

{{out}}

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

Before collapse: «««😍😀🙌💃😍😍😍🙌»»» (length 8)

After collapse: «««😍😀🙌💃😍🙌»»» (length 6)

</pre>

 

=={{header|Go}}==

 

import "fmt"

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

}

 

{{out}}

collapsed: length = 6, string = «««😍😀🙌💃😍🙌»»»

</pre>

=={{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>

new: 6 «««😍😀🙌💃😍🙌»»»

</pre>

 

=={{header|J}}==

 

=={{header|Java}}==

// Title: Determine if a string is collapsible

 

 

}

 

{{out}}

new: 14 <<<headmistreship>>>

</pre>

 

=={{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 = «««»»»

original : length = 8, string = «««aardvark»»»

collapsed : length = 7, string = «««ardvark»»»</pre>

 

=={{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.

{{out}}

<pre>

length 72 input: <<< --- Harry S Truman >>>

length 17 output: <<< - Hary S Truman >>>

</pre>

 

=={{header|PHP}}==

 

 

function collapseString($string) {

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

}

 

{{out}}

Original : <<<😍😀🙌💃😍😍😍🙌>>> (len=8)

Collapse : <<<😍😀🙌💃😍🙌>>> (len=6)</pre>

 

=={{header|Prolog}}==

collapse_( [A], [A] ).

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

string_chars( Str, Chars ),

collapse_( Chars, Result ),

{{out}}

<pre>

37 ?- S = "123456789", collapse(S,S).

S = "123456789" .

</pre>

 

=={{header|Python}}==

 

def collapser(txt):

this = "Collapsed"

sqz = collapser(txt)

 

{{out}}

Original Size: 8 «««😍😀🙌💃😍😍😍🙌»»»

Collapsed Size: 6 «««😍😀🙌💃😍🙌»»»</pre>

 

=={{header|Raku}}==

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

Length: 1 <<<A>>>

</pre>

 

=={{header|REXX}}==

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

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

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)

w= length(new)

end /*j*/

exit /*stick a fork in it, we're all done. */

/*──────────────────────────────────────────────────────────────────────────────────────*/

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

<pre>

═════════════════════════════════════════════════════════════════════════════════════════════════════════

length= 0 input=«««»»»

length= 0 output=«««»»»

═════════════════════════════════════════════════════════════════════════════════════════════════════════

length= 72 input=«««"If I were two-faced, would I be wearing this one?" --- Abraham Lincoln »»»

length= 70 output=«««"If I were two-faced, would I be wearing this one?" - Abraham Lincoln »»»

═════════════════════════════════════════════════════════════════════════════════════════════════════════

length= 72 input=«««..1111111111111111111111111111111111111111111111111111111111111117777888»»»

length= 4 output=«««.178»»»

═════════════════════════════════════════════════════════════════════════════════════════════════════════

length= 72 input=«««I never give 'em hell, I just tell the truth, and they think it's hell. »»»

length= 69 output=«««I never give 'em hel, I just tel the truth, and they think it's hel. »»»

═════════════════════════════════════════════════════════════════════════════════════════════════════════

length= 72 input=««« --- Harry S Truman »»»

length= 17 output=««« - Hary S Truman »»»

═════════════════════════════════════════════════════════════════════════════════════════════════════════

</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 = «««»»»

COLLAPSED : length = 7, string = «««ardvark»»»

This string IS collapsible !</pre>

 

=={{header|Sidef}}==

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

}

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

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

{{out}}

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

«««😍😀🙌💃😍😍😍🙌»»» (length: 8)

«««😍😀🙌💃😍🙌»»» (length: 6)

</pre>

 

=={{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>

Subbed (length 14): headmistreship

----------------------

</pre>

 

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

original : length = 8, string = «««😍😀🙌💃😍😍😍🙌»»»

collapsed: length = 6, string = «««😍😀🙌💃😍🙌»»»

</pre>

 

=={{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>