Multi-stage selection (C # / Python) (old)

Both C # / Python support infinite list.

C# ##

During the recital, I said, "I might be able to use IEnumerable," so it's the law of saying.

Since cbrt is DllImport, it depends on the environment. How to make an iterator was done by Mr. Masui's calculation of the shortest path (http://qiita.com/cielavenir/items/ac96da5e3040c2edb78c), but it is still troublesome.

By the way, what you can do with C # is possible even after VB2012, but I stopped because there is not much effort. It may be possible to make it by using the shortest path calculation source listed above. And only.

The rest is Java. But I don't know Stream. </ del> Stream.generate is not a coroutine, so it seems to be useless. I don't think there is anything that corresponds to Teka Enumerator.

hena24.cs

using System;
using System.Linq;
using System.Collections.Generic;
using System.Runtime.InteropServices;

class Hena24{
	[DllImport("c")]
	private extern static double cbrt(double d);

	static private IEnumerable<int> generate(){
		int i=1;
		for(;;){
			yield return i;
			i+=1;
		}
	}
	static private IEnumerable<int> drop_prev_square(IEnumerable<int> _prev){
		IEnumerator<int> prev=_prev.GetEnumerator();
		prev.MoveNext();
		int a=prev.Current;
		prev.MoveNext();
		int b=prev.Current;
		for(;;){
			int x=(int)Math.Sqrt(b);
			if(x*x!=b)yield return a;
			a=b;
			prev.MoveNext();
			b=prev.Current;
		}
	}
	static private IEnumerable<int> drop_next_square(IEnumerable<int> _prev){
		IEnumerator<int> prev=_prev.GetEnumerator();
		prev.MoveNext();
		int a=prev.Current;
		prev.MoveNext();
		int b=prev.Current;
		yield return a;
		for(;;){
			int x=(int)Math.Sqrt(a);
			if(x*x!=a)yield return b;
			a=b;
			prev.MoveNext();
			b=prev.Current;
		}
	}
	static private IEnumerable<int> drop_prev_cubic(IEnumerable<int> _prev){
		IEnumerator<int> prev=_prev.GetEnumerator();
		prev.MoveNext();
		int a=prev.Current;
		prev.MoveNext();
		int b=prev.Current;
		for(;;){
			int x=(int)cbrt(b);
			if(x*x*x!=b)yield return a;
			a=b;
			prev.MoveNext();
			b=prev.Current;
		}
	}
	static private IEnumerable<int> drop_next_cubic(IEnumerable<int> _prev){
		IEnumerator<int> prev=_prev.GetEnumerator();
		prev.MoveNext();
		int a=prev.Current;
		prev.MoveNext();
		int b=prev.Current;
		yield return a;
		for(;;){
			int x=(int)cbrt(a);
			if(x*x*x!=a)yield return b;
			a=b;
			prev.MoveNext();
			b=prev.Current;
		}
	}
	static private IEnumerable<int> drop_num(int n,IEnumerable<int> _prev){
		IEnumerator<int> prev=_prev.GetEnumerator();
		int i=0;
		for(;;){
			i++;
			prev.MoveNext();
			int a=prev.Current;
			if(i%n!=0)yield return a;
		}
	}
	static private IEnumerable<int> drop_cnt(int n,IEnumerable<int> _prev){
		IEnumerator<int> prev=_prev.GetEnumerator();
		int i=0;
		for(;;){
			i++;
			prev.MoveNext();
			int a=prev.Current;
			if(i>n)yield return a;
		}
	}
	static void Main(){
		var f=new Dictionary<char,Func<IEnumerable<int>,IEnumerable<int>>>(){
			{'S',drop_next_square},
			{'s',drop_prev_square},
			{'C',drop_next_cubic},
			{'c',drop_prev_cubic},
			{'h',e => drop_cnt(100,e)},
		};
		for(int i=2;i<10;i++){
			int j=i; //Create a short-lived scope to avoid bugs in lambda-style captures.
			f[(char)('0'+j)] = e=>drop_num(j,e);
		}
		string line;
		for(;(line=Console.ReadLine())!=null;){
			bool first=true;
			foreach(int n in line.Aggregate(generate(),(s,e)=>f[e](s)).Take(10)){
				if(!first)Console.Write(',');
				first=false;
				Console.Write(n);
			}
			Console.WriteLine();
		}
	}
}

Python

It's just a bonus. Basically, the same logic as the Ruby version. cbrt uses scipy. I'm happy that Python becomes an external iterator without doing anything.

hena24_enum.py

#!/usr/bin/env python
#http://qiita.com/Nabetani/items/1c83005a854d2c6cbb69
#http://nabetani.sakura.ne.jp/hena/ord24eliseq/
import sys
import math
import itertools
from functools import partial,reduce
from scipy.special import cbrt # thx @ryosy383

'''
def generate():
	i=1
	while True:
		yield i
		i+=1
'''

def drop_prev_square(prev):
	a=next(prev)
	b=next(prev)
	while True:
		if int(math.sqrt(float(b)))**2!=b: yield a
		a,b=b,next(prev)

def drop_next_square(prev):
	a=next(prev)
	b=next(prev)
	yield a
	while True:
		if int(math.sqrt(float(a)))**2!=a: yield b
		a,b=b,next(prev)

def drop_prev_cubic(prev):
	a=next(prev)
	b=next(prev)
	while True:
		if int(cbrt(float(b)))**3!=b: yield a
		a,b=b,next(prev)

def drop_next_cubic(prev):
	a=next(prev)
	b=next(prev)
	yield a
	while True:
		if int(cbrt(float(a)))**3!=a: yield b
		a,b=b,next(prev)

def drop_num(n,prev):
	i=0
	while True:
		i+=1
		a=next(prev)
		if i%n!=0: yield a

def drop_cnt(n,prev):
	i=0
	while True:
		i+=1
		a=next(prev)
		if i>n: yield a

f={
	'S': drop_next_square,
	's': drop_prev_square,
	'C': drop_next_cubic,
	'c': drop_prev_cubic,
	'h': partial(drop_cnt,100),
}
for e in range(2,10): f[str(e)]=partial(drop_num,e)

if __name__=='__main__':
	try:
		while True:
			print(','.join(map(str,
				list(itertools.islice(
					reduce(lambda s,e:f[e](s),raw_input().rstrip(),itertools.count(1)),
				10))
			)))
	except EOFError:
		pass