Rosetta Code

Two identical strings: Difference between revisions

Page Discussion

Two identical strings (view source)

Revision as of 10:11, 3 May 2024

18,937 bytes added ,  16 days ago
Add Refal
(Add Draco)
(Add Refal)
 
(24 intermediate revisions by 18 users not shown)
Line 10:
=={{header|11l}}==
{{trans|Python}}
<syntaxhighlight lang="11l">F bits(=n)
 
<lang 11l>F bits(=n)
‘Count the amount of bits required to represent n’
V r = 0
Line 26 ⟶ 25:
L concat(n) <= 1000
print(‘#.: #.’.format(concat(n), bin(concat(n))))
n++</langsyntaxhighlight>
 
{{out}}
Line 63 ⟶ 62:
 
=={{header|8080 Assembly}}==
<langsyntaxhighlight lang="8080asm"> ;;; Print positive integers whose base-2 representation
;;; is the concatenation of two identical binary strings,
;;; for 1 < n < 1000
Line 152 ⟶ 151:
db '***********'
outbuf: db 9,'$'
nl: db 13,10,'$'</langsyntaxhighlight>
 
{{out}}
Line 188 ⟶ 187:
 
=={{header|8086 Assembly}}==
<langsyntaxhighlight lang="asm">puts: equ 9
cpu 8086
org 100h
Line 241 ⟶ 240:
nl: db 13,10,'$'
db '****************'
outbuf: db 9,'$'</langsyntaxhighlight>
{{out}}
<pre>3 11
Line 275 ⟶ 274:
 
=={{header|Action!}}==
<langsyntaxhighlight Actionlang="action!">INT FUNC Encode(INT x CHAR ARRAY s)
BYTE len,i
CHAR tmp
Line 310 ⟶ 309:
i==+1 count==+1
OD
RETURN</langsyntaxhighlight>
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Two_identical_strings.png Screenshot from Atari 8-bit computer]
Line 332 ⟶ 331:
 
=={{header|Ada}}==
<langsyntaxhighlight Adalang="ada">with Ada.Text_Io; use Ada.Text_Io;
with Ada.Strings.Fixed; use Ada.Strings.Fixed;
 
Line 353 ⟶ 352:
end if;
end loop;
end Two_Identical;</langsyntaxhighlight>
{{out}}
<pre> 3 2#11#
Line 387 ⟶ 386:
 
=={{header|ALGOL 68}}==
<langsyntaxhighlight lang="algol68">BEGIN # show the decimal and binary representations of numbers that are of the concatenation of #
# two identical binary strings #
# returns a binary representation of v #
Line 410 ⟶ 409:
print( ( whole( cat value, -4 ), ": ", TOBINSTRING cat value, newline ) )
OD
END</langsyntaxhighlight>
{{out}}
<pre>
Line 446 ⟶ 445:
 
=={{header|ALGOL-M}}==
<langsyntaxhighlight lang="algolm">begin
integer function concatself(n);
integer n;
Line 478 ⟶ 477:
m := concatself(n);
end;
end</langsyntaxhighlight>
{{out}}
<pre> 3: 11
Line 513 ⟶ 512:
=={{header|ALGOL W}}==
{{Trans|MAD}}
<langsyntaxhighlight lang="oberon2">BEGIN
INTEGER PROCEDURE BITSP ( INTEGER VALUE BT ) ;
BEGIN
Line 550 ⟶ 549:
END DO WRITE( S_W := 0, I_W := 3, DPLBIT(N), ": ", I_W := 10, BITSP(DPLBIT(N)) )
END
END.</langsyntaxhighlight>
{{out}}
<pre>
Line 587 ⟶ 586:
=={{header|APL}}==
{{works with|Dyalog APL}}
<langsyntaxhighlight APLlang="apl">↑(((⊂2∘⊥),⊂)(,⍨2∘⊥⍣¯1))¨⍳30</langsyntaxhighlight>
{{out}}
<pre> 3 1 1
Line 624 ⟶ 623:
Drawing members of the sequence from a non-finite list,
up to a given limit.
<langsyntaxhighlight lang="applescript">------ CONCATENATION OF TWO IDENTICAL BINARY STRINGS -----
 
-- binaryTwin :: Int -> (Int, String)
Line 809 ⟶ 808:
set my text item delimiters to dlm
s
end unlines</langsyntaxhighlight>
{{Out}}
<pre>3 -> 11
Line 843 ⟶ 842:
----
===Idiomatic===
<langsyntaxhighlight lang="applescript">on task(maxN)
set startWith0 to false -- Change to true to start with 0 and "00".
set rhv to -(startWith0 as integer) -- Start value of "right hand" string.
Line 877 ⟶ 876:
end task
 
task(999)</langsyntaxhighlight>
 
{{output}}
<langsyntaxhighlight lang="applescript">"3: 11
10: 1010
15: 1111
Line 909 ⟶ 908:
924: 1110011100
957: 1110111101
990: 1111011110"</langsyntaxhighlight>
 
=={{header|Arturo}}==
<syntaxhighlight lang="rebol">loop 0..1000 'i [
bin: as.binary i
if even? size bin [
half: (size bin)/2
if equal? slice bin 0 dec half
slice bin half dec size bin ->
print [pad to :string i 4 ":" bin]
]
]</syntaxhighlight>
 
{{out}}
 
<pre> 3 : 11
10 : 1010
15 : 1111
36 : 100100
45 : 101101
54 : 110110
63 : 111111
136 : 10001000
153 : 10011001
170 : 10101010
187 : 10111011
204 : 11001100
221 : 11011101
238 : 11101110
255 : 11111111
528 : 1000010000
561 : 1000110001
594 : 1001010010
627 : 1001110011
660 : 1010010100
693 : 1010110101
726 : 1011010110
759 : 1011110111
792 : 1100011000
825 : 1100111001
858 : 1101011010
891 : 1101111011
924 : 1110011100
957 : 1110111101
990 : 1111011110</pre>
 
=={{header|AutoHotkey}}==
<syntaxhighlight lang="autohotkey">n:=0
while (n++<=1000)
{
bin := LTrim(dec2bin(n), "0")
l := Strlen(bin)
if (l/2 <> Floor(l/2))
continue
if (SubStr(bin, 1, l/2) = SubStr(bin, l/2+1))
result .= n "`t" bin "`n"
}
MsgBox % result
return
 
Dec2Bin(i, s=0, c=0) {
l := StrLen(i := Abs(i + u := i < 0))
Loop, % Abs(s) + !s * l << 2
b := u ^ 1 & i // (1 << c++) . b
Return, b
}</syntaxhighlight>
{{out}}
<pre>3 11
10 1010
15 1111
36 100100
45 101101
54 110110
63 111111
136 10001000
153 10011001
170 10101010
187 10111011
204 11001100
221 11011101
238 11101110
255 11111111
528 1000010000
561 1000110001
594 1001010010
627 1001110011
660 1010010100
693 1010110101
726 1011010110
759 1011110111
792 1100011000
825 1100111001
858 1101011010
891 1101111011
924 1110011100
957 1110111101
990 1111011110</pre>
 
=={{header|AWK}}==
<syntaxhighlight lang="awk">
<lang AWK>
# syntax: GAWK -f TWO_IDENTICAL_STRINGS.AWK
BEGIN {
Line 938 ⟶ 1,033:
return(str)
}
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 973 ⟶ 1,068:
count: 30
</pre>
 
=={{header|BASIC}}==
<langsyntaxhighlight BASIClang="basic">10 DEFINT A-Z: DIM B(15)
20 N=0
30 N=N+1
Line 992 ⟶ 1,088:
170 NEXT I
180 PRINT
190 GOTO 30</langsyntaxhighlight>
{{out}}
<pre> 3 11
Line 1,024 ⟶ 1,120:
957 1110111101
990 1111011110</pre>
 
==={{header|BASIC256}}===
<syntaxhighlight lang="freebasic">n = 1
k = 0
p = 2
 
while True
if n >= p then p += p
k = n + n * p
if k < 1000 then print k; " = "; tobinary(k) else end
n += 1
end while</syntaxhighlight>
 
==={{header|QBasic}}===
{{works with|QBasic|1.1}}
{{works with|QuickBasic|4.5}}
<syntaxhighlight lang="qbasic">FUNCTION tobin$ (d)
s$ = ""
DO WHILE d <> 0
r = d MOD 2
s$ = STR$(r) + s$
d = d \ 2
LOOP
tobin$ = s$
END FUNCTION
 
k = 0 : n = 1 : p = 2
DO
IF n >= p THEN p = p + p
k = n + n * p
IF k < 1000 THEN
PRINT k; " = "; tobin$(k)
ELSE
EXIT DO
END IF
n = n + 1
LOOP</syntaxhighlight>
 
==={{header|PureBasic}}===
<syntaxhighlight lang="purebasic">OpenConsole()
n.i = 1
k.i = 0
p.i= 2
 
While #True
If n >= p
p + p
EndIf
k = n + n * p
If k < 1000
PrintN(Str(k) + " = " + Bin(k))
Else
Break
EndIf
n + 1
Wend
 
Input()
CloseConsole()
</syntaxhighlight>
 
==={{header|True BASIC}}===
<syntaxhighlight lang="qbasic">FUNCTION tobin$(d)
LET s$ = ""
DO WHILE d <> 0
LET r = REMAINDER(ROUND(d),2)
LET s$ = STR$(r) & s$
LET d = IP(ROUND(d)/2)
LOOP
LET tobin$ = s$
END FUNCTION
 
LET n = 1
LET k = 0
LET p = 2
DO
IF n >= p THEN LET p = p+p
LET k = n+n*p
IF k < 1000 THEN
PRINT k; " = "; tobin$(k)
ELSE
EXIT DO
END IF
LET n = n+1
LOOP
END</syntaxhighlight>
 
=={{header|BCPL}}==
<langsyntaxhighlight lang="bcpl">get "libhdr"
 
let bitlength(n) = n=0 -> 0, 1 + bitlength(n >> 1)
Line 1,045 ⟶ 1,227:
conc := concat(n,n)
$)
$)</langsyntaxhighlight>
{{out}}
<pre> 3: 11
Line 1,079 ⟶ 1,261:
 
=={{header|Befunge}}==
<langsyntaxhighlight lang="befunge">1>:::>:#v_++:91+v
>^ / >\vv**::<
^2\*2<>`#@_v
Line 1,087 ⟶ 1,269:
1:^
$!,
^_^</langsyntaxhighlight>
{{out}}
<pre>3 11
Line 1,121 ⟶ 1,303:
 
=={{header|C}}==
<langsyntaxhighlight lang="c">#include <stdio.h>
#include <stdint.h>
 
Line 1,150 ⟶ 1,332:
}
return 0;
}</langsyntaxhighlight>
 
{{out}}
Line 1,187 ⟶ 1,369:
=={{header|C#|CSharp}}==
{{trans|Visual Basic .NET}}
<langsyntaxhighlight lang="csharp">using System; using static System.Console;
class Program { static void Main() { int c = 0, lmt = 1000;
for (int n = 1, p = 2, k; n <= lmt; n++)
Line 1,194 ⟶ 1,376:
Convert.ToString(k, 2), ++c % 5 == 0 ? "\n" : "");
Write("\nFound {0} numbers whose base 2 representation is the " +
"concatenation of two identical binary strings.", c); } }</langsyntaxhighlight>
{{out}}
Same as Visual Basic. NET
 
=={{header|C++}}==
<langsyntaxhighlight lang="cpp">#include <iostream>
#include <string>
 
Line 1,226 ⟶ 1,408:
base2_increment(s);
}
}</langsyntaxhighlight>
 
{{out}}
Line 1,264 ⟶ 1,446:
 
=={{header|CLU}}==
<langsyntaxhighlight lang="clu">nth_ident = proc (n: int) returns (int)
h: int := n
l: int := n
Line 1,287 ⟶ 1,469:
stream$putl(po, ": " || bits(ident))
end
end start_up</langsyntaxhighlight>
{{out}}
<pre> 3: 11
Line 1,321 ⟶ 1,503:
 
=={{header|COBOL}}==
<langsyntaxhighlight lang="cobol"> IDENTIFICATION DIVISION.
PROGRAM-ID. IDENTICAL-STRINGS.
 
Line 1,385 ⟶ 1,567:
COMPUTE BIT-VALUE = 2 ** (10 - CURRENT-BIT)
MULTIPLY BIT(CURRENT-BIT) BY BIT-VALUE.
ADD BIT-VALUE TO OUTPUT-NUMBER.</langsyntaxhighlight>
{{out}}
<pre> 3: 11
Line 1,419 ⟶ 1,601:
 
=={{header|Cowgol}}==
<langsyntaxhighlight lang="cowgol">include "cowgol.coh";
 
sub bitLength(n: uint32): (l: uint8) is
Line 1,455 ⟶ 1,637:
print_nl();
n := n + 1;
end loop;</langsyntaxhighlight>
 
{{out}}
Line 1,492 ⟶ 1,674:
=={{header|Crystal}}==
{{trans|Ruby}}
<langsyntaxhighlight lang="ruby">(0..1000).each do |i|
bin = i.to_s(2)
if bin.size.even?
Line 1,500 ⟶ 1,682:
end
end
end</langsyntaxhighlight>
{{out}}
<pre> 3: 11
Line 1,532 ⟶ 1,714:
957: 1110111101
990: 1111011110</pre>
 
=={{header|Delphi}}==
{{works with|Delphi|6.0}}
{{libheader|SysUtils,StdCtrls}}
 
 
<syntaxhighlight lang="Delphi">
 
function IntToBinStr(IValue: Int64) : string;
{Convert integer to binary string, with no leading zero}
var I: integer;
begin
Result:='';
I:=IntPower2(32-1);
while I <> 0 do
begin
if (IValue and I)<>0 then Result:=Result + '1'
else if Length(Result)>0 then Result:=Result + '0';
I:=I shr 1;
end;
if Result='' then Result:='0';
end;
 
 
procedure IdenticalBinaryStrings(Memo: TMemo);
var S,S1,S2: string;
var Len,I: integer;
begin
for I:=2 to 1000-1 do
begin
{Get binary String}
S:=IntToBinStr(I);
{Only look at string evenly divisible by 2}
Len:=Length(S);
if (Len and 1)=0 then
begin
{Split string into equal pieces}
S1:=LeftStr(S,Len div 2);
S2:=RightStr(S,Len div 2);
{Each half should be the same}
if S1=S2 then Memo.Lines.Add(IntToStr(I)+': '+S);
end;
end;
end;
 
 
 
</syntaxhighlight>
{{out}}
<pre>
3: 11
10: 1010
15: 1111
36: 100100
45: 101101
54: 110110
63: 111111
136: 10001000
153: 10011001
170: 10101010
187: 10111011
204: 11001100
221: 11011101
238: 11101110
255: 11111111
528: 1000010000
561: 1000110001
594: 1001010010
627: 1001110011
660: 1010010100
693: 1010110101
726: 1011010110
759: 1011110111
792: 1100011000
825: 1100111001
858: 1101011010
891: 1101111011
924: 1110011100
957: 1110111101
990: 1111011110
 
Elapsed Time: 58.641 ms.
 
</pre>
 
 
=={{header|Draco}}==
<langsyntaxhighlight lang="draco">proc nonrec concat_self(word n) word:
word rslt, k;
k := n;
Line 1,555 ⟶ 1,822:
n := n + 1
od
corp</langsyntaxhighlight>
{{out}}
<pre> 3: 11
Line 1,587 ⟶ 1,854:
957: 1110111101
990: 1111011110</pre>
 
=={{header|EasyLang}}==
{{trans|BASIC256}}
<syntaxhighlight>
func$ tobin k .
if k > 0
return tobin (k div 2) & k mod 2
.
.
p = 2
repeat
n += 1
if n >= p
p += p
.
k = n + n * p
until k >= 1000
print k & ": " & tobin k
.
</syntaxhighlight>
 
=={{header|F_Sharp|F#}}==
<langsyntaxhighlight lang="fsharp">
// Nigel Galloway. April 5th., 2021
let fN g=let rec fN g=function n when n<2->(char(n+48))::g |n->fN((char(n%2+48))::g)(n/2) in fN [] g|>Array.ofList|>System.String
Seq.unfold(fun(n,g,l)->Some((n<<<l)+n,if n=g-1 then (n+1,g*2,l+1) else (n+1,g,l)))(1,2,1)|>Seq.takeWhile((>)1000)|>Seq.iter(fun g->printfn "%3d %s" g (fN g))
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 1,630 ⟶ 1,917:
=={{header|Factor}}==
{{works with|Factor|0.99 2021-02-05}}
<langsyntaxhighlight lang="factor">USING: formatting kernel lists lists.lazy math math.parser
sequences ;
 
1 lfrom [ >bin dup append bin> ] lmap-lazy [ 1000 < ] lwhile
[ dup "%d %b\n" printf ] leach</langsyntaxhighlight>
{{out}}
<pre style="height:14em">
Line 1,670 ⟶ 1,957:
 
=={{header|FALSE}}==
<langsyntaxhighlight FALSElang="false">1[$$$[$][2/\2*\]#%|$1000>~][
$.": "
0\10\[$1&'0+\2/$][]#%
[$][,]#%
1+
]#%%</langsyntaxhighlight>
 
{{out}}
Line 1,710 ⟶ 1,997:
 
=={{header|FOCAL}}==
<langsyntaxhighlight FOCALlang="focal">01.10 S N=0
01.20 S N=N+1
01.30 D 3
Line 1,737 ⟶ 2,024:
04.30 I (B(I))4.4,4.5,4.4
04.40 T "1"
04.50 T "0"</langsyntaxhighlight>
 
{{out}}
Line 1,773 ⟶ 2,060:
 
=={{header|Forth}}==
<langsyntaxhighlight lang="forth">: concat-self
dup dup
begin dup while
Line 1,800 ⟶ 2,087:
;
 
to1000 bye</langsyntaxhighlight>
 
{{out}}
Line 1,836 ⟶ 2,123:
 
=={{header|Fortran}}==
<langsyntaxhighlight lang="fortran"> program IdentStr
implicit none
integer n, concat, bits
Line 1,874 ⟶ 2,161:
goto 100
end if
end</langsyntaxhighlight>
{{out}}
<pre> 3 11
Line 1,908 ⟶ 2,195:
 
=={{header|FreeBASIC}}==
<langsyntaxhighlight lang="freebasic">dim as uinteger n=1, k=0
do
k = n + 2*n*2^int(log(n)/log(2))
if k<1000 then print k, bin(k) else end
n=n+1
loop</langsyntaxhighlight>
{{out}}
<pre>3 11
Line 1,948 ⟶ 2,235:
===Alternate===
No ''log()'' function required.
<langsyntaxhighlight lang="freebasic">dim as uinteger n = 1, k = 0, p = 2
do
if n >= p then p = p + p
Line 1,954 ⟶ 2,241:
if k < 1000 then print k, bin(k) else end
n = n + 1
loop</langsyntaxhighlight>
{{out}}
Same as ''log()'' version.
 
=={{header|Frink}}==
<syntaxhighlight lang="frink">for n = 1 to 999
if base2[n] =~ %r/^(\d+)\1$/
println["$n\t" + base2[n]]</syntaxhighlight>
{{out}}
<pre>
3 11
10 1010
15 1111
36 100100
45 101101
54 110110
63 111111
136 10001000
153 10011001
170 10101010
187 10111011
204 11001100
221 11011101
238 11101110
255 11111111
528 1000010000
561 1000110001
594 1001010010
627 1001110011
660 1010010100
693 1010110101
726 1011010110
759 1011110111
792 1100011000
825 1100111001
858 1101011010
891 1101111011
924 1110011100
957 1110111101
990 1111011110
</pre>
 
=={{header|FutureBasic}}==
<syntaxhighlight lang="futurebasic">
defstr byte
 
NSUInteger n = 1, k = 0, p = 2
 
while (1)
if n >= p then p += p
k = n + n * p
if k < 1000 then printf @"%4lu %@", k, bin(k) else exit while
n++
wend
 
HandleEvents
</syntaxhighlight>
{{output}}
<pre>
3 00000011
10 00001010
15 00001111
36 00100100
45 00101101
54 00110110
63 00111111
136 10001000
153 10011001
170 10101010
187 10111011
204 11001100
221 11011101
238 11101110
255 11111111
528 00010000
561 00110001
594 01010010
627 01110011
660 10010100
693 10110101
726 11010110
759 11110111
792 00011000
825 00111001
858 01011010
891 01111011
924 10011100
957 10111101
990 11011110
</pre>
 
=={{header|Go}}==
{{trans|Wren}}
<langsyntaxhighlight lang="go">package main
 
import (
Line 1,980 ⟶ 2,354:
}
fmt.Println("\nFound", i-1, "numbers.")
}</langsyntaxhighlight>
 
{{out}}
Line 2,020 ⟶ 2,394:
=={{header|Haskell}}==
===Data.Bits===
<langsyntaxhighlight lang="haskell">import Control.Monad (join)
import Data.Bits
( countLeadingZeros,
Line 2,048 ⟶ 2,422:
map (join $ printf "%d: %b") to1000
where
to1000 = takeWhile (<= 1000) identStrInts</langsyntaxhighlight>
 
{{out}}
Line 2,085 ⟶ 2,459:
===Data.Char===
As an alternative to Data.Bits, we could also express this in terms of Data.Char
<langsyntaxhighlight lang="haskell">import Control.Monad (join)
import Data.Char (digitToInt, intToDigit)
import Numeric (showIntAtBase)
Line 2,113 ⟶ 2,487:
(\c (e, n) -> (2 * e, digitToInt c * e + n))
(1, 0)
s</langsyntaxhighlight>
<pre>(3,"11")
(10,"1010")
Line 2,146 ⟶ 2,520:
 
=={{header|J}}==
<langsyntaxhighlight Jlang="j">(":,': ',":@#:)@(,~&.#:)"0 (>:i.30)</langsyntaxhighlight>
{{out}}
<pre>3: 1 1
Line 2,180 ⟶ 2,554:
 
=={{header|Java}}==
<langsyntaxhighlight lang="java">public class TwoIdenticalStrings {
public static void main(String[] args) {
System.out.println("Decimal Binary");
Line 2,193 ⟶ 2,567:
}
}
}</langsyntaxhighlight>
{{out}}
<pre>Decimal Binary
Line 2,230 ⟶ 2,604:
{{works with|jq}}
'''Works with gojq, the Go implementation of jq'''
<syntaxhighlight lang="jq">
<lang jq>
def binary_digits:
if . == 0 then 0
Line 2,246 ⟶ 2,620:
| select(.[$half:] == .[:$half])
| [$i, .]
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 2,279 ⟶ 2,653:
[957,"1110111101"]
[990,"1111011110"]</pre>
 
=={{header|Julia}}==
<langsyntaxhighlight lang="julia">function twoidenticalstringsinbase(base, maxnum, verbose=true)
found = Int[]
for i in 1:maxnum
Line 2,298 ⟶ 2,673:
twoidenticalstringsinbase(2, 999)
twoidenticalstringsinbase(16, 999)
</langsyntaxhighlight>{{out}}
<pre>
Decimal Base 2
Line 2,351 ⟶ 2,726:
 
=== Generator version ===
<langsyntaxhighlight lang="julia">function twoidenticalstringsinbase(base, mx, verbose = true)
gen = filter(x -> x < mx,
reduce(vcat, [[i * (base^d + 1) for i in base^(d-1):base^d-1] for d in 1:ndigits(mx; base) ÷ 2]))
Line 2,363 ⟶ 2,738:
twoidenticalstringsinbase(2, 999)
twoidenticalstringsinbase(16, 999)
</langsyntaxhighlight>{{out}}<pre>Same as filter version above.</pre>
 
=={{header|Liberty BASIC}}==
<langsyntaxhighlight lang="liberty basic">maxNumber = 1000
maxN = Int(Len(DecToBin$(maxNumber))/ 2)
Print "Value"," Binary"
Line 2,385 ⟶ 2,760:
Wend
If (DecToBin$ = "") Then DecToBin$ = "0"
End Function</langsyntaxhighlight>
 
{{out}}
Line 2,421 ⟶ 2,796:
990 1111011110</pre>
 
=={{header|MACRO-11}}==
<syntaxhighlight lang="macro11"> .TITLE IDNSTR
.MCALL .TTYOUT,.EXIT
IDNSTR::CLR R4
BR 2$
1$: MOV R3,R0
JSR PC,PRDEC
MOV R3,R0
JSR PC,PRBIN
2$: INC R4
JSR PC,IDENT
CMP R3,#^D1000
BLT 1$
.EXIT
 
; LET R3 BE R4'TH IDENTICAL NUMBER
IDENT: MOV R4,R3
MOV R4,R2
1$: ASL R3
ASR R2
BNE 1$
BIS R4,R3
RTS PC
 
; PRINT NUMBER IN R0 AS DECIMAL
PRDEC: MOV #4$,R1
1$: MOV #-1,R2
2$: INC R2
SUB #12,R0
BCC 2$
ADD #72,R0
MOVB R0,-(R1)
MOV R2,R0
BNE 1$
3$: MOVB (R1)+,R0
.TTYOUT
BNE 3$
RTS PC
.ASCII /...../
4$: .BYTE 11,0
.EVEN
 
; PRINT NUMBER IN R0 AS BINARY
PRBIN: MOV #3$,R1
1$: MOV #60,R2
ASR R0
ADC R2
MOVB R2,-(R1)
TST R0
BNE 1$
2$: MOVB (R1)+,R0
.TTYOUT
BNE 2$
RTS PC
.BLKB 20
3$: .BYTE 15,12,0
.END IDNSTR</syntaxhighlight>
{{out}}
<pre>3 11
10 1010
15 1111
36 100100
45 101101
54 110110
63 111111
136 10001000
153 10011001
170 10101010
187 10111011
204 11001100
221 11011101
238 11101110
255 11111111
528 1000010000
561 1000110001
594 1001010010
627 1001110011
660 1010010100
693 1010110101
726 1011010110
759 1011110111
792 1100011000
825 1100111001
858 1101011010
891 1101111011
924 1110011100
957 1110111101
990 1111011110</pre>
=={{header|MAD}}==
<langsyntaxhighlight MADlang="mad"> NORMAL MODE IS INTEGER
INTERNAL FUNCTION(BT)
Line 2,455 ⟶ 2,918:
 
VECTOR VALUES NFMT = $I3,2H: ,I10*$
END OF PROGRAM </langsyntaxhighlight>
{{out}}
<pre> 3: 11
Line 2,472 ⟶ 2,935:
238: 11101110
255: 11111111
528: 1000010000
561: 1000110001
594: 1001010010
627: 1001110011
660: 1010010100
693: 1010110101
726: 1011010110
759: 1011110111
792: 1100011000
825: 1100111001
858: 1101011010
891: 1101111011
924: 1110011100
957: 1110111101
990: 1111011110</pre>
 
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<syntaxhighlight lang="mathematica">max = 1000;
maxbin = Ceiling[Ceiling[Log2[max]]/2];
s = Table[
id = IntegerDigits[i, 2];
s = Join[id, id];
{FromDigits[s, 2], StringJoin[ToString /@ s]}
,
{i, 2^maxbin - 1}
];
Select[s, First/*LessThan[1000]] // Grid</syntaxhighlight>
{{out}}
<pre>3 11
10 1010
15 1111
36 100100
45 101101
54 110110
63 111111
136 10001000
153 10011001
170 10101010
187 10111011
204 11001100
221 11011101
238 11101110
255 11111111
528 1000010000
561 1000110001
594 1001010010
627 1001110011
660 1010010100
693 1010110101
726 1011010110
759 1011110111
792 1100011000
825 1100111001
858 1101011010
891 1101111011
924 1110011100
957 1110111101
990 1111011110</pre>
 
=={{header|Miranda}}==
<syntaxhighlight lang="miranda">main :: [sys_message]
main = [Stdout (lay (map display (takewhile (< 1000) identicals)))]
where display n = shownum n ++ ": " ++ bits n
 
bits :: num->[char]
bits = bits' []
where bits' acc 0 = acc
bits' acc n = bits' (decode (48 + n mod 2) : acc) (n div 2)
 
identicals :: [num]
identicals = map identical [1..]
 
identical :: num->num
identical n = n + n * 2^size n
 
size :: num->num
size 0 = 0
size n = 1 + size (n div 2)</syntaxhighlight>
{{out}}
<pre>3: 11
10: 1010
15: 1111
36: 100100
45: 101101
54: 110110
63: 111111
136: 10001000
153: 10011001
170: 10101010
187: 10111011
204: 11001100
221: 11011101
238: 11101110
255: 11111111
528: 1000010000
561: 1000110001
Line 2,489 ⟶ 3,046:
 
=={{header|Modula-2}}==
<langsyntaxhighlight lang="modula2">MODULE IdenticalStrings;
FROM InOut IMPORT WriteString, WriteCard, WriteLn;
 
Line 2,521 ⟶ 3,078:
INC(n);
END;
END IdenticalStrings.</langsyntaxhighlight>
{{out}}
<pre> 3: 11
Line 2,555 ⟶ 3,112:
 
=={{header|Nim}}==
<langsyntaxhighlight Nimlang="nim">import strformat
 
func isConcat(s: string): bool =
Line 2,564 ⟶ 3,121:
for n in 0..999:
let b = &"{n:b}"
if b.isConcat: echo &"{n:3} {b}"</langsyntaxhighlight>
 
{{out}}
Line 2,597 ⟶ 3,154:
957 1110111101
990 1111011110</pre>
 
=={{header|OCaml}}==
<syntaxhighlight lang="ocaml">let rec bin_of_int = function
| n when n < 2 -> string_of_int n
| n -> Printf.sprintf "%s%u" (bin_of_int (n lsr 1)) (n land 1)
 
let seq_task =
let rec next n l m () =
if n = l
then next n (l + l) (succ (l + l)) ()
else Seq.Cons (n * m, next (succ n) l m)
in next 1 2 3
 
let () =
let show n = Printf.printf "%u: %s\n" n (bin_of_int n) in
seq_task |> Seq.take_while ((>) 1000) |> Seq.iter show</syntaxhighlight>
{{out}}
<pre>
3: 11
10: 1010
15: 1111
36: 100100
45: 101101
54: 110110
63: 111111
136: 10001000
153: 10011001
170: 10101010
187: 10111011
204: 11001100
221: 11011101
238: 11101110
255: 11111111
528: 1000010000
561: 1000110001
594: 1001010010
627: 1001110011
660: 1010010100
693: 1010110101
726: 1011010110
759: 1011110111
792: 1100011000
825: 1100111001
858: 1101011010
891: 1101111011
924: 1110011100
957: 1110111101
990: 1111011110
</pre>
 
=={{header|Pascal}}==
{{works with|Turbo Pascal}}
<langsyntaxhighlight lang="pascal">program IdenticalStrings;
const
LIMIT = 1000;
Line 2,645 ⟶ 3,251:
n := n + 1;
end;
end.</langsyntaxhighlight>
 
{{out}}
Line 2,681 ⟶ 3,287:
 
=={{header|PL/I}}==
<langsyntaxhighlight lang="pli">identstr: procedure options(main);
bitLength: procedure(nn) returns(fixed);
declare (n, nn, r) fixed;
Line 2,718 ⟶ 3,324:
call printBits(concat(n,n));
end;
end identstr;</langsyntaxhighlight>
{{out}}
<pre> 3 11
Line 2,752 ⟶ 3,358:
 
=={{header|PL/M}}==
<langsyntaxhighlight lang="plm">100H:
 
/* BINARY CONCATENATION OF A NUMBER WITH ITSELF */
Line 2,803 ⟶ 3,409:
 
CALL BDOS(0,0);
EOF</langsyntaxhighlight>
{{out}}
<pre>3 11
Line 2,838 ⟶ 3,444:
=={{header|Python}}==
===Python: Procedural===
<langsyntaxhighlight lang="python">def bits(n):
"""Count the amount of bits required to represent n"""
r = 0
Line 2,853 ⟶ 3,459:
while concat(n) <= 1000:
print("{0}: {0:b}".format(concat(n)))
n += 1</langsyntaxhighlight>
 
{{out}}
Line 2,892 ⟶ 3,498:
 
Values are drawn, up to a limit, from a non-finite list.
<langsyntaxhighlight lang="python">'''Two identical strings'''
 
from itertools import count, takewhile
Line 2,925 ⟶ 3,531:
# MAIN ---
if __name__ == '__main__':
main()</langsyntaxhighlight>
{{Out}}
<pre>(3, '11')
Line 2,959 ⟶ 3,565:
 
=={{header|Perl}}==
<langsyntaxhighlight lang="perl">#!/usr/bin/perl
 
use strict; # https://rosettacode.org/wiki/Two_identical_strings
Line 2,969 ⟶ 3,575:
(my $decimal = oct "b$binary") >= 1000 and last;
printf "%4d %s\n", $decimal, $binary;
}</langsyntaxhighlight>
{{out}}
<pre>
Line 3,005 ⟶ 3,611:
 
=={{header|Phix}}==
<!--<langsyntaxhighlight Phixlang="phix">(phixonline)-->
<span style="color: #004080;">integer</span> <span style="color: #000000;">n</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">1</span>
<span style="color: #004080;">sequence</span> <span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{}</span>
Line 3,016 ⟶ 3,622:
<span style="color: #008080;">end</span> <span style="color: #008080;">while</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;">"Found %d numbers:\n%s\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">n</span><span style="color: #0000FF;">-</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">join_by</span><span style="color: #0000FF;">(</span><span style="color: #000000;">res</span><span style="color: #0000FF;">,</span><span style="color: #000000;">5</span><span style="color: #0000FF;">,</span><span style="color: #000000;">6</span><span style="color: #0000FF;">)})</span>
<!--</langsyntaxhighlight>-->{{out}}
<pre>
Found 30 numbers:
Line 3,025 ⟶ 3,631:
45 101101 170 10101010 255 11111111 660 1010010100 825 1100111001 990 1111011110
</pre>
 
=={{header|Picat}}==
<syntaxhighlight lang="picat">main =>
bp.length(_L,I),
I > 0,
B = to_binary_string(I),
BB = B++B,
parse_radix_string(BB,2) = Dec,
( Dec < 1000 -> printf("%4w %10w\n",Dec,BB), fail ; true),
nl.</syntaxhighlight>
 
{{out}}
<pre> 3 11
10 1010
15 1111
36 100100
45 101101
54 110110
63 111111
136 10001000
153 10011001
170 10101010
187 10111011
204 11001100
221 11011101
238 11101110
255 11111111
528 1000010000
561 1000110001
594 1001010010
627 1001110011
660 1010010100
693 1010110101
726 1011010110
759 1011110111
792 1100011000
825 1100111001
858 1101011010
891 1101111011
924 1110011100
957 1110111101
990 1111011110</pre>
 
=={{header|Prolog}}==
{{works with|SWI Prolog}}
<langsyntaxhighlight lang="prolog">main:-
writeln('Decimal\tBinary'),
main(1, 1000).
Line 3,041 ⟶ 3,689:
N1 is N + 1,
main(N1, Limit).
main(_, _).</langsyntaxhighlight>
 
{{out}}
Line 3,079 ⟶ 3,727:
 
=={{header|Quackery}}==
<syntaxhighlight lang="quackery"> [ 2 base put
 
<lang Quackery> [ 2 base put
number$ dup size 2 / split =
base release ] is 2identical ( n --> b )
Line 3,089 ⟶ 3,736:
2 base put
i^ echo cr
base release ] ] </langsyntaxhighlight>
 
{{out}}
Line 3,126 ⟶ 3,773:
 
=={{header|Raku}}==
<syntaxhighlight lang="raku" perl6line>my @cat = (1..*).map: { :2([~] .base(2) xx 2) };
say "{+$_} matching numbers\n{.batch(5)».map({$_ ~ .base(2).fmt('(%s)')})».fmt('%15s').join: "\n"}\n"
given @cat[^(@cat.first: * > 1000, :k)];</langsyntaxhighlight>
{{out}}
<pre>30 matching numbers
Line 3,138 ⟶ 3,785:
858(1101011010) 891(1101111011) 924(1110011100) 957(1110111101) 990(1111011110)</pre>
 
=={{header|Refal}}==
<syntaxhighlight lang="refal">$ENTRY Go {
= <IdentUpTo 1000>;
};
 
IdentUpTo {
s.M = <IdentUpTo s.M 1>;
s.M s.I, <Ident s.I>: s.Id, <Compare s.Id s.M>: {
'-' = <Prout <Symb s.Id> ': ' <Bin s.Id>>
<IdentUpTo s.M <+ s.I 1>>;
s.X = ;
};
};
 
Ident {
s.N = <Ident s.N s.N s.N>;
s.N s.R 0 = <+ s.N s.R>;
s.N s.R s.K = <Ident s.N <* s.R 2> <Div s.K 2>>;
};
 
Bin {
0 = ;
s.N, <Divmod s.N 2>: (s.X) s.Y = <Bin s.X> <Symb s.Y>;
};</syntaxhighlight>
{{out}}
<pre>3: 11
10: 1010
15: 1111
36: 100100
45: 101101
54: 110110
63: 111111
136: 10001000
153: 10011001
170: 10101010
187: 10111011
204: 11001100
221: 11011101
238: 11101110
255: 11111111
528: 1000010000
561: 1000110001
594: 1001010010
627: 1001110011
660: 1010010100
693: 1010110101
726: 1011010110
759: 1011110111
792: 1100011000
825: 1100111001
858: 1101011010
891: 1101111011
924: 1110011100
957: 1110111101
990: 1111011110</pre>
=={{header|REXX}}==
<syntaxhighlight lang="rexx">
=== sans formatting ===
/*REXX
<lang>/*REXX program finds/displays decimal numbers whose binary version is a doubled literal.*/
numeric * program finds/displays decimal numbers digits 20 /*ensure 'nuff dec. digs for conversion*/
* whose binary version is a doubled literal.
do #=1 for 1000-1; b= x2b( d2x(#) ) + 0 /*find binary values that can be split.*/
*/
L= length(b); if L//2 then iterate /*get length of binary; if odd, skip. */
numeric digits 20 /*ensure 'nuff dec. digs for conversion*/
if left(b, L%2)\==right(b, L%2) then iterate /*Left half ≡ right half? No, skip it.*/
do i=1 to 1000
say right(#, 4)':' right(b, 12) /*display number in decimal and binary.*/
b= x2b( d2x(i) ) + 0 /*find binary values that can be split.*/
end /*#*/ /*stick a fork in it, we're all done. */</lang>
L= length(b)
if L//2 then iterate /*get length of binary; if odd, skip. */
if left(b, L%2)\==right(b, L%2) then iterate /*Left half ≡ right half?*/
say right(i, 4)':' right(b, 12) /*display number in dec and bin */
end /*i*/ /*stick a fork in it, we're all done. */
*/</syntaxhighlight>
{{out|output|text=&nbsp; (shown at three-quarter size.)}}
<pre style="font-size:75%">
Line 3,182 ⟶ 3,890:
 
=== with formatting ===
<langsyntaxhighlight lang="rexx">/*REXX program finds/displays decimal numbers whose binary version is a doubled literal.*/
numeric digits 100 /*ensure hangling of larger integers. */
parse arg hi cols . /*obtain optional argument from the CL.*/
Line 3,213 ⟶ 3,921:
exit 0 /*stick a fork in it, we're all done. */
/*──────────────────────────────────────────────────────────────────────────────────────*/
commas: parse arg ?; do jc=length(?)-3 to 1 by -3; ?=insert(',', ?, jc); end; return ?</langsyntaxhighlight>
{{out|output|text=&nbsp; when using the default inputs:}}
<pre>
Line 3,232 ⟶ 3,940:
 
=={{header|Ring}}==
<langsyntaxhighlight lang="ring">load "stdlib.ring"
decList = [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15]
Line 3,285 ⟶ 3,993:
s = string(x) l = len(s)
if l > y y = l ok
return substr(" ", 11 - y + l) + s</langsyntaxhighlight>
{{out}}
<pre>working...
Line 3,298 ⟶ 4,006:
Found 30 numbers whose base 2 representation is the juxtaposition of two identical strings
done...</pre>
 
=={{header|RPL}}==
===Slow version===
Binary versions of numbers from 1 to 999 are converted into strings to check the half-half identity.
{{works with|Halcyon Calc|4.2.8}}
≪ R→B →STR 3 OVER SIZE 1 - SUB
'''IF''' DUP SIZE 2 MOD '''THEN''' DROP 0
'''ELSE'''
1 OVER SIZE 2 / SUB
LAST SWAP DROP 1 + OVER SIZE SUB ==
'''END'''
≫ ‘'''TWIN?'''' STO
≪ BIN { } 1 999 FOR n
'''IF''' n '''TWIN?'''
'''THEN''' n →STR "=" +
n R→B →STR 2 OVER SIZE 1 - SUB + + '''END NEXT'''
≫ ''''TASK'''' STO
{{out}}
<pre>
1: { "3= 11" "10= 1010" "15= 1111" "36= 100100" "45= 101101" "54= 110110" "63= 111111" "136= 10001000" "153= 10011001" "170= 10101010" "187= 10111011" "204= 11001100" "221= 11011101" "238= 11101110" "255= 11111111" "528= 1000010000" "561= 1000110001" "594= 1001010010" "627= 1001110011" "660= 1010010100" "693= 1010110101" "726= 1011010110" "759= 1011110111" "792= 1100011000" "825= 1100111001" "858= 1101011010" "891= 1101111011" "924= 1110011100" "957= 1110111101" "990= 1111011110" }
</pre>
Runs on an HP-28S in 130 seconds.
 
=== Optimized version===
{{trans|FreeBASIC}}
40% of the code is dedicated to the display of the results.
{{works with|Halcyon Calc|4.2.8}}
{| class="wikitable"
! RPL code
! Comment
|-
|
≪ BIN { }
2 1
'''DO'''
'''IF''' DUP2 ≤ '''THEN''' OVER ROT + SWAP '''END'''
DUP2 * OVER +
4 ROLL OVER DUP →STR "=" +
SWAP R→B →STR 2 OVER SIZE 1 - SUB + + 4 ROLLD
SWAP 1 +
'''UNTIL''' SWAP 1000 ≥ '''END''' DROP2
≫ ''''TASK'''' STO
|
'''TASK''' ''( -- { "results" } )''
n = 1, p = 2
do
if n >= p then p = p + p
k = n + n * p
print "k= ";
print "bin(k)"
n = n + 1
loop until k ≥ 1000
|}
Runs on an HP-28S in 6 seconds.
 
=={{header|Ruby}}==
{{trans|C}}
<langsyntaxhighlight lang="ruby">for i in 0 .. 1000
bin = i.to_s(2)
if bin.length % 2 == 0 then
Line 3,309 ⟶ 4,073:
end
end
end</langsyntaxhighlight>
{{out}}
<pre> 3: 11
Line 3,341 ⟶ 4,105:
957: 1110111101
990: 1111011110</pre>
 
=={{header|SETL}}==
<syntaxhighlight lang="setl">program identical_strings;
loop init i := 0; doing n := ident(i +:= 1); while n<1000 do
print(lpad(str n, 4) + lpad(binary(n), 15));
end loop;
 
proc ident(n);
ns := n;
loop init t := n; doing t div:= 2; until t = 0 do
ns *:= 2;
end loop;
return ns + n;
end proc;
 
proc binary(n);
return {[0,""]}(n) ? binary(n div 2) + str (n mod 2);
end proc;
end program;</syntaxhighlight>
{{out}}
<pre> 3 11
10 1010
15 1111
36 100100
45 101101
54 110110
63 111111
136 10001000
153 10011001
170 10101010
187 10111011
204 11001100
221 11011101
238 11101110
255 11111111
528 1000010000
561 1000110001
594 1001010010
627 1001110011
660 1010010100
693 1010110101
726 1011010110
759 1011110111
792 1100011000
825 1100111001
858 1101011010
891 1101111011
924 1110011100
957 1110111101
990 1111011110</pre>
 
=={{header|Snobol}}==
<langsyntaxhighlight lang="snobol"> define("bits(n)") :(bits_end)
bits bits = gt(n,0) remdr(n,2) bits :f(return)
n = n / 2 :(bits)
Line 3,360 ⟶ 4,174:
m = concat(n)
output = lt(m,1000) m ": " bits(m) :s(loop)
end</langsyntaxhighlight>
{{out}}
<pre>3: 11
Line 3,394 ⟶ 4,208:
 
=={{header|Swift}}==
<langsyntaxhighlight lang="swift">print("Decimal\tBinary")
var n = 1
while (true) {
Line 3,404 ⟶ 4,218:
print("\(i)\t\(binary)\(binary)")
n += 1
}</langsyntaxhighlight>
 
{{out}}
Line 3,443 ⟶ 4,257:
=={{header|Visual Basic .NET}}==
{{trans|FreeBASIC}}Based on the Alternate version.
<langsyntaxhighlight lang="vbnet">Imports System.Console
Module Module1
Sub Main()
Line 3,454 ⟶ 4,268:
Next : WriteLine(vbLf + "Found {0} numbers whose base 2 representation is the concatenation of two identical binary strings.", c)
End Sub
End Module</langsyntaxhighlight>
{{out}}
<pre> 3 (11 ) 10 (1010 ) 15 (1111 ) 36 (100100 ) 45 (101101 )
Line 3,464 ⟶ 4,278:
 
Found 30 numbers whose base 2 representation is the concatenation of two identical binary strings.</pre>
 
=={{header|V (Vlang)}}==
{{trans|Go}}
<syntaxhighlight lang="v (vlang)">import strconv
fn main() {
mut i := i64(1)
for {
mut b2 := '${i:b}'
b2 += b2
d := strconv.parse_int(b2,2,16) ?
if d >= 1000 {
break
}
println("$d : $b2")
i++
}
println("\nFound ${i-1} numbers.")
}</syntaxhighlight>
 
{{out}}
<pre>
3 : 11
10 : 1010
15 : 1111
36 : 100100
45 : 101101
54 : 110110
63 : 111111
136 : 10001000
153 : 10011001
170 : 10101010
187 : 10111011
204 : 11001100
221 : 11011101
238 : 11101110
255 : 11111111
528 : 1000010000
561 : 1000110001
594 : 1001010010
627 : 1001110011
660 : 1010010100
693 : 1010110101
726 : 1011010110
759 : 1011110111
792 : 1100011000
825 : 1100111001
858 : 1101011010
891 : 1101111011
924 : 1110011100
957 : 1110111101
990 : 1111011110
 
Found 30 numbers.
</pre>
 
=={{header|Wren}}==
{{libheader|Wren-fmt}}
<langsyntaxhighlight ecmascriptlang="wren">import "./fmt" for Conv, Fmt
 
var i = 1
Line 3,478 ⟶ 4,347:
i = i + 1
}
System.print("\nFound %(i-1) numbers.")</langsyntaxhighlight>
 
{{out}}
Line 3,517 ⟶ 4,386:
 
=={{header|XPL0}}==
<langsyntaxhighlight XPL0lang="xpl0">proc BinOut(N); \Output N in binary
int N, Rem;
[Rem:= N&1;
Line 3,538 ⟶ 4,407:
];
];
]</langsyntaxhighlight>
 
{{out}}
Line 3,573 ⟶ 4,442:
990: 1111011110
</pre>
 
=={{header|Yabasic}}==
<syntaxhighlight lang="yabasic">// Rosetta Code problem: http://rosettacode.org/wiki/Two_identical_strings
// by Galileo, 04/2022
 
for n = 1 to 1000
n$ = bin$(n)
if not mod(len(n$), 2) then
k = len(n$) / 2
if left$(n$, k) = right$(n$, k) print n, " = ", n$
endif
next</syntaxhighlight>
{{out}}
<pre>3 = 11
10 = 1010
15 = 1111
36 = 100100
45 = 101101
54 = 110110
63 = 111111
136 = 10001000
153 = 10011001
170 = 10101010
187 = 10111011
204 = 11001100
221 = 11011101
238 = 11101110
255 = 11111111
528 = 1000010000
561 = 1000110001
594 = 1001010010
627 = 1001110011
660 = 1010010100
693 = 1010110101
726 = 1011010110
759 = 1011110111
792 = 1100011000
825 = 1100111001
858 = 1101011010
891 = 1101111011
924 = 1110011100
957 = 1110111101
990 = 1111011110
---Program done, press RETURN---</pre>
Not a robot
2,094

edits

Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/310912...364200"