code
stringlengths 1
46.1k
⌀ | label
class label 1.18k
classes | domain_label
class label 21
classes | index
stringlengths 4
5
|
|---|---|---|---|
def eulers_sum_of_powers():
max_n = 250
pow_5 = [n**5 for n in range(max_n)]
pow5_to_n = {n**5: n for n in range(max_n)}
for x0 in range(1, max_n):
for x1 in range(1, x0):
for x2 in range(1, x1):
for x3 in range(1, x2):
pow_5_sum = sum(pow_5[i] for i in (x0, x1, x2, x3))
if pow_5_sum in pow5_to_n:
y = pow5_to_n[pow_5_sum]
return (x0, x1, x2, x3, y)
print(% eulers_sum_of_powers()) | 892Euler's sum of powers conjecture
| 3python
| c7a9q |
use feature 'say';
use ntheory qw(forprimes is_prime);
sub emirp_list {
my $count = shift;
my($i, $inc, @n) = (13, 100+10*$count);
while (@n < $count) {
forprimes {
push @n, $_ if is_prime(reverse $_) && $_ ne reverse($_);
} $i, $i+$inc-1;
($i, $inc) = ($i+$inc, int($inc * 1.03) + 1000);
}
splice @n, $count;
@n;
}
say "First 20: ", join " ", emirp_list(20);
print "Between 7700 and 8000:";
forprimes { print " $_" if is_prime(reverse $_) && $_ ne reverse($_) } 7700,8000;
print "\n";
say "The 10_000'th emirp: ", (emirp_list(10000))[-1]; | 903Emirp primes
| 2perl
| 5pju2 |
null | 902Even or odd
| 11kotlin
| szdq7 |
<?php
function is_prime($n) {
if ($n <= 3) {
return $n > 1;
} elseif (($n % 2 == 0) or ($n % 3 == 0)) {
return false;
}
$i = 5;
while ($i * $i <= $n) {
if ($n % $i == 0) {
return false;
}
$i += 2;
if ($n % $i == 0) {
return false;
}
$i += 4;
}
return true;
}
function is_emirp($n) {
$r = (int) strrev((string) $n);
return (($r != $n) and is_prime($r) and is_prime($n));
}
$c = $x = 0;
$first20 = $between = '';
do {
$x++;
if (is_emirp($x)) {
$c++;
if ($c <= 20) {
$first20 .= $x . ' ';
}
if (7700 <= $x and $x <= 8000) {
$between .= $x . ' ';
}
}
} while ($c < 10000);
echo
'First twenty emirps:', PHP_EOL, $first20, PHP_EOL,
'Emirps between 7,700 and 8,000:', PHP_EOL, $between, PHP_EOL,
'The 10,000th emirp:', PHP_EOL, $x, PHP_EOL; | 903Emirp primes
| 12php
| oyt85 |
String s = "";
if(s != null && s.isEmpty()){ | 904Empty string
| 9java
| qtoxa |
var s = "";
var s = new String(); | 904Empty string
| 10javascript
| imtol |
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
public class Mult{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int first = sc.nextInt();
int second = sc.nextInt();
if(first < 0){
first = -first;
second = -second;
}
Map<Integer, Integer> columns = new HashMap<Integer, Integer>();
columns.put(first, second);
int sum = isEven(first)? 0: second;
do{
first = halveInt(first);
second = doubleInt(second);
columns.put(first, second);
if(!isEven(first)){
sum += second;
}
}while(first > 1);
System.out.println(sum);
}
public static int doubleInt(int doubleMe){
return doubleMe << 1; | 901Ethiopian multiplication
| 9java
| re1g0 |
var eth = {
halve : function ( n ){ return Math.floor(n/2); },
double: function ( n ){ return 2*n; },
isEven: function ( n ){ return n%2 === 0); },
mult: function ( a , b ){
var sum = 0, a = [a], b = [b];
while ( a[0] !== 1 ){
a.unshift( eth.halve( a[0] ) );
b.unshift( eth.double( b[0] ) );
}
for( var i = a.length - 1; i > 0 ; i -= 1 ){
if( !eth.isEven( a[i] ) ){
sum += b[i];
}
}
return sum + b[0];
}
} | 901Ethiopian multiplication
| 10javascript
| b0qki |
from __future__ import print_function
from prime_decomposition import primes, is_prime
from heapq import *
from itertools import islice
def emirp():
largest = set()
emirps = []
heapify(emirps)
for pr in primes():
while emirps and pr > emirps[0]:
yield heappop(emirps)
if pr in largest:
yield pr
else:
rp = int(str(pr)[::-1])
if rp > pr and is_prime(rp):
heappush(emirps, pr)
largest.add(rp)
print('First 20:\n ', list(islice(emirp(), 20)))
print('Between 7700 and 8000:\n [', end='')
for pr in emirp():
if pr >= 8000: break
if pr >= 7700: print(pr, end=', ')
print(']')
print('10000th:\n ', list(islice(emirp(), 10000-1, 10000))) | 903Emirp primes
| 3python
| 41h5k |
fun main(args: Array<String>) {
val s = ""
println(s.isEmpty()) | 904Empty string
| 11kotlin
| 1oxpd |
sub entropy {
my %count; $count{$_}++ for @_;
my $entropy = 0;
for (values %count) {
my $p = $_/@_;
$entropy -= $p * log $p;
}
$entropy / log 2
}
print entropy split //, "1223334444"; | 900Entropy
| 2perl
| wdne6 |
power5 = (1..250).each_with_object({}){|i,h| h[i**5]=i}
result = power5.keys.repeated_combination(4).select{|a| power5[a.inject(:+)]}
puts result.map{|a| a.map{|i| }.join(' + ') + } | 892Euler's sum of powers conjecture
| 14ruby
| 2hwlw |
import math
math.factorial(n) | 882Factorial
| 3python
| 3uszc |
library(gmp)
emirp <- function(start = 1, end = Inf, howmany = Inf, ignore = 0) {
count <- 0
p <- start
while (count<howmany+ignore && p <= end) {
p <- nextprime(p)
p_reverse <- as.bigz(paste0(rev(unlist(strsplit(as.character(p), ""))), collapse = ""))
if (p != p_reverse && isprime(p_reverse) > 0) {
if (count >= ignore) cat(as.character(p)," ",sep="")
count <- count + 1
}
}
cat("\n")
}
cat("First 20 emirps: ")
emirp(howmany = 20)
cat("Emirps between 7700 and 8000: ")
emirp(start = 7700, end = 8000)
cat("The 10000th emirp: ")
emirp(ignore = 9999, howmany = 1) | 903Emirp primes
| 13r
| 2hglg |
package main
func main() { } | 905Empty program
| 0go
| p8ebg |
null | 905Empty program
| 7groovy
| 7wkrz |
<?php
function shannonEntropy($string) {
$h = 0.0;
$len = strlen($string);
foreach (count_chars($string, 1) as $count) {
$h -= (double) ($count / $len) * log((double) ($count / $len), 2);
}
return $h;
}
$strings = array(
'1223334444',
'1225554444',
'aaBBcccDDDD',
'122333444455555',
'Rosetta Code',
'1234567890abcdefghijklmnopqrstuvwxyz',
);
foreach ($strings AS $string) {
printf(
'%36s:%s' . PHP_EOL,
$string,
number_format(shannonEntropy($string), 6)
);
} | 900Entropy
| 12php
| lj7cj |
main = return () | 905Empty program
| 8haskell
| fl3d1 |
const MAX_N: u64 = 250;
fn eulers_sum_of_powers() -> (usize, usize, usize, usize, usize) {
let pow5: Vec<u64> = (0..MAX_N).map(|i| i.pow(5)).collect();
let pow5_to_n = |pow| pow5.binary_search(&pow);
for x0 in 1..MAX_N as usize {
for x1 in 1..x0 {
for x2 in 1..x1 {
for x3 in 1..x2 {
let pow_sum = pow5[x0] + pow5[x1] + pow5[x2] + pow5[x3];
if let Ok(n) = pow5_to_n(pow_sum) {
return (x0, x1, x2, x3, n)
}
}
}
}
}
panic!();
}
fn main() {
let (x0, x1, x2, x3, y) = eulers_sum_of_powers();
println!("{}^5 + {}^5 + {}^5 + {}^5 == {}^5", x0, x1, x2, x3, y)
} | 892Euler's sum of powers conjecture
| 15rust
| vkx2t |
null | 901Ethiopian multiplication
| 11kotlin
| vkj21 |
import scala.collection.Searching.{Found, search}
object EulerSopConjecture extends App {
val (maxNumber, fifth) = (250, (1 to 250).map { i => math.pow(i, 5).toLong })
def binSearch(fact: Int*) = fifth.search(fact.map(f => fifth(f)).sum)
def sop = (0 until maxNumber)
.flatMap(a => (a until maxNumber)
.flatMap(b => (b until maxNumber)
.flatMap(c => (c until maxNumber)
.map { case x$1@d => (binSearch(a, b, c, d), x$1) }
.withFilter { case (f, _) => f.isInstanceOf[Found] }
.map { case (f, d) => (a + 1, b + 1, c + 1, d + 1, f.insertionPoint + 1) }))).take(1)
.map { case (a, b, c, d, f) => s"$a + $b + $c + $d = $f" }
println(sop)
} | 892Euler's sum of powers conjecture
| 16scala
| 41050 |
null | 902Even or odd
| 1lua
| 03fsd |
require 'prime'
emirp = Enumerator.new do |y|
Prime.each do |prime|
rev = prime.to_s.reverse.to_i
y << prime if rev.prime? and rev!= prime
end
end
puts , emirp.first(20).join()
puts
emirp.with_index(1) do |prime,i|
print if (7700..8000).cover?(prime)
if i==10000
puts , , prime
break
end
end | 903Emirp primes
| 14ruby
| rebgs |
fact <- function(n) {
if (n <= 1) 1
else n * Recall(n - 1)
} | 882Factorial
| 13r
| dcent |
#![feature(iterator_step_by)]
extern crate primal;
fn is_prime(n: u64) -> bool {
if n == 2 || n == 3 || n == 5 || n == 7 || n == 11 || n == 13 { return true; }
if n% 2 == 0 || n% 3 == 0 || n% 5 == 0 || n% 7 == 0 || n% 11 == 0 || n% 13 == 0 { return false; }
let root = (n as f64).sqrt() as u64 + 1;
(17..root).step_by(2).all(|i| n% i!= 0)
}
fn is_emirp(n: u64) -> bool {
let mut aux = n;
let mut rev_prime = 0;
while aux > 0 {
rev_prime = rev_prime * 10 + aux % 10;
aux /= 10;
}
if n == rev_prime { return false; }
is_prime(rev_prime)
}
fn calculate() -> (Vec<usize>, Vec<usize>, usize) {
let mut count = 1;
let mut vec1 = Vec::new();
let mut vec2 = Vec::new();
let mut emirp_10_000 = 0;
for i in primal::Primes::all() {
if is_emirp(i as u64) {
if count < 21 { vec1.push(i) }
if i > 7_700 && i < 8_000 { vec2.push(i) }
if count == 10_000 {
emirp_10_000 = i;
break;
}
count += 1;
}
}
(vec1, vec2, emirp_10_000)
}
fn main() {
let (vec1, vec2, emirp_10_000) = calculate();
println!("First 20 emirp-s: {:?}", vec1);
println!("Emirps-s between 7700 and 8000: {:?}", vec2);
println!("10.000-th emirp: {}", emirp_10_000);
} | 903Emirp primes
| 15rust
| 7wprc |
def isEmirp( v:Long ) : Boolean = {
val b = BigInt(v.toLong)
val r = BigInt(v.toString.reverse.toLong)
b != r && b.isProbablePrime(16) && r.isProbablePrime(16)
} | 903Emirp primes
| 16scala
| ksehk |
null | 904Empty string
| 1lua
| aiq1v |
from __future__ import division
import math
def hist(source):
hist = {}; l = 0;
for e in source:
l += 1
if e not in hist:
hist[e] = 0
hist[e] += 1
return (l,hist)
def entropy(hist,l):
elist = []
for v in hist.values():
c = v / l
elist.append(-c * math.log(c ,2))
return sum(elist)
def printHist(h):
flip = lambda (k,v): (v,k)
h = sorted(h.iteritems(), key = flip)
print 'Sym\thi\tfi\tInf'
for (k,v) in h:
print '%s\t%f\t%f\t%f'%(k,v,v/l,-math.log(v/l, 2))
source =
(l,h) = hist(source);
print '.[Results].'
print 'Length',l
print 'Entropy:', entropy(h, l)
printHist(h) | 900Entropy
| 3python
| xfdwr |
public class EmptyApplet extends java.applet.Applet {
@Override public void init() {
}
} | 905Empty program
| 9java
| 03ise |
null | 905Empty program
| 10javascript
| dcznu |
entropy = function(s)
{freq = prop.table(table(strsplit(s, '')[1]))
-sum(freq * log(freq, base = 2))}
print(entropy("1223334444")) | 900Entropy
| 13r
| 1o8pn |
extension BinaryInteger {
@inlinable
public func power(_ n: Self) -> Self {
return stride(from: 0, to: n, by: 1).lazy.map({_ in self }).reduce(1, *)
}
}
func sumOfPowers(maxN: Int = 250) -> (Int, Int, Int, Int, Int) {
let pow5 = (0..<maxN).map({ $0.power(5) })
let pow5ToN = {n in pow5.firstIndex(of: n)}
for x0 in 1..<maxN {
for x1 in 1..<x0 {
for x2 in 1..<x1 {
for x3 in 1..<x2 {
let powSum = pow5[x0] + pow5[x1] + pow5[x2] + pow5[x3]
if let idx = pow5ToN(powSum) {
return (x0, x1, x2, x3, idx)
}
}
}
}
}
fatalError("Did not find solution")
}
let (x0, x1, x2, x3, y) = sumOfPowers()
print("\(x0)^5 + \(x1)^5 + \(x2)^5 \(x3)^5 = \(y)^5") | 892Euler's sum of powers conjecture
| 17swift
| ljec2 |
import Foundation
extension BinaryInteger {
var isPrime: Bool {
if self == 0 || self == 1 {
return false
} else if self == 2 {
return true
}
let max = Self(ceil((Double(self).squareRoot())))
for i in stride(from: 2, through: max, by: 1) where self% i == 0 {
return false
}
return true
}
}
func isEmirp<T: BinaryInteger>(n: T) -> Bool {
guard n.isPrime else {
return false
}
var aux = n
var revPrime = T(0)
while aux > 0 {
revPrime = revPrime * 10 + aux% 10
aux /= 10
}
guard n!= revPrime else {
return false
}
return revPrime.isPrime
}
let lots = (2...).lazy.filter(isEmirp).prefix(10000)
let rang = (7700...8000).filter(isEmirp)
print("First 20 emirps: \(Array(lots.prefix(20)))")
print("Emirps between 7700 and 8000: \(rang)")
print("10,000th emirp: \(Array(lots).last!)") | 903Emirp primes
| 17swift
| gak49 |
function halve(a)
return a/2
end
function double(a)
return a*2
end
function isEven(a)
return a%2 == 0
end
function ethiopian(x, y)
local result = 0
while (x >= 1) do
if not isEven(x) then
result = result + y
end
x = math.floor(halve(x))
y = double(y)
end
return result;
end
print(ethiopian(17, 34)) | 901Ethiopian multiplication
| 1lua
| ubhvl |
fun main(a: Array<String>) {} | 905Empty program
| 11kotlin
| enqa4 |
def entropy(s)
counts = Hash.new(0.0)
s.each_char { |c| counts[c] += 1 }
leng = s.length
counts.values.reduce(0) do |entropy, count|
freq = count / leng
entropy - freq * Math.log2(freq)
end
end
p entropy() | 900Entropy
| 14ruby
| sztqw |
fn entropy(s: &[u8]) -> f32 {
let mut histogram = [0u64; 256];
for &b in s {
histogram[b as usize] += 1;
}
histogram
.iter()
.cloned()
.filter(|&h| h!= 0)
.map(|h| h as f32 / s.len() as f32)
.map(|ratio| -ratio * ratio.log2())
.sum()
}
fn main() {
let arg = std::env::args().nth(1).expect("Need a string.");
println!("Entropy of {} is {}.", arg, entropy(arg.as_bytes()));
} | 900Entropy
| 15rust
| 03zsl |
import scala.math._
def entropy( v:String ) = { v
.groupBy (a => a)
.values
.map( i => i.length.toDouble / v.length )
.map( p => -p * log10(p) / log10(2))
.sum
} | 900Entropy
| 16scala
| imyox |
null | 905Empty program
| 1lua
| wdsea |
import Foundation
func entropy(of x: String) -> Double {
return x
.reduce(into: [String: Int](), {cur, char in
cur[String(char), default: 0] += 1
})
.values
.map({i in Double(i) / Double(x.count) } as (Int) -> Double)
.map({p in -p * log2(p) } as (Double) -> Double)
.reduce(0.0, +)
}
print(entropy(of: "1223334444")) | 900Entropy
| 17swift
| qtfxg |
def factorial_recursive(n)
n.zero?? 1: n * factorial_recursive(n - 1)
end
def factorial_tail_recursive(n, prod = 1)
n.zero?? prod: factorial_tail_recursive(n - 1, prod * n)
end
def factorial_iterative(n)
(2...n).each { |i| n *= i }
n.zero?? 1: n
end
def factorial_inject(n)
(1..n).inject(1){ |prod, i| prod * i }
end
def factorial_reduce(n)
(2..n).reduce(1,:*)
end
require 'benchmark'
n = 400
m = 10000
Benchmark.bm(16) do |b|
b.report('recursive:') {m.times {factorial_recursive(n)}}
b.report('tail recursive:') {m.times {factorial_tail_recursive(n)}}
b.report('iterative:') {m.times {factorial_iterative(n)}}
b.report('inject:') {m.times {factorial_inject(n)}}
b.report('reduce:') {m.times {factorial_reduce(n)}}
end | 882Factorial
| 14ruby
| y486n |
for(0..10){
print "$_ is ", qw(even odd)[$_ % 2],"\n";
} | 902Even or odd
| 2perl
| ubjvr |
if ($s eq "") {
print "The string is empty";
}
if ($s ne "") {
print "The string is not empty";
} | 904Empty string
| 2perl
| mg2yz |
<?php
$str = '';
if (empty($str)) { ... }
if (! empty($str)) { ... }
if ($str == '') { ... }
if ($str != '') { ... }
if (strlen($str) == 0) { ... }
if (strlen($str) != 0) { ... } | 904Empty string
| 12php
| ensa9 |
fn factorial_recursive (n: u64) -> u64 {
match n {
0 => 1,
_ => n * factorial_recursive(n-1)
}
}
fn factorial_iterative(n: u64) -> u64 {
(1..=n).product()
}
fn main () {
for i in 1..10 {
println!("{}", factorial_recursive(i))
}
for i in 1..10 {
println!("{}", factorial_iterative(i))
}
} | 882Factorial
| 15rust
| mgoya |
echo (2 & 1)? 'odd' : 'even';
echo (3 & 1)? 'odd' : 'even';
echo (3 % 2)? 'odd' : 'even';
echo (4 % 2)? 'odd' : 'even'; | 902Even or odd
| 12php
| 86t0m |
def factorial(n: Int)={
var res = 1
for(i <- 1 to n)
res *= i
res
} | 882Factorial
| 16scala
| ljdcq |
s = ''
s = str()
if not s or s == '':
print()
if len(s) == 0:
print()
else:
print()
def emptystring(s):
if isinstance(s, (''.__class__ , u''.__class__) ):
if len(s) == 0:
return True
else
return False
elif s is None:
return True | 904Empty string
| 3python
| 9rvmf |
s <- ''
if (s == '') cat('Empty\n')
if (nchar(s) == 0) cat('Empty\n')
if (s!= '') cat('Not empty\n')
if (nchar(s) > 0) cat('Not empty\n') | 904Empty string
| 13r
| 3u9zt |
>>> def is_odd(i): return bool(i & 1)
>>> def is_even(i): return not is_odd(i)
>>> [(j, is_odd(j)) for j in range(10)]
[(0, False), (1, True), (2, False), (3, True), (4, False), (5, True), (6, False), (7, True), (8, False), (9, True)]
>>> [(j, is_even(j)) for j in range(10)]
[(0, True), (1, False), (2, True), (3, False), (4, True), (5, False), (6, True), (7, False), (8, True), (9, False)]
>>> | 902Even or odd
| 3python
| 5phux |
typedef int bool;
int compareInts(const void *a, const void *b) {
int aa = *(int *)a;
int bb = *(int *)b;
return aa - bb;
}
bool contains(int a[], int b, size_t len) {
int i;
for (i = 0; i < len; ++i) {
if (a[i] == b) return TRUE;
}
return FALSE;
}
int gcd(int a, int b) {
while (a != b) {
if (a > b)
a -= b;
else
b -= a;
}
return a;
}
bool areSame(int s[], int t[], size_t len) {
int i;
qsort(s, len, sizeof(int), compareInts);
qsort(t, len, sizeof(int), compareInts);
for (i = 0; i < len; ++i) {
if (s[i] != t[i]) return FALSE;
}
return TRUE;
}
int main() {
int s, n, i;
int starts[5] = {2, 5, 7, 9, 10};
int ekg[5][LIMIT];
for (s = 0; s < 5; ++s) {
ekg[s][0] = 1;
ekg[s][1] = starts[s];
for (n = 2; n < LIMIT; ++n) {
for (i = 2; ; ++i) {
if (!contains(ekg[s], i, n) && gcd(ekg[s][n - 1], i) > 1) {
ekg[s][n] = i;
break;
}
}
}
printf(, starts[s]);
for (i = 0; i < 30; ++i) printf(, ekg[s][i]);
printf();
}
for (i = 2; i < LIMIT; ++i) {
if (ekg[1][i] == ekg[2][i] && areSame(ekg[1], ekg[2], i)) {
printf(, i + 1);
return 0;
}
}
printf(, LIMIT);
return 0;
} | 906EKG sequence convergence
| 5c
| ljvcy |
is.even <- function(x)!is.odd(x)
is.odd <- function(x) intToBits(x)[1] == 1
is.odd <- function(x) x%% 2 == 1 | 902Even or odd
| 13r
| ljgce |
package main
import (
"fmt"
"sort"
)
func contains(a []int, b int) bool {
for _, j := range a {
if j == b {
return true
}
}
return false
}
func gcd(a, b int) int {
for a != b {
if a > b {
a -= b
} else {
b -= a
}
}
return a
}
func areSame(s, t []int) bool {
le := len(s)
if le != len(t) {
return false
}
sort.Ints(s)
sort.Ints(t)
for i := 0; i < le; i++ {
if s[i] != t[i] {
return false
}
}
return true
}
func main() {
const limit = 100
starts := [5]int{2, 5, 7, 9, 10}
var ekg [5][limit]int
for s, start := range starts {
ekg[s][0] = 1
ekg[s][1] = start
for n := 2; n < limit; n++ {
for i := 2; ; i++ { | 906EKG sequence convergence
| 0go
| xfswf |
import Data.List (findIndex, isPrefixOf, tails)
import Data.Maybe (fromJust)
seqEKGRec :: Int -> Int -> [Int] -> [Int]
seqEKGRec _ 0 l = l
seqEKGRec k n [] = seqEKGRec k (n - 2) [k, 1]
seqEKGRec k n l@(h: t) =
seqEKGRec
k
(pred n)
( head
( filter
(((&&) . flip notElem l) <*> ((1 <) . gcd h))
[2 ..]
):
l
)
seqEKG :: Int -> Int -> [Int]
seqEKG k n = reverse (seqEKGRec k n [])
main :: IO ()
main =
mapM_
( \x ->
putStr "EKG ("
>> (putStr . show $ x)
>> putStr ") is "
>> print (seqEKG x 20)
)
[2, 5, 7, 9, 10]
>> putStr "EKG(5) and EKG(7) converge at "
>> print
( succ $
fromJust $
findIndex
(isPrefixOf (replicate 20 True))
( tails
( zipWith
(==)
(seqEKG 7 80)
(seqEKG 5 80)
)
)
) | 906EKG sequence convergence
| 8haskell
| y4966 |
null | 905Empty program
| 2perl
| c7v9a |
main. | 905Empty program
| 12php
| xf0w5 |
s =
s = String.new
s = ; s.clear | 904Empty string
| 14ruby
| lj5cl |
print
p -5.upto(5).select(&:even?)
print
p -5.upto(5).select(&:odd?) | 902Even or odd
| 14ruby
| gab4q |
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class EKGSequenceConvergence {
public static void main(String[] args) {
System.out.println("Calculate and show here the first 10 members of EKG[2], EKG[5], EKG[7], EKG[9] and EKG[10].");
for ( int i : new int[] {2, 5, 7, 9, 10} ) {
System.out.printf("EKG[%d] =%s%n", i, ekg(i, 10));
}
System.out.println("Calculate and show here at which term EKG[5] and EKG[7] converge.");
List<Integer> ekg5 = ekg(5, 100);
List<Integer> ekg7 = ekg(7, 100);
for ( int i = 1 ; i < ekg5.size() ; i++ ) {
if ( ekg5.get(i) == ekg7.get(i) && sameSeq(ekg5, ekg7, i)) {
System.out.printf("EKG[%d](%d) = EKG[%d](%d) =%d, and are identical from this term on%n", 5, i+1, 7, i+1, ekg5.get(i));
break;
}
}
} | 906EKG sequence convergence
| 9java
| dctn9 |
let s = "";
println!("is empty: {}", s.is_empty());
let t = "x";
println!("is empty: {}", t.is_empty());
let a = String::new();
println!("is empty: {}", a.is_empty());
let b = "x".to_string();
println!("is empty: {}", b.is_empty());
println!("is not empty: {}",!b.is_empty()); | 904Empty string
| 15rust
| 2h4lt |
null | 904Empty string
| 16scala
| 5p7ut |
use strict;
sub halve { int((shift) / 2); }
sub double { (shift) * 2; }
sub iseven { ((shift) & 1) == 0; }
sub ethiopicmult
{
my ($plier, $plicand, $tutor) = @_;
print "ethiopic multiplication of $plier and $plicand\n" if $tutor;
my $r = 0;
while ($plier >= 1)
{
$r += $plicand unless iseven($plier);
if ($tutor) {
print "$plier, $plicand ", (iseven($plier) ? " struck" : " kept"), "\n";
}
$plier = halve($plier);
$plicand = double($plicand);
}
return $r;
}
print ethiopicmult(17,34, 1), "\n"; | 901Ethiopian multiplication
| 2perl
| 03ts4 |
let is_odd = |x: i32| x & 1 == 1;
let is_even = |x: i32| x & 1 == 0; | 902Even or odd
| 15rust
| repg5 |
def isEven( v:Int ) : Boolean = v % 2 == 0
def isOdd( v:Int ) : Boolean = v % 2 != 0 | 902Even or odd
| 16scala
| hqeja |
null | 906EKG sequence convergence
| 11kotlin
| 03osf |
<?php
function halve($x)
{
return floor($x/2);
}
function double($x)
{
return $x*2;
}
function iseven($x)
{
return !($x & 0x1);
}
function ethiopicmult($plier, $plicand, $tutor)
{
if ($tutor) echo ;
$r = 0;
while($plier >= 1) {
if ( !iseven($plier) ) $r += $plicand;
if ($tutor)
echo , (iseven($plier)? : ), ;
$plier = halve($plier);
$plicand = double($plicand);
}
return $r;
}
echo ethiopicmult(17, 34, true), ;
?> | 901Ethiopian multiplication
| 12php
| 5pkus |
void wait_for_zombie(int s)
{
while(waitpid(-1, NULL, WNOHANG) > 0) ;
}
void echo_lines(int csock)
{
char buf[BUF_LEN];
int r;
while( (r = read(csock, buf, BUF_LEN)) > 0 ) {
(void)write(csock, buf, r);
}
exit(EXIT_SUCCESS);
}
void take_connections_forever(int ssock)
{
for(;;) {
struct sockaddr addr;
socklen_t addr_size = sizeof(addr);
int csock;
csock = accept(ssock, &addr, &addr_size);
if ( csock == -1 ) {
perror();
} else if ( fork() == 0 ) {
close(ssock);
echo_lines(csock);
} else {
close(csock);
}
}
}
int main()
{
struct addrinfo hints, *res;
struct sigaction sa;
int sock;
memset(&hints, 0, sizeof(struct addrinfo));
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_STREAM;
hints.ai_flags = AI_PASSIVE;
if ( getaddrinfo(NULL, PORT_STR, &hints, &res) != 0 ) {
perror();
exit(EXIT_FAILURE);
}
if ( (sock = socket(res->ai_family, res->ai_socktype, res->ai_protocol)) == -1 ) {
perror();
exit(EXIT_FAILURE);
}
sa.sa_handler = wait_for_zombie;
sigemptyset(&sa.sa_mask);
sa.sa_flags = SA_RESTART;
if ( sigaction(SIGCHLD, &sa, NULL) == -1 ) {
perror();
exit(EXIT_FAILURE);
}
if ( bind(sock, res->ai_addr, res->ai_addrlen) != 0 ) {
perror();
exit(EXIT_FAILURE);
}
freeaddrinfo(res);
if ( listen(sock, MAX_ENQUEUED) != 0 ) {
perror();
exit(EXIT_FAILURE);
}
take_connections_forever(sock);
return EXIT_SUCCESS;
} | 907Echo server
| 5c
| 7wjrg |
package main
import (
"fmt"
"strings"
)
func btoi(b bool) int {
if b {
return 1
}
return 0
}
func evolve(l, rule int) {
fmt.Printf(" Rule #%d:\n", rule)
cells := "O"
for x := 0; x < l; x++ {
cells = addNoCells(cells)
width := 40 + (len(cells) >> 1)
fmt.Printf("%*s\n", width, cells)
cells = step(cells, rule)
}
}
func step(cells string, rule int) string {
newCells := new(strings.Builder)
for i := 0; i < len(cells)-2; i++ {
bin := 0
b := uint(2)
for n := i; n < i+3; n++ {
bin += btoi(cells[n] == 'O') << b
b >>= 1
}
a := '.'
if rule&(1<<uint(bin)) != 0 {
a = 'O'
}
newCells.WriteRune(a)
}
return newCells.String()
}
func addNoCells(cells string) string {
l, r := "O", "O"
if cells[0] == 'O' {
l = "."
}
if cells[len(cells)-1] == 'O' {
r = "."
}
cells = l + cells + r
cells = l + cells + r
return cells
}
func main() {
for _, r := range []int{90, 30} {
evolve(25, r)
fmt.Println()
}
} | 908Elementary cellular automaton/Infinite length
| 0go
| jxj7d |
use List::Util qw(none sum);
sub gcd { my ($u,$v) = @_; $v ? gcd($v, $u%$v) : abs($u) }
sub shares_divisors_with { gcd( $_[0], $_[1]) > 1 }
sub EKG {
my($n,$limit) = @_;
my @ekg = (1, $n);
while (@ekg < $limit) {
for my $i (2..1e18) {
next unless none { $_ == $i } @ekg and shares_divisors_with($ekg[-1], $i);
push(@ekg, $i) and last;
}
}
@ekg;
}
sub converge_at {
my($n1,$n2) = @_;
my $max = 100;
my @ekg1 = EKG($n1,$max);
my @ekg2 = EKG($n2,$max);
do { return $_+1 if $ekg1[$_] == $ekg2[$_] && sum(@ekg1[0..$_]) == sum(@ekg2[0..$_])} for 2..$max;
return "(no convergence in $max terms)";
}
print "EKG($_): " . join(' ', EKG($_,10)) . "\n" for 2, 5, 7, 9, 10;
print "EKGs of 5 & 7 converge at term " . converge_at(5, 7) . "\n" | 906EKG sequence convergence
| 2perl
| 5pgu2 |
import Control.Comonad
import Data.InfList (InfList (..), (+++))
import qualified Data.InfList as Inf
data Cells a = Cells (InfList a) a (InfList a) deriving Functor
view n (Cells l x r) = reverse (Inf.take n l) ++ [x] ++ (Inf.take n r)
fromList [] = fromList [0]
fromList (x:xs) = let zeros = Inf.repeat 0
in Cells zeros x (xs +++ zeros) | 908Elementary cellular automaton/Infinite length
| 8haskell
| oyo8p |
var s = ""
if s.isEmpty { | 904Empty string
| 17swift
| c7u9t |
1
QUIT | 905Empty program
| 3python
| ljucv |
(use '[clojure.contrib.server-socket :only (create-server)])
(use '[clojure.contrib.duck-streams :only (read-lines write-lines)])
(defn echo [input output]
(write-lines (java.io.PrintWriter. output true) (read-lines input)))
(create-server 12321 echo) | 907Echo server
| 6clojure
| p81bd |
null | 908Elementary cellular automaton/Infinite length
| 11kotlin
| b0bkb |
from itertools import count, islice, takewhile
from math import gcd
def EKG_gen(start=2):
c = count(start + 1)
last, so_far = start, list(range(2, start))
yield 1, []
yield last, []
while True:
for index, sf in enumerate(so_far):
if gcd(last, sf) > 1:
last = so_far.pop(index)
yield last, so_far[::]
break
else:
so_far.append(next(c))
def find_convergence(ekgs=(5,7)):
ekg = [EKG_gen(n) for n in ekgs]
for e in ekg:
next(e)
return 2 + len(list(takewhile(lambda state: not all(state[0] == s for s in state[1:]),
zip(*ekg))))
if __name__ == '__main__':
for start in 2, 5, 7, 9, 10:
print(f, str([n[0] for n in islice(EKG_gen(start), 10)])[1: -1])
print(f) | 906EKG sequence convergence
| 3python
| 41r5k |
null | 905Empty program
| 13r
| y4c6h |
sub evolve {
my ($rule, $pattern) = @_;
my $offset = 0;
while (1) {
my ($l, $r, $st);
$pattern =~ s/^((.)\g2*)/$2$2/ and $l = $2, $offset -= length($2);
$pattern =~ s/(.)\g1*$/$1$1/ and $r = $1;
$st = $pattern;
$pattern =~ tr/01/.
printf "%5d|%s%s\n", $offset, ' ' x (40 + $offset), $pattern;
$pattern = join '', map(1 & ($rule>>oct "0b$_"),
$l x 3,
map(substr($st, $_, 3), 0 .. length($st)-3),
$r x 3);
}
}
evolve(90, "010"); | 908Elementary cellular automaton/Infinite length
| 2perl
| 65636 |
-- Setup a table with some integers
CREATE TABLE ints(INT INTEGER);
INSERT INTO ints VALUES (-1);
INSERT INTO ints VALUES (0);
INSERT INTO ints VALUES (1);
INSERT INTO ints VALUES (2);
-- Are they even or odd?
SELECT
INT,
CASE MOD(INT, 2) WHEN 0 THEN 'Even' ELSE 'Odd' END
FROM
ints; | 902Even or odd
| 19sql
| p8qb1 |
package main
import "fmt"
func main() {
tree := eertree([]byte("eertree"))
fmt.Println(subPalindromes(tree))
}
type edges map[byte]int
type node struct {
length int
edges
suffix int
}
const evenRoot = 0
const oddRoot = 1
func eertree(s []byte) []node {
tree := []node{
evenRoot: {length: 0, suffix: oddRoot, edges: edges{}},
oddRoot: {length: -1, suffix: oddRoot, edges: edges{}},
}
suffix := oddRoot
var n, k int
for i, c := range s {
for n = suffix; ; n = tree[n].suffix {
k = tree[n].length
if b := i - k - 1; b >= 0 && s[b] == c {
break
}
}
if e, ok := tree[n].edges[c]; ok {
suffix = e
continue
}
suffix = len(tree)
tree = append(tree, node{length: k + 2, edges: edges{}})
tree[n].edges[c] = suffix
if tree[suffix].length == 1 {
tree[suffix].suffix = 0
continue
}
for {
n = tree[n].suffix
if b := i - tree[n].length - 1; b >= 0 && s[b] == c {
break
}
}
tree[suffix].suffix = tree[n].edges[c]
}
return tree
}
func subPalindromes(tree []node) (s []string) {
var children func(int, string)
children = func(n int, p string) {
for c, n := range tree[n].edges {
c := string(c)
p := c + p + c
s = append(s, p)
children(n, p)
}
}
children(0, "")
for c, n := range tree[1].edges {
c := string(c)
s = append(s, c)
children(n, c)
}
return
} | 909Eertree
| 0go
| uk2vt |
typedef unsigned long long ull;
void evolve(ull state, int rule)
{
int i;
ull st;
printf(, rule);
do {
st = state;
for (i = N; i--; ) putchar(st & B(i) ? '
putchar('\n');
for (state = i = 0; i < N; i++)
if (rule & B(7 & (st>>(i-1) | st<<(N+1-i))))
state |= B(i);
} while (st != state);
}
int main(int argc, char **argv)
{
evolve(B(N/2), 90);
evolve(B(N/4)|B(N - N/4), 30);
return 0;
} | 910Elementary cellular automaton
| 5c
| d9onv |
def _notcell(c):
return '0' if c == '1' else '1'
def eca_infinite(cells, rule):
lencells = len(cells)
rulebits = '{0:08b}'.format(rule)
neighbours2next = {'{0:03b}'.format(n):rulebits[::-1][n] for n in range(8)}
c = cells
while True:
yield c
c = _notcell(c[0])*2 + c + _notcell(c[-1])*2
c = ''.join(neighbours2next[c[i-1:i+2]] for i in range(1,len(c) - 1))
if __name__ == '__main__':
lines = 25
for rule in (90, 30):
print('\nRule:%i'% rule)
for i, c in zip(range(lines), eca_infinite('1', rule)):
print('%2i:%s%s'% (i, ' '*(lines - i), c.replace('0', '.').replace('1', ' | 908Elementary cellular automaton/Infinite length
| 3python
| y4y6q |
null | 905Empty program
| 14ruby
| vk42n |
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class Eertree {
public static void main(String[] args) {
List<Node> tree = eertree("eertree");
List<String> result = subPalindromes(tree);
System.out.println(result);
}
private static class Node {
int length;
Map<Character, Integer> edges = new HashMap<>();
int suffix;
public Node(int length) {
this.length = length;
}
public Node(int length, Map<Character, Integer> edges, int suffix) {
this.length = length;
this.edges = edges != null ? edges : new HashMap<>();
this.suffix = suffix;
}
}
private static final int EVEN_ROOT = 0;
private static final int ODD_ROOT = 1;
private static List<Node> eertree(String s) {
List<Node> tree = new ArrayList<>();
tree.add(new Node(0, null, ODD_ROOT));
tree.add(new Node(-1, null, ODD_ROOT));
int suffix = ODD_ROOT;
int n, k;
for (int i = 0; i < s.length(); ++i) {
char c = s.charAt(i);
for (n = suffix; ; n = tree.get(n).suffix) {
k = tree.get(n).length;
int b = i - k - 1;
if (b >= 0 && s.charAt(b) == c) {
break;
}
}
if (tree.get(n).edges.containsKey(c)) {
suffix = tree.get(n).edges.get(c);
continue;
}
suffix = tree.size();
tree.add(new Node(k + 2));
tree.get(n).edges.put(c, suffix);
if (tree.get(suffix).length == 1) {
tree.get(suffix).suffix = 0;
continue;
}
while (true) {
n = tree.get(n).suffix;
int b = i - tree.get(n).length - 1;
if (b >= 0 && s.charAt(b) == c) {
break;
}
}
tree.get(suffix).suffix = tree.get(n).edges.get(c);
}
return tree;
}
private static List<String> subPalindromes(List<Node> tree) {
List<String> s = new ArrayList<>();
subPalindromes_children(0, "", tree, s);
for (Map.Entry<Character, Integer> cm : tree.get(1).edges.entrySet()) {
String ct = String.valueOf(cm.getKey());
s.add(ct);
subPalindromes_children(cm.getValue(), ct, tree, s);
}
return s;
} | 909Eertree
| 9java
| kqjhm |
func isEven(n:Int) -> Bool { | 902Even or odd
| 17swift
| 41k5g |
def notcell(c)
c.tr('01','10')
end
def eca_infinite(cells, rule)
neighbours2next = Hash[8.times.map{|i|[%i, [rule[i]]]}]
c = cells
Enumerator.new do |y|
loop do
y << c
c = notcell(c[0])*2 + c + notcell(c[-1])*2
c = (1..c.size-2).map{|i| neighbours2next[c[i-1..i+1]]}.join
end
end
end
if __FILE__ == $0
lines = 25
for rule in [90, 30]
puts % rule
for i, c in (0...lines).zip(eca_infinite('1', rule))
puts '%2i:%s%s' % [i, ' '*(lines - i), c.tr('01', '.
end
end
end | 908Elementary cellular automaton/Infinite length
| 14ruby
| 9r9mz |
fn main(){} | 905Empty program
| 15rust
| ubgvj |
object emptyProgram extends App {} | 905Empty program
| 16scala
| gaj4i |
null | 909Eertree
| 11kotlin
| g154d |
func factorial(_ n: Int) -> Int {
return n < 2? 1: (2...n).reduce(1, *)
} | 882Factorial
| 17swift
| 6503j |
package main
import (
"fmt"
"rcu"
)
func main() {
limit := int(1e9)
gapStarts := make(map[int]int)
primes := rcu.Primes(limit * 5)
for i := 1; i < len(primes); i++ {
gap := primes[i] - primes[i-1]
if _, ok := gapStarts[gap]; !ok {
gapStarts[gap] = primes[i-1]
}
}
pm := 10
gap1 := 2
for {
for _, ok := gapStarts[gap1]; !ok; {
gap1 += 2
}
start1 := gapStarts[gap1]
gap2 := gap1 + 2
if _, ok := gapStarts[gap2]; !ok {
gap1 = gap2 + 2
continue
}
start2 := gapStarts[gap2]
diff := start2 - start1
if diff < 0 {
diff = -diff
}
if diff > pm {
cpm := rcu.Commatize(pm)
cst1 := rcu.Commatize(start1)
cst2 := rcu.Commatize(start2)
cd := rcu.Commatize(diff)
fmt.Printf("Earliest difference >%s between adjacent prime gap starting primes:\n", cpm)
fmt.Printf("Gap%d starts at%s, gap%d starts at%s, difference is%s.\n\n", gap1, cst1, gap2, cst2, cd)
if pm == limit {
break
}
pm *= 10
} else {
gap1 = gap2
}
}
} | 911Earliest difference between prime gaps
| 0go
| 9g3mt |
import java.util.HashMap;
import java.util.Map;
public class PrimeGaps {
private Map<Integer, Integer> gapStarts = new HashMap<>();
private int lastPrime;
private PrimeGenerator primeGenerator = new PrimeGenerator(1000, 500000);
public static void main(String[] args) {
final int limit = 100000000;
PrimeGaps pg = new PrimeGaps();
for (int pm = 10, gap1 = 2;;) {
int start1 = pg.findGapStart(gap1);
int gap2 = gap1 + 2;
int start2 = pg.findGapStart(gap2);
int diff = start2 > start1 ? start2 - start1 : start1 - start2;
if (diff > pm) {
System.out.printf(
"Earliest difference >%,d between adjacent prime gap starting primes:\n"
+ "Gap%,d starts at%,d, gap%,d starts at%,d, difference is%,d.\n\n",
pm, gap1, start1, gap2, start2, diff);
if (pm == limit)
break;
pm *= 10;
} else {
gap1 = gap2;
}
}
}
private int findGapStart(int gap) {
Integer start = gapStarts.get(gap);
if (start != null)
return start;
for (;;) {
int prev = lastPrime;
lastPrime = primeGenerator.nextPrime();
int diff = lastPrime - prev;
gapStarts.putIfAbsent(diff, prev);
if (diff == gap)
return prev;
}
}
} | 911Earliest difference between prime gaps
| 9java
| g1v4m |
void eop_
for_i for_j c[i][j] = a[i][j] _op_ b[i][j];}
OPM(add, +);OPM(sub, -);OPM(mul, *);OPM(div, /);
void eop_s_
for_i for_j {x = a[i][j]; b[i][j] = res;}}
OPS(mul, x*s);OPS(div, x/s);OPS(add, x+s);OPS(sub, x-s);OPS(pow, pow(x, s)); | 912Element-wise operations
| 5c
| xdpwu |
typedef int64_t integer;
struct Pair {
integer md;
int tc;
};
integer mod(integer x, integer y) {
return ((x % y) + y) % y;
}
integer gcd(integer a, integer b) {
if (0 == a) return b;
if (0 == b) return a;
if (a == b) return a;
if (a > b) return gcd(a - b, b);
return gcd(a, b - a);
}
void write0(bool show, char *str) {
if (show) {
printf(str);
}
}
void write1(bool show, char *format, integer a) {
if (show) {
printf(format, a);
}
}
void write2(bool show, char *format, integer a, integer b) {
if (show) {
printf(format, a, b);
}
}
struct Pair egyptian(integer x, integer y, bool show) {
struct Pair ret;
integer acc = 0;
bool first = true;
ret.tc = 0;
ret.md = 0;
write2(show, , x, y);
while (x > 0) {
integer z = (y + x - 1) / x;
if (z == 1) {
acc++;
} else {
if (acc > 0) {
write1(show, , acc);
first = false;
acc = 0;
ret.tc++;
} else if (first) {
first = false;
} else {
write0(show, );
}
if (z > ret.md) {
ret.md = z;
}
write1(show, , z);
ret.tc++;
}
x = mod(-y, x);
y = y * z;
}
if (acc > 0) {
write1(show, , acc);
ret.tc++;
}
write0(show, );
return ret;
}
int main() {
struct Pair p;
integer nm = 0, dm = 0, dmn = 0, dmd = 0, den = 0;;
int tm, i, j;
egyptian(43, 48, true);
egyptian(5, 121, true);
egyptian(2014, 59, true);
tm = 0;
for (i = 1; i < 100; i++) {
for (j = 1; j < 100; j++) {
p = egyptian(i, j, false);
if (p.tc > tm) {
tm = p.tc;
nm = i;
dm = j;
}
if (p.md > den) {
den = p.md;
dmn = i;
dmd = j;
}
}
}
printf(, nm, dm, tm);
printf(, dmn, dmd);
egyptian(dmn, dmd, true);
return 0;
} | 913Egyptian fractions
| 5c
| y5d6f |
tutor = True
def halve(x):
return x
def double(x):
return x * 2
def even(x):
return not x% 2
def ethiopian(multiplier, multiplicand):
if tutor:
print(%
(multiplier, multiplicand))
result = 0
while multiplier >= 1:
if even(multiplier):
if tutor:
print(%
(multiplier, multiplicand))
else:
if tutor:
print(%
(multiplier, multiplicand))
result += multiplicand
multiplier = halve(multiplier)
multiplicand = double(multiplicand)
if tutor:
print()
return result | 901Ethiopian multiplication
| 3python
| 86z0o |
$str = "eertree";
for $n (1 .. length($str)) {
for $m (1 .. length($str)) {
$strrev = "";
$strpal = substr($str, $n-1, $m);
if ($strpal ne "") {
for $p (reverse 1 .. length($strpal)) {
$strrev .= substr($strpal, $p-1, 1);
}
($strpal eq $strrev) and push @pal, $strpal;
}
}
}
print join ' ', grep {not $seen{$_}++} @pal, "\n"; | 909Eertree
| 2perl
| nmoiw |
use strict;
use warnings;
use ntheory qw( primes );
my @gaps;
my $primeref = primes( 1e9 );
for my $i ( 2 .. $
{
my $diff = $primeref->[$i] - $primeref->[$i - 1];
$gaps[ $diff >> 1 ] //= $primeref->[$i - 1];
}
my %first;
for my $i ( 1 .. $
{
defined $gaps[$i] && defined $gaps[$i-1] or next;
my $diff = abs $gaps[$i] - $gaps[$i-1];
for my $m ( map 10 ** $_, 1 .. 10 )
{
$diff > $m and !$first{$m}++ and
print "above $m gap @{[$i * 2 - 2 ]} abs( $gaps[$i-1] - $gaps[$i] )\n";
}
} | 911Earliest difference between prime gaps
| 2perl
| steq3 |
halve <- function(a) floor(a/2)
double <- function(a) a*2
iseven <- function(a) (a%%2)==0
ethiopicmult <- function(plier, plicand, tutor=FALSE) {
if (tutor) { cat("ethiopic multiplication of", plier, "and", plicand, "\n") }
result <- 0
while(plier >= 1) {
if (!iseven(plier)) { result <- result + plicand }
if (tutor) {
cat(plier, ", ", plicand, " ", ifelse(iseven(plier), "struck", "kept"), "\n", sep="")
}
plier <- halve(plier)
plicand <- double(plicand)
}
result
}
print(ethiopicmult(17, 34, TRUE)) | 901Ethiopian multiplication
| 13r
| xfnw2 |
from primesieve import primes
LIMIT = 10**9
pri = primes(LIMIT * 5)
gapstarts = {}
for i in range(1, len(pri)):
if pri[i] - pri[i - 1] not in gapstarts:
gapstarts[pri[i] - pri[i - 1]] = pri[i - 1]
PM, GAP1, = 10, 2
while True:
while GAP1 not in gapstarts:
GAP1 += 2
start1 = gapstarts[GAP1]
GAP2 = GAP1 + 2
if GAP2 not in gapstarts:
GAP1 = GAP2 + 2
continue
start2 = gapstarts[GAP2]
diff = abs(start2 - start1)
if diff > PM:
print(f)
print(f)
if PM == LIMIT:
break
PM *= 10
else:
GAP1 = GAP2 | 911Earliest difference between prime gaps
| 3python
| 0zwsq |
(defn initial-mtx [i1 i2 value]
(vec (repeat i1 (vec (repeat i2 value)))))
(defn operation [f mtx1 mtx2]
(if (vector? mtx1)
(vec (map #(vec (map f %1 %2)) mtx1 mtx2)))
(recur f (initial-mtx (count mtx2) (count (first mtx2)) mtx1) mtx2)
)) | 912Element-wise operations
| 6clojure
| o6x8j |
uint64_t egyptian_division(uint64_t dividend, uint64_t divisor, uint64_t *remainder) {
static uint64_t powers[64];
static uint64_t doublings[64];
int i;
for(i = 0; i < 64; i++) {
powers[i] = 1 << i;
doublings[i] = divisor << i;
if(doublings[i] > dividend)
break;
}
uint64_t answer = 0;
uint64_t accumulator = 0;
for(i = i - 1; i >= 0; i--) {
if(accumulator + doublings[i] <= dividend) {
accumulator += doublings[i];
answer += powers[i];
}
}
if(remainder)
*remainder = dividend - accumulator;
return answer;
}
void go(uint64_t a, uint64_t b) {
uint64_t x, y;
x = egyptian_division(a, b, &y);
printf(, a, b, x, y);
assert(a == b * x + y);
}
int main(void) {
go(580, 32);
} | 914Egyptian division
| 5c
| vh62o |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.