Two identical strings
From Rosetta Code
Two identical strings is a draft programming task. It is not yet considered ready to be promoted as a complete task, for reasons that should be found in its talk page.
- Task
Find and display (here on this page) positive integers, n, whose base 2 representation is the concatenation of two identical binary strings,
where n < 1,00010 (one thousand).
For each such integer, show its decimal and binary forms.
Contents
- 1 11l
- 2 8080 Assembly
- 3 8086 Assembly
- 4 Action!
- 5 Ada
- 6 ALGOL 68
- 7 ALGOL-M
- 8 ALGOL W
- 9 APL
- 10 AppleScript
- 11 Arturo
- 12 AWK
- 13 BASIC
- 14 BCPL
- 15 Befunge
- 16 C
- 17 C#
- 18 C++
- 19 CLU
- 20 COBOL
- 21 Cowgol
- 22 Crystal
- 23 Draco
- 24 F#
- 25 Factor
- 26 FALSE
- 27 FOCAL
- 28 Forth
- 29 Fortran
- 30 FreeBASIC
- 31 Frink
- 32 Go
- 33 Haskell
- 34 J
- 35 Java
- 36 jq
- 37 Julia
- 38 Liberty BASIC
- 39 MAD
- 40 Modula-2
- 41 Nim
- 42 Pascal
- 43 PL/I
- 44 PL/M
- 45 Python
- 46 Perl
- 47 Phix
- 48 Picat
- 49 Prolog
- 50 Quackery
- 51 Raku
- 52 REXX
- 53 Ring
- 54 Ruby
- 55 Snobol
- 56 Swift
- 57 Visual Basic .NET
- 58 Vlang
- 59 Wren
- 60 XPL0
- 61 Yabasic
11l[edit]
F bits(=n)
‘Count the amount of bits required to represent n’
V r = 0
L n != 0
n >>= 1
r++
R r
F concat(n)
‘Concatenate the binary representation of n to itself’
R n << bits(n) [|] n
V n = 1
L concat(n) <= 1000
print(‘#.: #.’.format(concat(n), bin(concat(n))))
n++
- Output:
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
8080 Assembly[edit]
;;; Print positive integers whose base-2 representation
;;; is the concatenation of two identical binary strings,
;;; for 1 < n < 1000
puts: equ 9 ; CP/M syscall to print a string
org 100h
lxi b,1 ; Counter
loop: mov h,b ; HL = counter
mov l,c
call concat ; Get current concatenated number
lxi d,1000 ; Reached the end yet?
call cmp16
rnc ; Stop when >1000
push b ; Keep the counter
push h ; And the concatenated number
call hldec ; Print decimal value
pop h ; Restore number
call hlbin ; Print binary value
lxi d,nl ; Print newline
mvi c,puts
call 5
pop b ; Restore counter
inx b ; Increment counter
jmp loop
;;; 16-bit compare HL to DE
cmp16: mov a,h
cmp d
rnz
mov a,l
cmp e
ret
;;; Concatenate HL with itself
concat: push h ; Keep a copy of HL on the stack
mov d,h ; DE = copy of HL
mov e,l
ctloop: mov a,d ; When DE=0, we are done
ora e
jz ctdone
mov a,d ; Rotate DE left
rar
mov d,a
mov a,e
rar
mov e,a
dad h ; And rotate HL right (add to itself)
jmp ctloop
ctdone: pop d ; Retrieve old HL
dad d ; Add to shifted version (same as OR)
ret
;;; Print HL as a decimal value
hldec: lxi d,outbuf
push d ; Output pointer on the stack
lxi b,-10 ; Divisor
decdgt: lxi d,-1 ; Quotient
div10: inx d ; Divide HL by 10 using trial subtraction
dad b
jc div10
mvi a,'0'+10
add l ; L contains remainder - 10
pop h ; Retrieve output pointer
dcx h ; Store digit
mov m,a
push h
xchg ; Continue with quotient
mov a,h ; If any digits left
ora l
jnz decdgt ; Find the next digits
pop d ; Otherwise, retrieve pointer
mvi c,puts ; And print result using CP/M
jmp 5
;;; Print HL as a binary value
hlbin: lxi d,outbuf
ora a ; Zero the carry flag
bindgt: mov a,h ; Rotate HL right
rar
mov h,a
mov a,l
rar
mov l,a
mvi a,0 ; A = '0' + carry flag (i.e. lowest bit)
aci '0'
dcx d ; Store digit
stax d
mov a,h ; Any more digits?
ora l
jnz bindgt ; If so, find next digits
mvi c,puts ; Otherwise, print the result
jmp 5
db '***********'
outbuf: db 9,'$'
nl: db 13,10,'$'
- Output:
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
8086 Assembly[edit]
puts: equ 9
cpu 8086
org 100h
section .text
main: mov di,1 ; Counter
.loop: mov ax,di
call concat ; Concatenate current number to itself
cmp ax,1000
jge .done ; Stop when >= 1000
mov si,ax ; Keep a copy of AX
call pdec ; Print decimal value
mov ax,si
call pbin ; Print binary value
mov bx,nl ; Print newline
call pstr
inc di ; Next number
jmp .loop
.done: ret
;;; Concatenate AX to itself
concat: mov bx,ax ; Store a copy of AX in BP
mov cx,ax ; Store a copy of AX in CX
.loop: shl ax,1 ; Shift AX left
shr cx,1 ; Shift CX right
jnz .loop ; Keep going until CX is zero
or ax,bx ; OR original AX with shifted AX
ret
;;; Print AX as decimal
pdec: mov bp,10 ; Divisor
mov bx,outbuf ; Buffer pointer
.loop: xor dx,dx
div bp
add dl,'0' ; Add '0' to remainder
dec bx ; Store digit
mov [bx],dl
test ax,ax ; Any more digits?
jnz .loop
jmp pstr ; When done, print the result
;;; Print AX as binary
pbin: mov bx,outbuf ; Buffer pointer
.loop: shr ax,1 ; Shift AX
mov dl,'0' ; ASCII 0 or 1
adc dl,0
dec bx
mov [bx],dl ; Store digit
test ax,ax
jnz .loop
pstr: mov ah,puts ; When done, print the result
mov dx,bx
int 21h
ret
section .data
nl: db 13,10,'$'
db '****************'
outbuf: db 9,'$'
- Output:
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
Action![edit]
INT FUNC Encode(INT x CHAR ARRAY s)
BYTE len,i
CHAR tmp
len=0 tmp=x
WHILE tmp#0
DO
len==+1
s(len)='0+(tmp&1)
tmp==RSH 1
OD
FOR i=1 TO len RSH 1
DO
tmp=s(i) s(i)=s(len-i+1) s(len-i+1)=tmp
OD
FOR i=1 TO len
DO
s(i+len)=s(i)
OD
s(0)=len
RETURN (x LSH len+x)
PROC Main()
CHAR ARRAY s(20)
INT i=[1],res,count=[0]
DO
res=Encode(i,s)
IF res>=1000 THEN
EXIT
FI
Position((count&1)*15+2,count RSH 1+1)
PrintF("%I: %S",res,s)
i==+1 count==+1
OD
RETURN
- Output:
Screenshot from Atari 8-bit computer
3: 1 10: 10 15: 11 36: 100 45: 101 54: 110 63: 111 136: 1000 153: 1001 170: 1010 187: 1011 204: 1100 221: 1101 238: 1110 255: 1111 528: 10000 561: 10001 594: 10010 627: 10011 660: 10100 693: 10101 726: 10110 759: 10111 792: 11000 825: 11001 858: 11010 891: 11011 924: 11100 957: 11101 990: 11110
Ada[edit]
with Ada.Text_Io; use Ada.Text_Io;
with Ada.Strings.Fixed; use Ada.Strings.Fixed;
procedure Two_Identical is
package Integer_Io is
new Ada.Text_Io.Integer_Io (Integer);
use Integer_Io;
Image : String (1 .. 16);
Pos_1, Pos_2 : Natural;
Mid : Natural;
begin
for N in 1 .. 1000 loop
Put (Image, N, Base => 2);
Pos_1 := Index (Image, "#");
Pos_2 := Index (Image, "#", Pos_1 + 1);
Mid := (Pos_1 + Pos_2) / 2;
if Image (Pos_1 + 1 .. Mid) = Image (Mid + 1 .. Pos_2 - 1) then
Put (N, Width => 3); Put (" "); Put (Image); New_Line;
end if;
end loop;
end Two_Identical;
- Output:
3 2#11# 10 2#1010# 15 2#1111# 36 2#100100# 45 2#101101# 54 2#110110# 63 2#111111# 136 2#10001000# 153 2#10011001# 170 2#10101010# 187 2#10111011# 204 2#11001100# 221 2#11011101# 238 2#11101110# 255 2#11111111# 528 2#1000010000# 561 2#1000110001# 594 2#1001010010# 627 2#1001110011# 660 2#1010010100# 693 2#1010110101# 726 2#1011010110# 759 2#1011110111# 792 2#1100011000# 825 2#1100111001# 858 2#1101011010# 891 2#1101111011# 924 2#1110011100# 957 2#1110111101# 990 2#1111011110#
ALGOL 68[edit]
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 #
OP TOBINSTRING = ( INT v )STRING:
IF v = 0 THEN "0"
ELSE
STRING result := "";
INT rest := v;
WHILE rest > 0 DO
IF ODD rest THEN "1" ELSE "0" FI +=: result;
rest OVERAB 2
OD;
result
FI # TOBINSTRING # ;
INT power of 2 := 1;
FOR b WHILE IF b = power of 2 THEN
power of 2 *:= 2
FI;
INT cat value = ( b * power of 2 ) + b;
cat value < 1000
DO
print( ( whole( cat value, -4 ), ": ", TOBINSTRING cat value, newline ) )
OD
END
- Output:
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
ALGOL-M[edit]
begin
integer function concatself(n);
integer n;
begin
integer shift, copy, test;
test := n;
shift := n;
while test > 0 do
begin
test := test / 2;
shift := shift * 2;
end;
concatself := shift + n;
end;
procedure writebits(n);
integer n;
begin
if n>1 then writebits(n/2);
writeon(if n-n/2*2=0 then "0" else "1");
end;
integer n, m;
n := 1;
m := concatself(n);
while m < 1000 do
begin
write(m, ": ");
writebits(m);
n := n + 1;
m := concatself(n);
end;
end
- Output:
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
ALGOL W[edit]
BEGIN
INTEGER PROCEDURE BITSP ( INTEGER VALUE BT ) ;
BEGIN
INTEGER BITN, BITRSL, BITIDX;
BITN := BT;
BITRSL := 0;
BITIDX := 1;
WHILE BITN > 0 DO BEGIN
INTEGER BITNX;
BITNX := BITN DIV 2;
BITRSL := BITRSL + BITIDX*(BITN-BITNX*2);
BITN := BITNX;
BITIDX := BITIDX*10
END;
BITRSL
END BITSP ;
INTEGER PROCEDURE DPLBIT ( INTEGER VALUE DVAL ) ;
BEGIN
INTEGER DTEMP, DSHFT;
DTEMP := DVAL;
DSHFT := DVAL;
WHILE DTEMP > 0 DO BEGIN
DSHFT := DSHFT * 2;
DTEMP := DTEMP DIV 2;
END;
DSHFT + DVAL
END DPLBIT ;
BEGIN
INTEGER N;
N := 0;
WHILE BEGIN
N := N + 1;
DPLBIT(N) < 1000
END DO WRITE( S_W := 0, I_W := 3, DPLBIT(N), ": ", I_W := 10, BITSP(DPLBIT(N)) )
END
END.
- Output:
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
APL[edit]
↑(((⊂2∘⊥),⊂)(,⍨2∘⊥⍣¯1))¨⍳30
- Output:
3 1 1 10 1 0 1 0 15 1 1 1 1 36 1 0 0 1 0 0 45 1 0 1 1 0 1 54 1 1 0 1 1 0 63 1 1 1 1 1 1 136 1 0 0 0 1 0 0 0 153 1 0 0 1 1 0 0 1 170 1 0 1 0 1 0 1 0 187 1 0 1 1 1 0 1 1 204 1 1 0 0 1 1 0 0 221 1 1 0 1 1 1 0 1 238 1 1 1 0 1 1 1 0 255 1 1 1 1 1 1 1 1 528 1 0 0 0 0 1 0 0 0 0 561 1 0 0 0 1 1 0 0 0 1 594 1 0 0 1 0 1 0 0 1 0 627 1 0 0 1 1 1 0 0 1 1 660 1 0 1 0 0 1 0 1 0 0 693 1 0 1 0 1 1 0 1 0 1 726 1 0 1 1 0 1 0 1 1 0 759 1 0 1 1 1 1 0 1 1 1 792 1 1 0 0 0 1 1 0 0 0 825 1 1 0 0 1 1 1 0 0 1 858 1 1 0 1 0 1 1 0 1 0 891 1 1 0 1 1 1 1 0 1 1 924 1 1 1 0 0 1 1 1 0 0 957 1 1 1 0 1 1 1 1 0 1 990 1 1 1 1 0 1 1 1 1 0
AppleScript[edit]
Functional[edit]
Drawing members of the sequence from a non-finite list, up to a given limit.
------ CONCATENATION OF TWO IDENTICAL BINARY STRINGS -----
-- binaryTwin :: Int -> (Int, String)
on binaryTwin(n)
-- A tuple of an integer m and a string s, where
-- s is a self-concatenation of the binary
-- represention of n, and m is the integer value of s.
set b to showBinary(n)
set s to b & b
{readBinary(s), s}
end binaryTwin
--------------------------- TEST -------------------------
on run
script p
on |λ|(pair)
1000 > item 1 of pair
end |λ|
end script
script format
on |λ|(pair)
set {n, s} to pair
(n as string) & " -> " & s
end |λ|
end script
unlines(map(format, ¬
takeWhile(p, ¬
fmap(binaryTwin, enumFrom(1)))))
end run
------------------------- GENERIC ------------------------
-- enumFrom :: Int -> [Int]
on enumFrom(x)
script
property v : missing value
on |λ|()
if missing value is not v then
set v to 1 + v
else
set v to x
end if
return v
end |λ|
end script
end enumFrom
-- fmap <$> :: (a -> b) -> Gen [a] -> Gen [b]
on fmap(f, gen)
script
property g : mReturn(f)
on |λ|()
set v to gen's |λ|()
if v is missing value then
v
else
g's |λ|(v)
end if
end |λ|
end script
end fmap
-- foldr :: (a -> b -> b) -> b -> [a] -> b
on foldr(f, startValue, xs)
tell mReturn(f)
set v to startValue
set lng to length of xs
repeat with i from lng to 1 by -1
set v to |λ|(item i of xs, v, i, xs)
end repeat
return v
end tell
end foldr
-- map :: (a -> b) -> [a] -> [b]
on map(f, xs)
-- The list obtained by applying f
-- to each element of xs.
tell mReturn(f)
set lng to length of xs
set lst to {}
repeat with i from 1 to lng
set end of lst to |λ|(item i of xs, i, xs)
end repeat
return lst
end tell
end map
-- mReturn :: First-class m => (a -> b) -> m (a -> b)
on mReturn(f)
-- 2nd class handler function lifted into 1st class script wrapper.
if script is class of f then
f
else
script
property |λ| : f
end script
end if
end mReturn
-- quotRem :: Int -> Int -> (Int, Int)
on quotRem(m, n)
{m div n, m mod n}
end quotRem
-- readBinary :: String -> Int
on readBinary(s)
-- The integer value of the binary string s
script go
on |λ|(c, en)
set {e, n} to en
set v to ((id of c) - 48)
{2 * e, v * e + n}
end |λ|
end script
item 2 of foldr(go, {1, 0}, s)
end readBinary
-- showBinary :: Int -> String
on showBinary(n)
script binaryChar
on |λ|(n)
character id (48 + n)
end |λ|
end script
showIntAtBase(2, binaryChar, n, "")
end showBinary
-- showIntAtBase :: Int -> (Int -> Char) -> Int -> String -> String
on showIntAtBase(base, toDigit, n, rs)
script go
property f : mReturn(toDigit)
on |λ|(nd_, r)
set {n, d} to nd_
set r_ to f's |λ|(d) & r
if n > 0 then
|λ|(quotRem(n, base), r_)
else
r_
end if
end |λ|
end script
|λ|(quotRem(n, base), rs) of go
end showIntAtBase
-- takeWhile :: (a -> Bool) -> Generator [a] -> [a]
on takeWhile(p, xs)
set ys to {}
set v to |λ|() of xs
tell mReturn(p)
repeat while (|λ|(v))
set end of ys to v
set v to xs's |λ|()
end repeat
end tell
return ys
end takeWhile
-- unlines :: [String] -> String
on unlines(xs)
-- A single string formed by the intercalation
-- of a list of strings with the newline character.
set {dlm, my text item delimiters} to ¬
{my text item delimiters, linefeed}
set s to xs as text
set my text item delimiters to dlm
s
end unlines
- Output:
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
Idiomatic[edit]
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.
script o
property bits : {rhv}
property output : {}
end script
set astid to AppleScript's text item delimiters
set AppleScript's text item delimiters to ""
repeat
-- Add 1 to the binary-digit list's LSD and perform any carries.
set carry to 1
repeat with i from (count o's bits) to 1 by -1
set columnSum to (item i of o's bits) + carry
set item i of o's bits to columnSum mod 2
set carry to columnSum div 2
if (carry = 0) then exit repeat
end repeat
if (carry = 1) then set beginning of o's bits to carry
-- Add 1 to the "right-hand" value and work out the corresponding n.
set rhv to rhv + 1
set n to rhv * (2 ^ (count o's bits)) div 1 + rhv
-- Unless n exceeds maxN, append it and its binary form to the output.
if (n > maxN) then exit repeat
set end of o's output to (n as text) & ": " & o's bits & o's bits
end repeat
set AppleScript's text item delimiters to linefeed
set o's output to o's output as text
set AppleScript's text item delimiters to astid
return o's output
end task
task(999)
- Output:
"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"
Arturo[edit]
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]
]
]
- Output:
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
AWK[edit]
# syntax: GAWK -f TWO_IDENTICAL_STRINGS.AWK
BEGIN {
for (i=1; i<1000; i++) {
b = dec2bin(i)
leng = length(b)
if (leng % 2 == 0) {
if (substr(b,1,leng/2) == substr(b,leng/2+1)) {
printf("%4d %10s\n",i,b)
count++
}
}
}
printf("count: %d\n",count)
exit(0)
}
function dec2bin(n, str) {
while (n) {
str = ((n%2 == 0) ? "0" : "1") str
n = int(n/2)
}
if (str == "") {
str = "0"
}
return(str)
}
- Output:
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 count: 30
BASIC[edit]
10 DEFINT A-Z: DIM B(15)
20 N=0
30 N=N+1
40 C=0: X=N
50 C=C+1
60 X=X\2
70 IF X>0 THEN 50
80 K=N+2^C*N
90 IF K>1000 THEN END
100 PRINT K,
110 FOR I=C*2 TO 1 STEP -1
120 B(I)=K AND 1
130 K=K\2
140 NEXT I
150 FOR I=1 TO C*2
160 PRINT USING "#";B(I);
170 NEXT I
180 PRINT
190 GOTO 30
- Output:
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
BASIC256[edit]
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
QBasic[edit]
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
PureBasic[edit]
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()
True BASIC[edit]
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
BCPL[edit]
get "libhdr"
let bitlength(n) = n=0 -> 0, 1 + bitlength(n >> 1)
let concat(n,m) = (n << bitlength(n)) | m;
let writebits(n) be
$( if n>1 then writebits(n >> 1)
wrch('0' + (n & 1))
$)
let start() be
$( let n = 1 and conc = concat(n,n)
while conc < 1000 do
$( writef("%I4: ", conc)
writebits(conc)
wrch('*N')
n := n + 1
conc := concat(n,n)
$)
$)
- Output:
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
Befunge[edit]
1>:::>:#v_++:91+v
>^ / >\vv**::<
^2\*2<>`#@_v
v_v#!:<\+19\0.:<
$ : ^ /2<
+v<>2%68*+\^
1:^
$!,
^_^
- Output:
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
C[edit]
#include <stdio.h>
#include <stdint.h>
uint8_t bit_length(uint32_t n) {
uint8_t r;
for (r=0; n; r++) n >>= 1;
return r;
}
uint32_t concat_bits(uint32_t n) {
return (n << bit_length(n)) | n;
}
char *bits(uint32_t n) {
static char buf[33];
char *ptr = &buf[33];
*--ptr = 0;
do {
*--ptr = '0' + (n & 1);
} while (n >>= 1);
return ptr;
}
int main() {
uint32_t n, r;
for (n=1; (r = concat_bits(n)) < 1000; n++) {
printf("%d: %s\n", r, bits(r));
}
return 0;
}
- Output:
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
C#[edit]
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++)
if ((k = n + n * (p += n >= p ? p : 0)) > lmt) break;
else Console.Write("{0,3} ({1,-10}) {2}", k,
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); } }
- Output:
Same as Visual Basic. NET
C++[edit]
#include <iostream>
#include <string>
// Given the base 2 representation of a number n, transform it into the base 2
// representation of n + 1.
void base2_increment(std::string& s) {
size_t z = s.rfind('0');
if (z != std::string::npos) {
s[z] = '1';
size_t count = s.size() - (z + 1);
s.replace(z + 1, count, count, '0');
} else {
s.assign(s.size() + 1, '0');
s[0] = '1';
}
}
int main() {
std::cout << "Decimal\tBinary\n";
std::string s("1");
for (unsigned int n = 1; ; ++n) {
unsigned int i = n + (n << s.size());
if (i >= 1000)
break;
std::cout << i << '\t' << s << s << '\n';
base2_increment(s);
}
}
- Output:
Decimal Binary 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
CLU[edit]
nth_ident = proc (n: int) returns (int)
h: int := n
l: int := n
while l>0 do h, l := h*2, l/2 end
return(h + n)
end nth_ident
bits = proc (n: int) returns (string)
p: string := ""
if n>1 then p := bits(n/2) end
return(p || int$unparse(n//2))
end bits
start_up = proc ()
po: stream := stream$primary_output()
n: int := 0
while true do
n := n+1
ident: int := nth_ident(n)
if ident>=1000 then break end
stream$putright(po, int$unparse(ident), 3)
stream$putl(po, ": " || bits(ident))
end
end start_up
- Output:
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
COBOL[edit]
IDENTIFICATION DIVISION.
PROGRAM-ID. IDENTICAL-STRINGS.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 VARIABLES.
03 INPUT-NUMBER PIC 9(4).
03 BINARY-REPRESENTATION PIC 9(10).
03 BIT REDEFINES BINARY-REPRESENTATION,
PIC 9 OCCURS 10 TIMES.
03 FIRST-SET-BIT PIC 99.
03 CURRENT-BIT PIC 99.
03 SECOND-BIT PIC 99.
03 BIT-VALUE PIC 9(4).
03 OUTPUT-NUMBER PIC 9(4) VALUE ZERO.
03 REMAINING-BITS PIC 9(4)V9.
03 FILLER REDEFINES REMAINING-BITS.
05 REST PIC 9(4).
05 FILLER PIC 9.
88 BIT-IS-SET VALUE 5.
01 OUTPUT-FORMAT.
03 DECIMAL-OUTPUT PIC Z(3)9.
03 BINARY-OUTPUT PIC Z(9)9.
PROCEDURE DIVISION.
BEGIN.
PERFORM IDENTICAL-STRING
VARYING INPUT-NUMBER FROM 1 BY 1
UNTIL OUTPUT-NUMBER IS GREATER THAN 1000.
STOP RUN.
IDENTICAL-STRING.
MOVE ZERO TO BINARY-REPRESENTATION.
MOVE 10 TO CURRENT-BIT.
MOVE INPUT-NUMBER TO REMAINING-BITS.
PERFORM EXTRACT-BIT UNTIL REMAINING-BITS EQUAL ZERO.
MOVE CURRENT-BIT TO FIRST-SET-BIT.
MOVE 10 TO SECOND-BIT.
PERFORM COPY-BIT UNTIL SECOND-BIT IS EQUAL TO FIRST-SET-BIT.
MOVE ZERO TO OUTPUT-NUMBER.
IF CURRENT-BIT IS EQUAL TO ZERO, MOVE 1 TO CURRENT-BIT.
PERFORM INSERT-BIT
VARYING CURRENT-BIT FROM CURRENT-BIT BY 1
UNTIL CURRENT-BIT IS GREATER THAN 10.
MOVE OUTPUT-NUMBER TO DECIMAL-OUTPUT.
MOVE BINARY-REPRESENTATION TO BINARY-OUTPUT.
IF OUTPUT-NUMBER IS LESS THAN 1000,
DISPLAY DECIMAL-OUTPUT ": " BINARY-OUTPUT.
EXTRACT-BIT.
DIVIDE 2 INTO REMAINING-BITS.
IF BIT-IS-SET, MOVE 1 TO BIT(CURRENT-BIT).
SUBTRACT 1 FROM CURRENT-BIT.
MOVE REST TO REMAINING-BITS.
COPY-BIT.
MOVE BIT(SECOND-BIT) TO BIT(CURRENT-BIT).
SUBTRACT 1 FROM SECOND-BIT.
SUBTRACT 1 FROM CURRENT-BIT.
INSERT-BIT.
COMPUTE BIT-VALUE = 2 ** (10 - CURRENT-BIT)
MULTIPLY BIT(CURRENT-BIT) BY BIT-VALUE.
ADD BIT-VALUE TO OUTPUT-NUMBER.
- Output:
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
Cowgol[edit]
include "cowgol.coh";
sub bitLength(n: uint32): (l: uint8) is
l := 0;
while n != 0 loop
n := n >> 1;
l := l + 1;
end loop;
end sub;
sub concatBits(n: uint32): (r: uint32) is
r := (n << bitLength(n)) | n;
end sub;
sub printBits(n: uint32) is
var buf: uint8[33];
var ptr := &buf[32];
[ptr] := 0;
loop
ptr := @prev ptr;
[ptr] := '0' + (n as uint8 & 1);
n := n >> 1;
if n == 0 then break; end if;
end loop;
print(ptr);
end sub;
var n: uint32 := 1;
loop
var r := concatBits(n);
if r > 1000 then break; end if;
print_i32(r);
print(": ");
printBits(r);
print_nl();
n := n + 1;
end loop;
- Output:
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
Crystal[edit]
(0..1000).each do |i|
bin = i.to_s(2)
if bin.size.even?
half = bin.size // 2
if bin[0..half-1] == bin[half..]
print "%3d: %10s\n" % [i, bin]
end
end
end
- Output:
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
Draco[edit]
proc nonrec concat_self(word n) word:
word rslt, k;
k := n;
rslt := n;
while k ~= 0 do
k := k >> 1;
rslt := rslt << 1
od;
rslt | n
corp
proc nonrec main() void:
word n, conc;
n := 1;
while
conc := concat_self(n);
conc < 1000
do
writeln(conc:3, ": ", conc:b:10);
n := n + 1
od
corp
- Output:
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
F#[edit]
// 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))
- Output:
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
Factor[edit]
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
- Output:
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
FALSE[edit]
1[$$$[$][2/\2*\]#%|$1000>~][
$.": "
0\10\[$1&'0+\2/$][]#%
[$][,]#%
1+
]#%%
- Output:
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
FOCAL[edit]
01.10 S N=0
01.20 S N=N+1
01.30 D 3
01.40 I (K-1000)1.5;Q
01.50 T %3,K,": "
01.60 D 4
01.70 G 1.2
02.10 S BC=0;S BT=N
02.20 S BC=BC+1
02.30 S BT=FITR(BT/2)
02.40 I (-BT)2.2
03.10 D 2;S I=BC;S BT=N
03.20 S BX=FITR(BT/2)
03.30 S I=I-1
03.40 S B(I)=BT-BX*2
03.50 S BT=BX
03.60 I (-I)3.2,3.2
03.70 F I=0,BC-1;S B(BC+I)=B(I)
03.80 S BC=BC*2;S K=0
03.90 F I=0,BC-1;S K=K*2+B(I)
04.10 F I=0,BC-1;D 4.3
04.20 T !;R
04.30 I (B(I))4.4,4.5,4.4
04.40 T "1"
04.50 T "0"
- Output:
= 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
Forth[edit]
: concat-self
dup dup
begin dup while
1 rshift
swap 1 lshift swap
repeat
drop or
;
: print-bits
0 swap
begin
dup 1 and '0 +
swap 1 rshift
dup 0= until drop
begin dup while emit repeat drop
;
: to1000
1
begin dup concat-self dup 1000 < while
dup . 9 emit print-bits cr
1+
repeat
2drop
;
to1000 bye
- Output:
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
Fortran[edit]
program IdentStr
implicit none
integer n, concat, bits
n = 1
100 if (concat(n) .lt. 1000) then
write (*,'(I3,2X,I11)') concat(n), bits(concat(n))
n = n + 1
goto 100
end if
stop
end
C Concatenate binary representation of number with itself
integer function concat(num)
integer num, sl, sr
sl = num
sr = num
100 if (sr .gt. 0) then
sl = sl * 2
sr = sr / 2
goto 100
end if
concat = num + sl
end
C Calculate binary representation of number
integer function bits(num)
integer num, n, bx
n = num
bits = 0
bx = 1
100 if (n .gt. 0) then
bits = bits + bx * mod(n,2)
bx = bx * 10
n = n / 2
goto 100
end if
end
- Output:
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
FreeBASIC[edit]
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
- Output:
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
Alternate[edit]
No log() function required.
dim as uinteger n = 1, k = 0, p = 2
do
if n >= p then p = p + p
k = n + n * p
if k < 1000 then print k, bin(k) else end
n = n + 1
loop
- Output:
Same as log() version.
Frink[edit]
for n = 1 to 999
if base2[n] =~ %r/^(\d+)\1$/
println["$n\t" + base2[n]]
- Output:
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
Go[edit]
package main
import (
"fmt"
"strconv"
)
func main() {
i := int64(1)
for {
b2 := strconv.FormatInt(i, 2)
b2 += b2
d, _ := strconv.ParseInt(b2, 2, 64)
if d >= 1000 {
break
}
fmt.Printf("%3d : %s\n", d, b2)
i++
}
fmt.Println("\nFound", i-1, "numbers.")
}
- Output:
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.
Haskell[edit]
Data.Bits[edit]
import Control.Monad (join)
import Data.Bits
( countLeadingZeros,
finiteBitSize,
shift,
(.|.)
)
import Text.Printf (printf)
-- Find the amount of bits required to represent a number
nBits :: Int -> Int
nBits = (-) . finiteBitSize <*> countLeadingZeros
-- Concatenate the bits of a number to itself
concatSelf :: Int -> Int
concatSelf = (.|.) =<< shift <*> nBits
-- Integers whose base-2 representation is the concatenation
-- of two identical binary strings
identStrInts :: [Int]
identStrInts = map concatSelf [1 ..]
main :: IO ()
main =
putStr $
unlines $
map (join $ printf "%d: %b") to1000
where
to1000 = takeWhile (<= 1000) identStrInts
- Output:
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
Data.Char[edit]
As an alternative to Data.Bits, we could also express this in terms of Data.Char
import Control.Monad (join)
import Data.Char (digitToInt, intToDigit)
import Numeric (showIntAtBase)
------ CONCATENATION OF TWO IDENTICAL BINARY STRINGS -----
binaryTwin :: Int -> (Int, String)
binaryTwin = ((,) =<< readBinary) . join (<>) showBinary
--------------------------- TEST -------------------------
main :: IO ()
main =
mapM_ print $
takeWhile ((1000 >) . fst) $
binaryTwin <$> [1 ..]
------------------------- GENERIC ------------------------
showBinary :: Int -> String
showBinary = flip (showIntAtBase 2 intToDigit) []
readBinary :: String -> Int
readBinary s =
snd $
foldr
(\c (e, n) -> (2 * e, digitToInt c * e + n))
(1, 0)
s
(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")
J[edit]
(":,': ',":@#:)@(,~&.#:)"0 (>:i.30)
- Output:
3: 1 1 10: 1 0 1 0 15: 1 1 1 1 36: 1 0 0 1 0 0 45: 1 0 1 1 0 1 54: 1 1 0 1 1 0 63: 1 1 1 1 1 1 136: 1 0 0 0 1 0 0 0 153: 1 0 0 1 1 0 0 1 170: 1 0 1 0 1 0 1 0 187: 1 0 1 1 1 0 1 1 204: 1 1 0 0 1 1 0 0 221: 1 1 0 1 1 1 0 1 238: 1 1 1 0 1 1 1 0 255: 1 1 1 1 1 1 1 1 528: 1 0 0 0 0 1 0 0 0 0 561: 1 0 0 0 1 1 0 0 0 1 594: 1 0 0 1 0 1 0 0 1 0 627: 1 0 0 1 1 1 0 0 1 1 660: 1 0 1 0 0 1 0 1 0 0 693: 1 0 1 0 1 1 0 1 0 1 726: 1 0 1 1 0 1 0 1 1 0 759: 1 0 1 1 1 1 0 1 1 1 792: 1 1 0 0 0 1 1 0 0 0 825: 1 1 0 0 1 1 1 0 0 1 858: 1 1 0 1 0 1 1 0 1 0 891: 1 1 0 1 1 1 1 0 1 1 924: 1 1 1 0 0 1 1 1 0 0 957: 1 1 1 0 1 1 1 1 0 1 990: 1 1 1 1 0 1 1 1 1 0
Java[edit]
public class TwoIdenticalStrings {
public static void main(String[] args) {
System.out.println("Decimal Binary");
for (int i = 0; i < 1_000; i++) {
String binStr = Integer.toBinaryString(i);
if (binStr.length() % 2 == 0) {
int len = binStr.length() / 2;
if (binStr.substring(0, len).equals(binStr.substring(len))) {
System.out.printf("%7d %s%n", i, binStr);
}
}
}
}
}
- Output:
Decimal Binary
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
jq[edit]
Works with gojq, the Go implementation of jq
def binary_digits:
if . == 0 then 0
else [recurse( if . == 0 then empty else ./2 | floor end ) % 2 | tostring]
| reverse
| .[1:] # remove the leading 0
| join("")
end ;
range(1;1000)
| . as $i
| binary_digits
| select(length % 2 == 0)
| (length/2) as $half
| select(.[$half:] == .[:$half])
| [$i, .]
- Output:
[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"]
Julia[edit]
function twoidenticalstringsinbase(base, maxnum, verbose=true)
found = Int[]
for i in 1:maxnum
dig = digits(i; base)
k = length(dig)
iseven(k) && dig[begin:begin+k÷2-1] == dig[begin+k÷2:end] && push!(found, i)
end
if verbose
println("\nDecimal Base $base")
for n in found
println(rpad(n, 9), string(n, base=base))
end
end
return found
end
twoidenticalstringsinbase(2, 999)
twoidenticalstringsinbase(16, 999)
- Output:
Decimal Base 2 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 Decimal Base 16 17 11 34 22 51 33 68 44 85 55 102 66 119 77 136 88 153 99 170 aa 187 bb 204 cc 221 dd 238 ee 255 ff
Generator version[edit]
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]))
if verbose
println("\nDecimal Base $base")
foreach(n-> println(rpad(n, 9), string(n, base = base)), gen)
end
return gen
end
twoidenticalstringsinbase(2, 999)
twoidenticalstringsinbase(16, 999)
- Output:
Same as filter version above.
Liberty BASIC[edit]
maxNumber = 1000
maxN = Int(Len(DecToBin$(maxNumber))/ 2)
Print "Value"," Binary"
'Since 1 is obviously not applicable,
'just count to ((2^maxN) - 2); Using "- 2" because
'we know that ((2^5) - 1) = 1023 which is > 1000
For i = 1 To ((2^maxN) - 2)
bin$ = DecToBin$(i)
'Let's format the output nicely
Print (((2^Len(bin$))*i) + i),Space$((maxN * 2) - Len(bin$;bin$));bin$;bin$
Next i
End
Function DecToBin$(decNum)
While decNum
DecToBin$ = (decNum Mod 2);DecToBin$
decNum = Int(decNum/ 2)
Wend
If (DecToBin$ = "") Then DecToBin$ = "0"
End Function
- Output:
Value Binary 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
MAD[edit]
NORMAL MODE IS INTEGER
INTERNAL FUNCTION(BT)
ENTRY TO BITS.
BITN = BT
BITRSL = 0
BITIDX = 1
GETBIT WHENEVER BITN.G.0
BITNX = BITN/2
BITRSL = BITRSL + BITIDX*(BITN-BITNX*2)
BITN = BITNX
BITIDX = BITIDX*10
TRANSFER TO GETBIT
END OF CONDITIONAL
FUNCTION RETURN BITRSL
END OF FUNCTION
INTERNAL FUNCTION(DVAL)
ENTRY TO DPLBIT.
DTEMP = DVAL
DSHFT = DVAL
DSTEP WHENEVER DTEMP.G.0
DSHFT = DSHFT * 2
DTEMP = DTEMP / 2
TRANSFER TO DSTEP
END OF CONDITIONAL
FUNCTION RETURN DSHFT + DVAL
END OF FUNCTION
THROUGH NUM, FOR N=1, 1, DPLBIT.(N).GE.1000
NUM PRINT FORMAT NFMT, DPLBIT.(N), BITS.(DPLBIT.(N))
VECTOR VALUES NFMT = $I3,2H: ,I10*$
END OF PROGRAM
- Output:
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
Modula-2[edit]
MODULE IdenticalStrings;
FROM InOut IMPORT WriteString, WriteCard, WriteLn;
VAR n: CARDINAL;
PROCEDURE identical(n: CARDINAL): CARDINAL;
VAR shiftL, shiftR: CARDINAL;
BEGIN
shiftL := n;
shiftR := n;
WHILE shiftR > 0 DO
shiftL := shiftL * 2;
shiftR := shiftR DIV 2;
END;
RETURN shiftL + n;
END identical;
PROCEDURE WriteBits(n: CARDINAL);
BEGIN
IF n>1 THEN WriteBits(n DIV 2); END;
WriteCard(n MOD 2, 1);
END WriteBits;
BEGIN
n := 1;
WHILE identical(n) < 1000 DO
WriteCard(identical(n), 3);
WriteString(": ");
WriteBits(identical(n));
WriteLn;
INC(n);
END;
END IdenticalStrings.
- Output:
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
Nim[edit]
import strformat
func isConcat(s: string): bool =
if (s.len and 1) != 0: return false
let half = s.len shr 1
result = s[0..<half] == s[half..^1]
for n in 0..999:
let b = &"{n:b}"
if b.isConcat: echo &"{n:3} {b}"
- Output:
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
Pascal[edit]
program IdenticalStrings;
const
LIMIT = 1000;
var
n: Integer;
function BitLength(n: Integer): Integer;
var count: Integer;
begin
count := 0;
while n > 0 do
begin
n := n shr 1;
count := count + 1;
end;
BitLength := count;
end;
function Concat(n: Integer): Integer;
begin
Concat := n shl BitLength(n) or n;
end;
procedure WriteBits(n: Integer);
var bit: Integer;
begin
bit := 1 shl (BitLength(n)-1);
while bit > 0 do
begin
if (bit and n) <> 0 then Write('1')
else Write('0');
bit := bit shr 1;
end;
end;
begin
n := 1;
while Concat(n) < LIMIT do
begin
Write(Concat(n));
Write(': ');
WriteBits(Concat(n));
WriteLn;
n := n + 1;
end;
end.
- Output:
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
PL/I[edit]
identstr: procedure options(main);
bitLength: procedure(nn) returns(fixed);
declare (n, nn, r) fixed;
r = 0;
do n = nn repeat(n / 2) while(n > 0);
r = r + 1;
end;
return(r);
end bitLength;
concat: procedure(nn, m) returns(fixed);
declare (i, steps, nn, n, m) fixed;
steps = bitLength(m);
n = nn;
do i=1 to steps;
n = n * 2;
end;
return(n + m);
end concat;
printBits: procedure(nn);
declare (nn, n) fixed, bits char(16) varying;
bits = '';
do n = nn repeat(n / 2) while(n > 0);
if mod(n,2) = 0 then
bits = '0' || bits;
else
bits = '1' || bits;
end;
put list(bits);
end printBits;
declare n fixed;
do n=1 repeat(n+1) while(concat(n,n) < 1000);
put skip list(concat(n,n));
call printBits(concat(n,n));
end;
end identstr;
- Output:
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
PL/M[edit]
100H:
/* BINARY CONCATENATION OF A NUMBER WITH ITSELF */
CONCAT$SELF: PROCEDURE (I) ADDRESS;
DECLARE (I,J,K) ADDRESS;
J = I;
K = I;
DO WHILE J > 0;
J = SHR(J,1);
K = SHL(K,1);
END;
RETURN I OR K;
END CONCAT$SELF;
/* CP/M BDOS CALL */
BDOS: PROCEDURE (FN, ARG);
DECLARE FN BYTE, ARG ADDRESS;
GO TO 5;
END BDOS;
/* PRINT STRING */
PRINT: PROCEDURE (STR);
DECLARE STR ADDRESS;
CALL BDOS(9, STR);
END PRINT;
/* PRINT NUMBER IN GIVEN BASE (MAX 10) */
PRINT$BASE: PROCEDURE (BASE, N);
DECLARE S (17) BYTE INITIAL ('................$');
DECLARE N ADDRESS, BASE BYTE;
DECLARE P ADDRESS, C BASED P BYTE;
P = .S(16);
DIGIT:
P = P - 1;
C = N MOD BASE + '0';
N = N / BASE;
IF N > 0 THEN GO TO DIGIT;
CALL PRINT(P);
END PRINT$BASE;
DECLARE N ADDRESS INITIAL (1);
DECLARE C ADDRESS;
DO WHILE (C := CONCAT$SELF(N)) < 1000;
CALL PRINT$BASE(10, C);
CALL PRINT(.(9,'$'));
CALL PRINT$BASE(2, C);
CALL PRINT(.(13,10,'$'));
N = N + 1;
END;
CALL BDOS(0,0);
EOF
- Output:
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
Python[edit]
Python: Procedural[edit]
def bits(n):
"""Count the amount of bits required to represent n"""
r = 0
while n:
n >>= 1
r += 1
return r
def concat(n):
"""Concatenate the binary representation of n to itself"""
return n << bits(n) | n
n = 1
while concat(n) <= 1000:
print("{0}: {0:b}".format(concat(n)))
n += 1
- Output:
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
Python: Functional[edit]
A variant composed from pure functions, as an alternative to using mutable variables and a loop.
Values are drawn, up to a limit, from a non-finite list.
'''Two identical strings'''
from itertools import count, takewhile
# binaryTwin :: Int -> (Int, String)
def binaryTwin(n):
'''A tuple of an integer m and a string s, where
s is a self-concatenation of the binary
represention of n, and m is the integer value of s.
'''
s = bin(n)[2:] * 2
return int(s, 2), s
# ------------------------- TEST -------------------------
def main():
'''Numbers defined by duplicated binary sequences,
up to a limit of decimal 1000.
'''
print(
'\n'.join([
repr(pair) for pair
in takewhile(
lambda x: 1000 > x[0],
map(binaryTwin, count(1))
)
])
)
# MAIN ---
if __name__ == '__main__':
main()
- Output:
(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')
Perl[edit]
#!/usr/bin/perl
use strict; # https://rosettacode.org/wiki/Two_identical_strings
use warnings;
while( 1 )
{
my $binary = ( sprintf "%b", ++$- ) x 2;
(my $decimal = oct "b$binary") >= 1000 and last;
printf "%4d %s\n", $decimal, $binary;
}
- Output:
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
Phix[edit]
integer n = 1 sequence res = {} while true do string binary = sprintf("%b%b",n) integer decimal = to_number(binary,0,2) if decimal>1000 then exit end if res &= {sprintf("%-4d %-10s",{decimal,binary})} n += 1 end while printf(1,"Found %d numbers:\n%s\n",{n-1,join_by(res,5,6)})
- Output:
Found 30 numbers: 3 11 54 110110 187 10111011 528 1000010000 693 1010110101 858 1101011010 10 1010 63 111111 204 11001100 561 1000110001 726 1011010110 891 1101111011 15 1111 136 10001000 221 11011101 594 1001010010 759 1011110111 924 1110011100 36 100100 153 10011001 238 11101110 627 1001110011 792 1100011000 957 1110111101 45 101101 170 10101010 255 11111111 660 1010010100 825 1100111001 990 1111011110
Picat[edit]
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.
- Output:
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
Prolog[edit]
main:-
writeln('Decimal\tBinary'),
main(1, 1000).
main(N, Limit):-
format(string(Binary), '~2r', N),
string_length(Binary, Length),
I is N + (N << Length),
I < Limit,
!,
writef('%w\t%w%w\n', [I, Binary, Binary]),
N1 is N + 1,
main(N1, Limit).
main(_, _).
- Output:
Decimal Binary 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
Quackery[edit]
[ 2 base put
number$ dup size 2 / split =
base release ] is 2identical ( n --> b )
1000 times
[ i^ 2identical if
[ i^ echo sp
2 base put
i^ echo cr
base release ] ]
- Output:
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
Raku[edit]
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)];
- Output:
30 matching numbers
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)
REXX[edit]
sans formatting[edit]
/*REXX program finds/displays decimal numbers whose binary version is a doubled literal.*/
numeric digits 20 /*ensure 'nuff dec. digs for conversion*/
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. */
if left(b, L%2)\==right(b, L%2) then iterate /*Left half ≡ right half? No, skip it.*/
say right(#, 4)':' right(b, 12) /*display number in decimal and binary.*/
end /*#*/ /*stick a fork in it, we're all done. */
- output (shown at three-quarter size.)
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
with formatting[edit]
/*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.*/
if hi=='' | hi=="," then hi= 1000 /* " " " " " " */
if cols=='' | cols=="," then cols= 4 /* " " " " " " */
w= 20 /*width of a number in any column. */
title= ' decimal integers whose binary version is a doubled binary literal, N < ' ,
commas(hi)
if cols>0 then say ' index │'center(title, 1 + cols*(w+1) )
if cols>0 then say '───────┼'center("" , 1 + cols*(w+1), '─')
#= 0; idx= 1 /*initialize # of integers and index. */
$= /*a list of nice primes (so far). */
do j=1 for hi-1; b= x2b( d2x(j) ) + 0 /*find binary values that can be split.*/
L= length(b); h= L % 2 /*obtain length of the binary value. */
if L//2 then iterate /*Can binary version be split? No, skip*/
if left(b, h)\==right(b, h) then iterate /*Left half match right half? " " */
#= # + 1 /*bump the number of integers found. */
if cols<=0 then iterate /*Build the list (to be shown later)? */
c= commas(j) || '(' || b")" /*maybe add commas, add binary version.*/
$= $ right(c, max(w, length(c) ) ) /*add a nice prime ──► list, allow big#*/
if #//cols\==0 then iterate /*have we populated a line of output? */
say center(idx, 7)'│' substr($, 2); $= /*display what we have so far (cols). */
idx= idx + cols /*bump the index count for the output*/
end /*j*/
if $\=='' then say center(idx, 7)"│" substr($, 2) /*possible display residual output.*/
if cols>0 then say '───────┴'center("" , 1 + cols*(w+1), '─')
say
say 'Found ' commas(#) title
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 ?
- output when using the default inputs:
index │ decimal integers whose binary version is a doubled binary literal, N < 1,000 ───────┼───────────────────────────────────────────────────────────────────────────────────── 1 │ 3(11) 10(1010) 15(1111) 36(100100) 5 │ 45(101101) 54(110110) 63(111111) 136(10001000) 9 │ 153(10011001) 170(10101010) 187(10111011) 204(11001100) 13 │ 221(11011101) 238(11101110) 255(11111111) 528(1000010000) 17 │ 561(1000110001) 594(1001010010) 627(1001110011) 660(1010010100) 21 │ 693(1010110101) 726(1011010110) 759(1011110111) 792(1100011000) 25 │ 825(1100111001) 858(1101011010) 891(1101111011) 924(1110011100) 29 │ 957(1110111101) 990(1111011110) ───────┴───────────────────────────────────────────────────────────────────────────────────── Found 30 decimal integers whose binary version is a doubled binary literal, N < 1,000
Ring[edit]
load "stdlib.ring"
decList = [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15]
baseList = ["0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F"]
see "working..." + nl
see "Numbers whose base 2 representation is the juxtaposition of two identical strings:" + nl
row = 0
limit1 = 1000
for n = 1 to limit1
bin = decimaltobase(n,2)
ln = len(bin)
if ln & 1 = 0
if left(bin,ln/2) = right(bin,ln/2)
row++
see sfl(n, 3) + " (" + sfrs(bin, 10) + ") "
if row % 5 = 0 see nl ok
ok
ok
next
? nl + "Found " + row + " numbers whose base 2 representation is the juxtaposition of two identical strings"
? "done..."
func decimaltobase(nr,base)
binList = []
binary = 0
remainder = 1
while(nr != 0)
remainder = nr % base
ind = find(decList,remainder)
rem = baseList[ind]
add(binList,rem)
nr = floor(nr/base)
end
binlist = reverse(binList)
binList = list2str(binList)
binList = substr(binList,nl,"")
return binList
# a very plain string formatter, intended to even up columnar outputs
def sfrs x, y
l = len(x)
x += " "
if l > y y = l ok
return substr(x, 1, y)
# a very plain string formatter, intended to even up columnar outputs
def sfl x, y
s = string(x) l = len(s)
if l > y y = l ok
return substr(" ", 11 - y + l) + s
- Output:
working... Numbers whose base 2 representation is the juxtaposition of two identical strings: 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 whose base 2 representation is the juxtaposition of two identical strings done...
Ruby[edit]
for i in 0 .. 1000
bin = i.to_s(2)
if bin.length % 2 == 0 then
half = bin.length / 2
if bin[0..half-1] == bin[half..] then
print "%3d: %10s\n" % [i, bin]
end
end
end
- Output:
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
Snobol[edit]
define("bits(n)") :(bits_end)
bits bits = gt(n,0) remdr(n,2) bits :f(return)
n = n / 2 :(bits)
bits_end
define("concat(n)m") :(concat_end)
concat concat = n
m = n
c_loop m = gt(m,0) m / 2 :f(c_done)
concat = concat * 2 :(c_loop)
c_done concat = concat + n :(return)
concat_end
n = 0
loop n = n + 1
m = concat(n)
output = lt(m,1000) m ": " bits(m) :s(loop)
end
- Output:
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
Swift[edit]
print("Decimal\tBinary")
var n = 1
while (true) {
let binary = String(n, radix: 2)
let i = n + (n << binary.count)
if i >= 1000 {
break
}
print("\(i)\t\(binary)\(binary)")
n += 1
}
- Output:
Decimal Binary 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
Visual Basic .NET[edit]
Based on the Alternate version.Imports System.Console
Module Module1
Sub Main()
Dim p, c, k, lmt as integer : p = 2 : lmt = 1000
For n As Integer = 1 to lmt
p += If(n >= p, p, 0) : k = n + n * p
If k > lmt Then Exit For Else c += 1
Write("{0,3} ({1,-10}) {2}", k, Convert.ToString( k, 2),
If(c Mod 5 = 0, vbLf, ""))
Next : WriteLine(vbLf + "Found {0} numbers whose base 2 representation is the concatenation of two identical binary strings.", c)
End Sub
End Module
- Output:
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 whose base 2 representation is the concatenation of two identical binary strings.
Vlang[edit]
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.")
}
- Output:
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.
Wren[edit]
import "/fmt" for Conv, Fmt
var i = 1
while(true) {
var b2 = Conv.itoa(i, 2)
b2 = b2 + b2
var d = Conv.atoi(b2, 2)
if (d >= 1000) break
Fmt.print("$3d : $s", d, b2)
i = i + 1
}
System.print("\nFound %(i-1) numbers.")
- Output:
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.
XPL0[edit]
proc BinOut(N); \Output N in binary
int N, Rem;
[Rem:= N&1;
N:= N>>1;
if N then BinOut(N);
ChOut(0, Rem+^0);
];
int H, N, M;
[for H:= 1 to 31 do
[N:= H; M:= H;
while M do
[N:= N<<1; M:= M>>1];
N:= N+H;
if N < 1000 then
[IntOut(0, N);
Text(0, ": ");
BinOut(N);
CrLf(0);
];
];
]
- Output:
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
Yabasic[edit]
// 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
- Output:
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---
Categories:
- Draft Programming Tasks
- 11l
- 8080 Assembly
- 8086 Assembly
- Action!
- Ada
- ALGOL 68
- ALGOL-M
- ALGOL W
- APL
- AppleScript
- Arturo
- AWK
- BASIC
- BASIC256
- QBasic
- PureBasic
- True BASIC
- BCPL
- Befunge
- C
- C sharp
- C++
- CLU
- COBOL
- Cowgol
- Crystal
- Draco
- F Sharp
- Factor
- FALSE
- FOCAL
- Forth
- Fortran
- FreeBASIC
- Frink
- Go
- Haskell
- J
- Java
- Jq
- Julia
- Liberty BASIC
- MAD
- Modula-2
- Nim
- Pascal
- PL/I
- PL/M
- Python
- Perl
- Phix
- Picat
- Prolog
- Quackery
- Raku
- REXX
- Ring
- Ruby
- Snobol
- Swift
- Visual Basic .NET
- Vlang
- Wren
- Wren-fmt
- XPL0
- Yabasic
