new files

Task/Best-shuffle/REXX/best-shuffle-1.rexx

@@ -0,0 +1,42 @@
+/*REXX program to find the best shuffle  (for a character string).      */
+parse arg list                         /*get words from the command line*/
+if list='' then list='tree abracadabra seesaw elk grrrrrr up a'  /*def.?*/
+w=0                                    /*widest word , for prettifing.  */
+        do i=1  for words(list)
+        w=max(w,length(word(list,i)))  /*the maximum word width so far. */
+        end   /*i*/
+w=w+5                                  /*add five spaces to widest word.*/
+        do n=1  for words(list)        /*process the words in the list. */
+        $=word(list,n)                 /*the original word in the list. */
+        new=bestShuffle($)             /*shufflized version of the word.*/
+        say 'original:' left($,w) 'new:' left(new,w) 'count:' kSame($,new)
+        end   /*n*/
+exit                                   /*stick a fork in it, we're done.*/
+/*──────────────────────────────────BESTSHUFFLE subroutine──────────────*/
+bestShuffle: procedure;    parse arg x 1 ox;    Lx=length(x)
+if Lx<3 then return reverse(x)         /*fast track these puppies.      */
+
+   do j=1  for Lx-1                    /*first take care of replications*/
+   a=substr(x,j  ,1)
+   b=substr(x,j+1,1);          if a\==b then iterate
+   _=verify(x,a); if _==0 then iterate /*switch 1st rep with some char. */
+   y=substr(x,_,1);      x=overlay(a,x,_)
+                         x=overlay(y,x,j)
+   rx=reverse(x); _=verify(rx,a); if _==0 then iterate   /*¬ enuf unique*/
+   y=substr(rx,_,1);  _=lastpos(y,x)   /*switch 2nd rep with later char.*/
+   x=overlay(a,x,_);  x=overlay(y,x,j+1)  /*OVERLAYs: a fast way to swap*/
+   end    /*j*/
+
+           do k=1  for Lx              /*take care of same o'-same o's. */
+           a=substr(x, k,1)
+           b=substr(ox,k,1);   if a\==b then iterate
+           if k==Lx then x=left(x,k-2)a || substr(x,k-1,1)   /*last case*/
+                    else x=left(x,k-1)substr(x,k+1,1)a || substr(x,k+2)
+           end   /*k*/
+return x
+/*──────────────────────────────────KSAME procedure─────────────────────*/
+kSame: procedure;    parse arg x,y;    k=0
+                  do m=1  for min(length(x),length(y))
+                  k=k + (substr(x,m,1) == substr(y,m,1))
+                  end   /*m*/
+return k

Task/Best-shuffle/REXX/best-shuffle-2.rexx

@@ -0,0 +1,37 @@
+def best_shuffle(s)
+  # Fill _pos_ with positions in the order
+  # that we want to fill them.
+  pos = []
+  # g["a"] = [2, 4] implies that s[2] == s[4] == "a"
+  g = (0...s.length).group_by { |i| s[i] }
+
+  # k sorts letters from low to high count
+  k = g.sort_by { |k, v| v.length }.map! { |k, v| k }
+
+  until g.empty?
+    k.each { |letter|
+      g[letter] or next
+      pos.push(g[letter].pop)
+      g[letter].empty? and g.delete letter
+    }
+  end
+  pos.reverse!
+
+  # Now fill in _new_ with _letters_ according to each position
+  # in _pos_, but skip ahead in _letters_ if we can avoid
+  # matching characters that way.
+  letters = s.dup
+  new = "?" * s.length
+  until letters.empty?
+    i, p = 0, pos.shift
+    i += 1 while letters[i] == s[p] and i < (letters.length - 1)
+    new[p] = letters.slice! i
+  end
+
+  score = new.chars.zip(s.chars).count { |c, d| c == d }
+  [new, score]
+end
+
+%w(abracadabra seesaw elk grrrrrr up a).each { |word|
+  printf "%s, %s, (%d)\n", word, *best_shuffle(word)
+}

Task/Best-shuffle/REXX/best-shuffle-3.rexx

@@ -0,0 +1,25 @@
+list$ = "abracadabra seesaw pop grrrrrr up a"
+
+while word$(list$,ii + 1," ") <> ""
+ ii    = ii + 1
+ w$    = word$(list$,ii," ")
+ bs$   = bestShuffle$(w$)
+ count = 0
+ for i = 1 to len(w$)
+  if mid$(w$,i,1) = mid$(bs$,i,1) then count = count + 1
+ next i
+ print  w$;" ";bs$;" ";count
+wend
+
+function bestShuffle$(s1$)
+   s2$   = s1$
+   for i = 1 to len(s2$)
+        for j =  1 to len(s2$)
+            if (i <> j) and (mid$(s2$,i,1) <> mid$(s1$,j,1)) and (mid$(s2$,j,1) <> mid$(s1$,i,1)) then
+            if j < i then i1 = j:j1 = i else i1 = i:j1 = j
+            s2$ = left$(s2$,i1-1) + mid$(s2$,j1,1) + mid$(s2$,i1+1,(j1-i1)-1) + mid$(s2$,i1,1) + mid$(s2$,j1+1)
+            end if
+        next j
+   next i
+bestShuffle$ = s2$
+end function