rvprasad

Collection<Integer> ss = Collections.synchronizedSet(new HashSet<Integer>());
new Thread() {
  public void run() {
    for (int x = 0; x < 1000; x++) {
      ss.addAll(IntStream.range(x*1000, (x + 1)*1000)
          .boxed()
          .collect(Collectors.toList()));
    }
  }
}.start()

rvprasad

library(gtools)

installed <- c()

update <- function(p) {
  pd <- packageDescription(p, fields=c('Built'))
  pd <- gsub(";.*", "", pd)
  if (!is.na(pd) && pd != 'R 4.0.4') {  # mention the target versions here
    for (d in getDependencies(p)) {
      update(d)

rvprasad

localhost slots=9

rvprasad

import random
import statistics
from timeit import default_timer as timer

def time_function(f, data):
    times = []
    for _ in range(0, 20):
        start = timer()
        f(data)
        times.append(timer() - start)

rvprasad

import argparse
import glob
import hashlib
import logging
import os
import pathlib
import re
import shutil
import sys
import time

rvprasad

# Python -- v3.8

from multiprocessing import Process, Queue, managers
import time


def worker(id, data, queue, *args):
    tmp1 = time.time()
    if args:
        for i in range(args[0], args[1]):

rvprasad

class Producer<out T: Any>(val e:T) {
  fun read(): T = e
}

class Consumer<in T: Any>() {
  private lateinit var e: T
  fun write(v: T): Unit { e = v }
}

fun main() {

rvprasad

import scala.collection.mutable.ArrayBuffer
import scala.util.Random

object M {
  def main(args: Array[String]) {
    val t = new ArrayBuffer[Long]()
    while (true) {
      t += Random.nextLong
      if (t.length % 10000 == 0) {
        System.gc()

rvprasad

import kotlin.streams.asSequence
import kotlin.system.measureTimeMillis

val k = 500000000L

println(measureTimeMillis {
    java.util.stream.LongStream.range(1, k)
    .parallel()
    .asSequence()
    .map { it.toString().length.toLong() }

rvprasad

class PermutationGenerator(numOfValues:Int) : Iterator<List<Int>> {
    private val maxPos = numOfValues - 1
    private val values = (0..maxPos).shuffled()
    private var currPerm = (0..maxPos).toMutableList()

    @Synchronized override fun hasNext() = currPerm.isNotEmpty()

    @Synchronized override fun next(): List<Int> {
        val perm = currPerm.toList()
        val j = (maxPos - 1 downTo 0).find { currPerm[it] < currPerm[it + 1] }