daily pastebin goal
57%
SHARE
TWEET

Untitled

a guest Jun 3rd, 2018 47 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. package main
  2.  
  3. import (
  4.     "fmt"
  5. )
  6.  
  7.  
  8. type Unknown2 struct {
  9.     ind int
  10.     zif []int
  11.     buk []string
  12. }
  13.  
  14. type stk struct {
  15.     s []Unknown2
  16.     top Unknown2
  17.     size int
  18. }
  19.  
  20.  
  21. func Pop(stack stk) Unknown2{
  22.     if stack.size - 1 >0 {
  23.         stack.top = stack.s[stack.size-1]
  24.         //stack.size--
  25.     }
  26.     return stack.top
  27. }
  28. func Push(stack stk, nw Unknown2) {
  29.     stack.size++
  30.     stack.s[stack.size-1] = nw
  31.     stack.top = stack.s[stack.size-1]
  32.  
  33. }
  34.  
  35.  
  36.  
  37.  
  38. //////////////////////////////////
  39.  
  40. func Poisk(C []int, q int) int{
  41.     k := 0
  42.     for i := 0; i < len(C) ;i++  {
  43.         if q != C[i]{
  44.             return -1
  45.         }
  46.         k = k + 1
  47.     }
  48.     return k
  49. }
  50.  
  51. func Closure(del []Unknown2, z []int, n int, la string) []int{
  52.     C := make([]int, n)
  53.     for i := 0; i < n ; i++  {
  54.         C[i] = -1
  55.     }
  56.     for i := 0; i < len(z) ;i++ {
  57.         dfs(del, z[i], n, C, la)
  58.     }
  59.     return C
  60. }
  61.  
  62. func dfs (del []Unknown2, q int, n int, C []int, la string){
  63.     if Poisk(C, q) == -1{
  64.         for i:=0; i<len(C); i++ {
  65.             if C[i] == -1 && q != -1 {
  66.                 C[i] = q
  67.                 break
  68.             }
  69.         }
  70.  
  71.         for i:=0; i<len(del); i++ {
  72.             for k := 0; k < len (del[i].zif) ;k++ {
  73.                 //fmt.Print(del[i].buk[k], " YA BRIL NOSOK ", q, " ")
  74.                 if del[i].ind == q && del[i].buk[k] == "lambda" {
  75.                     dfs(del, del[i].zif[k], n, C, la)
  76.                 }
  77.             }
  78.         }
  79.     }
  80. }
  81.  
  82. func Che(z []int, Q []Unknown2) bool {
  83.     for i := 0; i < len(Q) ;i++  {
  84.         flag := 0
  85.         if len(z) == len(Q[i].zif){
  86.             for j := 0; j < len(z) ;j++  {
  87.                 if z[j] == Q[i].zif[j]{
  88.  
  89.                 }else{
  90.                     flag = -1
  91.                 }
  92.             }
  93.             if flag == 0{
  94.                 return true
  95.             }
  96.         }
  97.     }
  98.     return false
  99. }
  100.  
  101. func det(del []Unknown2, Fin []int, q int, n int, alf []string) []Unknown2{
  102.  
  103.     q0 := make([]int, n)
  104.     z := make([]int, 0)
  105.     z = append(z, q)
  106.     fmt.Print("!#@!$!@#$", z)
  107.     q0 = Closure(del, z, n, "lambda")
  108.     Q := make([]Unknown2, n)
  109.     F := make([]Unknown2, n)
  110.     fmt.Print(q0)
  111.     var prest Unknown2
  112.     prest.zif =q0
  113.     Q = append(Q, prest)
  114.     var stack stk
  115.     for i := 0; i < 1 ;i++  {
  116.             stack.top = prest
  117.             stack.s = append(stack.s, prest)
  118.             stack.size = 1
  119.     }
  120.     for i := stack.size; i >=1; {
  121.         prest = Pop(stack)
  122.         fmt.Print(prest, "(.)")
  123.         i = stack.size - 1
  124.         //fmt.Print(prest)
  125.         for j := 0; j< len(prest.zif) && prest.zif[j] != -1 ; j++   {
  126.             //fmt.Print("zif = ",prest.zif[j], " j = ", j, " ")
  127.             if Fin[prest.zif[j]] == 1 {
  128.  
  129.                 F = append(F, prest)
  130.                 break
  131.             }
  132.         }
  133.         for p := 0; p < len(alf) ; p++  {
  134.             z1 := make([]int, n)
  135.             z1 = Closure(del, prest.zif, n, alf[p])
  136.             fmt.Println(z1, "        !@#!@#!@#!@#!@        " )
  137.             var Help = Unknown2{p ,z1, alf}
  138.             if Che(z1, Q){
  139.                 Q = append(Q, Help)
  140.                 Push(stack, Help)
  141.             }
  142.         }
  143.     }
  144.     return Q
  145. }
  146.  
  147.  
  148. func kek(st []string, j string) bool {
  149.     for i := 0; i < len(st) ; i++  {
  150.         if st[i] == j{
  151.             return true
  152.         }
  153.     }
  154.     return false
  155. }
  156.  
  157.  
  158. func main() {
  159.     var n,m, j, jj int
  160.     var Last int
  161.     var preor []int
  162.     var alfa []string
  163.     var jjj string
  164.     fmt.Scan(&n, &m)
  165.  
  166.     GR := make ([]Unknown2, n)
  167.     for i :=0; i < m ; i++{
  168.         fmt.Scan(&j)
  169.         //fmt.Println(j)
  170.         fmt.Scan(&jj)
  171.  
  172.         GR[j].ind = j
  173.  
  174.         GR[j].zif = append(GR[j].zif, jj)
  175.  
  176.         fmt.Scan(&jjj)
  177.         GR[j].buk = append(GR[j].buk, jjj)
  178.         if !kek(alfa, jjj) {
  179.             alfa = append(alfa, jjj)
  180.         }
  181.     }
  182.     for i := 0; i  < n ;i++  {
  183.         preor = append(preor, 0)
  184.         fmt.Scan(preor[i])
  185.     }
  186.     fmt.Scan(&Last)
  187.     fmt.Println(GR)
  188.  
  189.     fmt.Print(det(GR,preor, Last, n, alfa))
  190.  
  191.  
  192. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top