code
stringlengths 1
46.1k
⌀ | label
class label 1.18k
classes | domain_label
class label 21
classes | index
stringlengths 4
5
|
|---|---|---|---|
from __future__ import print_function
class Node(object):
def __init__(self):
self.edges = {}
self.link = None
self.len = 0
class Eertree(object):
def __init__(self):
self.nodes = []
self.rto = Node()
self.rte = Node()
self.rto.link = self.rte.link = self.rto;
self.rto.len = -1
self.rte.len = 0
self.S = [0]
self.maxSufT = self.rte
def get_max_suffix_pal(self, startNode, a):
u = startNode
i = len(self.S)
k = u.len
while id(u) != id(self.rto) and self.S[i - k - 1] != a:
assert id(u) != id(u.link)
u = u.link
k = u.len
return u
def add(self, a):
Q = self.get_max_suffix_pal(self.maxSufT, a)
createANewNode = not a in Q.edges
if createANewNode:
P = Node()
self.nodes.append(P)
P.len = Q.len + 2
if P.len == 1:
P.link = self.rte
else:
P.link = self.get_max_suffix_pal(Q.link, a).edges[a]
Q.edges[a] = P
self.maxSufT = Q.edges[a]
self.S.append(a)
return createANewNode
def get_sub_palindromes(self, nd, nodesToHere, charsToHere, result):
for lnkName in nd.edges:
nd2 = nd.edges[lnkName]
self.get_sub_palindromes(nd2, nodesToHere+[nd2], charsToHere+[lnkName], result)
if id(nd) != id(self.rto) and id(nd) != id(self.rte):
tmp = .join(charsToHere)
if id(nodesToHere[0]) == id(self.rte):
assembled = tmp[::-1] + tmp
else:
assembled = tmp[::-1] + tmp[1:]
result.append(assembled)
if __name__==:
st =
print (, st)
eertree = Eertree()
for ch in st:
eertree.add(ch)
print (, len(eertree.nodes))
result = []
eertree.get_sub_palindromes(eertree.rto, [eertree.rto], [], result)
eertree.get_sub_palindromes(eertree.rte, [eertree.rte], [], result)
print (, result) | 909Eertree
| 3python
| d9in1 |
package main
import (
"fmt"
"net"
"bufio"
)
func echo(s net.Conn, i int) {
defer s.Close();
fmt.Printf("%d:%v <->%v\n", i, s.LocalAddr(), s.RemoteAddr())
b := bufio.NewReader(s)
for {
line, e := b.ReadBytes('\n')
if e != nil {
break
}
s.Write(line)
}
fmt.Printf("%d: closed\n", i)
}
func main() {
l, e := net.Listen("tcp", ":12321")
for i := 0; e == nil; i++ {
var s net.Conn
s, e = l.Accept()
go echo(s, i)
}
} | 907Echo server
| 0go
| dcfne |
null | 911Earliest difference between prime gaps
| 15rust
| iysod |
module Main where
import Network (withSocketsDo, accept, listenOn, sClose, PortID(PortNumber))
import Control.Monad (forever)
import System.IO (hGetLine, hPutStrLn, hFlush, hClose)
import System.IO.Error (isEOFError)
import Control.Concurrent (forkIO)
import Control.Exception (bracket)
withListenOn port body = bracket (listenOn port) sClose body
echo (handle, host, port) = catch (forever doOneLine) stop where
doOneLine = do line <- hGetLine handle
print (host, port, init line)
hPutStrLn handle line
hFlush handle
stop error = do putStrLn $ "Closed connection from " ++ show (host, port) ++ " due to " ++ show error
hClose handle
main = withSocketsDo $
withListenOn (PortNumber 12321) $ \listener ->
forever $ do
acc@(_, host, port) <- accept listener
putStrLn $ "Accepted connection from " ++ show (host, port)
forkIO (echo acc) | 907Echo server
| 8haskell
| 5p4ug |
null | 905Empty program
| 17swift
| 2h5lj |
package main
import (
"fmt"
"math/big"
"math/rand"
"strings"
)
func main() {
const cells = 20
const generations = 9
fmt.Println("Single 1, rule 90:")
a := big.NewInt(1)
a.Lsh(a, cells/2)
elem(90, cells, generations, a)
fmt.Println("Random intial state, rule 30:")
a = big.NewInt(1)
a.Rand(rand.New(rand.NewSource(3)), a.Lsh(a, cells))
elem(30, cells, generations, a)
}
func elem(rule uint, cells, generations int, a *big.Int) {
output := func() {
fmt.Println(strings.Replace(strings.Replace(
fmt.Sprintf("%0*b", cells, a), "0", " ", -1), "1", "#", -1))
}
output()
a1 := new(big.Int)
set := func(cell int, k uint) {
a1.SetBit(a1, cell, rule>>k&1)
}
last := cells - 1
for r := 0; r < generations; r++ {
k := a.Bit(last) | a.Bit(0)<<1 | a.Bit(1)<<2
set(0, k)
for c := 1; c < last; c++ {
k = k>>1 | a.Bit(c+1)<<2
set(c, k)
}
set(last, k>>1|a.Bit(0)<<2)
a, a1 = a1, a
output()
}
} | 910Elementary cellular automaton
| 0go
| 7e4r2 |
package main
import (
"fmt"
"math"
"rcu"
)
func isSquare(n int) bool {
s := int(math.Sqrt(float64(n)))
return s*s == n
}
func main() {
limit := 200000 | 915Duffinian numbers
| 0go
| 0zpsk |
class Node
def initialize(length, edges = {}, suffix = 0)
@length = length
@edges = edges
@suffix = suffix
end
attr_reader :length
attr_reader :edges
attr_accessor :suffix
end
EVEN_ROOT = 0
ODD_ROOT = 1
def eertree(s)
tree = [
Node.new(0, {}, ODD_ROOT),
Node.new(-1, {}, ODD_ROOT)
]
suffix = ODD_ROOT
s.each_char.with_index { |c, i|
n = suffix
k = 0
loop do
k = tree[n].length
b = i - k - 1
if b >= 0 and s[b] == c then
break
end
n = tree[n].suffix
end
if tree[n].edges.key?(c) then
suffix = tree[n].edges[c]
next
end
suffix = tree.length
tree << Node.new(k + 2)
tree[n].edges[c] = suffix
if tree[suffix].length == 1 then
tree[suffix].suffix = 0
next
end
loop do
n = tree[n].suffix
b = i - tree[n].length - 1
if b >= 0 and s[b] == c then
break
end
end
tree[suffix].suffix = tree[n].edges[c]
}
return tree
end
def subPalindromes(tree)
s = []
children = lambda { |n,p,f|
for c,v in tree[n].edges
m = tree[n].edges[c]
p = c + p + c
s << p
f.call(m, p, f)
end
}
children.call(0, '', children)
for c,n in tree[1].edges
s << c
children.call(n, c, children)
end
return s
end
tree = eertree()
print subPalindromes(tree), | 909Eertree
| 14ruby
| tldf2 |
import Data.Array (listArray, (!), bounds, elems)
step rule a = listArray (l,r) res
where (l,r) = bounds a
res = [rule (a!r) (a!l) (a!(l+1)) ] ++
[rule (a!(i-1)) (a!i) (a!(i+1)) | i <- [l+1..r-1] ] ++
[rule (a!(r-1)) (a!r) (a!l) ]
runCA rule = iterate (step rule) | 910Elementary cellular automaton
| 8haskell
| 83q0z |
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
public class EchoServer {
public static void main(String[] args) throws IOException {
try (ServerSocket listener = new ServerSocket(12321)) {
while (true) {
Socket conn = listener.accept();
Thread clientThread = new Thread(() -> handleClient(conn));
clientThread.start();
}
}
}
private static void handleClient(Socket connArg) {
Charset utf8 = StandardCharsets.UTF_8;
try (Socket conn = connArg) {
BufferedReader in = new BufferedReader(
new InputStreamReader(conn.getInputStream(), utf8));
PrintWriter out = new PrintWriter(
new OutputStreamWriter(conn.getOutputStream(), utf8),
true);
String line;
while ((line = in.readLine()) != null) {
out.println(line);
}
} catch (IOException e) {
e.printStackTrace();
}
}
} | 907Echo server
| 9java
| 9rcmu |
struct Interval {
int start, end;
bool print;
};
int main() {
struct Interval intervals[] = {
{2, 1000, true},
{1000, 4000, true},
{2, 10000, false},
{2, 100000, false},
{2, 1000000, false},
{2, 10000000, false},
{2, 100000000, false},
{2, 1000000000, false},
};
int idx;
for (idx = 0; idx < ARRAY_LEN(intervals, struct Interval); ++idx) {
struct Interval intv = intervals[idx];
int count = 0, i;
if (intv.start == 2) {
printf(, intv.end);
} else {
printf(, intv.start, intv.end);
}
for (i = intv.start; i <= intv.end; i += 2) {
int b = i / 1000000000;
int r = i % 1000000000;
int m = r / 1000000;
int t;
r = i % 1000000;
t = r / 1000;
r %= 1000;
if (m >= 30 && m <= 66) m %= 10;
if (t >= 30 && t <= 66) t %= 10;
if (r >= 30 && r <= 66) r %= 10;
if (b == 0 || b == 2 || b == 4 || b == 6) {
if (m == 0 || m == 2 || m == 4 || m == 6) {
if (t == 0 || t == 2 || t == 4 || t == 6) {
if (r == 0 || r == 2 || r == 4 || r == 6) {
if (intv.print) printf(, i);
count++;
}
}
}
}
}
if (intv.print) {
printf();
}
printf(, count);
}
return 0;
} | 916Eban numbers
| 5c
| g1m45 |
use strict;
use warnings;
use feature <say state>;
use List::Util 'max';
use ntheory qw<divisor_sum is_prime gcd>;
sub table { my $t = shift() * (my $c = 1 + max map {length} @_); ( sprintf( ('%'.$c.'s')x@_, @_) ) =~ s/.{1,$t}\K/\n/gr }
sub duffinian {
my($n) = @_;
state $c = 1; state @D;
do { push @D, $c if ! is_prime ++$c and 1 == gcd($c,divisor_sum($c)) } until @D > $n;
$D[$n];
}
say "First 50 Duffinian numbers:";
say table 10, map { duffinian $_-1 } 1..50;
my(@d3,@triples) = (4, 8, 9); my $n = 3;
while (@triples < 39) {
push @triples, '('.join(', ',@d3).')' if $d3[1] == 1+$d3[0] and $d3[2] == 2+$d3[0];
shift @d3 and push @d3, duffinian ++$n;
}
say 'First 39 Duffinian triplets:';
say table 3, @triples; | 915Duffinian numbers
| 2perl
| racgd |
(eval `(def ~(symbol (read)) 42)) | 917Dynamic variable names
| 6clojure
| g1y4f |
import java.awt.*;
import java.awt.event.ActionEvent;
import javax.swing.*;
import javax.swing.Timer;
public class WolframCA extends JPanel {
final int[] ruleSet = {30, 45, 50, 57, 62, 70, 73, 75, 86, 89, 90, 99,
101, 105, 109, 110, 124, 129, 133, 135, 137, 139, 141, 164,170, 232};
byte[][] cells;
int rule = 0;
public WolframCA() {
Dimension dim = new Dimension(900, 450);
setPreferredSize(dim);
setBackground(Color.white);
setFont(new Font("SansSerif", Font.BOLD, 28));
cells = new byte[dim.height][dim.width];
cells[0][dim.width / 2] = 1;
new Timer(5000, (ActionEvent e) -> {
rule++;
if (rule == ruleSet.length)
rule = 0;
repaint();
}).start();
}
private byte rules(int lhs, int mid, int rhs) {
int idx = (lhs << 2 | mid << 1 | rhs);
return (byte) (ruleSet[rule] >> idx & 1);
}
void drawCa(Graphics2D g) {
g.setColor(Color.black);
for (int r = 0; r < cells.length - 1; r++) {
for (int c = 1; c < cells[r].length - 1; c++) {
byte lhs = cells[r][c - 1];
byte mid = cells[r][c];
byte rhs = cells[r][c + 1];
cells[r + 1][c] = rules(lhs, mid, rhs); | 910Elementary cellular automaton
| 9java
| eipa5 |
const net = require('net');
function handleClient(conn) {
console.log('Connection from ' + conn.remoteAddress + ' on port ' + conn.remotePort);
conn.setEncoding('utf-8');
let buffer = '';
function handleData(data) {
for (let i = 0; i < data.length; i++) {
const char = data.charAt(i);
buffer += char;
if (char === '\n') {
conn.write(buffer);
buffer = '';
}
}
}
conn.on('data', handleData);
}
net.createServer(handleClient).listen(12321, 'localhost'); | 907Echo server
| 10javascript
| ub5vb |
const alive = '#';
const dead = '.'; | 910Elementary cellular automaton
| 10javascript
| 0zxsz |
import java.net.ServerSocket
import java.net.Socket
fun main() {
fun handleClient(conn: Socket) {
conn.use {
val input = conn.inputStream.bufferedReader()
val output = conn.outputStream.bufferedWriter()
input.forEachLine { line ->
output.write(line)
output.newLine()
output.flush()
}
}
}
ServerSocket(12321).use { listener ->
while (true) {
val conn = listener.accept()
Thread { handleClient(conn) }.start()
}
}
} | 907Echo server
| 11kotlin
| zv3ts |
package element
import (
"fmt"
"math"
)
type Matrix struct {
ele []float64
stride int
}
func MatrixFromRows(rows [][]float64) Matrix {
if len(rows) == 0 {
return Matrix{nil, 0}
}
m := Matrix{make([]float64, len(rows)*len(rows[0])), len(rows[0])}
for rx, row := range rows {
copy(m.ele[rx*m.stride:(rx+1)*m.stride], row)
}
return m
}
func like(m Matrix) Matrix {
return Matrix{make([]float64, len(m.ele)), m.stride}
}
func (m Matrix) String() string {
s := ""
for e := 0; e < len(m.ele); e += m.stride {
s += fmt.Sprintf("%6.3f \n", m.ele[e:e+m.stride])
}
return s
}
type binaryFunc64 func(float64, float64) float64
func elementWiseMM(m1, m2 Matrix, f binaryFunc64) Matrix {
z := like(m1)
for i, m1e := range m1.ele {
z.ele[i] = f(m1e, m2.ele[i])
}
return z
}
func elementWiseMS(m Matrix, s float64, f binaryFunc64) Matrix {
z := like(m)
for i, e := range m.ele {
z.ele[i] = f(e, s)
}
return z
}
func add(a, b float64) float64 { return a + b }
func sub(a, b float64) float64 { return a - b }
func mul(a, b float64) float64 { return a * b }
func div(a, b float64) float64 { return a / b }
func exp(a, b float64) float64 { return math.Pow(a, b) }
func AddMatrix(m1, m2 Matrix) Matrix { return elementWiseMM(m1, m2, add) }
func SubMatrix(m1, m2 Matrix) Matrix { return elementWiseMM(m1, m2, sub) }
func MulMatrix(m1, m2 Matrix) Matrix { return elementWiseMM(m1, m2, mul) }
func DivMatrix(m1, m2 Matrix) Matrix { return elementWiseMM(m1, m2, div) }
func ExpMatrix(m1, m2 Matrix) Matrix { return elementWiseMM(m1, m2, exp) }
func AddScalar(m Matrix, s float64) Matrix { return elementWiseMS(m, s, add) }
func SubScalar(m Matrix, s float64) Matrix { return elementWiseMS(m, s, sub) }
func MulScalar(m Matrix, s float64) Matrix { return elementWiseMS(m, s, mul) }
func DivScalar(m Matrix, s float64) Matrix { return elementWiseMS(m, s, div) }
func ExpScalar(m Matrix, s float64) Matrix { return elementWiseMS(m, s, exp) } | 912Element-wise operations
| 0go
| l76cw |
package main
import (
"fmt"
"math/big"
"strings"
)
var zero = new(big.Int)
var one = big.NewInt(1)
func toEgyptianRecursive(br *big.Rat, fracs []*big.Rat) []*big.Rat {
if br.Num().Cmp(zero) == 0 {
return fracs
}
iquo := new(big.Int)
irem := new(big.Int)
iquo.QuoRem(br.Denom(), br.Num(), irem)
if irem.Cmp(zero) > 0 {
iquo.Add(iquo, one)
}
rquo := new(big.Rat).SetFrac(one, iquo)
fracs = append(fracs, rquo)
num2 := new(big.Int).Neg(br.Denom())
num2.Rem(num2, br.Num())
if num2.Cmp(zero) < 0 {
num2.Add(num2, br.Num())
}
denom2 := new(big.Int)
denom2.Mul(br.Denom(), iquo)
f := new(big.Rat).SetFrac(num2, denom2)
if f.Num().Cmp(one) == 0 {
fracs = append(fracs, f)
return fracs
}
fracs = toEgyptianRecursive(f, fracs)
return fracs
}
func toEgyptian(rat *big.Rat) []*big.Rat {
if rat.Num().Cmp(zero) == 0 {
return []*big.Rat{rat}
}
var fracs []*big.Rat
if rat.Num().CmpAbs(rat.Denom()) >= 0 {
iquo := new(big.Int)
iquo.Quo(rat.Num(), rat.Denom())
rquo := new(big.Rat).SetFrac(iquo, one)
rrem := new(big.Rat)
rrem.Sub(rat, rquo)
fracs = append(fracs, rquo)
fracs = toEgyptianRecursive(rrem, fracs)
} else {
fracs = toEgyptianRecursive(rat, fracs)
}
return fracs
}
func main() {
fracs := []*big.Rat{big.NewRat(43, 48), big.NewRat(5, 121), big.NewRat(2014, 59)}
for _, frac := range fracs {
list := toEgyptian(frac)
if list[0].Denom().Cmp(one) == 0 {
first := fmt.Sprintf("[%v]", list[0].Num())
temp := make([]string, len(list)-1)
for i := 1; i < len(list); i++ {
temp[i-1] = list[i].String()
}
rest := strings.Join(temp, " + ")
fmt.Printf("%v ->%v +%s\n", frac, first, rest)
} else {
temp := make([]string, len(list))
for i := 0; i < len(list); i++ {
temp[i] = list[i].String()
}
all := strings.Join(temp, " + ")
fmt.Printf("%v ->%s\n", frac, all)
}
}
for _, r := range [2]int{98, 998} {
if r == 98 {
fmt.Println("\nFor proper fractions with 1 or 2 digits:")
} else {
fmt.Println("\nFor proper fractions with 1, 2 or 3 digits:")
}
maxSize := 0
var maxSizeFracs []*big.Rat
maxDen := zero
var maxDenFracs []*big.Rat
var sieve = make([][]bool, r+1) | 913Egyptian fractions
| 0go
| 187p5 |
def halve(x) x/2 end
def double(x) x*2 end
def ethiopian_multiply(a, b)
product = 0
while a >= 1
p [a, b, a.even?? : ] if $DEBUG
product += b unless a.even?
a = halve(a)
b = double(b)
end
product
end
def rec_ethiopian_multiply(a, b)
return 0 if a < 1
p [a, b, a.even?? : ] if $DEBUG
(a.even?? 0: b) + rec_ethiopian_multiply(halve(a), double(b))
end
$DEBUG = true
a, b = 20, 5
puts ; puts | 901Ethiopian multiplication
| 14ruby
| im6oh |
null | 910Elementary cellular automaton
| 11kotlin
| kq7h3 |
class NaiveMatrix {
List<List<Number>> contents = []
NaiveMatrix(Iterable<Iterable<Number>> elements) {
contents.addAll(elements.collect{ row -> row.collect{ cell -> cell } })
assertWellFormed()
}
void assertWellFormed() {
assert contents != null
assert contents.size() > 0
def nCols = contents[0].size()
assert nCols > 0
assert contents.every { it != null && it.size() == nCols }
}
Map getOrder() { [r: contents.size() , c: contents[0].size()] }
void assertConformable(NaiveMatrix that) { assert this.order == that.order }
NaiveMatrix unaryOp(Closure op) {
new NaiveMatrix(contents.collect{ row -> row.collect{ cell -> op(cell) } } )
}
NaiveMatrix binaryOp(NaiveMatrix m, Closure op) {
assertConformable(m)
new NaiveMatrix(
(0..<(this.order.r)).collect{ i ->
(0..<(this.order.c)).collect{ j -> op(this.contents[i][j],m.contents[i][j]) }
}
)
}
NaiveMatrix binaryOp(Number n, Closure op) {
assert n != null
new NaiveMatrix(contents.collect{ row -> row.collect{ cell -> op(cell,n) } } )
}
def plus = this.&binaryOp.rcurry { a, b -> a+b }
def minus = this.&binaryOp.rcurry { a, b -> a-b }
def multiply = this.&binaryOp.rcurry { a, b -> a*b }
def div = this.&binaryOp.rcurry { a, b -> a/b }
def mod = this.&binaryOp.rcurry { a, b -> a%b }
def power = this.&binaryOp.rcurry { a, b -> a**b }
def negative = this.&unaryOp.curry { - it }
def recip = this.&unaryOp.curry { 1/it }
String toString() {
contents.toString()
}
boolean equals(Object other) {
if (other == null || ! other instanceof NaiveMatrix) return false
def that = other as NaiveMatrix
this.contents == that.contents
}
int hashCode() {
contents.hashCode()
}
} | 912Element-wise operations
| 7groovy
| 6ud3o |
import Data.Ratio (Ratio, (%), denominator, numerator)
egyptianFraction :: Integral a => Ratio a -> [Ratio a]
egyptianFraction n
| n < 0 = map negate (egyptianFraction (-n))
| n == 0 = []
| x == 1 = [n]
| x > y = (x `div` y % 1): egyptianFraction (x `mod` y % y)
| otherwise = (1 % r): egyptianFraction ((-y) `mod` x % (y * r))
where
x = numerator n
y = denominator n
r = y `div` x + 1 | 913Egyptian fractions
| 8haskell
| tl8f7 |
fn double(a: i32) -> i32 {
2*a
}
fn halve(a: i32) -> i32 {
a/2
}
fn is_even(a: i32) -> bool {
a% 2 == 0
}
fn ethiopian_multiplication(mut x: i32, mut y: i32) -> i32 {
let mut sum = 0;
while x >= 1 {
print!("{} \t {}", x, y);
match is_even(x) {
true => println!("\t Not Kept"),
false => {
println!("\t Kept");
sum += y;
}
}
x = halve(x);
y = double(y);
}
sum
}
fn main() {
let output = ethiopian_multiplication(17, 34);
println!("---------------------------------");
println!("\t {}", output);
} | 901Ethiopian multiplication
| 15rust
| n9yi4 |
local CA = {
state = "..............................#..............................",
bstr = { [0]="...", "..#", ".#.", ".##", "#..", "#.#", "##.", "###" },
new = function(self, rule)
local inst = setmetatable({rule=rule}, self)
for b = 0,7 do
inst[inst.bstr[b]] = rule%2==0 and "." or "#"
rule = math.floor(rule/2)
end
return inst
end,
evolve = function(self)
local n, state, newstate = #self.state, self.state, ""
for i = 1,n do
local nbhd = state:sub((i+n-2)%n+1,(i+n-2)%n+1) .. state:sub(i,i) .. state:sub(i%n+1,i%n+1)
newstate = newstate .. self[nbhd]
end
self.state = newstate
end,
}
CA.__index = CA
ca = { CA:new(18), CA:new(30), CA:new(73), CA:new(129) }
for i = 1, 63 do
print(string.format("%-66s%-66s%-66s%-61s", ca[1].state, ca[2].state, ca[3].state, ca[4].state))
for j = 1, 4 do ca[j]:evolve() end
end | 910Elementary cellular automaton
| 1lua
| bsjka |
local socket = require("socket")
local function has_value(tab, value)
for i, v in ipairs(tab) do
if v == value then return i end
end
return false
end
local function checkOn(client)
local line, err = client:receive()
if line then
client:send(line .. "\n")
end
if err and err ~= "timeout" then
print(tostring(client) .. " " .. err)
client:close()
return true | 907Echo server
| 1lua
| 3u6zo |
import Data.Array (Array, Ix)
import Data.Array.Base
zipWithA :: (IArray arr a, IArray arr b, IArray arr c, Ix i) =>
(a -> b -> c) -> arr i a -> arr i b -> arr i c
zipWithA f a b =
case bounds a of
ba ->
if ba /= bounds b
then error "elemwise: bounds mismatch"
else
let n = numElements a
in unsafeArray ba [ (i, f (unsafeAt a i) (unsafeAt b i))
| i <- [0 .. n - 1]]
type ElemOp a b c = (IArray arr a, IArray arr b, IArray arr c, Ix i) =>
arr i a -> arr i b -> arr i c
type ElemOp1 a = ElemOp a a a
infixl 6 +:, -:
infixl 7 *:, /:, `divE`
(+:), (-:), (*:) :: (Num a) => ElemOp1 a
(+:) = zipWithA (+)
(-:) = zipWithA (-)
(*:) = zipWithA (*)
divE :: (Integral a) => ElemOp1 a
divE = zipWithA div
(/:) :: (Fractional a) => ElemOp1 a
(/:) = zipWithA (/)
infixr 8 ^:, **:, ^^:
(^:) :: (Num a, Integral b) => ElemOp a b a
(^:) = zipWithA (^)
(**:) :: (Floating a) => ElemOp1 a
(**:) = zipWithA (**)
(^^:) :: (Fractional a, Integral b) => ElemOp a b a
(^^:) = zipWithA (^^)
type ScalarOp a b c = (IArray arr a, IArray arr c, Ix i) =>
arr i a -> b -> arr i c
type ScalarOp1 a = ScalarOp a a a
samap :: (IArray arr a, IArray arr c, Ix i) =>
(a -> b -> c) -> arr i a -> b -> arr i c
samap f a s = amap (`f` s) a
infixl 6 +., -.
infixl 7 *., /., `divS`
(+.), (-.), (*.) :: (Num a) => ScalarOp1 a
(+.) = samap (+)
(-.) = samap (-)
(*.) = samap (*)
divS :: (Integral a) => ScalarOp1 a
divS = samap div
(/.) :: (Fractional a) => ScalarOp1 a
(/.) = samap (/)
infixr 8 ^., **., ^^.
(^.) :: (Num a, Integral b) => ScalarOp a b a
(^.) = samap (^)
(**.) :: (Floating a) => ScalarOp1 a
(**.) = samap (**)
(^^.) :: (Fractional a, Integral b) => ScalarOp a b a
(^^.) = samap (^^)
main :: IO ()
main = do
let m1, m2 :: (forall a. (Enum a, Num a) => Array (Int, Int) a)
m1 = listArray ((0, 0), (2, 3)) [1..]
m2 = listArray ((0, 0), (2, 3)) [10..]
s :: (forall a. Num a => a)
s = 99
putStrLn "m1"
print m1
putStrLn "m2"
print m2
putStrLn "s"
print s
putStrLn "m1 + m2"
print $ m1 +: m2
putStrLn "m1 - m2"
print $ m1 -: m2
putStrLn "m1 * m2"
print $ m1 *: m2
putStrLn "m1 `div` m2"
print $ m1 `divE` m2
putStrLn "m1 / m2"
print $ m1 /: m2
putStrLn "m1 ^ m2"
print $ m1 ^: m2
putStrLn "m1 ** m2"
print $ m1 **: m2
putStrLn "m1 ^^ m2"
print $ m1 ^^: m2
putStrLn "m1 + s"
print $ m1 +. s
putStrLn "m1 - s"
print $ m1 -. s
putStrLn "m1 * s"
print $ m1 *. s
putStrLn "m1 `div` s"
print $ m1 `divS` s
putStrLn "m1 / s"
print $ m1 /. s
putStrLn "m1 ^ s"
print $ m1 ^. s
putStrLn "m1 ** s"
print $ m1 **. s
putStrLn "m1 ^^ s"
print $ m1 ^^. s | 912Element-wise operations
| 8haskell
| 18jps |
package main
import "fmt"
func egyptianDivide(dividend, divisor int) (quotient, remainder int) {
if dividend < 0 || divisor <= 0 {
panic("Invalid argument(s)")
}
if dividend < divisor {
return 0, dividend
}
powersOfTwo := []int{1}
doublings := []int{divisor}
doubling := divisor
for {
doubling *= 2
if doubling > dividend {
break
}
l := len(powersOfTwo)
powersOfTwo = append(powersOfTwo, powersOfTwo[l-1]*2)
doublings = append(doublings, doubling)
}
answer := 0
accumulator := 0
for i := len(doublings) - 1; i >= 0; i-- {
if accumulator+doublings[i] <= dividend {
accumulator += doublings[i]
answer += powersOfTwo[i]
if accumulator == dividend {
break
}
}
}
return answer, dividend - accumulator
}
func main() {
dividend := 580
divisor := 34
quotient, remainder := egyptianDivide(dividend, divisor)
fmt.Println(dividend, "divided by", divisor, "is", quotient, "with remainder", remainder)
} | 914Egyptian division
| 0go
| stpqa |
package main
import "fmt"
type Range struct {
start, end uint64
print bool
}
func main() {
rgs := []Range{
{2, 1000, true},
{1000, 4000, true},
{2, 1e4, false},
{2, 1e5, false},
{2, 1e6, false},
{2, 1e7, false},
{2, 1e8, false},
{2, 1e9, false},
}
for _, rg := range rgs {
if rg.start == 2 {
fmt.Printf("eban numbers up to and including%d:\n", rg.end)
} else {
fmt.Printf("eban numbers between%d and%d (inclusive):\n", rg.start, rg.end)
}
count := 0
for i := rg.start; i <= rg.end; i += 2 {
b := i / 1000000000
r := i % 1000000000
m := r / 1000000
r = i % 1000000
t := r / 1000
r %= 1000
if m >= 30 && m <= 66 {
m %= 10
}
if t >= 30 && t <= 66 {
t %= 10
}
if r >= 30 && r <= 66 {
r %= 10
}
if b == 0 || b == 2 || b == 4 || b == 6 {
if m == 0 || m == 2 || m == 4 || m == 6 {
if t == 0 || t == 2 || t == 4 || t == 6 {
if r == 0 || r == 2 || r == 4 || r == 6 {
if rg.print {
fmt.Printf("%d ", i)
}
count++
}
}
}
}
}
if rg.print {
fmt.Println()
}
fmt.Println("count =", count, "\n")
}
} | 916Eban numbers
| 0go
| iyaog |
package main
import (
"bufio"
"fmt"
"log"
"os"
"strconv"
"strings"
)
func check(err error) {
if err != nil {
log.Fatal(err)
}
}
func main() {
scanner := bufio.NewScanner(os.Stdin)
n := 0
for n < 1 || n > 5 {
fmt.Print("How many integer variables do you want to create (max 5): ")
scanner.Scan()
n, _ = strconv.Atoi(scanner.Text())
check(scanner.Err())
}
vars := make(map[string]int)
fmt.Println("OK, enter the variable names and their values, below")
for i := 1; i <= n; {
fmt.Println("\n Variable", i)
fmt.Print(" Name : ")
scanner.Scan()
name := scanner.Text()
check(scanner.Err())
if _, ok := vars[name]; ok {
fmt.Println(" Sorry, you've already created a variable of that name, try again")
continue
}
var value int
var err error
for {
fmt.Print(" Value: ")
scanner.Scan()
value, err = strconv.Atoi(scanner.Text())
check(scanner.Err())
if err != nil {
fmt.Println(" Not a valid integer, try again")
} else {
break
}
}
vars[name] = value
i++
}
fmt.Println("\nEnter q to quit")
for {
fmt.Print("\nWhich variable do you want to inspect: ")
scanner.Scan()
name := scanner.Text()
check(scanner.Err())
if s := strings.ToLower(name); s == "q" {
return
}
v, ok := vars[name]
if !ok {
fmt.Println("Sorry there's no variable of that name, try again")
} else {
fmt.Println("It's value is", v)
}
}
} | 917Dynamic variable names
| 0go
| qfjxz |
int main()
{
initwindow(320,240,);
putpixel(100,100,RED);
getch();
return 0;
} | 918Draw a pixel
| 5c
| nm1i6 |
class EgyptianDivision {
static void main(String[] args) {
divide(580, 34)
}
static void divide(int dividend, int divisor) {
List<Integer> powersOf2 = new ArrayList<>()
List<Integer> doublings = new ArrayList<>() | 914Egyptian division
| 7groovy
| ao71p |
import java.math.BigDecimal;
import java.math.BigInteger;
import java.math.MathContext;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class EgyptianFractions {
private static BigInteger gcd(BigInteger a, BigInteger b) {
if (b.equals(BigInteger.ZERO)) {
return a;
}
return gcd(b, a.mod(b));
}
private static class Frac implements Comparable<Frac> {
private BigInteger num, denom;
public Frac(BigInteger n, BigInteger d) {
if (d.equals(BigInteger.ZERO)) {
throw new IllegalArgumentException("Parameter d may not be zero.");
}
BigInteger nn = n;
BigInteger dd = d;
if (nn.equals(BigInteger.ZERO)) {
dd = BigInteger.ONE;
} else if (dd.compareTo(BigInteger.ZERO) < 0) {
nn = nn.negate();
dd = dd.negate();
}
BigInteger g = gcd(nn, dd).abs();
if (g.compareTo(BigInteger.ZERO) > 0) {
nn = nn.divide(g);
dd = dd.divide(g);
}
num = nn;
denom = dd;
}
public Frac(int n, int d) {
this(BigInteger.valueOf(n), BigInteger.valueOf(d));
}
public Frac plus(Frac rhs) {
return new Frac(
num.multiply(rhs.denom).add(denom.multiply(rhs.num)),
rhs.denom.multiply(denom)
);
}
public Frac unaryMinus() {
return new Frac(num.negate(), denom);
}
public Frac minus(Frac rhs) {
return plus(rhs.unaryMinus());
}
@Override
public int compareTo(Frac rhs) {
BigDecimal diff = this.toBigDecimal().subtract(rhs.toBigDecimal());
if (diff.compareTo(BigDecimal.ZERO) < 0) {
return -1;
}
if (BigDecimal.ZERO.compareTo(diff) < 0) {
return 1;
}
return 0;
}
@Override
public boolean equals(Object obj) {
if (null == obj || !(obj instanceof Frac)) {
return false;
}
Frac rhs = (Frac) obj;
return compareTo(rhs) == 0;
}
@Override
public String toString() {
if (denom.equals(BigInteger.ONE)) {
return num.toString();
}
return String.format("%s/%s", num, denom);
}
public BigDecimal toBigDecimal() {
BigDecimal bdn = new BigDecimal(num);
BigDecimal bdd = new BigDecimal(denom);
return bdn.divide(bdd, MathContext.DECIMAL128);
}
public List<Frac> toEgyptian() {
if (num.equals(BigInteger.ZERO)) {
return Collections.singletonList(this);
}
List<Frac> fracs = new ArrayList<>();
if (num.abs().compareTo(denom.abs()) >= 0) {
Frac div = new Frac(num.divide(denom), BigInteger.ONE);
Frac rem = this.minus(div);
fracs.add(div);
toEgyptian(rem.num, rem.denom, fracs);
} else {
toEgyptian(num, denom, fracs);
}
return fracs;
}
public void toEgyptian(BigInteger n, BigInteger d, List<Frac> fracs) {
if (n.equals(BigInteger.ZERO)) {
return;
}
BigDecimal n2 = new BigDecimal(n);
BigDecimal d2 = new BigDecimal(d);
BigDecimal[] divRem = d2.divideAndRemainder(n2, MathContext.UNLIMITED);
BigInteger div = divRem[0].toBigInteger();
if (divRem[1].compareTo(BigDecimal.ZERO) > 0) {
div = div.add(BigInteger.ONE);
}
fracs.add(new Frac(BigInteger.ONE, div));
BigInteger n3 = d.negate().mod(n);
if (n3.compareTo(BigInteger.ZERO) < 0) {
n3 = n3.add(n);
}
BigInteger d3 = d.multiply(div);
Frac f = new Frac(n3, d3);
if (f.num.equals(BigInteger.ONE)) {
fracs.add(f);
return;
}
toEgyptian(f.num, f.denom, fracs);
}
}
public static void main(String[] args) {
List<Frac> fracs = List.of(
new Frac(43, 48),
new Frac(5, 121),
new Frac(2014, 59)
);
for (Frac frac : fracs) {
List<Frac> list = frac.toEgyptian();
Frac first = list.get(0);
if (first.denom.equals(BigInteger.ONE)) {
System.out.printf("%s -> [%s] + ", frac, first);
} else {
System.out.printf("%s ->%s", frac, first);
}
for (int i = 1; i < list.size(); ++i) {
System.out.printf(" +%s", list.get(i));
}
System.out.println();
}
for (Integer r : List.of(98, 998)) {
if (r == 98) {
System.out.println("\nFor proper fractions with 1 or 2 digits:");
} else {
System.out.println("\nFor proper fractions with 1, 2 or 3 digits:");
}
int maxSize = 0;
List<Frac> maxSizeFracs = new ArrayList<>();
BigInteger maxDen = BigInteger.ZERO;
List<Frac> maxDenFracs = new ArrayList<>();
boolean[][] sieve = new boolean[r + 1][];
for (int i = 0; i < r + 1; ++i) {
sieve[i] = new boolean[r + 2];
}
for (int i = 1; i < r; ++i) {
for (int j = i + 1; j < r + 1; ++j) {
if (sieve[i][j]) continue;
Frac f = new Frac(i, j);
List<Frac> list = f.toEgyptian();
int listSize = list.size();
if (listSize > maxSize) {
maxSize = listSize;
maxSizeFracs.clear();
maxSizeFracs.add(f);
} else if (listSize == maxSize) {
maxSizeFracs.add(f);
}
BigInteger listDen = list.get(list.size() - 1).denom;
if (listDen.compareTo(maxDen) > 0) {
maxDen = listDen;
maxDenFracs.clear();
maxDenFracs.add(f);
} else if (listDen.equals(maxDen)) {
maxDenFracs.add(f);
}
if (i < r / 2) {
int k = 2;
while (true) {
if (j * k > r + 1) break;
sieve[i * k][j * k] = true;
k++;
}
}
}
}
System.out.printf(" largest number of items =%s\n", maxSize);
System.out.printf("fraction(s) with this number:%s\n", maxSizeFracs);
String md = maxDen.toString();
System.out.printf(" largest denominator =%s digits, ", md.length());
System.out.printf("%s...%s\n", md.substring(0, 20), md.substring(md.length() - 20, md.length()));
System.out.printf("fraction(s) with this denominator:%s\n", maxDenFracs);
}
}
} | 913Egyptian fractions
| 9java
| 83e06 |
def ethiopian(i:Int, j:Int):Int=
pairIterator(i,j).filter(x=> !isEven(x._1)).map(x=>x._2).foldLeft(0){(x,y)=>x+y}
def ethiopian2(i:Int, j:Int):Int=
pairIterator(i,j).map(x=>if(isEven(x._1)) 0 else x._2).foldLeft(0){(x,y)=>x+y}
def ethiopian3(i:Int, j:Int):Int=
{
var res=0;
for((h,d) <- pairIterator(i,j) if !isEven(h)) res+=d;
res
}
def ethiopian4(i: Int, j: Int): Int = if (i == 1) j else ethiopian(halve(i), double(j)) + (if (isEven(i)) 0 else j)
def isEven(x:Int)=(x&1)==0
def halve(x:Int)=x>>>1
def double(x:Int)=x<<1 | 901Ethiopian multiplication
| 16scala
| t2cfb |
class Main {
private static class Range {
int start
int end
boolean print
Range(int s, int e, boolean p) {
start = s
end = e
print = p
}
}
static void main(String[] args) {
List<Range> rgs = Arrays.asList(
new Range(2, 1000, true),
new Range(1000, 4000, true),
new Range(2, 10_000, false),
new Range(2, 100_000, false),
new Range(2, 1_000_000, false),
new Range(2, 10_000_000, false),
new Range(2, 100_000_000, false),
new Range(2, 1_000_000_000, false)
)
for (Range rg: rgs) {
if (rg.start == 2) {
println("eban numbers up to and including $rg.end")
} else {
println("eban numbers between $rg.start and $rg.end")
}
int count = 0
for (int i = rg.start; i <= rg.end; ++i) {
int b = (int) (i / 1_000_000_000)
int r = i % 1_000_000_000
int m = (int) (r / 1_000_000)
r = i % 1_000_000
int t = (int) (r / 1_000)
r %= 1_000
if (m >= 30 && m <= 66) m %= 10
if (t >= 30 && t <= 66) t %= 10
if (r >= 30 && r <= 66) r %= 10
if (b == 0 || b == 2 || b == 4 || b == 6) {
if (m == 0 || m == 2 || m == 4 || m == 6) {
if (t == 0 || t == 2 || t == 4 || t == 6) {
if (r == 0 || r == 2 || r == 4 || r == 6) {
if (rg.print) {
print("$i ")
}
count++
}
}
}
}
}
if (rg.print) {
println()
}
println("count = $count")
println()
}
}
} | 916Eban numbers
| 7groovy
| qfhxp |
def varname = 'foo'
def value = 42
new GroovyShell(this.binding).evaluate("${varname} = ${value}")
assert foo == 42 | 917Dynamic variable names
| 7groovy
| 185p6 |
data Var a = Var String a deriving Show
main = do
putStrLn "please enter you variable name"
vName <- getLine
let var = Var vName 42
putStrLn $ "this is your variable: " ++ show var | 917Dynamic variable names
| 8haskell
| m4oyf |
import Data.List (unfoldr)
egyptianQuotRem :: Integer -> Integer -> (Integer, Integer)
egyptianQuotRem m n =
let expansion (i, x)
| x > m = Nothing
| otherwise = Just ((i, x), (i + i, x + x))
collapse (i, x) (q, r)
| x < r = (q + i, r - x)
| otherwise = (q, r)
in foldr collapse (0, m) $ unfoldr expansion (1, n)
main :: IO ()
main = print $ egyptianQuotRem 580 34 | 914Egyptian division
| 8haskell
| 9gfmo |
use strict;
use warnings;
package Automaton {
sub new {
my $class = shift;
my $rule = [ reverse split //, sprintf "%08b", shift ];
return bless { rule => $rule, cells => [ @_ ] }, $class;
}
sub next {
my $this = shift;
my @previous = @{$this->{cells}};
$this->{cells} = [
@{$this->{rule}}[
map {
4*$previous[($_ - 1) % @previous]
+ 2*$previous[$_]
+ $previous[($_ + 1) % @previous]
} 0 .. @previous - 1
]
];
return $this;
}
use overload
q{""} => sub {
my $this = shift;
join '', map { $_ ? '
};
}
my @a = map 0, 1 .. 91; $a[45] = 1;
my $a = Automaton->new(90, @a);
for (1..40) {
print "|$a|\n"; $a->next;
} | 910Elementary cellular automaton
| 2perl
| 3vfzs |
import Data.List (intercalate)
import Text.Printf (printf)
import Data.List.Split (chunksOf)
isEban :: Int -> Bool
isEban n = all (`elem` [0, 2, 4, 6]) z
where
(b, r1) = n `quotRem` (10 ^ 9)
(m, r2) = r1 `quotRem` (10 ^ 6)
(t, r3) = r2 `quotRem` (10 ^ 3)
z = b: map (\x -> if x >= 30 && x <= 66 then x `mod` 10 else x) [m, t, r3]
ebans = map f
where
f x = (thousands x, thousands $ length $ filter isEban [1..x])
thousands:: Int -> String
thousands = reverse . intercalate "," . chunksOf 3 . reverse . show
main :: IO ()
main = do
uncurry (printf "eban numbers up to and including 1000:%2s\n%s\n\n") $ r [1..1000]
uncurry (printf "eban numbers between 1000 and 4000:%2s\n%s\n\n") $ r [1000..4000]
mapM_ (uncurry (printf "eban numbers up and including%13s:%5s\n")) ebanCounts
where
ebanCounts = ebans [ 10_000
, 100_000
, 1_000_000
, 10_000_000
, 100_000_000
, 1_000_000_000 ]
r = ((,) <$> thousands . length <*> show) . filter isEban | 916Eban numbers
| 8haskell
| vhz2k |
double rot = 0;
float matCol[] = {1,0,0,0};
void display(){
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
glPushMatrix();
glRotatef(30,1,1,0);
glRotatef(rot,0,1,1);
glMaterialfv(GL_FRONT,GL_DIFFUSE,matCol);
glutWireCube(1);
glPopMatrix();
glFlush();
}
void onIdle(){
rot += 0.1;
glutPostRedisplay();
}
void reshape(int w,int h){
float ar = (float) w / (float) h ;
glViewport(0,0,(GLsizei)w,(GLsizei)h);
glTranslatef(0,0,-10);
glMatrixMode(GL_PROJECTION);
gluPerspective(70,(GLfloat)w/(GLfloat)h,1,12);
glLoadIdentity();
glFrustum ( -1.0, 1.0, -1.0, 1.0, 10.0, 100.0 ) ;
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
}
void init(){
float pos[] = {1,1,1,0};
float white[] = {1,1,1,0};
float shini[] = {70};
glClearColor(.5,.5,.5,0);
glShadeModel(GL_SMOOTH);
glLightfv(GL_LIGHT0,GL_AMBIENT,white);
glLightfv(GL_LIGHT0,GL_DIFFUSE,white);
glMaterialfv(GL_FRONT,GL_SHININESS,shini);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glEnable(GL_DEPTH_TEST);
}
int main(int argC, char* argV[])
{
glutInit(&argC,argV);
glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB|GLUT_DEPTH);
glutInitWindowSize(600,500);
glutCreateWindow();
init();
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutIdleFunc(onIdle);
glutMainLoop();
return 0;
} | 919Draw a rotating cube
| 5c
| jwm70 |
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.function.BiFunction;
import java.util.stream.Stream;
@SuppressWarnings("serial")
public class ElementWiseOp {
static final Map<String, BiFunction<Double, Double, Double>> OPERATIONS = new HashMap<String, BiFunction<Double, Double, Double>>() {
{
put("add", (a, b) -> a + b);
put("sub", (a, b) -> a - b);
put("mul", (a, b) -> a * b);
put("div", (a, b) -> a / b);
put("pow", (a, b) -> Math.pow(a, b));
put("mod", (a, b) -> a % b);
}
};
public static Double[][] scalarOp(String op, Double[][] matr, Double scalar) {
BiFunction<Double, Double, Double> operation = OPERATIONS.getOrDefault(op, (a, b) -> a);
Double[][] result = new Double[matr.length][matr[0].length];
for (int i = 0; i < matr.length; i++) {
for (int j = 0; j < matr[i].length; j++) {
result[i][j] = operation.apply(matr[i][j], scalar);
}
}
return result;
}
public static Double[][] matrOp(String op, Double[][] matr, Double[][] scalar) {
BiFunction<Double, Double, Double> operation = OPERATIONS.getOrDefault(op, (a, b) -> a);
Double[][] result = new Double[matr.length][Stream.of(matr).mapToInt(a -> a.length).max().getAsInt()];
for (int i = 0; i < matr.length; i++) {
for (int j = 0; j < matr[i].length; j++) {
result[i][j] = operation.apply(matr[i][j], scalar[i % scalar.length][j
% scalar[i % scalar.length].length]);
}
}
return result;
}
public static void printMatrix(Double[][] matr) {
Stream.of(matr).map(Arrays::toString).forEach(System.out::println);
}
public static void main(String[] args) {
printMatrix(scalarOp("mul", new Double[][] {
{ 1.0, 2.0, 3.0 },
{ 4.0, 5.0, 6.0 },
{ 7.0, 8.0, 9.0 }
}, 3.0));
printMatrix(matrOp("div", new Double[][] {
{ 1.0, 2.0, 3.0 },
{ 4.0, 5.0, 6.0 },
{ 7.0, 8.0, 9.0 }
}, new Double[][] {
{ 1.0, 2.0},
{ 3.0, 4.0}
}));
}
} | 912Element-wise operations
| 9java
| 7eurj |
public static void main(String... args){
HashMap<String, Integer> vars = new HashMap<String, Integer>(); | 917Dynamic variable names
| 9java
| fcwdv |
import java.util.ArrayList;
import java.util.List;
public class EgyptianDivision {
public static void main(String[] args) {
divide(580, 34);
}
public static void divide(int dividend, int divisor) {
List<Integer> powersOf2 = new ArrayList<>();
List<Integer> doublings = new ArrayList<>(); | 914Egyptian division
| 9java
| tl0f9 |
null | 913Egyptian fractions
| 11kotlin
| wnkek |
var varname = 'foo'; | 917Dynamic variable names
| 10javascript
| y586r |
(() => {
'use strict'; | 914Egyptian division
| 10javascript
| m4dyv |
import java.util.List;
public class Main {
private static class Range {
int start;
int end;
boolean print;
public Range(int s, int e, boolean p) {
start = s;
end = e;
print = p;
}
}
public static void main(String[] args) {
List<Range> rgs = List.of(
new Range(2, 1000, true),
new Range(1000, 4000, true),
new Range(2, 10_000, false),
new Range(2, 100_000, false),
new Range(2, 1_000_000, false),
new Range(2, 10_000_000, false),
new Range(2, 100_000_000, false),
new Range(2, 1_000_000_000, false)
);
for (Range rg : rgs) {
if (rg.start == 2) {
System.out.printf("eban numbers up to and including%d\n", rg.end);
} else {
System.out.printf("eban numbers between%d and%d\n", rg.start, rg.end);
}
int count = 0;
for (int i = rg.start; i <= rg.end; ++i) {
int b = i / 1_000_000_000;
int r = i % 1_000_000_000;
int m = r / 1_000_000;
r = i % 1_000_000;
int t = r / 1_000;
r %= 1_000;
if (m >= 30 && m <= 66) m %= 10;
if (t >= 30 && t <= 66) t %= 10;
if (r >= 30 && r <= 66) r %= 10;
if (b == 0 || b == 2 || b == 4 || b == 6) {
if (m == 0 || m == 2 || m == 4 || m == 6) {
if (t == 0 || t == 2 || t == 4 || t == 6) {
if (r == 0 || r == 2 || r == 4 || r == 6) {
if (rg.print) System.out.printf("%d ", i);
count++;
}
}
}
}
}
if (rg.print) {
System.out.println();
}
System.out.printf("count =%d\n\n", count);
}
}
} | 916Eban numbers
| 9java
| y5o6g |
null | 917Dynamic variable names
| 11kotlin
| 83b0q |
null | 914Egyptian division
| 11kotlin
| o6e8z |
def eca(cells, rule):
lencells = len(cells)
c = + cells +
rulebits = '{0:08b}'.format(rule)
neighbours2next = {'{0:03b}'.format(n):rulebits[::-1][n] for n in range(8)}
yield c[1:-1]
while True:
c = ''.join(['0',
''.join(neighbours2next[c[i-1:i+2]]
for i in range(1,lencells+1)),
'0'])
yield c[1:-1]
if __name__ == '__main__':
lines, start, rules = 50, '0000000001000000000', (90, 30, 122)
zipped = [range(lines)] + [eca(start, rule) for rule in rules]
print('\n Rules:%r'% (rules,))
for data in zip(*zipped):
i = data[0]
cells = data[1:]
print('%2i:%s'% (i, ' '.join(cells).replace('0', '.').replace('1', ' | 910Elementary cellular automaton
| 3python
| 6ut3w |
use IO::Socket;
my $use_fork = 1;
my $sock = new IO::Socket::INET (
LocalHost => '127.0.0.1',
LocalPort => '12321',
Proto => 'tcp',
Listen => 1,
Reuse => 1,
)
or die "socket: $!";
$SIG{CHLD} = 'IGNORE' if $use_fork;
print "listening...\n";
while (1) {
my $con = $sock->accept()
or die "accept: $!";
fork and next if $use_fork;
print "incoming..\n";
print $con $_ while(<$con>);
print "done\n";
last if $use_fork;
} | 907Echo server
| 2perl
| b0pk4 |
null | 912Element-wise operations
| 11kotlin
| uk9vc |
package main
import (
"fmt"
"image"
"image/color"
"image/draw"
)
func main() {
rect := image.Rect(0, 0, 320, 240)
img := image.NewRGBA(rect) | 918Draw a pixel
| 0go
| raygm |
function egyptian_divmod(dividend,divisor)
local pwrs, dbls = {1}, {divisor}
while dbls[#dbls] <= dividend do
table.insert(pwrs, pwrs[#pwrs] * 2)
table.insert(dbls, pwrs[#pwrs] * divisor)
end
local ans, accum = 0, 0
for i=#pwrs-1,1,-1 do
if accum + dbls[i] <= dividend then
accum = accum + dbls[i]
ans = ans + pwrs[i]
end
end
return ans, math.abs(accum - dividend)
end
local i, j = 580, 34
local d, m = egyptian_divmod(i, j)
print(i.." divided by "..j.." using the Egyptian method is "..d.." remainder "..m) | 914Egyptian division
| 1lua
| iywot |
null | 916Eban numbers
| 11kotlin
| fcxdo |
_G[io.read()] = 5 | 917Dynamic variable names
| 1lua
| o6p8h |
$socket = socket_create(AF_INET,SOCK_STREAM,SOL_TCP);
socket_bind($socket, '127.0.0.1', 12321);
socket_listen($socket);
$client_count = 0;
while (true){
if (($client = socket_accept($socket)) === false) continue;
$client_count++;
$client_name = 'Unknown';
socket_getpeername($client, $client_name);
echo ;
$pid = pcntl_fork();
if($pid == -1) die('Could not fork');
if($pid){
pcntl_waitpid(-1, $status, WNOHANG);
continue;
}
while(true){
if($input = socket_read($client, 1024)){
socket_write($client, $input);
} else {
socket_shutdown($client);
socket_close($client);
echo ;
exit();
}
}
} | 907Echo server
| 12php
| 65y3g |
function makeInterval(s,e,p)
return {start=s, end_=e, print_=p}
end
function main()
local intervals = {
makeInterval( 2, 1000, true),
makeInterval(1000, 4000, true),
makeInterval( 2, 10000, false),
makeInterval( 2, 1000000, false),
makeInterval( 2, 10000000, false),
makeInterval( 2, 100000000, false),
makeInterval( 2, 1000000000, false)
}
for _,intv in pairs(intervals) do
if intv.start == 2 then
print("eban numbers up to and including " .. intv.end_ .. ":")
else
print("eban numbers between " .. intv.start .. " and " .. intv.end_ .. " (inclusive)")
end
local count = 0
for i=intv.start,intv.end_,2 do
local b = math.floor(i / 1000000000)
local r = i % 1000000000
local m = math.floor(r / 1000000)
r = i % 1000000
local t = math.floor(r / 1000)
r = r % 1000
if m >= 30 and m <= 66 then m = m % 10 end
if t >= 30 and t <= 66 then t = t % 10 end
if r >= 30 and r <= 66 then r = r % 10 end
if b == 0 or b == 2 or b == 4 or b == 6 then
if m == 0 or m == 2 or m == 4 or m == 6 then
if t == 0 or t == 2 or t == 4 or t == 6 then
if r == 0 or r == 2 or r == 4 or r == 6 then
if intv.print_ then io.write(i .. " ") end
count = count + 1
end
end
end
end
end
if intv.print_ then
print()
end
print("count = " .. count)
print()
end
end
main() | 916Eban numbers
| 1lua
| tlqfn |
void insert(link* anchor, link* newlink) {
newlink->next = anchor->next;
newlink->prev = anchor;
(newlink->next)->prev = newlink;
anchor->next = newlink;
} | 920Doubly-linked list/Element insertion
| 5c
| aov11 |
import java.awt.Color;
import java.awt.Graphics;
import javax.swing.JFrame;
public class DrawAPixel extends JFrame{
public DrawAPixel() {
super("Red Pixel");
setSize(320, 240);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setVisible(true);
}
@Override
public void paint(Graphics g) {
g.setColor(new Color(255, 0, 0));
g.drawRect(100, 100, 1, 1);
}
public static void main(String[] args) {
new DrawAPixel();
}
} | 918Draw a pixel
| 9java
| ao51y |
sub egyptian_divmod {
my($dividend, $divisor) = @_;
die "Invalid divisor" if $divisor <= 0;
my @table = ($divisor);
push @table, 2*$table[-1] while $table[-1] <= $dividend;
my $accumulator = 0;
for my $k (reverse 0 .. $
next unless $dividend >= $table[$k];
$accumulator += 1 << $k;
$dividend -= $table[$k];
}
$accumulator, $dividend;
}
for ([580,34], [578,34], [7532795332300578,235117]) {
my($n,$d) = @$_;
printf "Egyption divmod%s%%%s =%s remainder%s\n", $n, $d, egyptian_divmod( $n, $d )
} | 914Egyptian division
| 2perl
| g1c4e |
use strict;
use warnings;
use bigint;
sub isEgyption{
my $nr = int($_[0]);
my $de = int($_[1]);
if($nr == 0 or $de == 0){
return;
}
if($de % $nr == 0){
printf "1/" . int($de/$nr);
return;
}
if($nr % $de == 0){
printf $nr/$de;
return;
}
if($nr > $de){
printf int($nr/$de) . " + ";
isEgyption($nr%$de, $de);
return;
}
my $tmp = int($de/$nr) + 1;
printf "1/" . $tmp . " + ";
isEgyption($nr*$tmp-$de, $de*$tmp);
}
my $nrI = 2014;
my $deI = 59;
printf "\nEgyptian Fraction Representation of " . $nrI . "/" . $deI . " is: \n\n";
isEgyption($nrI,$deI); | 913Egyptian fractions
| 2perl
| l73c5 |
class ElemCellAutomat
include Enumerable
def initialize (start_str, rule, disp=false)
@cur = start_str
@patterns = Hash[8.times.map{|i|[%i, [rule[i]]]}]
puts if disp
end
def each
return to_enum unless block_given?
loop do
yield @cur
str = @cur[-1] + @cur + @cur[0]
@cur = @cur.size.times.map {|i| @patterns[str[i,3]]}.join
end
end
end
eca = ElemCellAutomat.new('1'.center(39, ), 18, true)
eca.take(30).each{|line| puts line.tr(, )} | 910Elementary cellular automaton
| 14ruby
| m43yj |
use strict;
use warnings;
use feature 'say';
use Lingua::EN::Numbers qw(num2en);
sub comma { reverse ((reverse shift) =~ s/(.{3})/$1,/gr) =~ s/^,//r }
sub e_ban {
my($power) = @_;
my @n;
for (1..10**$power) {
next unless 0 == $_%2;
next if $_ =~ /[789]/ or /[12].$/ or /[135]..$/ or /[135]...$/ or /[135].....$/;
push @n, $_ unless num2en($_) =~ /e/;
}
@n;
}
my @OK = e_ban(my $max = 7);
my @a = grep { $_ <= 1000 } @OK;
say "Number of eban numbers up to and including 1000: @{[1+$
say join(', ',@a);
say '';
my @b = grep { $_ >= 1000 && $_ <= 4000 } @OK;
say "Number of eban numbers between 1000 and 4000 (inclusive): @{[1+$
say join(', ',@b);
say '';
for my $exp (4..$max) {
my $n = + grep { $_ <= 10**$exp } @OK;
printf "Number of eban numbers and%10s:%d\n", comma(10**$exp), $n;
} | 916Eban numbers
| 2perl
| hx2jl |
package main
import (
"image"
"image/color"
"image/gif"
"log"
"math"
"os"
)
const (
width, height = 640, 640
offset = height / 2
fileName = "rotatingCube.gif"
)
var nodes = [][]float64{{-100, -100, -100}, {-100, -100, 100}, {-100, 100, -100}, {-100, 100, 100},
{100, -100, -100}, {100, -100, 100}, {100, 100, -100}, {100, 100, 100}}
var edges = [][]int{{0, 1}, {1, 3}, {3, 2}, {2, 0}, {4, 5}, {5, 7}, {7, 6},
{6, 4}, {0, 4}, {1, 5}, {2, 6}, {3, 7}}
func main() {
var images []*image.Paletted
fgCol := color.RGBA{0xff, 0x00, 0xff, 0xff}
var palette = []color.Color{color.RGBA{0x00, 0x00, 0x00, 0xff}, fgCol}
var delays []int
imgFile, err := os.Create(fileName)
if err != nil {
log.Fatal(err)
}
defer imgFile.Close()
rotateCube(math.Pi/4, math.Atan(math.Sqrt(2)))
var frame float64
for frame = 0; frame < 360; frame++ {
img := image.NewPaletted(image.Rect(0, 0, width, height), palette)
images = append(images, img)
delays = append(delays, 5)
for _, edge := range edges {
xy1 := nodes[edge[0]]
xy2 := nodes[edge[1]]
drawLine(int(xy1[0])+offset, int(xy1[1])+offset, int(xy2[0])+offset, int(xy2[1])+offset, img, fgCol)
}
rotateCube(math.Pi/180, 0)
}
if err := gif.EncodeAll(imgFile, &gif.GIF{Image: images, Delay: delays}); err != nil {
imgFile.Close()
log.Fatal(err)
}
}
func rotateCube(angleX, angleY float64) {
sinX := math.Sin(angleX)
cosX := math.Cos(angleX)
sinY := math.Sin(angleY)
cosY := math.Cos(angleY)
for _, node := range nodes {
x := node[0]
y := node[1]
z := node[2]
node[0] = x*cosX - z*sinX
node[2] = z*cosX + x*sinX
z = node[2]
node[1] = y*cosY - z*sinY
node[2] = z*cosY + y*sinY
}
}
func drawLine(x0, y0, x1, y1 int, img *image.Paletted, col color.RGBA) {
dx := abs(x1 - x0)
dy := abs(y1 - y0)
var sx, sy int = -1, -1
if x0 < x1 {
sx = 1
}
if y0 < y1 {
sy = 1
}
err := dx - dy
for {
img.Set(x0, y0, col)
if x0 == x1 && y0 == y1 {
break
}
e2 := 2 * err
if e2 > -dy {
err -= dy
x0 += sx
}
if e2 < dx {
err += dx
y0 += sy
}
}
}
func abs(x int) int {
if x < 0 {
return -x
}
return x
} | 919Draw a rotating cube
| 0go
| fcad0 |
(defrecord Node [prev next data])
(defn new-node [prev next data]
(Node. (ref prev) (ref next) data))
(defn new-list [head tail]
(List. (ref head) (ref tail)))
(defn insert-between [node1 node2 new-node]
(dosync
(ref-set (:next node1) new-node)
(ref-set (:prev new-node) node1)
(ref-set (:next new-node) node2)
(ref-set (:prev node2) new-node)))
(set! *print-level* 1)
(let [h (new-node nil nil:A)
t (new-node nil nil:B)]
(insert-between h t (new-node nil nil:C))
(new-list h t)) | 920Doubly-linked list/Element insertion
| 6clojure
| strqr |
null | 918Draw a pixel
| 11kotlin
| hxcj3 |
import Darwin
func ethiopian(var #int1:Int, var #int2:Int) -> Int {
var lhs = [int1], rhs = [int2]
func isEven(#n:Int) -> Bool {return n% 2 == 0}
func double(#n:Int) -> Int {return n * 2}
func halve(#n:Int) -> Int {return n / 2}
while int1!= 1 {
lhs.append(halve(n: int1))
rhs.append(double(n: int2))
int1 = halve(n: int1)
int2 = double(n: int2)
}
var returnInt = 0
for (a,b) in zip(lhs, rhs) {
if (!isEven(n: a)) {
returnInt += b
}
}
return returnInt
}
println(ethiopian(int1: 17, int2: 34)) | 901Ethiopian multiplication
| 17swift
| oy38k |
fn main() {
struct ElementaryCA {
rule: u8,
state: u64,
}
impl ElementaryCA {
fn new(rule: u8) -> (u64, ElementaryCA) {
let out = ElementaryCA {
rule,
state: 1,
};
(out.state, out)
}
fn next(&mut self) -> u64 {
let mut next_state = 0u64;
let state = self.state;
for i in 0..64 {
next_state |= (((self.rule as u64)>>(7 & (state.rotate_left(1).rotate_right(i as u32)))) & 1)<<i;
}
self.state = next_state;
self.state
}
}
fn rep_u64(val: u64) -> String {
let mut out = String::new();
for i in (0..64).rev() {
if 1<<i & val!= 0 {
out = out + "\u{2588}";
} else {
out = out + "-";
}
}
out
}
let (i, mut thirty) = ElementaryCA::new(154);
println!("{}",rep_u64(i));
for _ in 0..32 {
let s = thirty.next();
println!("{}", rep_u64(s));
}
} | 910Elementary cellular automaton
| 15rust
| 9g6mm |
import java.awt._
import java.awt.event.ActionEvent
import javax.swing._
object ElementaryCellularAutomaton extends App {
SwingUtilities.invokeLater(() =>
new JFrame("Elementary Cellular Automaton") {
class ElementaryCellularAutomaton extends JPanel {
private val dim = new Dimension(900, 450)
private val cells = Array.ofDim[Byte](dim.height, dim.width)
private var rule = 0
private def ruleSet =
Seq(30, 45, 50, 57, 62, 70, 73, 75, 86, 89, 90, 99, 101, 105, 109, 110, 124, 129, 133, 135, 137, 139, 141, 164, 170, 232)
override def paintComponent(gg: Graphics): Unit = {
def drawCa(g: Graphics2D): Unit = {
def rules(lhs: Int, mid: Int, rhs: Int) = {
val idx = lhs << 2 | mid << 1 | rhs
(ruleSet(rule) >> idx & 1).toByte
}
g.setColor(Color.black)
for (r <- 0 until cells.length - 1;
c <- 1 until cells(r).length - 1;
lhs = cells(r)(c - 1);
mid = cells(r)(c);
rhs = cells(r)(c + 1)) {
cells(r + 1)(c) = rules(lhs, mid, rhs) | 910Elementary cellular automaton
| 16scala
| 2j9lb |
import Reflex.Dom
import Data.Map as DM (Map, lookup, insert, empty, fromList)
import Data.Matrix
import Data.Time.Clock
import Control.Monad.Trans
size = 500
updateFrequency = 0.2
rotationStep = pi/10
data Color = Red | Green | Blue | Yellow | Orange | Purple | Black deriving (Show,Eq,Ord,Enum)
zRot :: Float -> Matrix Float
zRot rotation =
let c = cos rotation
s = sin rotation
in fromLists [[ c, s, 0, 0 ]
,[-s, c, 0, 0 ]
,[ 0, 0, 1, 0 ]
,[ 0, 0, 0, 1 ]
]
xRot :: Float -> Matrix Float
xRot rotation =
let c = cos rotation
s = sin rotation
in fromLists [[ 1, 0, 0, 0 ]
,[ 0, c, s, 0 ]
,[ 0, -s, c, 0 ]
,[ 0, 0, 0, 1 ]
]
yRot :: Float -> Matrix Float
yRot rotation =
let c = cos rotation
s = sin rotation
in fromLists [[ c, 0, -s, 0 ]
,[ 0, 1, 0, 0 ]
,[ s, 0, c, 0 ]
,[ 0, 0, 0, 1 ]
]
translation :: (Float,Float,Float) -> Matrix Float
translation (x,y,z) =
fromLists [[ 1, 0, 0, 0 ]
,[ 0, 1, 0, 0 ]
,[ 0, 0, 1, 0 ]
,[ x, y, z, 1 ]
]
scale :: Float -> Matrix Float
scale s =
fromLists [[ s, 0, 0, 0 ]
,[ 0, s, 0, 0 ]
,[ 0, 0, s, 0 ]
,[ 0, 0, 0, 1 ]
]
perspective :: Matrix Float
perspective =
fromLists [[ 1, 0, 0, 0 ]
,[ 0, 1, 0, 0 ]
,[ 0, 0, 1, 1 ]
,[ 0, 0, 1, 1 ] ]
transformPoints :: Matrix Float -> Matrix Float -> [(Float,Float)]
transformPoints transform points =
let result4d = points `multStd2` transform
result2d = (\[x,y,z,w] -> (x/w,y/w)) <$> toLists result4d
in result2d
showRectangle :: MonadWidget t m => Float -> Float -> Float -> Float -> Color -> Dynamic t (Matrix Float) -> m ()
showRectangle x0 y0 x1 y1 faceColor dFaceView = do
let points = fromLists [[x0,y0,0,1],[x0,y1,0,1],[x1,y1,0,1],[x1,y0,0,1]]
pointsToString = concatMap (\(x,y) -> show x ++ ", " ++ show y ++ " ")
dAttrs <- mapDyn (\fvk -> DM.fromList [ ("fill", show faceColor)
, ("points", pointsToString (transformPoints fvk points))
] ) dFaceView
elDynAttrSVG "polygon" dAttrs $ return ()
showUnitSquare :: MonadWidget t m => Color -> Float -> Dynamic t (Matrix Float) -> m ()
showUnitSquare faceColor margin dFaceView =
showRectangle margin margin (1.0 - margin) (1.0 - margin) faceColor dFaceView
showFace :: MonadWidget t m => Color -> Dynamic t (Matrix Float) -> m ()
showFace faceColor dFaceView = do
showUnitSquare Black 0 dFaceView
showUnitSquare faceColor 0.03 dFaceView
facingCamera :: [Float] -> Matrix Float -> Bool
facingCamera viewPoint modelTransform =
let cross [x0,y0,z0] [x1,y1,z1] = [y0*z1-z0*y1, z0*x1-x0*z1, x0*y1-y0*x1 ]
dot v0 v1 = sum $ zipWith (*) v0 v1
vMinus = zipWith (-)
untransformedPoints = fromLists [ [0,0,0,1]
, [1,0,0,1]
, [0,1,0,1] ]
transformedPoints = toLists $ untransformedPoints `multStd2` modelTransform
pt00 = take 3 $ head transformedPoints
pt10 = take 3 $ transformedPoints !! 1
pt01 = take 3 $ transformedPoints !! 2
tVec_10_00 = pt10 `vMinus` pt00
tVec_01_00 = pt01 `vMinus` pt00
perpendicular = tVec_10_00 `cross` tVec_01_00
cameraToPlane = pt00 `vMinus` viewPoint
in cameraToPlane `dot` perpendicular < 0
faceView :: Matrix Float -> Matrix Float -> (Bool, Matrix Float)
faceView modelOrientation faceOrientation =
let modelTransform = translation (-1/2,-1/2,1/2)
`multStd2` faceOrientation
`multStd2` scale (1/2)
`multStd2` modelOrientation
isFacingCamera = facingCamera [0,0,-1] modelTransform
viewTransform = modelTransform
`multStd2` perspective
`multStd2` scale size
`multStd2` translation (size/2, size/2, 0)
in (isFacingCamera, viewTransform)
updateFaceViews :: Matrix Float -> Map Color (Matrix Float) -> (Color, Matrix Float) -> Map Color (Matrix Float)
updateFaceViews modelOrientation prevCollection (faceColor, faceOrientation) =
let (isVisible, newFaceView) = faceView modelOrientation faceOrientation
in if isVisible
then insert faceColor newFaceView prevCollection
else prevCollection
faceViews :: Matrix Float -> Map Color (Matrix Float)
faceViews modelOrientation =
foldl (updateFaceViews modelOrientation) empty
[ (Purple , xRot (0.0) )
, (Yellow , xRot (pi/2) )
, (Red , yRot (pi/2) )
, (Green , xRot (-pi/2) )
, (Blue , yRot (-pi/2) )
, (Orange , xRot (pi) )
]
viewModel :: MonadWidget t m => Dynamic t (Matrix Float) -> m ()
viewModel modelOrientation = do
faceMap <- mapDyn faceViews modelOrientation
listWithKey faceMap showFace
return ()
view :: MonadWidget t m => Dynamic t (Matrix Float) -> m ()
view modelOrientation = do
el "h1" $ text "Rotating Cube"
elDynAttrSVG "svg"
(constDyn $ DM.fromList [ ("width", show size), ("height", show size) ])
$ viewModel modelOrientation
main = mainWidget $ do
let initialOrientation = xRot (pi/4) `multStd2` zRot (atan(1/sqrt(2)))
update _ modelOrientation = modelOrientation `multStd2` (yRot (rotationStep) )
tick <- tickLossy updateFrequency =<< liftIO getCurrentTime
rec
view modelOrientation
modelOrientation <- foldDyn update initialOrientation tick
return ()
elDynAttrSVG a2 a3 a4 = do
elDynAttrNS' (Just "http://www.w3.org/2000/svg") a2 a3 a4
return () | 919Draw a rotating cube
| 8haskell
| 4pz5s |
typedef struct sListEntry {
const char *value;
struct sListEntry *next;
struct sListEntry *prev;
} *ListEntry, *LinkedList;
typedef struct sListIterator{
ListEntry link;
LinkedList head;
} *LIterator;
LinkedList NewList() {
ListEntry le = malloc(sizeof(struct sListEntry));
if (le) {
le->value = NULL;
le->next = le->prev = NULL;
}
return le;
}
int LL_Append(LinkedList ll, const char *newVal)
{
ListEntry le = malloc(sizeof(struct sListEntry));
if (le) {
le->value = strdup(newVal);
le->prev = ll->prev;
le->next = NULL;
if (le->prev)
le->prev->next = le;
else
ll->next = le;
ll->prev = le;
}
return (le!= NULL);
}
int LI_Insert(LIterator iter, const char *newVal)
{
ListEntry crnt = iter->link;
ListEntry le = malloc(sizeof(struct sListEntry));
if (le) {
le->value = strdup(newVal);
if ( crnt == iter->head) {
le->prev = NULL;
le->next = crnt->next;
crnt->next = le;
if (le->next)
le->next->prev = le;
else
crnt->prev = le;
}
else {
le->prev = ( crnt == NULL)? iter->head->prev : crnt->prev;
le->next = crnt;
if (le->prev)
le->prev->next = le;
else
iter->head->next = le;
if (crnt)
crnt->prev = le;
else
iter->head->prev = le;
}
}
return (le!= NULL);
}
LIterator LL_GetIterator(LinkedList ll )
{
LIterator liter = malloc(sizeof(struct sListIterator));
liter->head = ll;
liter->link = ll;
return liter;
}
{free(iter); \
iter = NULL;}
int LLI_AtEnd(LIterator iter)
{
return iter->link == NULL;
}
const char *LLI_Value(LIterator iter)
{
return (iter->link)? iter->link->value: NULL;
}
int LLI_Next(LIterator iter)
{
if (iter->link) iter->link = iter->link->next;
return(iter->link != NULL);
}
int LLI_Prev(LIterator iter)
{
if (iter->link) iter->link = iter->link->prev;
return(iter->link != NULL);
}
int main()
{
static const char *contents[] = {, , ,
, , };
int ix;
LinkedList ll = NewList();
LIterator iter;
for (ix=0; ix<6; ix++)
LL_Append(ll, contents[ix]);
iter = LL_GetIterator(ll);
printf();
while(LLI_Next(iter))
printf(, LLI_Value(iter));
LLI_Delete(iter);
printf();
iter = LL_GetIterator(ll);
while(LLI_Prev(iter))
printf(, LLI_Value(iter));
LLI_Delete(iter);
return 0;
} | 921Doubly-linked list/Traversal
| 5c
| iyho2 |
int compar(const void *a, const void *b){
char c1=*(const char*)a, c2=*(const char*)b;
return c1-c2;
}
_Bool issorted(char *balls){
int i,state;
state=0;
for(i=0;i<NUMBALLS;i++){
if(balls[i]<state)return false;
if(balls[i]>state)state=balls[i];
}
return true;
}
void printout(char *balls){
int i;
char str[NUMBALLS+1];
for(i=0;i<NUMBALLS;i++)str[i]=balls[i]==0?'r':balls[i]==1?'w':'b';
printf(,str);
}
int main(void) {
char balls[NUMBALLS];
int i;
srand(time(NULL));
rand();
for(i=0;i<NUMBALLS;i++)balls[i]=(double)rand()/RAND_MAX*3;
while(issorted(balls)){
printf();
printout(balls);
for(i=0;i<NUMBALLS;i++)balls[i]=(double)rand()/RAND_MAX*3;
}
printf();
printout(balls);
qsort(balls,NUMBALLS,sizeof(char),compar);
if(issorted(balls)){
printf();
printout(balls);
} else {
printf();
printout(balls);
}
return 0;
} | 922Dutch national flag problem
| 5c
| vho2o |
import SocketServer
HOST =
PORT = 12321
class EchoServer(SocketServer.ThreadingMixIn, SocketServer.TCPServer):
pass
class EchoRequestHandler(SocketServer.StreamRequestHandler):
def handle(self):
print % self.client_address[0]
while True:
line = self.rfile.readline()
if not line: break
print % (self.client_address[0], line.rstrip())
self.wfile.write(line)
print % self.client_address[0]
server = EchoServer((HOST, PORT), EchoRequestHandler)
print % server.server_address
server.serve_forever() | 907Echo server
| 3python
| p81bm |
import inflect
import time
before = time.perf_counter()
p = inflect.engine()
print(' ')
print('eban numbers up to and including 1000:')
print(' ')
count = 0
for i in range(1,1001):
if not 'e' in p.number_to_words(i):
print(str(i)+' ',end='')
count += 1
print(' ')
print(' ')
print('count = '+str(count))
print(' ')
print(' ')
print('eban numbers between 1000 and 4000 (inclusive):')
print(' ')
count = 0
for i in range(1000,4001):
if not 'e' in p.number_to_words(i):
print(str(i)+' ',end='')
count += 1
print(' ')
print(' ')
print('count = '+str(count))
print(' ')
print(' ')
print('eban numbers up to and including 10000:')
print(' ')
count = 0
for i in range(1,10001):
if not 'e' in p.number_to_words(i):
count += 1
print(' ')
print('count = '+str(count))
print(' ')
print(' ')
print('eban numbers up to and including 100000:')
print(' ')
count = 0
for i in range(1,100001):
if not 'e' in p.number_to_words(i):
count += 1
print(' ')
print('count = '+str(count))
print(' ')
print(' ')
print('eban numbers up to and including 1000000:')
print(' ')
count = 0
for i in range(1,1000001):
if not 'e' in p.number_to_words(i):
count += 1
print(' ')
print('count = '+str(count))
print(' ')
print(' ')
print('eban numbers up to and including 10000000:')
print(' ')
count = 0
for i in range(1,10000001):
if not 'e' in p.number_to_words(i):
count += 1
print(' ')
print('count = '+str(count))
print(' ')
after = time.perf_counter()
print()
print(+str(after - before)) | 916Eban numbers
| 3python
| kqvhf |
local SDL = require "SDL"
local ret = SDL.init { SDL.flags.Video }
local window = SDL.createWindow {
title = "Pixel",
height = 320,
width = 240
}
local renderer = SDL.createRenderer(window, 0, 0)
renderer:clear()
renderer:setDrawColor(0xFF0000)
renderer:drawPoint({x = 100,y = 100})
renderer:present()
SDL.delay(5000) | 918Draw a pixel
| 1lua
| kqlh2 |
from itertools import product
def egyptian_divmod(dividend, divisor):
assert divisor != 0
pwrs, dbls = [1], [divisor]
while dbls[-1] <= dividend:
pwrs.append(pwrs[-1] * 2)
dbls.append(pwrs[-1] * divisor)
ans, accum = 0, 0
for pwr, dbl in zip(pwrs[-2::-1], dbls[-2::-1]):
if accum + dbl <= dividend:
accum += dbl
ans += pwr
return ans, abs(accum - dividend)
if __name__ == :
for i, j in product(range(13), range(1, 13)):
assert egyptian_divmod(i, j) == divmod(i, j)
i, j = 580, 34
print(f'{i} divided by {j} using the Egyption method is%i remainder%i'
% egyptian_divmod(i, j)) | 914Egyptian division
| 3python
| ralgq |
from fractions import Fraction
from math import ceil
class Fr(Fraction):
def __repr__(self):
return '%s/%s'% (self.numerator, self.denominator)
def ef(fr):
ans = []
if fr >= 1:
if fr.denominator == 1:
return [[int(fr)], Fr(0, 1)]
intfr = int(fr)
ans, fr = [[intfr]], fr - intfr
x, y = fr.numerator, fr.denominator
while x != 1:
ans.append(Fr(1, ceil(1/fr)))
fr = Fr(-y% x, y* ceil(1/fr))
x, y = fr.numerator, fr.denominator
ans.append(fr)
return ans
if __name__ == '__main__':
for fr in [Fr(43, 48), Fr(5, 121), Fr(2014, 59)]:
print('%r %s'% (fr, ' '.join(str(x) for x in ef(fr))))
lenmax = denommax = (0, None)
for fr in set(Fr(a, b) for a in range(1,100) for b in range(1, 100)):
e = ef(fr)
elen, edenom = len(e), e[-1].denominator
if elen > lenmax[0]:
lenmax = (elen, fr, e)
if edenom > denommax[0]:
denommax = (edenom, fr, e)
print('Term max is%r with%i terms'% (lenmax[1], lenmax[0]))
dstr = str(denommax[0])
print('Denominator max is%r with%i digits%s...%s'%
(denommax[1], len(dstr), dstr[:5], dstr[-5:])) | 913Egyptian fractions
| 3python
| 2j6lz |
import java.awt.*;
import java.awt.event.ActionEvent;
import static java.lang.Math.*;
import javax.swing.*;
public class RotatingCube extends JPanel {
double[][] nodes = {{-1, -1, -1}, {-1, -1, 1}, {-1, 1, -1}, {-1, 1, 1},
{1, -1, -1}, {1, -1, 1}, {1, 1, -1}, {1, 1, 1}};
int[][] edges = {{0, 1}, {1, 3}, {3, 2}, {2, 0}, {4, 5}, {5, 7}, {7, 6},
{6, 4}, {0, 4}, {1, 5}, {2, 6}, {3, 7}};
public RotatingCube() {
setPreferredSize(new Dimension(640, 640));
setBackground(Color.white);
scale(100);
rotateCube(PI / 4, atan(sqrt(2)));
new Timer(17, (ActionEvent e) -> {
rotateCube(PI / 180, 0);
repaint();
}).start();
}
final void scale(double s) {
for (double[] node : nodes) {
node[0] *= s;
node[1] *= s;
node[2] *= s;
}
}
final void rotateCube(double angleX, double angleY) {
double sinX = sin(angleX);
double cosX = cos(angleX);
double sinY = sin(angleY);
double cosY = cos(angleY);
for (double[] node : nodes) {
double x = node[0];
double y = node[1];
double z = node[2];
node[0] = x * cosX - z * sinX;
node[2] = z * cosX + x * sinX;
z = node[2];
node[1] = y * cosY - z * sinY;
node[2] = z * cosY + y * sinY;
}
}
void drawCube(Graphics2D g) {
g.translate(getWidth() / 2, getHeight() / 2);
for (int[] edge : edges) {
double[] xy1 = nodes[edge[0]];
double[] xy2 = nodes[edge[1]];
g.drawLine((int) round(xy1[0]), (int) round(xy1[1]),
(int) round(xy2[0]), (int) round(xy2[1]));
}
for (double[] node : nodes)
g.fillOval((int) round(node[0]) - 4, (int) round(node[1]) - 4, 8, 8);
}
@Override
public void paintComponent(Graphics gg) {
super.paintComponent(gg);
Graphics2D g = (Graphics2D) gg;
g.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
RenderingHints.VALUE_ANTIALIAS_ON);
drawCube(g);
}
public static void main(String[] args) {
SwingUtilities.invokeLater(() -> {
JFrame f = new JFrame();
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
f.setTitle("Rotating Cube");
f.setResizable(false);
f.add(new RotatingCube(), BorderLayout.CENTER);
f.pack();
f.setLocationRelativeTo(null);
f.setVisible(true);
});
}
} | 919Draw a rotating cube
| 9java
| cro9h |
package Elementwise;
use Exporter 'import';
use overload
'=' => sub { $_[0]->clone() },
'+' => sub { $_[0]->add($_[1]) },
'-' => sub { $_[0]->sub($_[1]) },
'*' => sub { $_[0]->mul($_[1]) },
'/' => sub { $_[0]->div($_[1]) },
'**' => sub { $_[0]->exp($_[1]) },
;
sub new
{
my ($class, $v) = @_;
return bless $v, $class;
}
sub clone
{
my @ret = @{$_[0]};
return bless \@ret, ref($_[0]);
}
sub add { new Elementwise ref($_[1]) ? [map { $_[0][$_] + $_[1][$_] } 0 .. $
sub sub { new Elementwise ref($_[1]) ? [map { $_[0][$_] - $_[1][$_] } 0 .. $
sub mul { new Elementwise ref($_[1]) ? [map { $_[0][$_] * $_[1][$_] } 0 .. $
sub div { new Elementwise ref($_[1]) ? [map { $_[0][$_] / $_[1][$_] } 0 .. $
sub exp { new Elementwise ref($_[1]) ? [map { $_[0][$_] ** $_[1][$_] } 0 .. $
1; | 912Element-wise operations
| 2perl
| 83w0w |
(def dl (double-list [:a:b:c:d]))
((juxt seq rseq) dl)
(take-while identity (iterate get-next (get-head dl)))
(take-while identity (iterate get-prev (get-tail dl))) | 921Doubly-linked list/Traversal
| 6clojure
| z2atj |
struct Node
{
struct Node *next;
struct Node *prev;
void *data;
}; | 923Doubly-linked list/Element definition
| 5c
| 9gxm1 |
print "Enter a variable name: ";
$varname = <STDIN>;
chomp($varname);
$$varname = 42;
print "$foo\n"; | 917Dynamic variable names
| 2perl
| 4p65d |
<?php
$varname = rtrim(fgets(STDIN));
$$varname = 42;
echo ;
?> | 917Dynamic variable names
| 12php
| iy1ov |
Egyptian_division <- function(num, den){
pow2 = 0
row = 1
Table = data.frame(powers_of_2 = 2^pow2,
doubling = den)
while(Table$doubling[nrow(Table)] < num){
row = row + 1
pow2 = pow2 + 1
Table[row, 1] <- 2^pow2
Table[row, 2] <- 2^pow2 * den
}
Table <- Table[-nrow(Table),]
answer <- 0
accumulator <- 0
for (i in nrow(Table):1) {
if (accumulator + Table$doubling[i] <= num) {
accumulator <- accumulator + Table$doubling[i]
answer <- answer + Table$powers_of_2[i]
}
}
remainder = abs(accumulator - num)
message(paste0("Answer is ", answer, ", remainder ", remainder))
}
Egyptian_division(580, 34)
Egyptian_division(300, 2) | 914Egyptian division
| 13r
| ukyvx |
null | 901Ethiopian multiplication
| 20typescript
| 2h7lu |
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<style>
canvas {
background-color: black;
}
</style>
</head>
<body>
<canvas></canvas>
<script>
var canvas = document.querySelector("canvas");
canvas.width = window.innerWidth;
canvas.height = window.innerHeight;
var g = canvas.getContext("2d");
var nodes = [[-1, -1, -1], [-1, -1, 1], [-1, 1, -1], [-1, 1, 1],
[1, -1, -1], [1, -1, 1], [1, 1, -1], [1, 1, 1]];
var edges = [[0, 1], [1, 3], [3, 2], [2, 0], [4, 5], [5, 7], [7, 6],
[6, 4], [0, 4], [1, 5], [2, 6], [3, 7]];
function scale(factor0, factor1, factor2) {
nodes.forEach(function (node) {
node[0] *= factor0;
node[1] *= factor1;
node[2] *= factor2;
});
}
function rotateCuboid(angleX, angleY) {
var sinX = Math.sin(angleX);
var cosX = Math.cos(angleX);
var sinY = Math.sin(angleY);
var cosY = Math.cos(angleY);
nodes.forEach(function (node) {
var x = node[0];
var y = node[1];
var z = node[2];
node[0] = x * cosX - z * sinX;
node[2] = z * cosX + x * sinX;
z = node[2];
node[1] = y * cosY - z * sinY;
node[2] = z * cosY + y * sinY;
});
}
function drawCuboid() {
g.save();
g.clearRect(0, 0, canvas.width, canvas.height);
g.translate(canvas.width / 2, canvas.height / 2);
g.strokeStyle = "#FFFFFF";
g.beginPath();
edges.forEach(function (edge) {
var p1 = nodes[edge[0]];
var p2 = nodes[edge[1]];
g.moveTo(p1[0], p1[1]);
g.lineTo(p2[0], p2[1]);
});
g.closePath();
g.stroke();
g.restore();
}
scale(200, 200, 200);
rotateCuboid(Math.PI / 4, Math.atan(Math.sqrt(2)));
setInterval(function() {
rotateCuboid(Math.PI / 180, 0);
drawCuboid();
}, 17);
</script>
</body>
</html> | 919Draw a rotating cube
| 10javascript
| 5btur |
(defn dutch-flag-order [color]
(get {:red 1:white 2:blue 3} color))
(defn sort-in-dutch-flag-order [balls]
(sort-by dutch-flag-order balls))
(defn random-balls [num-balls]
(repeatedly num-balls
#(rand-nth [:red:white:blue])))
(defn starting-balls [num-balls]
(let [balls (random-balls num-balls)
in-dutch-flag-order? (= balls
(sort-in-dutch-flag-order balls))]
(if in-dutch-flag-order?
(recur num-balls)
balls))) | 922Dutch national flag problem
| 6clojure
| ratg2 |
const char *shades = ;
void vsub(double *v1, double *v2, double *s) {
s[0] = v1[0] - v2[0];
s[1] = v1[1] - v2[1];
s[2] = v1[2] - v2[2];
}
double normalize(double * v) {
double len = sqrt(v[0]*v[0] + v[1]*v[1] + v[2]*v[2]);
v[0] /= len; v[1] /= len; v[2] /= len;
return len;
}
double dot(double *x, double *y) {
return x[0]*y[0] + x[1]*y[1] + x[2]*y[2];
}
double * cross(double x[3], double y[3], double s[3]) {
s[0] = x[1] * y[2] - x[2] * y[1];
s[1] = x[2] * y[0] - x[0] * y[2];
s[2] = x[0] * y[1] - x[1] * y[0];
return s;
}
double* madd(double *x, double *y, double d, double *r) {
r[0] = x[0] + y[0] * d;
r[1] = x[1] + y[1] * d;
r[2] = x[2] + y[2] * d;
return r;
}
double v000[] = { -4, -3, -2 };
double v100[] = { 4, -3, -2 };
double v010[] = { -4, 3, -2 };
double v110[] = { 4, 3, -2 };
double v001[] = { -4, -3, 2 };
double v101[] = { 4, -3, 2 };
double v011[] = { -4, 3, 2 };
double v111[] = { 4, 3, 2 };
typedef struct {
double * v[4];
double norm[3];
} face_t;
face_t f[] = {
{ { v000, v010, v110, v100 }, { 0, 0, -1 } },
{ { v001, v011, v111, v101 }, { 0, 0, 1 } },
{ { v000, v010, v011, v001 }, { -1, 0, 0 } },
{ { v100, v110, v111, v101 }, { 1, 0, 0 } },
{ { v000, v100, v101, v001 }, { 0, -1, 0 } },
{ { v010, v110, v111, v011 }, { 0, 1, 0 } },
};
int in_range(double x, double x0, double x1) {
return (x - x0) * (x - x1) <= 0;
}
int face_hit(face_t *face, double src[3], double dir[3], double hit[3], double *d)
{
int i;
double dist;
for (i = 0; i < 3; i++)
if (face->norm[i])
dist = (face->v[0][i] - src[i]) / dir[i];
madd(src, dir, dist, hit);
*d = fabs(dot(dir, face->norm) * dist);
if (face->norm[0]) {
return in_range(hit[1], face->v[0][1], face->v[2][1]) &&
in_range(hit[2], face->v[0][2], face->v[2][2]);
}
else if (face->norm[1]) {
return in_range(hit[0], face->v[0][0], face->v[2][0]) &&
in_range(hit[2], face->v[0][2], face->v[2][2]);
}
else if (face->norm[2]) {
return in_range(hit[0], face->v[0][0], face->v[2][0]) &&
in_range(hit[1], face->v[0][1], face->v[2][1]);
}
return 0;
}
int main()
{
int i, j, k;
double eye[3] = { 7, 7, 6 };
double dir[3] = { -1, -1, -1 }, orig[3] = {0, 0, 0};
double hit[3], dx[3], dy[3] = {0, 0, 1}, proj[3];
double d, *norm, dbest, b;
double light[3] = { 6, 8, 6 }, ldist[3], decay, strength = 10;
normalize(cross(eye, dy, dx));
normalize(cross(eye, dx, dy));
for (i = -10; i <= 17; i++) {
for (j = -35; j < 35; j++) {
vsub(orig, orig, proj);
madd(madd(proj, dx, j / 6., proj), dy, i/3., proj);
vsub(proj, eye, dir);
dbest = 1e100;
norm = 0;
for (k = 0; k < 6; k++) {
if (!face_hit(f + k, eye, dir, hit, &d)) continue;
if (dbest > d) {
dbest = d;
norm = f[k].norm;
}
}
if (!norm) {
putchar(' ');
continue;
}
vsub(light, hit, ldist);
decay = normalize(ldist);
b = dot(norm, ldist) / decay * strength;
if (b < 0) b = 0;
else if (b > 1) b = 1;
b += .2;
if (b > 1) b = 0;
else b = 1 - b;
putchar(shades[(int)(b * (sizeof(shades) - 2))]);
}
putchar('\n');
}
return 0;
} | 924Draw a cuboid
| 5c
| m4eys |
def main
intervals = [
[2, 1000, true],
[1000, 4000, true],
[2, 10000, false],
[2, 100000, false],
[2, 1000000, false],
[2, 10000000, false],
[2, 100000000, false],
[2, 1000000000, false]
]
for intv in intervals
(start, ending, display) = intv
if start == 2 then
print % [ending]
else
print % [start, ending]
end
count = 0
for i in (start .. ending).step(2)
b = (i / 1000000000).floor
r = (i % 1000000000)
m = (r / 1000000).floor
r = (r % 1000000)
t = (r / 1000).floor
r = (r % 1000)
if m >= 30 and m <= 66 then
m = m % 10
end
if t >= 30 and t <= 66 then
t = t % 10
end
if r >= 30 and r <= 66 then
r = r % 10
end
if b == 0 or b == 2 or b == 4 or b == 6 then
if m == 0 or m == 2 or m == 4 or m == 6 then
if t == 0 or t == 2 or t == 4 or t == 6 then
if r == 0 or r == 2 or r == 4 or r == 6 then
if display then
print ' ', i
end
count = count + 1
end
end
end
end
end
if display then
print
end
print % [count]
end
end
main() | 916Eban numbers
| 14ruby
| p05bh |
package main
import "fmt"
type dlNode struct {
string
next, prev *dlNode
}
type dlList struct {
head, tail *dlNode
}
func (list *dlList) String() string {
if list.head == nil {
return fmt.Sprint(list.head)
}
r := "[" + list.head.string
for p := list.head.next; p != nil; p = p.next {
r += " " + p.string
}
return r + "]"
}
func (list *dlList) insertTail(node *dlNode) {
if list.tail == nil {
list.head = node
} else {
list.tail.next = node
}
node.next = nil
node.prev = list.tail
list.tail = node
}
func (list *dlList) insertAfter(existing, insert *dlNode) {
insert.prev = existing
insert.next = existing.next
existing.next.prev = insert
existing.next = insert
if existing == list.tail {
list.tail = insert
}
}
func main() {
dll := &dlList{}
fmt.Println(dll)
a := &dlNode{string: "A"}
dll.insertTail(a)
dll.insertTail(&dlNode{string: "B"})
fmt.Println(dll)
dll.insertAfter(a, &dlNode{string: "C"})
fmt.Println(dll)
} | 920Doubly-linked list/Element insertion
| 0go
| m4syi |
insert _ Leaf = Leaf
insert nv l@(Node pl v r) = (\(Node c _ _) -> c) new
where new = updateLeft left . updateRight right $ Node l nv r
left = Node pl v new
right = case r of
Leaf -> Leaf
Node _ v r -> Node new v r | 920Doubly-linked list/Element insertion
| 8haskell
| kq9h0 |
(defrecord Node [prev next data])
(defn new-node [prev next data]
(Node. (ref prev) (ref next) data)) | 923Doubly-linked list/Element definition
| 6clojure
| ukovi |
>>> name = raw_input()
Enter a variable name: X
>>> globals()[name] = 42
>>> X
42 | 917Dynamic variable names
| 3python
| g1y4h |
object EbanNumbers {
class ERange(s: Int, e: Int, p: Boolean) {
val start: Int = s
val end: Int = e
val print: Boolean = p
}
def main(args: Array[String]): Unit = {
val rgs = List(
new ERange(2, 1000, true),
new ERange(1000, 4000, true),
new ERange(2, 10000, false),
new ERange(2, 100000, false),
new ERange(2, 1000000, false),
new ERange(2, 10000000, false),
new ERange(2, 100000000, false),
new ERange(2, 1000000000, false)
)
for (rg <- rgs) {
if (rg.start == 2) {
println(s"eban numbers up to an including ${rg.end}")
} else {
println(s"eban numbers between ${rg.start} and ${rg.end}")
}
var count = 0
for (i <- rg.start to rg.end) {
val b = i / 1000000000
var r = i % 1000000000
var m = r / 1000000
r = i % 1000000
var t = r / 1000
r %= 1000
if (m >= 30 && m <= 66) {
m %= 10
}
if (t >= 30 && t <= 66) {
t %= 10
}
if (r >= 30 && r <= 66) {
r %= 10
}
if (b == 0 || b == 2 || b == 4 || b == 6) {
if (m == 0 || m == 2 || m == 4 || m == 6) {
if (t == 0 || t == 2 || t == 4 || t == 6) {
if (r == 0 || r == 2 || r == 4 || r == 6) {
if (rg.print) {
print(s"$i ")
}
count += 1
}
}
}
}
}
if (rg.print) {
println()
}
println(s"count = $count")
println()
}
}
} | 916Eban numbers
| 16scala
| wn7es |
null | 919Draw a rotating cube
| 11kotlin
| 3vxz5 |
>>> import random
>>> from operator import add, sub, mul, floordiv
>>> from pprint import pprint as pp
>>>
>>> def ewise(matrix1, matrix2, op):
return [[op(e1,e2) for e1,e2 in zip(row1, row2)] for row1,row2 in zip(matrix1, matrix2)]
>>> m,n = 3,4
>>> a0 = [[random.randint(1,9) for y in range(n)] for x in range(m)]
>>> a1 = [[random.randint(1,9) for y in range(n)] for x in range(m)]
>>> pp(a0); pp(a1)
[[7, 8, 7, 4], [4, 9, 4, 1], [2, 3, 6, 4]]
[[4, 5, 1, 6], [6, 8, 3, 4], [2, 2, 6, 3]]
>>> pp(ewise(a0, a1, add))
[[11, 13, 8, 10], [10, 17, 7, 5], [4, 5, 12, 7]]
>>> pp(ewise(a0, a1, sub))
[[3, 3, 6, -2], [-2, 1, 1, -3], [0, 1, 0, 1]]
>>> pp(ewise(a0, a1, mul))
[[28, 40, 7, 24], [24, 72, 12, 4], [4, 6, 36, 12]]
>>> pp(ewise(a0, a1, floordiv))
[[1, 1, 7, 0], [0, 1, 1, 0], [1, 1, 1, 1]]
>>> pp(ewise(a0, a1, pow))
[[2401, 32768, 7, 4096], [4096, 43046721, 64, 1], [4, 9, 46656, 64]]
>>> pp(ewise(a0, a1, lambda x, y:2*x - y))
[[10, 11, 13, 2], [2, 10, 5, -2], [2, 4, 6, 5]]
>>>
>>> def s_ewise(scalar1, matrix1, op):
return [[op(scalar1, e1) for e1 in row1] for row1 in matrix1]
>>> scalar = 10
>>> a0
[[7, 8, 7, 4], [4, 9, 4, 1], [2, 3, 6, 4]]
>>> for op in ( add, sub, mul, floordiv, pow, lambda x, y:2*x - y ):
print(% op.__name__, s_ewise(scalar, a0, op))
add: [[17, 18, 17, 14], [14, 19, 14, 11], [12, 13, 16, 14]]
sub: [[3, 2, 3, 6], [6, 1, 6, 9], [8, 7, 4, 6]]
mul: [[70, 80, 70, 40], [40, 90, 40, 10], [20, 30, 60, 40]]
floordiv: [[1, 1, 1, 2], [2, 1, 2, 10], [5, 3, 1, 2]]
pow: [[10000000, 100000000, 10000000, 10000], [10000, 1000000000, 10000, 10], [100, 1000, 1000000, 10000]]
<lambda>: [[13, 12, 13, 16], [16, 11, 16, 19], [18, 17, 14, 16]]
>>> | 912Element-wise operations
| 3python
| o6x81 |
import java.util.LinkedList;
@SuppressWarnings("serial")
public class DoublyLinkedListInsertion<T> extends LinkedList<T> {
public static void main(String[] args) {
DoublyLinkedListInsertion<String> list = new DoublyLinkedListInsertion<String>();
list.addFirst("Add First 1");
list.addFirst("Add First 2");
list.addFirst("Add First 3");
list.addFirst("Add First 4");
list.addFirst("Add First 5");
traverseList(list);
list.addAfter("Add First 3", "Add New");
traverseList(list);
}
public void addAfter(T after, T element) {
int index = indexOf(after);
if ( index >= 0 ) {
add(index + 1, element);
}
else {
addLast(element);
}
}
private static void traverseList(LinkedList<String> list) {
System.out.println("Traverse List:");
for ( int i = 0 ; i < list.size() ; i++ ) {
System.out.printf("Element number%d - Element value = '%s'%n", i, list.get(i));
}
System.out.println();
}
} | 920Doubly-linked list/Element insertion
| 9java
| 4pt58 |
varname <- readline("Please name your variable >")
varname <- make.names(varname)
message(paste("The variable being assigned is '", varname, "'"))
assign(varname, 42)
ls(pattern=varname)
get(varname) | 917Dynamic variable names
| 13r
| vht27 |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.