Rep-string: Difference between revisions

{{trans|Python: Functional}}

R (1 .< 1 + text.len I/ 2).filter(x -> @text.starts_with(@text[x..])).map(x -> @text[0 .< x])

L(line) matchstr.split("\n")

{{out}}

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

BYTE i,j,count

Test("00")

Test("1")

{{out}}

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

=={{header|Ada}}==

procedure Rep_String is

Ada.Text_IO.Put_Line("Longest rep-string for """& X &""": """& Y &"""");

end if;

{{out}}

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

{{works with|ALGOL 68G|Any - tested with release 2.8.win32}}

# the input string is not validated to contain only "0" and "1" characters #

PROC longest rep string = ( STRING input )STRING:

)

OD

{{out}}

<pre>1001110011: longest rep string: "10011"

This function returns a list of all possible repeated substrings.

It returns the empty list if there are none.

{{out}}

<pre> rep '1001110011'

=={{header|AppleScript}}==

-- repCycles :: String -> [String]

on unlines(xs)

|λ|(xs) of intercalate(linefeed)

{{Out}}

<pre>Longest cycle:

=={{header|Arturo}}==

loop ((size text)/2)..0 'x [

if prefix? text slice text x (size text)-1 [

else ->

print [str "->" rep "( length:" size rep ")"]

{{out}}

=={{header|AutoHotkey}}==

{{works with|AutoHotkey 1.1}}

, "1111111111", "0100101101", "0100100", "101", "11", "00", "1"]

for k, v in In

}

return "N/A"

{{Out}}

<pre>10011 1001110011

=={{header|BaCon}}==

FOR word$ IN all$

PRINT "Not a repeating string: ", word$

{{out}}

<pre>

=={{header|BASIC}}==

20 READ S: IF S="" THEN END

30 IF LEN(S)<2 THEN 80 ELSE FOR I = LEN(S)\2 TO 1 STEP -1

130 DATA "0100100","101"

140 DATA "11","00"

{{out}}

<pre>1001110011: 10011

=={{header|BCPL}}==

// Returns the length of the longest rep-string

rep("00")

rep("1")

{{out}}

<pre>1001110011: 10011

=={{header|Bracmat}}==

= reps L x y

. ( reps

& rep-string$00

& rep-string$1

{{Out}}

<pre>1001110011 : 10011

=={{header|BQN}}==

Reps←(⌊≠÷2˙)((⊣≥≠¨∘⊢)/⊢)(<≡¨≠⥊¨1↓↑)/1↓↑

⟩

{{out}}

<pre>"1001110011:⟨ ""10011"" ⟩

===Longest substring ===

#include <stdio.h>

#include <string.h>

return 0;

}

{{out}}

<pre>

</pre>

===shortest substring===

// strstr : Returns a pointer to the first occurrence of str2 in str1, or a null pointer if str2 is not part of str1.

// size_t is an unsigned integer typ

return 0;

}

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

#include <vector>

#include <boost/regex.hpp>

}

return 0 ;

{{out}}

<pre>1001110011 is a rep string! Here is a repeating string:

=={{header|Clojure}}==

(let [len (count s)

first-half (subs s 0 (/ len 2))

test-group (take-while seq (iterate butlast first-half))

test-reptd (map (comp #(take len %) cycle) test-group)]

{{out}}

(def test-strings ["1001110011"

"1110111011"

(map (juxt identity rep-string) test-strings)

<pre>

(["1001110011" true]

=={{header|CLU}}==

for len: int in int$from_to_by(string$size(s)/2, 1, -1) do

repstr: string := string$substr(s, 1, len)

stream$putc(po, '\n')

end

{{out}}

<pre>1001110011: <10011>

=={{header|Common Lisp}}==

(ql:quickload :alexandria)

(defun rep-stringv (a-str &optional (max-rotation (floor (/ (length a-str) 2))))

;; Recurse function reducing length of rotation.

(t (rep-stringv a-str (1- max-rotation)))))

{{out}}

(setf test-strings '("1001110011"

"1110111011"

(loop for item in test-strings

collecting (cons item (rep-stringv item)))

<pre>

(("1001110011" . "10011") ("1110111011" . "1110") ("0010010010" . "001")

=={{header|Crystal}}==

{{trans|Go}}

x = s.size // 2

main

{{out}}

=={{header|D}}==

Two different algorithms. The second is from the Raku entry.

std.ascii, std.typecons;

writefln("%(%s %)", w.chunks(r1));

}

{{out}}

<pre>10011 10011

{{libheader| System.SysUtils}}

{{Trans|Go}}

program Rep_string;

end;

{$IFNDEF UNIX}readln;{$ENDIF}

=={{header|Dyalect}}==

{{trans|Go}}

var x = s.Length() / 2

while x > 0 {

print("\(s) not a rep-string")

}

{{out}}

=={{header|EchoLisp}}==

(lib 'list) ;; list-rotate

'too-short-no-rep))

{{out}}

(define strings '["1001110011" "1110111011" "0010010010" "1010101010"

"1111111111" "0100101101" "0100100" "101" "11" "00" "1"])

"00" "0"

"1" too-short-no-rep

=={{header|Elixir}}==

def find(""), do: IO.puts "String was empty (no repetition)"

def find(str) do

1)

{{out}}

{{Works with|Office 365 betas 2021}}

=LAMBDA(s,

LET(

)

)

And also assuming the following generic bindings in the Name Manager:

=LAMBDA(p,

LAMBDA(xs,

NA()

)

{{Out}}

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

let getPrefix n (s : string) = s.Substring(0,n)

match repPrefixOf s with | None -> s + ": NO" | Some(p) -> s + ": YES ("+ p + ")")

|> List.iter (printfn "%s")

{{out}}

<pre>Testing for rep-string (and showing the longest repeated prefix in case):

=={{header|Factor}}==

IN: rosetta-code.rep-string

0100101101 0100100 101 11 00 1 }

"Shortest cycle:\n\n" printf

{{out}}

<pre>

{{trans|Python}}

{{works with|GNU Forth}}

2dup dup >r r@ 2/ /string

begin 2over 2over string-prefix? 0= over r@ < and while -1 /string repeat

s" 11" test

s" 00" test

{{out}}

1001110011 has 10011 as repeating substring

1110111011 has 1110 as repeating substring

00 has 0 as repeating substring

1 has no repeating substring

=={{header|FreeBASIC}}==

{{trans|Yabasic}}

Data "1001110011", "1110111011", "0010010010", "1010101010", "1111111111", "0100101101", "0100100", "101", "11", "00", "1", ""

Loop

Sleep

{{out}}

<pre>

=={{header|Go}}==

{{trans|Python}}

import (

}

}

{{out}}

<pre>

=={{header|Haskell}}==

import Data.Maybe (fromMaybe)

processIO xs = do

putStr (xs <> ": ")

{{Out}}

<pre>1001110011: 10011

Or, alternatively:

import Data.List (inits, intercalate, transpose)

<*> ((" -> " <>) . fxShow . f)

)

{{Out}}

<pre>Longest cycles:

The following works in both languages.

every write(s := !A,": ",(repString(s) | "Not a rep string!")\1)

end

while *s1 < n do s1 ||:= s2

return s1[1+:n]

{{Out}}

Here's a test:

rep=: $@] $ $

Example use:

1

Tests=: noun define

)

isRepStr;._2 Tests NB. run all tests

We could also report the lengths of the repeated prefix, though this seems more arbitrary:

With the above examples:

5

4

1

Here, the "non-str-rep" cases are indicated by an empty list of prefix lengths.

=={{header|Java}}==

static final String[] input = {"1001110011", "1110111011", "0010010010",

return "none";

}

{{Out}}

=={{header|JavaScript}}==

===ES6===

'use strict';

// MAIN ---

return main();

{{Out}}

<pre>Longest cycles:

=={{header|jq}}==

For each test string, a JSON object giving details about the prefixes that satisfy the requirement is presented; if the string is not a rep-string, the empty array ([]) is shown.

# if self is a rep-string then return [n, prefix]

# where n is the number of full occurrences of prefix

| select( .[0] > 1 ) ]

;

'''Example''':

(

"1001110011",

;

{{Out}}

{"1001110011":[[2,"10011"]]}

{"1110111011":[[2,"1110"]]}

{"11":[[2,"1"]]}

{"00":[[2,"0"]]}

=={{header|Julia}}==

<tt>repstring</tt> returns a list of all of the substrings of its input that are the repeating units of a rep-string. If the input is not a valid rep-string, it returns an empty list. Julia indexes strings, including those that contain multi-byte characters, at the byte level. Because of this characteristic, <tt>repstring</tt> indexes its input using the <tt>chr2ind</tt> built-in.

n = length(r)

replst = String[]

println("$r is a rep-string of ", join(replst, ", "), ".")

end

{{out}}

=={{header|Kotlin}}==

fun repString(s: String): MutableList<String> {

println("${s.padStart(10)} -> ${if (size > 0) reps[size - 1] else "Not a rep-string"}")

}

{{out}}

The heavy lifting:

(defun get-reps (text)

(lists:filtermap

(1 head)

(_ '()))))

Displaying the results:

(defun report

((`#(,text ()))

(lists:zip data (lists:map #'get-reps/1 data)))

'ok))

Running the code:

=={{header|Maple}}==

The built-in <code>Period</code> command in the <code>StringTools</code> package computes the length of the longest repeated prefix.

local per := StringTools:-Period( s );

if 2 * per <= length( s ) then

false, ""

end if

For the given set of test strings, we can generate the following output.

> Test := ["1001110011", "1110111011", "0010010010", "1010101010", "1111111111", \

"0100101101", "0100100", "101", "11", "00", "1"]:

1 false

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

Mathematica is based on pattern-based matching, so this is very easily implemented:

Trying it out for the test-strings:

{{out}}

<pre>1001110011 {10011}

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

FROM InOut IMPORT Write, WriteString, WriteLn, WriteCard;

FROM Strings IMPORT Copy, Length;

rep("00");

rep("1");

{{out}}

<pre>1001110011: 10011

=={{header|NetRexx}}==

{{trans|REXX}}

options replace format comments java crossref symbols nobinary

end w_

return

{{out}}

<pre>

=={{header|NGS}}==

{{trans|Python}}

'1001110011'

'1110111011'

echo("${test} ${if r "has repetition of length ${r} (i.e. ${test[0..r]})" "is not a rep-string"}")

})

{{out}}<pre>1001110011 has repetition of length 5 (i.e. 10011)

1110111011 has repetition of length 4 (i.e. 1110)

=={{header|Nim}}==

{{trans|Python}}

proc isRepeated(text: string): int =

let ln = isRepeated(line)

echo "'", line, "' has a repetition length of ", ln, " i.e ",

{{Out}}

<pre>'1001110011' has a repetition length of 5 i.e '10011'

=={{header|Objeck}}==

function : Main(args : String[]) ~ Nil {

strings := ["1001110011", "1110111011", "0010010010", "1111111111",

return true;

}

Output:

Returns null if no rep string.

| sz i |

s size dup ->sz 2 / 1 -1 step: i [

s left(sz i - ) s right(sz i -) == ifTrue: [ s left(i) return ]

]

{{Out}}

=={{header|PARI/GP}}==

v=["1001110011","1110111011","0010010010","1010101010","1111111111","0100101101","0100100","101","11","00","1"];

{{out}}

<pre>1001110011 5

=={{header|Perl}}==

print "$_\n";

if (/^(.+)\1+(.*$)(?(?{ substr($1, 0, length $2) eq $2 })|(?!))/) {

print " (no repeat)\n\n";

}

{{out}}

<pre>1001110011

{{trans|Julia}}

Shows all possible repeated sub-strings, as Julia, but in the output style of Perl/Elixir

<span style="color: #008080;">function</span> <span style="color: #000000;">list_reps</span><span style="color: #0000FF;">(</span><span style="color: #004080;">string</span> <span style="color: #000000;">r</span><span style="color: #0000FF;">)</span>

<span style="color: #004080;">sequence</span> <span style="color: #000000;">replist</span> <span style="color: #0000FF;">=</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: #008000;">"\n"</span><span style="color: #0000FF;">)</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>

{{out}}

<pre>

=={{header|Phixmonti}}==

def repstr /# s n -- s #/

len for

get repString print nl

{{out}}

<pre>1001110011: 10011

=={{header|Picat}}==

Strings = [

"1001110011", % 10011

% the last (truncated) slice (or []) must be a substring of Substr

Rest = slice(S,Len2+1,Len),

{{out}}

=={{header|PicoLisp}}==

(let Lst (chop Str)

(for (N (/ (length Lst) 2) (gt0 N) (dec N))

(NIL (head X H))

(NIL Lst T) ) ) )

Test:

(test 4 (repString "1110111011"))

(test 3 (repString "0010010010"))

(test 1 (repString "00"))

(test NIL (repString "1"))

=={{header|PL/I}}==

{{Incorrect|PL/I|"0100101101" is not a rep-string.}}

declare s bit (10) varying;

declare (i, k) fixed binary;

end;

{{Out}}

<pre>

=={{header|PL/M}}==

DECLARE MAX$REP LITERALLY '32';

CALL PRINT$STRING( .( CR, LF, '$' ) );

END;

{{out}}

<pre>

Using SWI-Prolog 7 library(func), for some functional syntax.

%% Implementation logic:

report_repstrings :-

Results = maplist(test_for_repstring) $ test_strings(~),

Output

=={{header|PureBasic}}==

"0100101101"+#CRLF$+"0100100" +#CRLF$+"101" +#CRLF$+"11" +#CRLF$+"00" +#CRLF$+

"1" +#CRLF$

If Not Len(s2$) : PrintN(LSet(s1$,15,Chr(32))+#TAB$+"found nothing.") : EndIf

Next

{{out}}

<pre>1001110011 longest sequence: 10011

===Python: Procedural===

'check if the first part of the string is repeated throughout the string'

for x in range(len(text)//2, 0, -1):

ln = is_repeated(line)

print('%r has a repetition length of %i i.e. %s'

{{out}}

===Python: Functional===

This returns all the possible repeated substrings

return [text[:x] for x in range(1, 1 + len(text) // 2)

if text.startswith(text[x:])]

'00' has reps ['0']

'1' has reps []

{{Trans|Haskell}}

{{Works with|Python|3.7}}

from itertools import (accumulate, chain, cycle, islice)

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre>Longest cycles:

===Python: Regexp===

This version, inspired by the Raku entry uses the regexp substitute where what the match is substituted with is returned by a function.

matchstr = """\

print(re.sub(r'(.+)(\1+)(.*)|(.*)', _checker, txt))

{{out}}

<code>factors</code> is defined at [http://rosettacode.org/wiki/Factors_of_an_integer#Quackery Factors of an integer].

dup size 1 > if

[ [] temp put

[ say 'There is no rep-string for "'

nip echo$ say '".' ]

{{out}}

=={{header|Racket}}==

(define (rep-string str)

"00"

"1")])

{{Out}}

=={{header|Raku}}==

(formerly Perl 6)

if /^ (.+) $0+: (.*$) <?{ $0.substr(0,$1.chars) eq $1 }> / {

my $rep = $0.chars;

say "$_ (no repeat)";

}

{{out}}

<pre>10011𝟙𝟘𝟘𝟙𝟙

throw away the bits on the right that you want thrown away.)

This produces the same output as above.

my $bits = :2($s);

for reverse 1 .. $s.chars div 2 -> $left {

say "$_ (no repeat)";

}

=={{header|REXX}}==

===version 1===

* 11.05.2013 Walter Pachl

* 14.05.2013 Walter Pachl extend to show additional rep-strings

show_norep:

Say right(sq,12) 'is not a repeated string'

{{Out}}

<pre>'1001110011' has a repetition length of 5 i.e. '10011'

===version 2===

A check was added to validate if the strings are binary strings. &nbsp; The binary strings can be of any length.

parse arg s /*get optional strings from the C.L. */

if s='' then s=1001110011 1110111011 0010010010 1010101010 1111111111 0100101101 0100100 101 11 00 1 45

if left($$,L)==x then return @rep left($,15) "[length" j']'

end /*j*/ /* [↑] we have found a good repString.*/

'''output''' &nbsp; when using the default binary strings for input:

<pre>

=={{header|Ring}}==

# Project : Rep-string

ok

next

Output:

<pre>

=={{header|Ruby}}==

1110111011

0010010010

rep_pos = (str.size/2).downto(1).find{|pos| str.start_with? str[pos..-1]}

puts str, rep_pos ? " "*rep_pos + str[0, rep_pos] : "(no repetition)", ""

{{Out|Output (as Perl)}}

<pre>1001110011

=={{header|Rust}}==

let strings = vec![

String::from("1001110011"),

}

}

=={{header|Scala}}==

def repsOf(s: String) = s.trim match {

case s if s.length < 2 => Nil

val todo = if (args.length > 0) args else tests

todo.map(printReps).foreach(println)

{{out}}

<pre>1001110011: YES (10011)

=={{header|Seed7}}==

const func integer: repeatLength (in string: text) is func

end if;

end for;

{{out}}

=={{header|Sidef}}==

0010010010 1010101010

1111111111 0100101101

say "#{n} (no repeat)";

}

{{out}}

<pre>10011𝟙𝟘𝟘𝟙𝟙

=={{header|Snobol4}}==

strings = "1001110011 1110111011 0010010010 1010101010 1111111111 0100101101 0100100 101 11 00 1 "

pat1 = (len(1) $ fc breakx(*fc)) $ x *x (arbno(*x) (rpos(0) | rem $ y *?(x ? y)))

:(getstring)

end

{{out}}

<pre>1001110011 has shortest rep-string value of -> 10011

=={{header|Swift}}==

func repString(_ input: String) -> [String] {

for testCase in testCases {

print("\(testCase) has reps: \(repString(testCase))")

{{out}}

=={{header|Tcl}}==

set len [string length $text]

for {set i [expr {$len/2}]} {$i > 0} {incr i -1} {

}

error "no repetition"

Demonstrating:

"1001110011" "1110111011" "0010010010" "1010101010" "1111111111"

"0100101101" "0100100" "101" "11" "00" "1"

puts [format "\"%s\" is not a repeated string" $sample]

}

{{out}}

<pre>

{{trans|Tcl}}

{{works with|bash}}

local str=$1 len rep part

for (( len = ${#str} / 2; len > 0; len-- )); do

00

1

{{out}}

=={{header|VBScript}}==

Function rep_string(s)

max_len = Int(Len(s)/2)

WScript.StdOut.WriteLine

Next

{{Out}}

=={{header|Vlang}}==

{{trans|Go}}

for x := s.len / 2; x > 0; x-- {

if s.starts_with(s[x..]) {

}

}

{{out}}

{{trans|Kotlin}}

{{libheader|Wren-fmt}}

var repString = Fn.new { |s|

var t = (reps.count > 0) ? reps[-1] : "Not a rep-string"

Fmt.print("$10s -> $s", s, t)

{{out}}

=={{header|Yabasic}}==

sub rep$(c$, n)

print p$, " is composed of ", b$, " repeated"

end if

=={{header|zkl}}==

{{trans|D}}

foreach n in ([s.len()/2+1..1,-1]){

Walker.cycle(s[0,n]).pump(s.len(),String) :

}

return(False)

{{trans|Python}}

foreach n in ([s.len()/2..0,-1]){

if(s.matches(s[n,*] + "*") and n*2<=s.len()) return(n);

}

return(False)

"1111111111 0100101101 0100100 101 11 00 1").split(" ");

foreach w in (words){

else [0..*,n].tweak('wrap(z){ if(s:=w[z,n]) s else Void.Stop })

.walk().concat(" ").println();

{{out}}

<pre>