Perhaps you want to correct the image link in your old post so that you avoid saying that the new logo is nice. ;-)

I like your original post describing the logo.

Niels

Although the new globe lacks the contrast level of it’s predecessor, and could so with some refinements, it’s a change for the better.

IMO, both versions of the logo are ‘non logos’ so wanting them to revert to the old one for the sake of fixing the new one is a but pointless.

Who goes to wikipedia to look at their logo anyway.

I’ll grow used to the new logo, but in my view this is not an upgrade.

The trickiest ones were marry/Mary/merry (I pronounce those all nearly the same way), “could” (I initially thought it was “cooed”), and I find it hard to distinguish theta from barred “O,” and to distinguish a lowercase alpha from an italicized, lowercase English letter “A.” Also, that schwa with hook is just weird.

Thanks for the quiz!

<cffunction name="is_steal" returntype="boolean">
    <cfargument name ="bigword">
    <cfargument name="littleword">

<cfset matches = 0>
<cfloop from ="1" to="#len(littleword)#" index="i">
    <cfif findnocase("#mid(littleword,i,1)#", bigword)>
        <cfset matches++>
		<cfset bigword=#replace(bigword,mid(littleword,i,1),"")#>
    </cfif>
</cfloop>

    <cfif matches eq #len(littleword)#>
        <cfreturn true>
    <cfelse>
        <cfreturn false>
    </cfif>
</cffunction>

<cfoutput>
is_steal("test","tes")
#is_steal("test","tes")# <br />
is_steal("test","abc")
#is_steal("test","abc")# <br />
is_steal("deevvil","devil")
#is_steal("deevvil","devil")#<br />
is_steal("aaaab","abb")
#is_steal("aaaab","abb")#<br />
</cfoutput>

-Carlos

    (defn steal? [steal base]
      (let [map-update (fn [m i f]
                         (assoc! m i (f (get m i 0))))
            steal-map    (reduce #(map-update %1 %2 inc)
                                 (transient {}) steal)
            combined-map (persistent!
                           (reduce #(map-update %1 %2 dec)
                                   steal-map base))]
        (not (some #(< (int %) (int 0))
             (vals combined-map)))))

(define (extras super sub)
  (if (null? sub) super
      (if (null? super) #f
          (let ((fsup (car super))
                (fsub (car sub)))
            (if (char=? fsup fsub) (extras (cdr super) (cdr sub))
                (if (char< ? fsup fsub) (extras (cdr super) sub)
                    #f))))))

(define (is-steal steal base)
  (let ((steal (sort (string->list steal) char< ?))
        (base  (sort (string->list base) char< ?)))
    (extras steal base)))

(define (ok test) (display (if test "ok" "NOT ok")) (newline))

(ok (not (is-steal "proud" "rrod")))
(ok (is-steal "proud" "rod"))
(ok (is-steal "devil" "live"))
(ok (not (is-steal "foo" "bar")))
(ok (is-steal "bananas" "bans"))
(ok (not (is-steal "bananas" "babs")))

–Rob*

(define (filter test lis)
  (if (null? lis)
      lis
      (let ((head          (car lis))
            (filtered-rest (filter test (cdr lis))))
        (if (test head)
            (cons head filtered-rest)
            filtered-rest))))

(define (reduce op seed lis)
  (if (null? lis)
      seed
      (op (reduce op seed (cdr lis))
          (car lis))))

(define (1+ x) (+ x 1))
(define (1- x) (- x 1))

(define (is-steal steal-s base-s)
  (let  (( steal (string->list steal-s) )
         ( base  (string->list base-s)  ))
    (let* (( map-update   (lambda (m i func default)
                            (let ((prev (assoc i m))
                                  (rest (filter (lambda (p)
                                                  (not (equal? (car p) i)))
                                                m)))
                              (cons (list i (if prev
                                                (func (cadr prev))
                                                default))
                                    rest))))
           ( steal-map    (reduce (lambda (m i) (map-update m i 1+ 1))
                                  '() steal) )
           ( combined-map (reduce (lambda (m i) (map-update m i 1- -1))
                                  steal-map base) )
           ( missings     (filter (lambda (x) (< x 0))
                                  (map cadr combined-map)) ))
      (null? missings))))

(define (ok test) (display (if test "ok" "NOT ok")) (newline))

(ok (not (is-steal "proud" "rrod")))
(ok (is-steal "proud" "rod"))
(ok (is-steal "devil" "live"))
(ok (not (is-steal "foo" "bar")))

i mean, if he didn’t shoot you when you opened the door and told him to get out, then i guess punching him very hard in the head and then strangling him to the point of being unconscious, then that’s what i would have done.

but bravo for taking el camino. it’s a nice road.

I can go on forever, you know.

-dan