기능적 프로그래밍 스타일로 Sierpinski Triangle 생성기를 만들려고
https://stackoverflow.com/questions/1734537
-
20-09-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
Russian문제
스칼라에는 함수가 있고 JavaScript에서 동일한 기능이 있지만 기능 스타일이라고 생각하지 않습니다.
def drawSurroundingTriangles(startx : Double, starty : Double, width : Double) {
var newwidth = width/2;
var newstartx = startx + newwidth / 2;
var newstarty = starty - newwidth;
drawTriangle(newstartx, newstarty, newwidth);
drawTriangle(newstartx - newwidth, starty + newwidth, newwidth);
drawTriangle(newstartx + newwidth, starty + newwidth, newwidth);
if(newwidth < 6)
return;
drawSurroundingTriangles(newstartx, newstarty, newwidth);
drawSurroundingTriangles(newstartx - newwidth, starty + newwidth, newwidth);
drawSurroundingTriangles(newstartx + newwidth, starty + newwidth, newwidth);
}
내 희망은 이것을 반복적 인 것이 아니라 반복적 인 것이 아니라 다음 반복을 계속 얻을 수 있고 다음 레벨을 인쇄 할 수있게되므로 내 프로그램이 처음에는 외부 삼각형을 생성 한 다음 첫 번째 내부 삼각형을 그립니다. 반복자로 만들어서 키 프레스가 다음 반복을 수행 할 때까지 기다릴 수 있습니다.
그 후, 그것은이 기능에 도달하여 각 반복마다 루프 할 것입니다.
- 3 개의 삼각형, 중앙 삼각형의 양쪽에 하나를 그립니다.
- 이전 반복에서 3 개의 삼각형의 양쪽에 하나씩 삼각형 9 개를 그립니다.
- 27 개의 삼각형을 그립니다
...
업데이트:
죄송합니다. 물음표를 잊어 버렸으므로 질문을보기가 어렵습니다.
기본적으로, 나는 그것을 반복적 인 함수에서 주문형 기능으로 변경하고 다음 반복을 그릴 수 있도록하고 싶습니다. 어떻게 할 수 있습니까?
Update 2:
나는 작동하는 솔루션이 있지만 어떤 솔루션이 더 나은지, 내 또는이 질문의 답변이라는 솔루션을 모릅니다.
def drawSurroundingTriangles(indexlist : List[(Double, Double, Double)]) : List[(Double, Double, Double)] = {
var mylist = ListBuffer[(Double, Double, Double)]()
indexlist.foreach{
case (startx, starty, width) => { mylist ++ drawSingleTriangle(startx, starty, width) } }
mylist.toList;
}
def drawSingleTriangle(startx : Double, starty : Double, width : Double) : List[(Double, Double, Double)] = {
val newwidth = width/2;
val newstartx = startx + newwidth / 2;
val newstarty = starty - newwidth;
var list = List((newstartx, newstarty, newwidth),
((newstartx - newwidth, starty + newwidth, newwidth)),
(newstartx + newwidth, starty + newwidth, newwidth));
list.foreach{ case (nstartx, nstarty, nwidth) => drawTriangle(nstartx, nstarty, nwidth)}
list;
}
해결책
당신의 기능에 쌍을 반환하도록하십시오. 왼쪽 절반에는 현재 반복의 삼각형이 포함되어 있습니다. 오른쪽 절반에는 다음 반복과 함수를 위해 삼각형이 포함 된 쌍을 반환하는 함수가 포함되어 있습니다 ...
편집하다 솔루션을 다시 작성하는 방법은 다음과 같습니다.
type Triangle = (Double, Double, Double)
def fractal(width : Double): Stream[List[Triangle]] = {
val w2 = width / 2
def surrounding(t: Triangle) = match t case (startx, starty, width) => {
val w = width/2
val x = startx + w / 2
val y = starty - w
List((x, y, w),
(x - w, starty + w, w),
(x + w, starty + w, w))
}
def s(tris: List[Triangle]): Stream[List[Triangle]] =
Stream.cons(tris, s(tris.flatMap(surrounding(_))))
s(List((w2/2, w2, w2)))
}
나는 이것을 시도하지 않았지만,이 효과에 매우 많은 것이 당신에게 반복의 흐름을 줄 것입니다. 각 반복은 삼각형 목록입니다. 반복을 그리려면 스트림에서 팝업하고 전화하십시오. drawTriangle 그 위에.
스타일 팁 : 피하십시오 foreach. 탭 대신 2 개 또는 3 개의 공간을 사용하십시오. Terse 이름을 사용하여 도망 갈 수 있습니다. 코드가 구조를 쉽게 스캔 할 수 있습니다. 세미콜론은 불필요한 소음입니다.
다른 팁
스트림은 잠재적으로 무한한 시퀀스의 게으른 계산을 캡슐화합니다. 그들은 작업하기가 까다로울 수 있습니다. Scaladoc을 확인하고 블로그를 찾고 Scala Mailing List Archives를 검색하여 2.7 라이브러리의 구현이 적용되는 것이 무엇인지에 대한 충분한 이해가 없을 때 자신의 사용을 둘러싼 많은 이야기에 대해 검색하십시오. ..
너무 모호하게 미안하지만 한 번 사용했지만 더 구체적으로 노력할 자격이 없다고 생각합니다 ...
랜달 슐츠
아래 코드가 귀하의 코드를 충실하게 재현한다고 생각합니다. 당신은 an을 만듭니다 Iterator그리고 다른 반복자처럼 루프.
case class Triangle(startx: Double, starty: Double, width: Double)
class drawSurroundingTrianglesIterator(original: Triangle) extends Iterator[Unit] {
private case class Iteration(old: Triangle, `new`: Triangle)
private var iteration = List(newIteration(original))
def hasNext = ! iteration.isEmpty
def next = {
iteration = iteration flatMap variants map newIteration
iteration map (_.old) foreach draw
iteration = iteration filter (_.`new`.width > 5)
}
private def newIteration(triangle: Triangle) = {
import triangle._
Iteration(triangle, Triangle(startx + width / 4, starty - width / 2, width / 2))
}
private def variants(iteration: Iteration) = {
import iteration._
import `new`._
List(Triangle(startx, starty, width),
Triangle(startx - width, old.starty + width, width),
Triangle(startx + width, old.starty + width, width))
}
private def draw(triangle: Triangle) = {
import triangle._
drawTriangle(startx, starty, width)
}
}
사용 예 :
scala> new drawSurroundingTrianglesIterator(Triangle(100, 100, 40))
res1: drawSurroundingTrianglesIterator = non-empty iterator
scala> res1 foreach (x => x)
Drawing 110,000000, 80,000000, 20,000000
Drawing 90,000000, 120,000000, 20,000000
Drawing 130,000000, 120,000000, 20,000000
Drawing 115,000000, 70,000000, 10,000000
Drawing 105,000000, 90,000000, 10,000000
Drawing 125,000000, 90,000000, 10,000000
Drawing 95,000000, 110,000000, 10,000000
Drawing 85,000000, 130,000000, 10,000000
Drawing 105,000000, 130,000000, 10,000000
Drawing 135,000000, 110,000000, 10,000000
Drawing 125,000000, 130,000000, 10,000000
Drawing 145,000000, 130,000000, 10,000000
이제 var 분명히, 이것은 완전히 비 기능적입니다. 반복적이지만 기능적으로 수행하려면 "상태"를 인수로 전달해야합니다. next 하고있다:
case class Triangle(startx: Double, starty: Double, width: Double)
case class Iteration(old: Triangle, `new`: Triangle)
object TriangleIterator {
def iterate(from: List[Iteration]) = {
val iteration = from flatMap variants map newIteration
iteration map (_.old) foreach draw
iteration filter (_.`new`.width > 5)
}
def newIteration(triangle: Triangle) = {
import triangle._
Iteration(triangle, Triangle(startx + width / 4, starty - width / 2, width / 2))
}
private def variants(iteration: Iteration) = {
import iteration._
import `new`._
List(Triangle(startx, starty, width),
Triangle(startx - width, old.starty + width, width),
Triangle(startx + width, old.starty + width, width))
}
private def draw(triangle: Triangle) = {
import triangle._
drawTriangle(startx, starty, width)
}
}
이 경우 나는 만들었다 newIteration 공개적으로 첫 번째를 생산할 수 있습니다. 사용 예는 다음과 같습니다.
scala> List(TriangleIterator.newIteration(Triangle(100, 100, 50)))
res0: List[Iteration] = List(Iteration(Triangle(100.0,100.0,50.0),Triangle(112.5,75.0,25.0)))
scala> TriangleIterator.iterate(res0)
Drawing 112,500000, 75,000000, 25,000000
Drawing 87,500000, 125,000000, 25,000000
Drawing 137,500000, 125,000000, 25,000000
res1: List[Iteration] = List(Iteration(Triangle(112.5,75.0,25.0),Triangle(118.75,62.5,12.5)), Iteration(Triangle(87.5,12
5.0,25.0),Triangle(93.75,112.5,12.5)), Iteration(Triangle(137.5,125.0,25.0),Triangle(143.75,112.5,12.5)))
scala> TriangleIterator.iterate(res1)
Drawing 118,750000, 62,500000, 12,500000
Drawing 106,250000, 87,500000, 12,500000
Drawing 131,250000, 87,500000, 12,500000
Drawing 93,750000, 112,500000, 12,500000
Drawing 81,250000, 137,500000, 12,500000
Drawing 106,250000, 137,500000, 12,500000
Drawing 143,750000, 112,500000, 12,500000
Drawing 131,250000, 137,500000, 12,500000
Drawing 156,250000, 137,500000, 12,500000
res2: List[Iteration] = List(Iteration(Triangle(118.75,62.5,12.5),Triangle(121.875,56.25,6.25)), Iteration(Triangle(106.
25,87.5,12.5),Triangle(109.375,81.25,6.25)), Iteration(Triangle(131.25,87.5,12.5),Triangle(134.375,81.25,6.25)), Iterati
on(Triangle(93.75,112.5,12.5),Triangle(96.875,106.25,6.25)), Iteration(Triangle(81.25,137.5,12.5),Triangle(84.375,131.25
,6.25)), Iteration(Triangle(106.25,137.5,12.5),Triangle(109.375,131.25,6.25)), Iteration(Triangle(143.75,112.5,12.5),Tri
angle(146.875,106.25,6.25)), Iteration(Triangle(131.25,137.5,12.5),Triangle(134.375,131.25,6.25)), Iteration(Triangle(15
6.25,137.5,12.5),Triangle(159.375,131.25,6.25)))
scala> TriangleIterator.iterate(res2)
Drawing 121,875000, 56,250000, 6,250000
Drawing 115,625000, 68,750000, 6,250000
Drawing 128,125000, 68,750000, 6,250000
Drawing 109,375000, 81,250000, 6,250000
Drawing 103,125000, 93,750000, 6,250000
Drawing 115,625000, 93,750000, 6,250000
Drawing 134,375000, 81,250000, 6,250000
Drawing 128,125000, 93,750000, 6,250000
Drawing 140,625000, 93,750000, 6,250000
Drawing 96,875000, 106,250000, 6,250000
Drawing 90,625000, 118,750000, 6,250000
Drawing 103,125000, 118,750000, 6,250000
Drawing 84,375000, 131,250000, 6,250000
Drawing 78,125000, 143,750000, 6,250000
Drawing 90,625000, 143,750000, 6,250000
Drawing 109,375000, 131,250000, 6,250000
Drawing 103,125000, 143,750000, 6,250000
Drawing 115,625000, 143,750000, 6,250000
Drawing 146,875000, 106,250000, 6,250000
Drawing 140,625000, 118,750000, 6,250000
Drawing 153,125000, 118,750000, 6,250000
Drawing 134,375000, 131,250000, 6,250000
Drawing 128,125000, 143,750000, 6,250000
Drawing 140,625000, 143,750000, 6,250000
Drawing 159,375000, 131,250000, 6,250000
Drawing 153,125000, 143,750000, 6,250000
Drawing 165,625000, 143,750000, 6,250000
res3: List[Iteration] = List()
여기에 내가 온 최종 답변은 다음과 같습니다.
나는 이것을 더 좋게 만들기 위해 특성을 사용해야하는지 모르겠지만, 이것이 반복하는 가장 좋은 방법이라고 생각합니다.
def drawFractal(width : Double) {
val mywidth = width / 2;
val drawSurroundingTriangles = drawSurroundingTrianglesComplete((startx, starty, width) => {
val newwidth = width/2;
val newstartx = startx + newwidth / 2;
val newstarty = starty - newwidth;
var list = List((newstartx, newstarty, newwidth),
((newstartx - newwidth, starty + newwidth, newwidth)),
(newstartx + newwidth, starty + newwidth, newwidth));
list.foreach{ case (nstartx, nstarty, nwidth) => drawTriangle(nstartx, nstarty, nwidth)}
list;
})_
var mylist = drawSurroundingTriangles(List((mywidth/2, mywidth, mywidth)));
mylist.foreach{ case (startx, starty, width) => print ("[" + startx + "," + starty + "," + width + "]\n")}
print("\n");
mylist = drawSurroundingTriangles(mylist);
mylist.foreach{ case (startx, starty, width) => print ("[" + startx + "," + starty + "," + width + "]\n")}
}
def drawSurroundingTrianglesComplete(myfunc : (Double, Double, Double) => List[(Double, Double, Double)])
(indexlist : List[(Double, Double, Double)]) :
List[(Double, Double, Double)] = {
var mylist = ListBuffer[(Double, Double, Double)]()
indexlist.foreach{
case (startx, starty, width) => { mylist ++= myfunc(startx, starty, width) } }
mylist.toList;
}
제휴하지 않습니다 StackOverflow
