[模拟]ZOJ3480 Duck Typing

题意:给了一坨...按题目意思输出就好了...

给一组案例

100
begin
class d
class c:d
class b:c
class a:b
def d.m
def d.n
call a.m
end

答案应该是

class dclass c:dclass b:cclass a:b
def d.m
def d.n
invoke d.m

建立的泪应该是这样的

a:b:c:d

d有method m和n

那么call a、b、c的n、m时都应invoke d的

  1 map<string, bool> mp_class, mp_method;
  2 map<string, string> mp_super[100005];
  3 map<string, int> s_num;
  4 bool dfs(string name, string method)
  5 {
  6     if(mp_method[name+"."+method])
  7     {
  8         printf("invoke ");
  9         cout<<name<<"."<<method<<endl;
 10         return true;
 11     }
 12     for(int i=0;i<s_num[name];i++)
 13         if(dfs(mp_super[i][name], method))
 14             return true;
 15     return false;
 16 }
 17 int main()
 18 {
 19     int t;
 20     scanf("%d", &t);
 21     while(t--)
 22     {
 23         getchar();
 24         char s[10005];
 25         mp_class.clear();
 26         mp_method.clear();
 27         s_num.clear();
 28         while(gets(s))
 29         {
 30             if(s[0]==‘b‘)
 31                 continue;
 32             if(s[0]==‘e‘)
 33                 break;
 34             int n=strlen(s);
 35             if(s[0]==‘c‘ && s[1]==‘l‘)   // class
 36             {
 37                 int i;
 38                 for(i=6;i<n;i++)
 39                     if(s[i]==‘:‘)
 40                         break;
 41                 if(i==n)           // ding yi
 42                 {
 43                     string name="";
 44                     for(int j=6;j<n;j++)
 45                         name+=s[j];
 46                     if(mp_class[name]==0)
 47                     {
 48                         mp_class[name]=1;
 49                         puts(s);
 50                     }
 51                     else
 52                         puts("oops!");
 53                 }
 54                 else
 55                 {
 56                     string name="", super="";
 57                     for(int j=6;j<i;j++)
 58                         name+=s[j];
 59                     for(int j=i+1;j<n;j++)
 60                         super+=s[j];
 61                     if(mp_class[name] || !mp_class[super])
 62                         puts("oops!");
 63                     else
 64                     {
 65                         mp_class[name]=1;
 66                         mp_super[s_num[name]++][name]=super;
 67                         puts(s);
 68                     }
 69                 }
 70             }
 71             else if(s[0]==‘d‘)  // def
 72             {
 73                 int i;
 74                 for(i=0;i<n;i++)
 75                     if(s[i]==‘.‘)
 76                         break;
 77                 string name="";
 78                 for(int j=4;j<i;j++)
 79                     name+=s[j];
 80                 string method=name+".";
 81                 for(int j=i+1;j<n;j++)
 82                     method+=s[j];
 83                 if(!mp_class[name])
 84                     puts("oops!");
 85                 else if(mp_method[method])
 86                 {
 87                     printf("redef ");
 88                     cout<<method<<endl;
 89                 }
 90                 else
 91                 {
 92                     mp_method[method]=1;
 93                     printf("def ");
 94                     cout<<method<<endl;
 95                 }
 96             }
 97             else if(s[0]==‘u‘)  // undef
 98             {
 99                 string name="";
100                 for(int i=6;i<n;i++)
101                     name+=s[i];
102                 if(!mp_method[name])
103                     puts("oops!");
104                 else
105                 {
106                     printf("undef ");
107                     cout<<name<<endl;
108                     mp_method[name]=0;
109                 }
110             }
111             else                // call
112             {
113                 int i;
114                 for(i=5;i<n;i++)
115                     if(s[i]==‘.‘)
116                         break;
117                 string na="";
118                 for(int j=5;j<i;j++)   // class
119                     na+=s[j];
120                 string name="";
121                 for(int j=i+1;j<n;j++)  // method
122                     name+=s[j];
123                 if(mp_method[na+"."+name])
124                 {
125                     printf("invoke ");
126                     cout<<na<<"."<<name<<endl;
127                     continue;
128                 }
129                 if(!dfs(na, name))
130                     puts("oops!");
131 //                bool flag=0;
132 //                string cur=na;
133 //                while(s_num[na])
134 //                {
135 //                    for(int k=0;k<s_num[na];k++)
136 //                        if(mp_method[mp_super[k][na]+"."+name])
137 //                        {
138 //                            printf("invoke ");
139 //                            cout<<mp_super[k][na]<<"."<<name<<endl;
140 //                            flag=1;
141 //                            break;
142 //                        }
143 //                }
144 //                if(!flag)
145 //                    puts("oops!");
146             }
147         }
148         puts("");
149     }
150     return 0;
151 }

ZOJ 3480

时间: 2024-10-11 22:53:29

[模拟]ZOJ3480 Duck Typing的相关文章

Duck typing

第一次了解到这个词汇是我在知乎提了一个问题,知乎传送地址. vczh在答案中提到了duck type,于是google了一番,大概了解了一下,附上wiki地址. 在面向对象的编程语言中,所谓的duck type是指:对象的属性和方法决定了类的语义,而不是它的继承关系或者是它实现了某个接口.这个概念最早是由James Whitcomb Riley提出的,下面这句话可以帮助我们理解: When I see a bird that walks like a duck and swims like a

什么是鸭子类型(duck typing)

"当看到一只鸟走起来像鸭子.游泳起来像鸭子.叫起来也像鸭子,那么这只鸟就可以被称为鸭子." 我们并不关心对象是什么类型,到底是不是鸭子,只关心行为. 比如在python中,有很多file-like的东西,比如StringIO,GzipFile,socket.它们有很多相同的方法,我们把它们当作文件使用. 鸭子类型在动态语言中经常使用,非常灵活,使得python不想java那样专门去弄一大堆的设计模式. 下面例子用duck typing来实现多态. #coding=utf-8 class

什么是“鸭子类型(duck typing)”?

在计算机编程世界里会接触到一个知识点 —— duck typing,叫“鸭子类型”. 它有一个形象的解释: “当看到一只鸟走起来像鸭子.游泳起来像鸭子.叫起来也像鸭子,那么这只鸟就可以被称为鸭子.” 怎么去理解这句话呢? 鸭子,假如我们都不知道它表示什么.我定义:会走的.会游泳的.会叫的鸟 —— 叫“鸭子”. 我定义的这个“鸭子”,可以说是一个分类,在这个分类里,都是包含了具有共同技能(走.游泳和叫)的鸟. 这个“鸭子”就属于“鸭子类型”.对于这个类型里的每一个成员(不只有“鸭子”),其分类的依

Monkey Patch/Monkey Testing/Duck Typing/Duck Test

Monkey Patch Monkey Testing Duck Typing Duck Test

【ZOJ 3480】Duck Typing

题 题意 1.有t组数据,输入时每组数据之间空格隔开,输出时也要求空格隔开. 2.每组都是一行begin开始,一行end结束. 3.class ClassName[:Super] 表示声明一个类型,Super值存在时,说明它继承Super类型. 4.def ClassName.Method 表示声明ClassName类型的一个方法. 5.undef ClassName.Method 表示删除该类型下该方法. 6.call ClassName.Method 表示调用该方法,如果该类型本身没有该方法

duck type鸭子类型

在程序设计中,鸭子类型(英语:duck typing)是动态类型的一种风格.在这种风格中,一个对象有效的语义,不是由继承自特定的类或实现特定的接口,而是由当前方法和属性的集合决定.这个概念的名字来源于由James Whitcomb Riley提出的鸭子测试(见下面的"历史"章节),"鸭子测试"可以这样表述: "当看到一只鸟走起来像鸭子.游泳起来像鸭子.叫起来也像鸭子,那么这只鸟就可以被称为鸭子."[1][2] 在鸭子类型中,关注的不是对象的类型本

Duck Type in Python

在程序设计中,鸭子类型(英语:duck typing)是动态类型的一种风格.在这种风格中,一个对象有效的语义,不是由继承自特定的类或实现特定的接口,而是由当前方法和属性的集合决定 “当看到一只鸟走起来像鸭子.游泳起来像鸭子.叫起来也像鸭子,那么这只鸟就可以被称为鸭子.” 就我个人的理解来看,duck type 是一种语法糖,它不强调对象的类型,或者它继承自哪里,只在乎它是否能够实现了我需要的方法,总的来说,就是,不管你什么出身,不管黑猫白猫,能抓住老鼠的就是好猫. 这种动态类型可以很方便的实现多

LINQ综合学习大全

LINQ体验 LINQ体验(1)——Visual Studio 2008新特性 一.写本系列的目的 我平时利用课余零碎时间来学习ASP.NET3.5.LINQ.Silverlight.ASP.NET 3.5 Extensions等新东西,通过笔记形式来记录自己所学的历程,也给大家一起学习Visual Studio 2008 和 .NET 3.5提供一个平台,为保证此系列的完整性,我打算先依次介绍一下C# 3.0新语言特性和改进,然后从一条一条LINQ语句分析来贯穿LINQ的知识点.最后通过一个实

Python的对象协议

Python是一门动态语言,Duck Typing概念遍布其中,所以其中的Concept并不是以类型的约束为载体,而是使用称作为协议的概念.那什么是Duck Typing呢? Duck Typing是鸭子类型,在动态语言中用的较多,是动态类型语言设计的一种风格.在这种风格中,一个对象有效的语义,不是由继承自特定的类或实现特定的接口决定,而是由当前方法和属性的集合决定.说白了就是并不关心对象是什么类型,只关心行为. 这个概念的名字来源于由James Whitcomb Riley提出的鸭子测试(见下