Does anyone know of a function that takes any number >= 0 and performs the following transformation?
 0 => 0
 1 => 1
 n => 2

#lang racket
(require srfi/2 math/number-theory)

(define (try n)
  (let loop ([i 10]
             [result '()])
    (if (= i 1)
        result
        (let* ([num (string->number n i)]
               [divisor (car (prime-divisors num))])
          (if (= divisor num)
              #f
              (loop (sub1 i) (cons divisor result)))))))

(define (perform n j)
  (define 2^n-1 (arithmetic-shift 1 (- n 1)))
  (let loop ([i j]
             [seen (set)])
    (when (positive? i)
      (or
       (and-let* ([num (number->string (bitwise-ior (+ (random 2^n-1) 2^n-1) 1) 2)]

#lang racket
(define (count-runs str)
  (let loop ([runs 0]
             [last #\+]
             [i (sub1 (string-length str))])
    (if (negative? i)
        runs
        (let ([cur (string-ref str i)])
          (loop (if (char=? cur last) runs (add1 runs)) cur (sub1 i))))))

(for ([i (in-range (call-with-input-string (read-line) read))]
      [line (in-port read-line)])
  (printf "Case #~a: ~a~%" (add1 i) (count-runs line)))

import sys

with open(sys.argv[1]) as f:
    cases = f.readlines()[1:]

    for i, case in enumerate(cases):
        n=0
        last = ""
        for k in case[:-1]:
            if k != last:
                n += 1
            last = k
        print("Case #{}: {}". format(i+1, n - 1 + (case[-2]=="-")))

sub solution ($S) {
    $S.subst(/\++$/,"")
      .comb
      .squish
      .elems;
}

#lang racket
(define (count-sheep n)
  (define number->set (compose list->set string->list number->string))
  (let loop ([remaining (number->set 1234567890)]
             [i n])
    (let ([next (set-subtract remaining (number->set i))])
      (if (set-empty? next)
          i
          (loop next (+ i n))))))

(for ([i (in-range (read))]
      [n (in-port)])
  (printf "Case #~a: ~a~%"
          (add1 i)
          (if (zero? n)
              "INSOMNIA"
              (count-sheep n))))

sub solution ($N is copy) {
    if $N == 0 {
        return "INSOMNIA";
    }
    my @seen = 0 xx 10;
    my $i;
    until [*] @seen {
        my @digits = (++$i * $N).comb.unique;
        @seen[@digits] = 1 xx *;
    }
    return $i * $N;
}

sub solution ($S) {
    $S.subst(/\++$/,"")
      .comb
      .squish
      .elems;
}