Sélection en plusieurs étapes (C # / Python) (ancien)

Les deux C # / Python prennent en charge la liste infinie.

C# ##

Pendant le récital, j'ai dit: «Je pourrais peut-être utiliser IEnumerable», c'est donc la loi du dire.

Puisque cbrt est DllImport, cela dépend de l'environnement. Comment faire un itérateur a été fait par le calcul de M. Masui de l'itinéraire le plus court (http://qiita.com/cielavenir/items/ac96da5e3040c2edb78c), mais cela reste gênant.

Au fait, ce que vous pouvez faire avec C # est possible même après VB2012, mais j'ai arrêté car il n'y a pas beaucoup d'effort. Il peut être possible de le faire en utilisant la source du calcul de l'itinéraire le plus court mentionné ci-dessus. Et seulement.

Le reste est Java. Mais je ne connais pas Stream. </ del> Stream.generate n'est pas un collout, il semble donc inutile. Je ne pense pas qu'il y ait quoi que ce soit qui corresponde à 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; //Créez une portée de courte durée pour éviter les bogues dans les captures lambda.
			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

C'est juste un bonus. En gros, la même logique que la version Ruby. cbrt utilise scipy. Je suis heureux que Python devienne un itérateur externe sans rien faire.

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