λ - programming

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___