λ - programming

-- | The function required by the challenge
genPrimes :: (Integral i) => Int -> [i]
genPrimes n = take n primes

-- | A lazy list of all prime numbers
primes :: (Integral i) => [i]
primes = 2:lazyPrimes [2] 3

lazyPrimes :: (Integral i) => [i] -> i -> [i]
lazyPrimes primes n
    | n `divisibleBy` primes = lazyPrimes primes (n+1)
    -- A number not divisible by any prime numbers is a prime number
    | otherwise = n:lazyPrimes (primes++[n]) (n+1)

-- | Check wether n is divisible by a prime smaller or equal to n's square root
divisibleBy :: (Integral i) => i -> [i] -> Bool
divisibleBy n = foldr (\p b -> (p * p <= n) && n `mod` p == 0 || b) False

def primes(how_many):
primes = []
for i in range(1, how_many+1)
for x in range(1, int(sqrt(i)) ):
if i % x == 0:
continue
primes.append(i)
return primes

(defparameter *primes* '(2))

(defun isprime (n primes)
   (cond
      ((null primes) t)
      ((> (car primes) (sqrt n)) t)
      ((zerop (mod n (car primes))) nil)
      (t (isprime n (cdr primes)))))

(defun primes-up-to (n)
   (do ((i 3 (+ i 2)))
          ((> i n) *primes*)
      (when (isprime i *primes*)
         (setf *primes* (append *primes* (list i))))))

def primes(n):
    i = 2
    primes = []
    while i <= n:
        for p in primes:
            if i % p == 0:
                break
        else:
            primes.append(i)
        i += 1
    return [1] + primes

if flag:
    continue
i += 1
primes.append(i)

if not flag:
    primes.append(i)
i += 1

for i in range(2, n+1):

def primes(n):
    primes = []
    for i in range(2, n+1):
        for p in primes:
            if i % p == 0:
                break
        else:
            primes.append(i)
        i += 1
    return primes

def genPrimes():
    num = 2
    primes = []
    while True:
        for p in primes:
            if num % p == 0:
                break
        else:
            primes.append(num)
            yield num
        num += 1

# a = genPrimes()
# a.next() # Python 2
# next(a)  # Python 3

include Math

def primes_list(range)
  return 2 if range == 2
  return "not a usable range" if range <= 1
  collection = (0..range).to_a

  collection[0] = collection[1] = nil

  (2..sqrt(range)).each do |integer|
    if collection[integer]
      step = integer**2
      while step <= range do
        collection[step] = nil
        step+=integer
      end
    end
  end
  return collection.compact
end

import math

def prime_list(rang):
  if rang <= 1: return "not a usable range"
  if rang == 2: return [2]
  collection = range(0,rang+1)

  collection[0] = collection[1] = None
  for integer in range(2,int(math.sqrt(rang))+1):
    if collection[integer] is not None:
      step = integer**2
      while step <= rang:
        collection[step] = None
        step+=integer
  return [item for item in collection if item is not None]

#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
#include <string.h>
#include <errno.h>

#define MAX 100000
#define BLK 32
int main(int argc, char **argv)
{
        long long *sieve = malloc(BLK * sizeof(long long)), *sievep = sieve, *end;
        long long c, i, p;

        if(argc != 2) {
                fprintf(stderr, "Not enough arguments\nUsage: %s n\n"
                        "Where `n' is a value from 0 to %lld", argv[0], (long long)MAX);
        }

        p = strtoll(argv[1], argv + 1 + strnlen(argv[1], 32), 10);

        if(errno || p < 0) {
                fprintf(stderr, "Argument `%s' out of range (0 - %lld) or system error.\n",
                        argv[1], (long long)MAX);
                printf("%lld\n", p);
                return 1;
        }

        if(p > MAX) {
                puts("Don't bother...");
                return 0;
        }

        sieve[0] = 2;
        sieve[1] = 3;
        for(i = 2, c = 3; i < p; c+=2) {
                for(sieve = sievep, end = sievep+i-1; sieve < end; sieve++) {
                        if(c % *sieve == 0)
                                break;
                }
                if(sieve == end && c % *sieve != 0) {
                        if(i % (BLK-1) == 0) {
                                *(sievep+i) = '\0';
                                if((sievep = realloc(sievep, (i+BLK)*sizeof(sievep)))
                                   == NULL) {
                                        fprintf(stderr, "realloc failed\n");
                                        return 1;
                                }
                        }

                        *(sievep+i) = c;
                        i++;
                        printf("New prime: %lld [%lld]\n", c, i);
                }
        }

        return 0;
}

#include<stdio.h>

void prime(int amount);

int main(void)
{
  int amount;
  
  printf("Enter the amount of prime numbers you want to calculate: ");
  scanf("%d", &amount);

  prime(amount);
}

void prime(int amount)
{
  int prime[amount], number = 3, i = 0, found = 1;
  prime[0] = 2;

  while (found < amount)
    {
      for (i = 0; number % prime[i] != 0 && i < found; ++i);

      if (i == found)
  prime[found++] = number++;  
      else
  ++number;
    }
  for (i = 0; i <= amount-1; ++i)
    printf("%2d: %d\n", i+1, prime[i]);
}

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <math.h>

void
die(char *msg)
{
    fprintf(stderr, "error: %s\n", msg);
    exit(1);
}

int
main(int argc, char *argv[])
{
    long n, root_n, m, i, j;
    char *sieve;

    if(argc < 2)
        die("not enough arguments");

    n = strtol(argv[1], NULL, 0);
    root_n = (long) sqrt(n);
    sieve = calloc(n + 1, sizeof(*sieve));
    if(!sieve)
        die("could not allocate memory");

    for(i = 1; i < root_n+1; i++) {
        for(j = 1; j < root_n+1; j++) {
            m = 4*i*i + j*j;
            if(m <= n && (m % 12 == 1 || m % 12 == 5))
                sieve[m] = !sieve[m];
            m = 3*i*i + j*j;
            if(m <= n && m % 12 == 7)
                sieve[m] = !sieve[m];
            m = 3*i*i - j*j;
            if(i > j && m <= n && m % 12 == 11)
                sieve[m] = !sieve[m];
        }
    }

    for(i = 5; i < root_n; i++)
        if(sieve[i])
            for(j = i*i; j < n+1; j += i*i)
                sieve[j] = false;

    printf("2\n3\n");
    for(i = 0; i < n+1; i++)
        if(sieve[i])
            printf("%ld\n", i);

    free(sieve);

    return 0;
}

include Math

def primes_list(limit)
  range = 2
  collection = (0..range).to_a

  collection[0] = collection[1] = nil
  
  loop do
    range+=1
    collection.push range
    (2..sqrt(range)).each do |integer|
      if collection[integer]
        step = integer**2
        while step <= range do
          collection[step] = nil
          step+=integer
        end
      end
    end
    return collection.compact if collection.compact.size == limit
  end
end

import math

def prime_list(limit):
  rang = 2
  collection = range(0,rang+1)
  collection[0] = collection[1] = None
  while True:
    rang+=1
    collection.append(rang)
    for integer in range(2,int(math.sqrt(rang))+1):
      if collection[integer] is not None:
        step = integer**2
        while step <= rang:
          collection[step] = None
          step+=integer
    primes = [item for item in collection if item is not None]
    if len(primes) == limit: return primes

$ time gforth nprimes.fs -e '500000 n-first-primes bye' > /dev/null
real0m2.444s
user0m2.437s
sys0m0.003s
$ time gforth pprimes.fs -e '500000 primes bye' > /dev/null
real0m9.573s
user0m9.553s
sys0m0.010s

: fill-with-primes ( addr sz -- )
    \ special cases
    \ and initialization
    dup 1 < if 2drop exit then
    >r 2 over ! r>
    dup 2 < if 2drop exit then
    >r 3 over cell+ ! r>

    \ store initial pc (pc: prime-candidate)
    \ iterate over i1 = [2,sieve-size) ...index 0 and 1 have been precalculated
    \     until pf == true (pf: prime-found)
    \         set assumption pf = true
    \         iterate over i2 = [0,i1)
    \             if sieve[i2] divides pc
    \                 set pf = false
    \                 break innermost loop
    \             if sieve[i2]^2 > pc
    \                 break innermost loop
    \         if pf == true
    \             store pc at sieve[i1]
    \         pc += 2

    0 rot 5                          \ sz pf addr pc=5
    3 pick 2 ?do
        begin
            rot drop 1 -rot          \ sz pf=1 addr pc
            i 0 ?do
                over i cells + @     \ sz pf addr pc addr[i2]
                2dup swap mod 0=     \ sz pf addr pc addr[i2] divides?
                if
                    drop rot drop 0 -rot  \ sz pf=0 addr pc
                    leave
                then
                dup * over >         \ sz pf addr pc squarebigger?
                if
                    leave
                then
            loop
            2 pick if
                2dup swap i cells + !
            then
            2 +                      \ sz pf addr pc+2
            dup 0< if -11 throw then \ crash on pc overflow
        2 pick until
    loop
    2drop 2drop
;

\ print the contents of an array
: print-array ( addr sz -- )
    0 ?do
        dup i cells + @ .
    loop
    drop
;

\ print the n first primes
: primes ( n -- )
    dup cells allocate throw \ n addr
    swap
    2dup fill-with-primes
    2dup print-array
    drop free throw
;

\ example:
\ 100 primes cr

(ql:quickload :iterate)
(defpackage #:primes (:use :iterate :cl))
(in-package :primes)

(defun prime? (number)
  (when (> number 1)
    (iterate (for factor from 2 to (isqrt number))
      (never (zerop (mod number factor))))))

(defun primes-upto (number)
  (when (>= number 2)
    (iterate (for i from 2 to number)
      (when (prime? i)
        (collect i)))))

PRIMES> (primes-upto 100)
(2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97)

#lang racket

(define (prime-sieve n)
  (define (whole-sqrt x)
    (inexact->exact (truncate (sqrt x))))
  (define table (make-vector (add1 n) #t))
  (define (prime? x) (vector-ref table x))
  (define (remove-multiples x)
    (define multiples 
      (map (lambda (y) (* x y))
           (filter prime? (range x n))))
    (for ([i multiples])
      #:break (> i n)
      (vector-set! table i #f)))
  (let sieve ([x 2])
    (cond
      [(> x (whole-sqrt n)) table]
      [(prime? x)
       (remove-multiples x)
       (sieve (add1 x))]
      [else 
        (sieve (add1 x))])))

(define (primes-up-to n)
  (define tab (prime-sieve n))
  (filter (lambda (i) (vector-ref tab i))
          (range (add1 n))))

(define (primes-up-to n)
  (for/list ((p (prime-sieve n) #:when p) p))

2dup swap mod 0=     \ sz pf addr pc addr[i2] divides?

-- fast-primes.hs
-- Using the Integral type class instead of just saying Integer might result in
-- the list being calculated multiple times, which is really bad.

-- Every prime above 3 is of the form 6*n+1 or 6*n-1, so we only test those
-- primes
testNums :: [Integer]
testNums = genList [1..]
  where genList (n:ns) = 6*n-1:6*n+1:genList ns

primes :: [Integer]
primes = 2 : 3 : accum [3,2] testNums
  where accum ps (n:ns) = if testP ps n
                          then n : accum (ps ++ [n]) ns
                          else accum ps ns

-- Test if a number is prime given a list of the prime numbers below it in
-- order
testP :: [Integer] -> Integer -> Bool
testP ps n = not $ any (== 0) $
             map (n `mod`) $
             takeWhile ((<= sqrt (fromIntegral n)) . fromIntegral) ps

-- required by the challenge, I guess
genPrimes = flip take primes


-- used for benchmarking
main = putStrLn $ "The 10000th prime number is " ++ show (primes !! 10000)

[alex@jupiter scratch]$ time ./fast-primes
The 10000th prime number is 104743

real0m0.199s
user0m0.197s
sys0m0.000s
[alex@jupiter scratch]$ time ./primes
The 10000th prime number is 104743

real0m3.639s
user0m3.613s
sys0m0.020s

$ time gforth-fast nprimes.fs -e '10000000 nthprime bye'
179424673 

real0m12.363s
user0m12.240s
sys0m0.110s

get_primes(N) -> filter(lists:seq(2, N), []).
  
filter([], Acc) -> lists:reverse(Acc);
filter(L, Acc) -> 
    FL = [N || N<-L, N rem hd(L) =/= 0 orelse N =:= hd(L)],
    filter(tl(FL), [hd(FL)] ++ Acc).

filter([], Acc) -> lists:reverse(Acc);
filter(L, Acc) -> 
    [H|T] = [N || N<-L, N rem hd(L) =/= 0 orelse N =:= hd(L)],
    filter(T, [H] ++ Acc).

(define (brainfuck program)
  (let ((data (make-vector 150 0)))
    (let loop ((inst 0) (data-ptr 0))
      (when (< inst (string-length program))
        (case (string-ref program inst)
          ((#\>) (loop (+ inst 1) (+ data-ptr 1)))
          ((#\<) (loop (+ inst 1) (- data-ptr 1)))
          ((#\+)
           (vector-set! data data-ptr (+ (vector-ref data data-ptr) 1))
           (loop (+ inst 1) data-ptr))
          ((#\-)
           (vector-set! data data-ptr (- (vector-ref data data-ptr) 1))
           (loop (+ inst 1) data-ptr))
          ((#\.)
           (write-char (integer->char (vector-ref data data-ptr)))
           (loop (+ inst 1) data-ptr))
          ((#\,)
           (vector-set! data data-ptr (read))
           (loop (+ inst 1) data-ptr))
          ((#\[)
           (loop (if (zero? (vector-ref data data-ptr))
                     (+ (matching-paren program inst 1 #\[ #\]) 1)
                     (+ inst 1))
                 data-ptr))
          ((#\])
           (loop (if (zero? (vector-ref data data-ptr))
                     (+ inst 1)
                     (+ (matching-paren program inst -1 #\] #\[) 1))
                 data-ptr))
          (else (loop (+ inst 1) data-ptr)))))
    (newline)
    (print data)))

(define (matching-paren s i step add sub)
  (let loop ((i (+ i step)) (n 0))
    (let ((c (string-ref s i)))
      (cond
       ((eq? c add) 
        (loop (+ i step) (+ n 1)))
       ((eq? c sub)
        (if (zero? n)
            i
            (loop (+ i step) (- n 1))))
       (else (loop (+ i step) n))))))

(brainfuck "++++++++[>++++[>++>+++>+++>+<<<<-]>+>+>->>+[<]<-]>>.>---.+++++++..+++.>>.<-.<.+++.------.--------.>>+.>++.") ; Hello World!

    (newline)
    (print data)

let jump_forward program ip =
  let rec iter ip depth =
    match program.[ip], depth with
    | ']', 0 -> ip + 1
    | ']', _ -> iter (ip + 1) (depth - 1)
    | '[', _ -> iter (ip + 1) (depth + 1)
    | _, _ -> iter (ip + 1) depth
  in iter (ip + 1) 0

let jump_back program ip =
  let rec iter ip depth =
    match program.[ip], depth with
    | '[', 0 -> ip
    | '[', _ -> iter (ip - 1) (depth - 1)
    | ']', _ -> iter (ip - 1) (depth + 1)
    | _, _ -> iter (ip - 1) depth
  in iter (ip - 1) 0

let run program =
  let memory = Array.make 256 '\x00' in
  let rec execute ip dp =
    if ip < String.length program then
      match program.[ip] with
      | '+' -> memory.(dp) <- Char.chr (Char.code memory.(dp) + 1);
               execute (ip + 1) dp
      | '-' -> memory.(dp) <- Char.chr (Char.code memory.(dp) - 1);
               execute (ip + 1) dp
      | '>' -> execute (ip + 1) (dp + 1)
      | '<' -> execute (ip + 1) (dp - 1)
      | '[' -> if ((Char.code memory.(dp)) = 0) then
                 execute (jump_forward program ip) dp
               else
                 execute (ip + 1) dp
      | ']' -> execute (jump_back program ip) dp
      | '.' -> print_char memory.(dp);
               execute (ip + 1) dp
      | ',' -> memory.(dp) <- (input_char stdin);
               execute (ip + 1) dp
      | _ -> execute (ip + 1) dp
  in
  execute 0 0

let () =
  run "++++++++[>++++[>++>+++>+++>+<<<<-]>+>+>->>+[<]<-]>>.>---.+++++++..+++.>>.<-.<.+++.------.--------.>>+.>++."

$location = 0
$buffers = [0]
script_location = 0
file = File.new(ARGF.argv[0], 'r')
$script = (file.read).split("")
loop_end = 0

def run_command(cmd,script_location)
  case cmd 
  when ">"
    $location+=1
    $buffers.push 0 if $location > $buffers.size-1
    script_location+=1
  when "<"
    $location=$location-1
    script_location+=1
  when "+"
    $buffers[$location]=$buffers[$location]+1
    script_location+=1
  when "-"
    $buffers[$location]=$buffers[$location]-1
    script_location+=1
  when "."
    print ($buffers[$location]).chr
    script_location+=1
  when ","
    a = IO.read '/dev/stdin', 1
    print a
    if a == nil
      $buffers[$location] = 0
    else
      $buffers[$location] = a.ord
    end
    script_location+=1
  when "["
    script_location = run_loop script_location
  else script_location+=1 end
  return script_location
end

def run_loop(location)
  location+=1
  loop_start = location
  loop do
  if $buffers[$location] == 0
    until $script[location] == "]"
      location+=1
    end
    return location+1
  else
    until $script[location] == "]"
      location = run_command $script[location],location
    end
    if $buffers[$location] != 0
      location = loop_start
    else
      return location+1
    end
  end
  end
end
  
while script_location+1 < $script.size do
  cmd = $script[script_location]
  script_location = run_command cmd,script_location
end

1024 constant dn \ size of memory consant
     variable d0 \ address of first memory unit
     variable di \ memory index
     variable cn \ size of code
     variable c0 \ address of first code unit
     variable ci \ code index

: init-mem
        dn chars allocate throw d0 ! \ allocate
        d0 @ dn 0 fill               \ set zero
        0 ci ! 0 di !
;
: free-mem d0 @ free throw ;

: ooc? ci @ dup 0 < swap cn @ >= or ;   \ out of code?

: ci@ ooc? throw c0 @ ci @ chars + c@ ; \ get instruction
: cii ci dup @ 1+ swap ! ;              \ go to next instruction
: cid ci dup @ 1- swap ! ;              \ go to previous instruction
: di@ d0 @ di @ chars + c@   ;          \ read at data+index
: di! d0 @ di @ chars + c!   ;          \ store at data+index
: dii di @ 1+ dn 1- and di ! ;          \ increase data index
: did di @ 1- dn 1- and di ! ;          \ decrease data index

: _ postpone postpone ; immediate
: compile-bracerunner
        >r _ begin
                r> compile, _ ci@
                _ dup '[ _ literal _ = _ if _ swap _ 1+ _ swap _ else
                _ dup '] _ literal _ = _ if _ swap _ 1- _ swap _ then _ then _ drop
        _ dup _ 0= _ until
        _ drop
;

: interpretchar ( c -- )
        dup '< = if did                                              else
        dup '> = if dii                                              else
        dup '+ = if di@ 1+ di!                                       else
        dup '- = if di@ 1- di!                                       else
        dup '. = if di@ emit                                         else
        dup ', = if key di!                                          else
        dup '[ = if di@ 0=  if  1 [ ' cii compile-bracerunner ] then else
        dup '] = if di@ 0<> if -1 [ ' cid compile-bracerunner ] then then
                 then then then then then then then drop
;

: runinterpreter ( -- )
        init-mem
        begin
                ci@ interpretchar cii
        ooc?  until
        free-mem
;

: runstring ( addr n -- )
        cn ! c0 !
        runinterpreter
;

\ Hello World! found on wikipedia
s" ++++++++[>++++[>++>+++>+++>+<<<<-]>+>+>->>+[<]<-]>>.>---.+++++++..+++.>>.<-.<.+++.------.--------.>>+.>++."
runstring
bye

di@ 1+ di!

d0 @ di @ chars + c@ 1+ d0 @ di @ chars + c!

d0 @ di @ chars + dup c@ 1+ swap !

di@ 0=  if  1 [ ' cii compile-bracerunner ] then 

di@ 0= if                     \ if the current memory cell is 0, skip until matching closing brace
    1 begin                   \ ctr=1        seed the counter with 1, since we begin on a '['
        cii ci@               \ ctr instr    go to the next instruction and read it
        dup '[ = if           \              check what the instruction is - probably be case of should be using case
            swap 1+ swap      \ ctr+1 instr  '[' - increase the counter
        else                  \
            dup '] = if       \
                swap 1- swap  \ ctr-1 instr  ']' - decrease the counter
            then              \
        then                  \
        drop                  \ ctr          instruction testing done, drop it from the stack
    dup 0= until              \ ctr          loop until the counter reaches 0 = we have reached '['-']'-balance
then

di@ 0= if 1 begin cii runtime-bracerunner until then 

[ ' cii 1 ' 0= compiletime-evenmoreconvoluted-bracerunner ]

dup '[ = if     \ ctr instr
    drop 1+     \ ctr+1
else            \ ctr instr
    dup '] = if \ ctr instr
        drop 1- \ ctr-1
    else        \ ctr instr
        drop    \ ctr
    then        \ ctr
then

: dii di @ 1+ dn 1- and di ! ;          \ increase data index

: dii di @ 1+ [ dn 1- ] literal and di ! ;

: init-mem
        [ dn chars ] literal allocate throw d0 ! \ allocate
        d0 @ dn 0 fill               \ set zero
        0 ci ! 0 di !
;

int primes[] = {2,3,5,7,11};
int primes[5]
int primes[] // This is an error, length neither stated nor implied

(define (rep n s l)
    (if (= n 0)
        l
        (rep (- n 1) s (cons s l))))

(define bfvector (list->vector (rep 100 0 '())))

(define pos 0)

(define spos 0)

(define loop-stack '())

(define (reset)
    (begin (set! pos 0)
           (set! spos 0)
           (set! loop-stack '())
           (set! bfvector (list->vector (rep 100 0 '())))))

(define (ev x) (case x   ((43) (begin (set! spos (+ spos 1))
                                      (vector-set! bfvector pos (+ (vector-ref bfvector pos) 1)))) ; +
                         ((45) (begin (set! spos (+ spos 1))
                                      (vector-set! bfvector pos (- (vector-ref bfvector pos) 1)))) ; -
                         ((62) (begin (set! spos (+ spos 1))
                                      (set! pos (+ pos 1)))) ; >
                         ((60) (begin (set! spos (+ spos 1))
                                      (set! pos (- pos 1)))) ; <
                         ((91) (begin (set! spos (+ spos 1))
                                      (set! loop-stack (cons spos loop-stack)))) ; [
                         ((93) (if (= (vector-ref bfvector pos) 0)
                                   (begin (set! loop-stack (cdr loop-stack))
                                          (set! spos (+ spos 1)))
                                   (set! spos (car loop-stack)))) ; ]
                         ((46) (begin (set! spos (+ spos 1))
                                      (display (integer->char (vector-ref bfvector pos))))) ; .
                         ((44) (begin (set! spos (+ spos 1))
                                      (vector-set! bfvector pos (char->integer (read-char))))) ; ,
                         ))

(define (evaluate xs)
    (define (iter len xs)
        (if (= spos len)
            (newline)
            (begin (ev (list-ref xs spos)) (iter len xs))))
    (iter (length xs) xs))

(define (bf x) (evaluate (map char->integer (string->list x))))

> (bf "++++++++[>++++[>++>+++>+++>+<<<<-]>+>+>->>+[<]<-]>>.>---.+++++++..+++.>>.<-.<.+++.------.--------.>>+.>++.")
Hello World!

primes :: Integral i => [i]
primes = go [2..]
    where go (p:rest)        = let next = go . filter (`notDivisibleBy` p) $ rest
                               in  p:next
          notDivisibleBy a b = a `mod` b /= 0

file = File.new(ARGF.argv[0], 'r')
tosort = file.readlines()
file.close()
file = File.new(ARGF.argv[0], 'w')
(tosort.sort).each{ |line| file.write(line) }
file.close()

import std.algorithm, std.array, std.stdio;
void main() { foreach (l; stdin.byLineCopy().array().sort()) writeln(l); }

\ print array contents
: .array ( A n -- ) '( emit space cells 0 ?do dup i + @ . cell +loop ') emit cr drop ;

\ allocate space and stuff a number of stack items onto the heap
\ note that the array is top-loaded
: >array ( d0 ... dn-1 n -- A )
        dup cells allocate throw \ dn-1 ... d0 n A
        over cells -1 swap \ -1 nc
        do \ dn-1 ... d0 A
                tuck i + !
        cell -loop
;

\ swaps two elements of an array
: array-swap ( i j A -- )
        >r               \ r:A i j
        cells r@ + dup @ \ r:A i A+j A[j]
        rot              \ r:A A+j A[j] i
        cells r> + dup @ \ A+j A[j] A+i A[i]
        -rot !           \ A+j A[i]
        swap !
;

: _ postpone postpone ; immediate
\ compiles a function that does something with data
\ fetched from two positions in an array
: compile-array-binf ( compile-time: xt -- ) ( run-time: i j A -- ? )
        _ rot _ cells _ over _ + _ @ \ j A A[i]
        _ rot _ cells _ rot  _ + _ @ \ A[i] A[j]
        compile,                     \ ?
;

\ Hoare partitioning with the first element as pivot
: partition ( A n -- )
        0 swap  \ A left=0 right=n
        begin
                \ count down the right counter
                \ A left right
                begin
                        1-                          \ A left right-=1
                        dup 0 4 pick                \ A left right right 0
                        [ ' <= compile-array-binf ] \ A left right f
                until

                \ count up the left counter
                swap \ A right left
                begin
                        1+                          \ A right left+=1
                        dup 0 4 pick                \ A right left left 0
                        [ ' >= compile-array-binf ] \ A right left f
                until
                swap \ A left right

                \ swap as necessary and possibly return
                2dup < if
                        2dup 4 pick array-swap
                else
                        nip \ A right
                        dup rot 0 swap \ right right 0 A
                        array-swap
                        exit \ right
                then
        again
;

: quicksort ( A n -- )
        dup 1 > if
                2dup partition \ A n p

                2 pick over             \ A n p A p
                recurse
                1+ tuck                 \ A p+1 n p+1
                - swap cells rot + swap \ A+p+1 n-p-1
                recurse
        else
                2drop
        then
;

." EXAMPLE ( numbers chosen by fair dice roll ) :" cr

3 19 9 16 20 6 7 4 5 14 10 8 18 2 15 13 1 12 11 17
20 >array

        4 spaces ." unsorted:" cr
        8 spaces dup 20 .array
        dup 20 quicksort

        4 spaces ." sorted:" cr
        8 spaces dup 20 .array

free throw

cr cr

92 60 7 74 43 68 48 66 87 27 11 9 3 51 10 42 62 85 30 45
33 26 17 1 8 91 84 99 37 21 86 56 98 76 71 20 95 4 24 70
13 6 82 88 77 55 23 41 75 94 34 36 12 35 96 100 2 25 38 28
32 15 47 61 14 54 69 93 19 22 81 59 72 97 53 18 40 78 63 50
52 46 39 5 90 64 57 16 79 31 89 73 44 83 80 58 65 29 67 49
100 >array

        4 spaces ." unsorted:" cr
        8 spaces dup 100 .array
        dup 100 quicksort

        4 spaces ." sorted:" cr
        8 spaces dup 100 .array

free throw

bye

: small-example
    \ will print an '@'
    cr
    [bf-setup]
    [bf]" ++++[->++++<]>[-<++++>]<."
    [bf-teardown]
    cr
;
small-example 
@

see small-example 
: small-example  
  cr bf-setup 4 bf+- 
  BEGIN  2dup + c@ 
  WHILE  -1 bf+- 1 bf<> 4 bf+- -1 bf<> 
  REPEAT 
  1 bf<> 
  BEGIN  2dup + c@ 
  WHILE  -1 bf+- -1 bf<> 4 bf+- 1 bf<> 
  REPEAT 
  -1 bf<> bf. bf-teardown cr ;

# -*- coding: utf-8 -*-
import random
import time
import os

os.system("color a")
def newline():
    chars = "1234567890+/\\"
    space = " " * random.randint(0, 2)
    line = random.choice(chars) + space
    return line
while True:
    stringlist = list()
    for i in range(0, 81):
        matrixline = list()
        matrixline.append(newline())
        if len(matrixline) >= 80:
            break
    string = "".join(matrixline)
    if string not in stringlist:
        stringlist.append(string)
        print string,
    time.sleep(0.001)

# -*- coding: utf-8 -*-
import random
import time
import os
os.system("color a")    # turns font colour into a more 37331 one, lincucks will never get this


def matrixline():
    xlist = list()
    for i in range(0, 81):
        chars = "1234567890+/\\"
        space = " " * random.randint(0, 3)
        line = random.choice(chars) + space
        xlist.append(line)
        if len(("".join(xlist))) >= 80:
            break
    xstring = "".join(xlist)
    return xstring

onetime = 1
while True:
    if onetime == 1:
        onetime -= 1
        matrixlist = list()
    string = matrixline()
    if string not in matrixlist:
        matrixlist.append(string)
        print string
        time.sleep(0.04)

#include <stdio.h>

int test(int I, int t_num) {
    if(test_1(I, t_num) && test_2(I, t_num))
        return 1;
    return 0;
}

int test_1(int I, int t_num) {
    if(I % t_num == 0) return 1; return 0;
}

int test_2(int I, int t_num) {
    if(I != t_num) return 1; return 0;
}

int main() {
    int I;
    for(I = 2; I <= 100; I++) {
        if(test(I, 2) || \
           test(I, 3) || \
           test(I, 5) || \
           test(I, 7) || \
           test(I, 11))
        { printf(""); } else printf("%d ", I);} return 0;
}

# Revision to Version 0.2
# Change log
# *subtotal, tax, and tip variables changed from string to integers.
# **Reasoning: Strings cannot have arithmetic performed on them.
# *"%s" Changed to "%f"
# **Reasoning:"%s" is for strings. The printed result contains decimal values, and therefore it is a float, and same with the variables. Therefore, "%f" is used.
#
# Original code left for example of not what to do.

print "Python Tip Calculator Version 0.2"

print "Tip Calculator"

subtotal = 15.85
tax = .08
gratuity = .15

meal = subtotal * tax + subtotal
tip = subtotal * gratuity
total = meal + tip

print("%f" % tip)
print("%f" % total)

subtotal = input()
tax = input()
gratuity = input()

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{
    if(argc != 2)
    {
        printf("Requires length arg.\n");
        return 0;
    }
    int lines = atoi(argv[1]);
    char *line = (char *)malloc(sizeof(char)*lines);
    int i;
    for(i =0; i<lines; i++)
        line[i] = ' ';
    int a, b, x, y, z;
    a=0;
    b=lines-1;
    for(z=0; z<lines; z++)
    {
        for(y=0; y<lines; y++)
        {
            line[a] = '*';
            line[b] = '*';
        }
        if(a<lines && b>-1)
        {
            a++;
            b--;
        }
        for(x=0; x<lines; x++)
        {
            printf("%c", line[x]);
            line[x] = ' ';
        }
        printf("\n");
    }
    return 0;
}                       

#include<stdio.h>
#include<math.h>

int size = 10;

void main(int argc, char* argv[])
{
  if(argc == 2) { size = atoi(argv[2]); }
  int x,y;
  for(y=0;y<size;y++, printf("\n"))
    for(x=0;x<size;x++)
    {
      printf(abs(y/x)==1?"X":" ");
    }
}

printf(x==y?"X":" ");

#include<stdio.h>
#include<math.h>

void main(int argc, char* argv[])
{
        float size = 10;
        if(argc == 2) size = atof(argv[2]);

        float mid = size/2;

        float x,y;
        for(y=1;y<size;y++, printf("\n"))
                for(x=1;x<size;x++)
                        printf(mid-x+mid-y==0 || fabs( (mid-y)/(mid-x) )==1 ? "x":"_");
}

#include<stdio.h>
void main(int argc, char* argv[])
{
        int x, y, size = 10;
        if(argc == 2) size = atoi(argv[1]);
        for(y=0; y<size; printf("\n"), y++)
                for(x=0; x<size; printf(x==y||y==size-1-x?"X":"_"), x++);
}

: x dup 0 do dup 0 do i j <> over i - 1- j <> -88 * * 120 + emit loop cr loop drop ;

void x(int n) {
    for (int j=0; j<n; ++j) {
        for (int i=0; i<n; ++i) {
            fputc((i!=j)*(n-i-1!=j)*-88 + 120, stdout);
        }
        fputc(10, stdout);
     }
}

for(divisor = 2; divisor * divisor <= n; divisor++){
  if(n % divisor == 0)
    return false;
  else
    return true;
}

for(divisor = 2; divisor * divisor <= n; divisor++){
  if(n % divisor == 0)
    return false;
}
return false;

return true;

#!/usr/bin/env python3
import random

print("You rolled %s." %
      random.randint(0, int(input("What number do you want to roll to? "))))

#include <stdio.h>
#include <stdlib.h>
void main(int c, char** v) {
    for(int n=c==2?atoi(v[1]):10, j=n; j--; puts(""))
        for (c=n; c-=printf(c==j+1||j==n-c?"X":" "););
}

import math

def allPrimes(n):
    
    numPrimos = 0
    
    for i in range(2, n + 1):
        primo = True;
        
        for j in range(2, int(math.sqrt(i)) + 1):
            if i % j == 0:
                primo = False
        
        if(primo == True):
            print("The number", i, "is prime.\n")
            numPrimos += 1
            
    print("Total number of prime numbers is", numPrimos, ".\n")

# True, because "_l_ove _l_ain"
fuzzy_match("ll", "love lain")

# False, because there's no a between the l's
fuzzy_match("lal", "love lain")

fuzzyMatch :: Eq a => [a] -> [a] -> Bool
fuzzyMatch _  []    = False
fuzzyMatch [] _     = True
fuzzyMatch (p:ps) (x:xs)
    | p == x    = fuzzyMatch ps xs
    | otherwise = fuzzyMatch (p:ps) xs

Prelude> fuzzyMatch "ll" "love lain"
True
Prelude> fuzzyMatch "lal" "love lain"
False
Prelude> fuzzyMatch "ll" "ll"
False

fuzzyMatch :: Eq a => [a] -> [a] -> Bool
fuzzyMatch [] _     = True
fuzzyMatch _  []    = False
fuzzyMatch (p:ps) (x:xs)
    | p == x    = fuzzyMatch ps xs
    | otherwise = fuzzyMatch (p:ps) xs

format ELF64
section '.text' executable

publicfuzzy_match

; extern bool fuzzy_match(const char *needle, const char *hay)
; rdi = const char *needle
; rsi = const char *hay
; rax = ret
fuzzy_match:
movecx, [rdi]
top:
moveax, [rsi]
testal, al
jeexit

incrsi
cmpcl, al
jnetop

incrdi
movecx, [rdi]
jmptop
exit:
testcl, cl
seteal
ret

format ELF64
section '.text' executable

public   fuzzy_match

; extern bool fuzzy_match(const char *needle, const char *hay)
; rdi = const char *needle
; rsi = const char *hay
; rax = ret
fuzzy_match:
        mov     ecx, [rdi]
top:
        mov     eax, [rsi]
        test    al, al
        je      exit
        
        inc     rsi
        cmp     cl, al
        jne     top
        
        inc     rdi
        mov     ecx, [rdi]
        jmp     top
exit:
        test    cl, cl
        sete    al
        ret

fuzzy_match([], _) ->
    true;
fuzzy_match(_, []) ->
    false;
fuzzy_match([A|R],[A|T]) ->
    fuzzy_match(R, T);
fuzzy_match(R, [_|T]) ->
    fuzzy_match(R, T).

>>> import functools
>>> fuzzy = lambda data, key: functools.reduce (lambda left, ch: "" if left == "" else left if left [0] != ch else left [1:], data, key) == ""
>>> fuzzy ("alice in wonderland", "lol")
True
>>> fuzzy ("alice in wonderland", "cider")
True
>>> fuzzy ("alice in wonderland", "lain")
False

>>> import functools
>>> fuzzy2 = lambda data, key: functools.reduce (lambda t, ch: t if t [1] == False else (lambda s, i: (s [i+1:], True) if i >= 0 else (s, False)) (t [0], t [0].find (ch)), key, (data, True)) [1]
>>> fuzzy2 ("alice in wonderland", "a wand")
True
>>> fuzzy2 ("alice in wonderland", "anon")
True
>>> fuzzy2 ("alice in wonderland", "lain")
False

sub fuzzy($chars, $string) {
    return True unless $chars;
    my $regex = $chars.comb(/./).join('.*');
    $string ~~ /<$regex>/;
}

>>> fuzzy ("12345", "24")
True
>>> fuzzy ("12345", "42")
False
>>> fuzzy2 ("12345", "24")
True
>>> fuzzy2 ("12345", "42")
False
>>> fuzzy ("alice in wonderland", "red")
False
>>> fuzzy2 ("alice in wonderland", "red")
False
>>> fuzzy ("alice in wonderland", "icen")
True
>>> fuzzy ("alice in wonderland", "nice")
False
>>> fuzzy2 ("alice in wonderland", "icen")
True
>>> fuzzy2 ("alice in wonderland", "nice")
False

fuzzyMatch : String -> String -> Bool
fuzzyMatch s1 s2 = fuzzyMatch' (unpack s1) (unpack s2)
  where
    fuzzyMatch' : List Char -> List Char -> Bool
    fuzzyMatch' [] _ = True
    fuzzyMatch' _ [] = False
    fuzzyMatch' (x::xs) (y::ys) = if x == y then fuzzyMatch' xs ys
                                            else fuzzyMatch' (x::xs) ys

function fuzzy(exp, str) { 
  return !!str.match( new RegExp(exp.split('').join('.*')) );
}
fuzzy('ll', 'lolin'); // true

fn fuzzy_match (matcher: &str, text: &str) -> bool
{
    let mut iter = text.chars();
    for c in matcher.chars()
    {
        loop
        {
            match iter.next()
            {
                None => return false,
                Some(tc) => if tc == c {break;}
            };
        }
    }
    true
}

int fuzz(char* pat, char* str) {
    while(*pat && *str)
        if (*pat == *(str++))
            pat++;
    return *pat ? 0 : 1;
}

primes = eval(input("Enter number of prime numbers desired: "))
 soykaf = 0
number = 1
factors = 0
while  soykaf < primes:
    for i in range(1, number+1):
        if i == number:
            continue
        elif number/i == number//i:
            factors +=1
    if factors == 0:
        print(number)
        shit+=1
    else:
        factors = 0
    number+=1

number/i == number//i

primes = eval(input("Enter number of prime numbers desired: "))
 soykaf = 0
number = 1
factors = 0
while  soykaf < primes:
    for i in range(2, number+1):
        if i == number:
            continue
        elif number/i == number//i:
            factors +=1
    if factors == 0:
        print(number)
        shit+=1
    else:
        factors = 0
    number+=1

Dr. Awkward
Gnu dung
Kayak

import Data.Char (toLower)

palindrome = test . filter criteria . map toLower
    where criteria = flip elem $ ['a'..'z'] ++ ['0'..'9']
          test xs = all (==True) $ zipWith (==) (start xs) (reverse $ end xs)
          start xs = take (length xs `div` 2) xs
          end xs = drop (length xs `div` 2) xs

main = (return . palindrome =<< getLine) >>= print

def p(s):
    def r(s): return ''.join([i.strip(' .').lower() for i in s.split()])
    return r(s) == r(s[::-1])

import Data.Char (isAlpha, toLower)

isPalindrome :: String -> Bool
isPalindrome l = let raw = map toLower . filter isAlpha $ l
                 in  raw == reverse raw

criterie = (`elem` ['a'..'z'] ++ ['0'..'9'])

int ispalindrome(const char *str)
{
const char *s = str, *t = str;

while (*(t++) != '\0');

--t; 
while (s < t) {
if ((!isalpha(*s) && ++s) || (!isalpha(*t) && --t))
continue;
if (tolower(*s++) != tolower(*t--))
return 0;
}

return 1;
}

>>> palindromedary = lambda t: (lambda s: s == s [::-1]) ("".join (map (str.lower, filter (str.isalpha, t))))
>>> palindromedary ("Dr. Awkward")
True
>>> palindromedary ("Gnu dung")
True
>>> palindromedary ("Kayak")
True
>>> palindromedary ("bopqod")
False
>>> palindromedary ("shush")
False
>>> palindromedary ("A Santa dog lived as a devil god at NASA.")
True

$ node
> function isPalindrome(s) {
...   s=s.replace(/\W/g,"").toLowerCase();
...   return s.split("").reverse().join("") === s;
... };
undefined
>
undefined
> isPalindrome ("Dr. Awkward")
true
> isPalindrome("Gnu dung")
true
> isPalindrome("Kayak")
true
> isPalindrome("bopqod")
false
> isPalindrome("shush")
false
> isPalindrome("A Santa dog lived as a devil god at NASA.")
true
>

(define (findprime n)
  (let ([one-to-n (foldr (lambda (x y) (cons (- (first y) x) y)) `(,n) (make-list (- n 2) 1))])
  (foldr (lambda (x y) (if (empty? (filter (lambda (z) (equal? 0 (remainder x z))) (remove x one-to-n))) (cons x y) y)) empty one-to-n)))

fn main ()
{
    let t1 = "Dr. Awkward";
    let t2 = "Gnu dung";
    let t3 = "Kayak";
    
    if !palindrome(t1)
    {
        panic!("Dr. Awkward isn't a palindrome ?");
    }
    
    if !palindrome(t2)
    {
        panic!("Gnu dung isn't a palindrome ?");
    }
    
    if !palindrome(t3)
    {
        panic!("Kayak isn't a palindrome ?");
    }
}

fn palindrome(text: &str) -> bool
{
    let filtered = text.chars()
        .filter_map(|c: char| if c.is_alphanumeric() {c.to_lowercase().next()} else {None});
    let reversed = text.chars()
        .filter_map(|c: char| if c.is_alphanumeric() {c.to_lowercase().next()} else {None}).rev();
    filtered.zip(filtered.rev()).all(|(x,y)| x == y)
}

(define (isPali lst)
    (equal? (foldr (λ(x y) `(,@y ,x)) null lst) lst))

defmodule Lainchan do
  def anagram?(word) do
    x = word |> cleanup |> String.downcase
    x == String.reverse(x)
  end

  def cleanup(word) do
    Regex.replace(~r/\W/, word, "")
  end
end

    public void nPrimes (int i, int j){

        
        if (i == 1){
            return;
        }
        if (j == 1){
           //---------If it's prime
            System.out.println( i);
            nPrimes(i - 1, i - 2);
        }
        else{
            if (i % j == 0){
                //System.out.println(i +" Isn't prime");
                //--------------------If isn't prime
                nPrimes(i - 1, i - 2);
            }
            else
            {
                nPrimes(i, j - 1);
            }
        }
        

    } 

f(3,[1, 2, 3, 4, 5, 6]) -> 3

(define (f n l) (list-ref (sort l <) (- n 1)))

smallest :: Ord a => Int -> [a] -> a
smallest n xs = sort xs !! (n - 1)

smallest :: Ord a => Int -> [a] -> a
smallest n xs
  | n < 1         = error "n needs to be at lest 1"
  | length xs < n = error $ "List need to be at least " ++ show n ++ " elements long"
  | otherwise = let x = head xs in go (x, x, 1) . tail $ xs
  where go (_, solution, _) [] = solution
        go p@(lowerBound, current, c) (x:xs)
          | current == x = go p xs
          | c < n =
            if current < x
              then go (current, x, c + 1) xs
              else go (nextLowerBound, current, c + 1) xs
          | otherwise =
            if current < x
              then go p xs
              else go (nextLowerBound, next, c) xs
          where nextLowerBound = min x lowerBound
                next           = max x lowerBound

#include <vector>
#include <limits>
#include <stdexcept>
using namespace std;

double nthSmallest(unsigned int n, vector<double> numbers)
{
    if (n==0)                   throw out_of_range("Pick a non-zero n");
    else if (n>numbers.size())  throw out_of_range("Pick n smaller than vector size");
    double lastValue = numeric_limits<double>::lowest();
    double* toBeDiscarded = 0;
    for (unsigned int i = 0; i<n; ++i)
    {
        double currentLow = numeric_limits<double>::max();
        for (double& num : numbers)
            if (num>=lastValue && num<currentLow)
            {
                currentLow = num;
                toBeDiscarded = &num;
            }
        lastValue = currentLow;
        *toBeDiscarded = numeric_limits<double>::lowest();
    }
    return lastValue;
}

# assuming we don't want to consider punctuation or whitespace chars
from string import whitespace as w
from string import punctuation as p

strip = w + p

def p(word):
    alphaNum = ''.join(c for c in word if c not in strip)
    alphaNum = alphaNum.lower()  # caps aren't important if order flips
    n = 0
    while n <= (len(alphaNum) // 2):
        if alphaNum[n] != alphaNum[len(alphaNum) - (n + 1)]:
            return False
        n += 1
    return True

package main
import "fmt"
func main(){
var n, temp int
list := [10] int {5,7,33,8,2,74,17,6,1,11}
fmt.Print("Enter a number n, in between 1-10 to find ")
fmt.Println("the nth smallest number on the list")
for _, value := range list {
fmt.Printf("%d ",value)
}
fmt.Println()
fmt.Scanf("%d", &n)
for i:=0; i < len(list); i++ {
for j:=0; j <len(list);j++ {
if list[i] < list[j] {
temp = list[i]
list[i] = list[j]
list[j] = temp
}
}
}
fmt.Printf("%d smallest number is %d\n", n, list[n-1])
}

#include <stdlib.h>
#include <stdio.h>
int min(int array[],size_t length){
  int min = array[0];
  for(int i=0; i < length; i++){
    if(min > array[i]){
      min = array[i];
    }
  }
  return min;
}
int main(){
  int test[] = {12,3,1,3,4,5,67,3,12,4,5,6,7,123,5,6,3,12,4,5,67,8,9,7,5,3,1,231,12,35,234,124,23452,2394,30,40,2,3,4,5,67,8};
  printf("%d\n",min(test,(sizeof(test)/sizeof(int))));
  return 0;
}

def nthSmallest(nth, of):
    for n in of:
        while of.count(n) > 1:
            of.remove(n)
    of.sort()
    return of[(nth - 1)]

cat list | sort -un | sed -n $1p

cat list | sed 's/ /\n/g' | sort -un | sed -n $1p

#include <stdlib.h>
#include <stdio.h>
#include <stdbool.h>
int min(int array[],size_t length,int nth){
  for(;;){
    bool swapped = false;
    for(int i=0;i<(int)length-1;i++){
      if(array[i] > array[i+1]){
        printf("sorted\n");
        swapped = true;
        int temp = array[i];
        array[i] = array[i+1];
        array[i+1]  = temp;
      }
    }
    if(!swapped){
      return array[nth-1];
    }
  }
}
int main(){
  int test[] = {12,3,1,3,4,5,67,3,12,4,5,6,7,123,5,6,3,12,4,5,67,8,9,7,5,3,1,231,12,35,234,124,23452,2394,30,40,2,3,4,5,67,8};
  printf("%d\n",min(test,sizeof(test)/sizeof(int),3));
  return 0;
}

smallest 3 [3, 4, 5, 2, 1, 6]

smallest' :: Ord a => Int -> [a] -> a
smallest' n xs
  | n < 1         = error "n needs to be at lest 1"
  | length xs < n = error $ "List need to be at least " ++ show n ++ " elements long"
  | otherwise = let x = head xs in go ([], x, 1) . tail $ xs
  where go (_, solution, _) [] = solution
        go p@(lowerStack, current, c) (x:xs)
          | current == x = go p xs
          | c < n =
            if current < x
              then go (current:lowerStack , x      , c + 1) xs
              else go (insert x lowerStack, current, c + 1) xs
          | otherwise =
            if current < x
              then go p xs
              else let (next:nextLowerStack) = insert x lowerStack
                   in  go (nextLowerStack, next, c) xs

        insert x []     = [x]
        insert x (y:ys)
          | x == y      = y:ys
          | x >  y      = x:y:ys
          | otherwise   = y:insert x ys

from itertools import islice
from bisect import insort_right

def nthsmallest (n, data):
   if n < 1: return None
   if n == 1: return min (data)

   iterdata = iter (data)
   cache = list (islice (iterdata, n))
   if len (cache) < n: return None

   cache = sorted (cache)
   guard = cache [-1]

   for x in iterdata:
      if x < guard:
         insort_right (cache, x)
         del cache [-1]
         guard = cache [-1]

   return guard

>>> nthsmallest (3, [3, 4, 5, 2, 1, 6])
3
>>> nthsmallest (3, 'nthsmallest')
'h'

>>> import heapq
>>> nthsmallest = lambda n, data: heapq.nsmallest (n, data) [-1]
>>> nthsmallest (3, 'nthsmallest')
'h'
>>> nthsmallest (3, [3, 4, 5, 2, 1, 6])
3

 
if(i%x==0){
     not a prime
} 

 
if(i%array.get(x)==0){
     not a prime
} 

for(long prime : primes) {
    if(i % x == 0) {
        print = false;
        break;
    }
    else {
        print = true;
    }
}

for(long x : primes) {

sub hanoi(Int $n where $n>=0) {
    sub formatted(@pos) {
        my @conv;
        {my @empty; @conv[$_] = @empty;} for 0..2;
        @conv[@pos[$_]].push($_) for 0..$n-1;
        gather for 0..2 -> $i {
            take " ";
            for 0..$n-1 -> $j {
                if ($j < @conv[$i].elems) {
                    take ~@conv[$i][$j];
        } else {
                    take " ";
                }
            }
            take " |";
        }.join("");
    }
    my @positions; @positions[$_-1] = 0 for 1..$n;
    my @pows; @pows[$_] = 2**$_ for 0..$n;
    for 0..2**$n-1 -> $t {
        for 0..$n-1 -> $p {
            @positions[$p] = (@positions[$p]-2*($p%2)+1)%3 if ($t-@pows[$p])%@pows[$p+1]==0;
        }
        say formatted(@positions);
    }
}

 012 |     |     |
 12  | 0   |     |
 2   | 0   | 1   |
 2   |     | 01  |
     | 2   | 01  |
 0   | 2   | 1   |
 0   | 12  |     |
     | 012 |     |

#include <fstream>
#include <string>
#include <cmath>

using namespace std;

void writeCircle(double r, char outside, char border, char inside)
{
    ofstream out("circle.txt");
    size_t rAbs = size_t(round(abs(r))),
           diameter = 2*rAbs;
    for (size_t i = 0; i<=diameter; ++i)
    {
        string circleLine;
        for (size_t j = 0; j<=diameter; ++j)
        {
            double iDiff = double(i)-r,
                   jDiff = double(j)-r;
            size_t ijRad = size_t(round(sqrt(iDiff*iDiff+jDiff*jDiff)));
            circleLine.push_back(
                (ijRad>r) ? outside :
                (ijRad<r) ? inside :
                            border
            );
        }
        out<<circleLine<<endl;
    }
}

___XXXXX___
__X/////X__
_X///////X_
X/////////X
X/////////X
X/////////X
X/////////X
X/////////X
_X///////X_
__X/////X__
___XXXXX___