Determine if a string is squeezable: Difference between revisions

{{Template:Strings}}

<br><br>

 

=={{header|Ada}}==

procedure Test_Squeezable is

procedure Squeeze (S : in String; C : in Character) is

Squeeze (" --- Harry S Truman ", 'r');

end Test_Squeezable;

 

{{out}}

 

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

# returns a squeezed version of s #

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

test squeeze( hst, "-" );

test squeeze( hst, "r" )

{{out}}

<pre>

-> <<< --- Hary S Truman >>> (length 71)

</pre>

 

=={{header|AutoHotkey}}==

for i, ch in StrSplit(str){

if (ch <> prev) || !InStr(ch, char)

)"

return result

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

, "..1111111111111111111111111111111111111111111111111111111111111117777888"

for i, char in [" ","-","r"]

MsgBox % squeezable_string(str, char)

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

Original string: 0 characters «««»»»

 

=={{header|AWK}}==

# syntax: GAWK -f DETERMINE_IF_A_STRING_IS_SQUEEZABLE.AWK

BEGIN {

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

}

{{out}}

<pre>

</pre>

 

=={{header|C}}==

Identical implementation as in [[Determine_if_a_string_is_collapsible]], 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 Squeeze(string s, char c) => string.IsNullOrEmpty(s) ? "" :

s[0] + new string(Range(1, s.Length - 1).Where(i => s[i] != c || 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 <string>

#include <iostream>

test(truman, 'r');

return 0;

 

{{out}}

 

=={{header|Clojure}}==

(defn squeeze [s c]

(let [spans (partition-by #(= c %) s)

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

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

 

{{out}}

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

</pre>

 

=={{header|D}}==

{{trans|C#}}

 

void squeezable(string s, char rune) {

squeezable(s, '-');

squeezable(s, 'r');

{{out}}

<pre>squeeze: ' '

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

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

=={{header|Delphi}}==

{{libheader| System.SysUtils}}

{{Trans|Java}}

program Determine_if_a_string_is_squeezable;

 

begin

if (i = 1) or (s[i - 1] <> s[i]) or ((s[i - 1] = s[i]) and (s[i] <> include)) then

end;

Result := sb.ToString;

end;

readln;

{{out}}

<pre>use: " "

old: 16 <<<headmistressship>>>

new: 14 <<<headmistreship>>></pre>

 

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

// Determine if a string is squeezable. Nigel Galloway: June 9th., 2020

let squeeze n i=if String.length n=0 then None else

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

let fN=isSqueezable " --- Harry S Truman " in fN ' '; fN '-'; fN 'r'

{{out}}

<pre>

'r' squeezes <<< --- Harry S Truman >>> (length 72) to <<< --- Hary S Truman >>> (length 71)

</pre>

=={{header|Factor}}==

IN: rosetta-code.squeeze

 

[ show-squeeze ] 2tri@ ;

{{out}}

<pre>

Before squeeze: ««« --- Harry S Truman »»» (length 72)

After squeeze: ««« --- Hary S Truman »»» (length 71)

</pre>

 

=={{header|Go}}==

 

import "fmt"

}

}

 

{{out}}

=={{header|Groovy}}==

{{trans|Java}}

static void main(String[] args) {

String[] testStrings = [

return sb.toString()

}

{{out}}

<pre>use: ' '

 

=={{header|Haskell}}==

 

input :: [(String, Char)]

main =

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

{{out}}

<pre>

=={{header|J}}==

Invoking j with the standard startup scripts includes definitions to delete excess, leading, and trailing blanks. <tt>deb</tt> corresponds to task squeeze, additionally removing leading and trailing blanks. The definitions are

dlb

}.~ (=&' ' (i.) 0:)

deb

#~ ((+.) (1: |. (> </\)))@(' '&~:)

Onward with the task. <tt>squeeze</tt> makes a logical vector of inequality and uses Boolean algebra against itself shifted by one position to mask the text.

<pre>

)

</pre>

'x' squeeze 'xabxxcxdxxx' NB. example

xabxcxdx

│<<< --- Hary S Truman>>> │

└──────────────────────────────────────────────────────────────────────────────┘

=={{header|Java}}==

 

// Title: Determine if a string is squeezable

 

}

 

{{out}}

 

* "SQUEEZE returns a string that reduces all multiple occurrences of a [specified] character to one ..."

 

=== jq program ===

def squeeze($c): gsub("[\($c)]+"; $c);

 

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

(squeeze($c) | "result is \(Guillemets) with length \(length)")),

=== Demo ===

Squeeze ("..1111111111111111111111111111111111111111111111111111111111111117777888"; "7"),

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

Squeeze (" --- Harry S Truman "; "r"),

 

{{out}}

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

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

Squeeze character: S

Original: «««SabcSS:SSdefSSSghSS»»» has length 19

 

=={{header|Julia}}==

("", ' '),

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

":\n«««$t»»» (length $(length(t))).\n")

end

<pre>

«««»»» (length 0)

=={{header|Kotlin}}==

{{trans|Java}}

val testStrings = arrayOf(

"",

}

return sb.toString()

{{out}}

<pre>use: ' '

=={{header|Lua}}==

{{trans|D}}

print("squeeze: `" .. rune .. "`")

print("old: <<<" .. s .. ">>>, length = " .. string.len(s))

end

 

{{out}}

<pre>squeeze: ` `

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

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

 

 

squeeze is a base function Matlab and Octave, therefore its name is changed to squeezee()

 

function r = squeezee(s,c)

ix = [];

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

 

 

{{out}}

ans = ║ --- Hary S Truman ║

</pre>

 

=={{header|Nim}}==

 

proc squeeze(s: string; ch: Rune) =

for i, s in Strings:

for ch in Chars[i]:

 

{{out}}

 

=={{header|Perl}}==

use warnings;

use Unicode::UCD 'charinfo';

$phrase ne $squeeze ? 'True' : 'False',

length($squeeze), $squeeze

{{out}}

<pre>Original length: 0 <<<>>>

 

=={{header|Phix}}==

{{out}}

<pre>

=={{header|PHP}}==

 

 

function squeezeString($string, $squeezeChar) {

echo 'Squeeze(', $char, ') : string is not squeezable (char=', $char, ')...', PHP_EOL, PHP_EOL;

}

 

{{out}}

 

=={{header|Prolog}}==

squeeze_( [A], _, [A] ).

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

string_chars( Str, Chars ),

squeeze_( Chars, SqueezeChar, Result ),

{{out}}

<pre>

 

=={{header|Python}}==

 

def squeezer(s, txt):

this = f"Squeezer '{ch}'"

sqz = squeezer(ch, txt)

 

{{out}}

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

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

 

=={{header|Raku}}==

{{works with|Rakudo|2019.07.1}}

 

my $squeeze = $^phrase;

sink $^reg;

' --- Harry S Truman ', ' ',

' --- Harry S Truman ', '-',

{{out}}

<pre>Original length: 0 <<<>>>

 

=={{header|REXX}}==

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

#.1= ' '; @.1=

$= $ || _ /*append char., it's diff. */

end /*j*/

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

<pre>

 

=={{header|Ruby}}==

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

"..1111111111111111111111111111111111111111111111111111111111111117777888",

puts

end

{{out}}

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

See collapsible strings for the alternative implementation approach.

 

let mut previous = None;

 

 

inputs.iter().for_each(|(input, c)| show(input, *c));

 

=={{header|Sidef}}==

str.gsub(Regex("(" + c.escape + ")" + '\1+'), {|s1| s1 })

}

}

say ''

{{out}}

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

 

=={{header|Tcl}}==

# as test string and squeeze character(s) respectively.

set test {

}

 

{{out}}

<pre>

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

{{trans|C#}}

 

Module Module1

End Sub

 

{{out}}

<pre>squeeze: ' '

old: 72 ««« --- Harry S Truman »»»

new: 71 ««« --- Hary S Truman »»»</pre>

 

=={{header|Wren}}==

{{trans|Go}}

{{libheader|Wren-fmt}}

 

// Returns squeezed string, original and new lengths in

}

i = i + 1

 

{{out}}

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

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

</pre>

 

=={{header|zkl}}==

s,cc,sz,n := Data(Void,str), String(c,c), c.len(), 0; // byte buffer in case of LOTs of deletes

while(Void != (n=s.find(cc,n))){ str=s.del(n,sz) } // and searching is faster for big strings

s.text

T("",""),

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

sstr:=squeeze(c,s);

println("After: %2d <<<%s>>>\n".fmt(sstr.len(-8),sstr));

{{out}}

<pre>