Two identical strings

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 whose base 2 representation is the concatenation of two identical binary strings,
where   n   (in base ten)   <   1,000₁₀       (one thousand).

For each decimal number,   show its decimal form and also its binary form.

REXX

<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.*/ if hi== | hi=="," then hi= 1000 /* " " " " " " */ if cols== | cols=="," then cols= 4 /* " " " " " " */ w= 20 /*width of a number in any column. */

    @dnbn= ' decimal integers whose binary version is a doubled binary literal, N  < ' ,
             commas(hi)

if cols>0 then say ' index │'center(@dnbn, 1 + cols*(w+1) ) if cols>0 then say '───────┼'center("" , 1 + cols*(w+1), '─')

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.*/ say say 'Found ' commas(#) @dnbn 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 ?</lang>

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

<lang ring> 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%2 = 0
      if left(bin,ln/2) = right(bin,ln/2)
         row = row + 1
         see "" + n + "(" + bin + ")  "
         if row%5 = 0
            see nl
         ok
      ok
    ok

next

see "Found " + row + " numbers whose base 2 representation is the juxtaposition of two identical strings" + nl see "done..." + nl

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

</lang>

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