soyart

package main

import (
	"fmt"
)

func main() {
	r := permutation([]byte("abcdef"))
	for i := range r {
		pront(r[i])

soyart

#include <stdio.h>

void unescape(void);

int main(void)
{
    printf("knr 1-10\n");
    printf("Unescape special characters\n");

    unescape();

soyart

/*
  Rama 9 Sort (rama9sort)

  rama9sort is a highly efficient (and sufficient) sorting algorithm that runs in constant time and space (O(1)).
  
  rama9sort got its inspiration from Stalin Sort (another highly efficient algorithm).
  rama9sort borrows ideas from Stalin Sort - unwanted/unordered elements are discarded right away from the input,
  although rama9sort has some other _unorthodox_ checks to make it more suitable for deployment in Thailand.

  The differences from Stalin Sort are:

soyart

#include <stdio.h>

#define MAXLEN 1000

/* Avoid confilic with stdio.h */
int _getline(char line[], int limit);

int main(void) {
    char line[MAXLEN];
    int i, j, c, len;

soyart

// Generic draw down
fn draw_down<T, U>(points: &[T]) -> U
where
    T: Clone + Into<U>,
    U: Copy + Default + PartialOrd + std::ops::Sub<Output = U>,
{
    if points.len() <= 1 {
        return U::default();
    }

soyart

#![allow(dead_code)]

// Basic Rust `Iterator` and `DoubleEndedIterator` implementation on nested flattener.

struct Flattener<O>
where
    O: Iterator,
    O::Item: IntoIterator,
{
    outter: O,

soyart

package main

import (
	"crypto/rand"
	"fmt"
	"math/big"
	"strings"
	"time"
)

soyart

package main

import (
	"crypto/rand"
	"fmt"
	"math/big"
	"strings"
	"time"
)

soyart

fn get_largest<T: PartialOrd + Copy>(v: Vec<T>) -> T {
    let mut largest = v[0];
    for item in v {
        if largest > item {
            largest = item
        };
    };
    largest
}

soyart

#![allow(dead_code)]
#![allow(unused)]

use std::fs::File;
use std::io::{prelude::*, ErrorKind, Read, BufReader};
use std::io;

fn main() {
    let fname = ".gitignore";