Scratch

bharvey wrote:

joefarebrother wrote:

Question 1 cannot be...   QED.

Thanks for the first posted explanation of the solution and for teaching me about color=transparent!

Your welcome 

I also wrote a scheme program to brute-force it:

;; Generates all the possible combinations for n questions with 
;;  answers between start-char and end-char
;; Each solution is a string of length n 
(define (generate-possible-solutions n start-char end-char)
 (let next-solution 
       ((prev (make-string n start-char))
       (sofar '()))
  (if (string=? prev (make-string n end-char)) 
      (reverse (cons prev sofar))
      (next-solution 
       (let find-next ((prev prev))
        (if (= (string-length prev) 0) 
            ""
            (if (char=? end-char (string-ref prev 0))
              (string-append (string start-char) 
                             (find-next (substring prev 1 (string-length prev))))
              (string-append (integer->char (+ 1 (char->integer (string-ref prev 0)))) 
                             (substring prev 1 (string-length prev)))))
      (cons prev sofar)))))

;; Try all the solutions for the the list of questions. Each question is a procedure 
;; that takes 2 arguments: it's own answer (a character between start-char and end-char), 
;; and the solution (a string of all the answers), and returns #t or #f depending on weather 
;; the answer is right. Correct-solutions returns a list of all correct solutions.
(define (correct-solutions questions start-char end-char)
  (filter (lambda (solution) 
           (combine (lambda (a b) (and a b))
                    (map (lambda (question answer) (question answer solution))
                         questions
                         (string->list solution))) 
          (generate-possible-solutions (length questions) start-char end-char)))

;;The integers between start inclusive and end exclusive
(define (range start end) 
 (if (= start end) '() (cons start (range (+ 1 start) end)))

;; Prints the solutions
(define (print-solutions sols)
 (display "There ")
 (display (if (null? (cdr sols) "is" "are")
 (display (length sols)
 (display " possible solution"
 (if (null? (cdr sols)) #f (display "s"))
 (display ":")
 (newline)
 (for-each sols
  (lambda (sol) 
   (display (map (lambda (num ans) (string-append (number->string num) ") " ans (string #\newline))) 
                 (range 1 (string-length sol)) 
                 (string->list sol)))))

;;Solve bharvey's logic problem
(define (bharveys-logic-problem) 
 (print-solutions 
  (correct-solutions 
   (list 
    (lambda (answer solution) 
     (let ((answer (cdr (assoc answer '((#\A 1)
                                        (#\B 4)
                                        (#\C 3)
                                        (#\D 4)))))
      (first-B-is-at answer solution)))
    (lambda (answer solution) 
     (let ((answer (cdr (assoc answer '((#\A #\D)
                                        (#\B #\A)
                                        (#\C #\B)
                                        (#\D #\C)))))
      (char=? answer (string-ref solution 3)))) ;0 indexed so (string-ref solution 3) is answer to question 4
    (lambda (answer solution) 
     (let ((answer (cdr (assoc answer '((#\A #\D)
                                        (#\B #\C)
                                        (#\C #\B)
                                        (#\D #\A)))))
      (char=? answer (string-ref solution 0))))
    (lambda (answer solution) 
     (let ((answer (cdr (assoc answer '((#\A 3)
                                        (#\B 2)
                                        (#\C 1)
                                        (#\D 0)))))
      (= answer (number-of #\D solution))))
    (lambda (answer solution) 
     (let ((answer (cdr (assoc answer '((#\A 0)
                                        (#\B 2)
                                        (#\C 3)
                                        (#\D 1)))))
      (= answer (number-of #\B solution)))))
   #\A #\D))

;;Some procedures used in the questions

(define (first-B-is-at position solution)
 (and (char=? #\B (string-ref position solution)) 
      (not (contains-a-B (substring solution 0 position)))))

(define (contains-a-B str)
 (null? (filter (lambda (char) (char=? char #\B))
                (string->list str))

(define (number-of char str)
 (length (filter (lambda (char1) (char=? char char1))
                 (string->list str))))

(bharveys-logic-problem)

Last edited by joefarebrother (2013-03-09 13:00:09)

mythbusteranimator wrote:

joefarebrother wrote:

bharvey wrote:

Thanks for the first posted explanation of the solution and for teaching me about color=transparent!

Your welcome 

I also wrote a scheme program to brute-force it:

Code:

;; Generates all the possible combinations for n questions with 
;;  answers between start-char and end-char
;; Each solution is a string of length n 
(define (generate-possible-solutions n start-char end-char)
 (let next-solution 
       ((prev (make-string n start-char))
       (sofar '()))
  (if (string=? prev (make-string n end-char)) 
      (reverse (cons prev sofar))
      (next-solution 
       (let find-next ((prev prev))
        (if (= (string-length prev) 0) 
            ""
            (if (char=? end-char (string-ref prev 0))
              (string-append (string start-char) 
                             (find-next (substring prev 1 (string-length prev))))
              (string-append (integer->char (+ 1 (char->integer (string-ref prev 0)))) 
                             (substring prev 1 (string-length prev)))))
      (cons prev sofar)))))

;; Try all the solutions for the the list of questions. Each question is a procedure 
;; that takes 2 arguments: it's own answer (a character between start-char and end-char), 
;; and the solution (a string of all the answers), and returns #t or #f depending on weather 
;; the answer is right. Correct-solutions returns a list of all correct solutions.
(define (correct-solutions questions start-char end-char)
  (filter (lambda (solution) 
           (combine (lambda (a b) (and a b))
                    (map (lambda (question answer) (question answer solution))
                         questions
                         (string->list solution))) 
          (generate-possible-solutions (length questions) start-char end-char)))

;;The integers between start inclusive and end exclusive
(define (range start end) 
 (if (= start end) '() (cons start (range (+ 1 start) end)))

;; Prints the solutions
(define (print-solutions sols)
 (display "There ")
 (display (if (null? (cdr sols) "is" "are")
 (display (length sols)
 (display " possible solution"
 (if (null? (cdr sols)) #f (display "s"))
 (display ":")
 (newline)
 (for-each sols
  (lambda (sol) 
   (display (map (lambda (num ans) (string-append (number->string num) ") " ans (string #\newline))) 
                 (range 1 (string-length sol)) 
                 (string->list sol)))))

;;Solve bharvey's logic problem
(define (bharveys-logic-problem) 
 (print-solutions 
  (correct-solutions 
   (list 
    (lambda (answer solution) 
     (let ((answer (cdr (assoc answer '((#\A 1)
                                        (#\B 4)
                                        (#\C 3)
                                        (#\D 4)))))
      (first-B-is-at answer solution)))
    (lambda (answer solution) 
     (let ((answer (cdr (assoc answer '((#\A #\D)
                                        (#\B #\A)
                                        (#\C #\B)
                                        (#\D #\C)))))
      (char=? answer (string-ref solution 3)))) ;0 indexed so (string-ref solution 3) is answer to question 4
    (lambda (answer solution) 
     (let ((answer (cdr (assoc answer '((#\A #\D)
                                        (#\B #\C)
                                        (#\C #\B)
                                        (#\D #\A)))))
      (char=? answer (string-ref solution 0))))
    (lambda (answer solution) 
     (let ((answer (cdr (assoc answer '((#\A 3)
                                        (#\B 2)
                                        (#\C 1)
                                        (#\D 0)))))
      (= answer (number-of #\D solution))))
    (lambda (answer solution) 
     (let ((answer (cdr (assoc answer '((#\A 0)
                                        (#\B 2)
                                        (#\C 3)
                                        (#\D 1)))))
      (= answer (number-of #\B solution)))))
   #\A #\D))

;;Some procedures used in the questions

(define (first-B-is-at position solution)
 (and (char=? #\B (string-ref position solution)) 
      (not (contains-a-B (substring solution 0 position)))))

(define (contains-a-B str)
 (null? (filter (lambda (char) (char=? char #\B))
                (string->list str))

(define (number-of char str)
 (length (filter (lambda (char1) (char=? char char1))
                 (string->list str))))

What language is that?

Scheme.

Snap-NXT v0.2 is now out. Check it out on GitHub (search for snap-nxt). I fixed the sensor bug in it.

bharvey wrote:

@tb10: Welcome to the wonderful world of software development, where you do something useful and people start picking on you!  Isn't it fun?

There's a mild typo on line 171 of snap.py. Other than that, awesome! I hooked up a couple of sensors and tested reading them through into Snap! (I don't have a built robot to test the motors with atm, sorry!) and it seemed to work 

The trick to getting Bluetooth to work with the NXT on OS X was to:
* pair the Mindstorms first using "Set up Bluetooth device", and have that create a device socket for you in the background
* patch snap.py to read:
    b = nxt.locator.find_one_brick(method=nxt.Method(device=True))
(As described on the Google Code)
* make sure you use the version of nxt-python from the svn.

Cool stuff!

EDIT: excessive smileys again again

Last edited by blob8108 (2013-03-10 07:38:56)

Hardmath123 wrote:

Does Snap-NXT work with LeJOS?

no

technoboy10 wrote:

blob8108 wrote:

mild typo

Oh, is that where I somehow typed a 2 in the middle of PORT? 

"Somehow", yes. 

blob8108 wrote:

   

Hardmath123 wrote:

   

technoboy10 wrote:

   

This really is a cheerful group, isn't it?  I love hanging out with you guys.

bharvey wrote:

technoboy10 wrote:

   

This really is a cheerful group, isn't it?  I love hanging out with you guys.

I was about to object to the last one, until I realised they weren't in the same post...

technoboy10 wrote:

Snap-NXT 1.0 is out.

Could someone with both a Mac and a NXT please try out http://snap.berkeley.edu/Snap-NXT.app.zip?

@tb: Suggestion:  Change the filenames to Snap-NXT.{py,xml} so that people with multiple devices can run them all.

PS  I made it require Admin privs b/c the (Linux) readme says to run as root.  Is that necessary in MacOS too?

PPS What it really should do is pop up a little window with buttons to turn the server on and off, and to show ./Resources/nxt.xml in a finder window.

P^3S: I put a link to the github page on the snap.b.e page.

P^4S: Someone with a Windows machine, shadow, should package this up as a Windows app for us...

Last edited by bharvey (2013-03-10 20:31:17)

technoboy10 wrote:

Also, it looks like running as root is not necessary after all, though it might still be a good idea.

No, if it's not necessary then it's not a good idea!     Fixed.

Last edited by bharvey (2013-03-11 02:31:44)

PORT = 1330 #N reminded me of 13, X in Roman numerals is 10, and T is the 20th letter. I added X and T together.

This amuses me. 

[Including obligatory  ]

Last edited by blob8108 (2013-03-11 04:17:27)

bharvey wrote:

This really is a cheerful group, isn't it?  I love hanging out with you guys.

     (I kind of use these in series to show a logical series of emotions).

I've thought a lot about my language, so here's a little script, and literal python and JS equivalents:

import range from python
import ceil, floor from python.math

def divides (n, k)
    [return k mod n = 0]

def prime? (n) [
    set limit to
        ceil (sqrt n)
    for num in (range limit) do [
        if (divides num+2 n) [return false]
    ]
    return true
]

for i in range(100) do [
    if (prime? i) [print i]
]

from math import ceil, sqrt
def divides(n,k):
    return k%n==0

def prime(n):
    limit = int(ceil(sqrt(n)))
    for num in range(limit):
        if divides(num+2, n):
            return False
    return True

for i in range(100):
    if prime(i):
        print i

var ceil = Math.ceil
var sqrt = Math.sqrt
function divides(n,k) {
    return k%n==0;
}
function prime(n) {
    var limit = ceil(sqrt(n));
    for (var i=2; i<=limit; i++) {
        if (divides(i, n)) {
            return false;
        }
    }
    return true;
}
for (var i=0; i<=100; i++) {
    if (prime(i)) {
        console.log(i);
    }
}

What do you think? Which looks nicer, and which is easier to understand (for this one, imagine you don't know any of the languages)? Thanks. 

Last edited by Hardmath123 (2013-03-11 11:40:22)

blob8108 wrote:

You haven't saved the html file rather than the raw file by mistake, have you?

Fixed.  Please try again.