2022年9月20，相同字母的距离（明明有简单的方法，但我却要犯个蠢，哭哭哭）

题目： 
给你一个下标从 0 开始的字符串 s ，该字符串仅由小写英文字母组成，s 中的每个字母都 恰好 出现 两次 。

另给你一个下标从 0 开始、长度为 26 的的整数数组 distance 。

字母表中的每个字母按从 0 到 25 依次编号（即，'a' -> 0, 'b' -> 1, 'c' -> 2, ... , 'z' -> 25）。

在一个 匀整 字符串中，第 i 个字母的两次出现之间的字母数量是 distance[i] 。如果第 i 个字母没有在 s 中出现，那么 distance[i] 可以 忽略 。

如果 s 是一个 匀整 字符串，返回 true ；否则，返回 false 。

示例 1：

输入：s = "abaccb", distance = [1,3,0,5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]
输出：true
解释：
- 'a' 在下标 0 和下标 2 处出现，所以满足 distance[0] = 1 。
- 'b' 在下标 1 和下标 5 处出现，所以满足 distance[1] = 3 。
- 'c' 在下标 3 和下标 4 处出现，所以满足 distance[2] = 0 。
注意 distance[3] = 5 ，但是由于 'd' 没有在 s 中出现，可以忽略。
因为 s 是一个匀整字符串，返回 true 。
示例 2：

输入：s = "aa", distance = [1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]
输出：false
解释：
- 'a' 在下标 0 和 1 处出现，所以两次出现之间的字母数量为 0 。
但是 distance[0] = 1 ，s 不是一个匀整字符串。

提示：

2 <= s.length <= 52
s 仅由小写英文字母组成
s 中的每个字母恰好出现两次
distance.length == 26
0 <= distance[i] <= 50

代码1（蠢方法）：
  1 public boolean checkDistances(String s, int[] distance) {
  2         for (int i = 0; i <s.length() ; i++) {
  3             switch (s.charAt(i)){
  4                 case 'a':
  5                     for (int j = i+1; j <s.length() ; j++) {
  6                         switch (s.charAt(j)){
  7                             case 'a':
  8                                 if (distance[0]!=j-i-1){
  9                                     return false;
 10                                 }
 11                         }
 12                     }
 13                     break;
 14                 case 'b':
 15                     for (int j = i+1; j <s.length() ; j++) {
 16                         switch (s.charAt(j)){
 17                             case 'b':
 18                                 if(distance[1]!=j-i-1){
 19                                     return false;
 20                                 }
 21                         }
 22                     }
 23                     break;
 24                 case 'c':
 25                     for (int j = i+1; j <s.length() ; j++) {
 26                         switch (s.charAt(j)){
 27                             case 'c':
 28                                 if (distance[2]!=j-i-1){
 29                                     return false;
 30                                 }
 31                         }
 32                     }
 33                     break;
 34                 case 'd':
 35                     for (int j = i+1; j <s.length() ; j++) {
 36                         switch (s.charAt(j)){
 37                             case 'd':
 38                                 if(distance[3]!=j-i-1){
 39                                     return false;
 40                                 }
 41                         }
 42                     }
 43                     break;
 44                 case 'e':
 45                     for (int j = i+1; j <s.length() ; j++) {
 46                         switch (s.charAt(j)){
 47                             case 'e':
 48                                 if(distance[4]!=j-i-1){
 49                                     return false;
 50                                 }
 51                         }
 52                     }
 53                     break;
 54                 case 'f':
 55                     for (int j = i+1; j <s.length() ; j++) {
 56                         switch (s.charAt(j)){
 57                             case 'f':
 58                                 if (distance[5]!=j-i-1){
 59                                     return false;
 60                                 }
 61                         }
 62                     }
 63                     break;
 64                 case 'g':
 65                     for (int j = i+1; j <s.length() ; j++) {
 66                         switch (s.charAt(j)){
 67                             case 'g':
 68                                 if (distance[6]!=j-i-1){
 69                                     return false;
 70                                 }
 71                         }
 72                     }
 73                     break;
 74                 case 'h':
 75                     for (int j = i+1; j <s.length() ; j++) {
 76                         switch (s.charAt(j)){
 77                             case 'h':
 78                                 if(distance[7]!=j-i-1){
 79                                     return false;
 80                                 }
 81                         }
 82                     }
 83                     break;
 84                 case 'i':
 85                     for (int j = i+1; j <s.length() ; j++) {
 86                         switch (s.charAt(j)){
 87                             case 'i':
 88                                 if(distance[8]!=j-i-1){
 89                                     return false;
 90                                 }
 91                         }
 92                     }
 93                     break;
 94                 case 'j':
 95                     for (int j = i+1; j <s.length() ; j++) {
 96                         switch (s.charAt(j)){
 97                             case 'j':
 98                                 if(distance[9]!=j-i-1){
 99                                     return false;
100                                 }
101                         }
102                     }
103                     break;
104                 case 'k':
105                     for (int j = i+1; j <s.length() ; j++) {
106                         switch (s.charAt(j)){
107                             case 'k':
108                                 if(distance[10]!=j-i-1){
109                                     return false;
110                                 }
111                         }
112                     }
113                     break;
114                 case 'l':
115                     for (int j = i+1; j <s.length() ; j++) {
116                         switch (s.charAt(j)){
117                             case 'l':
118                                 if(distance[11]!=j-i-1){
119                                     return false;
120                                 }
121                         }
122                     }
123                     break;
124                 case 'm':
125                     for (int j = i+1; j <s.length() ; j++) {
126                         switch (s.charAt(j)){
127                             case 'm':
128                                 if(distance[12]!=j-i-1){
129                                     return false;
130                                 }
131                         }
132                     }
133                     break;
134                 case 'n':
135                     for (int j = i+1; j <s.length() ; j++) {
136                         switch (s.charAt(j)){
137                             case 'n':
138                                 if(distance[13]!=j-i-1){
139                                     return false;
140                                 }
141                         }
142                     }
143                     break;
144                 case 'o':
145                     for (int j = i+1; j <s.length() ; j++) {
146                         switch (s.charAt(j)){
147                             case 'o':
148                                 if(distance[14]!=j-i-1){
149                                     return false;
150                                 }
151                         }
152                     }
153                     break;
154                 case 'p':
155                     for (int j = i+1; j <s.length() ; j++) {
156                         switch (s.charAt(j)){
157                             case 'p':
158                                 if(distance[15]!=j-i-1) {
159                                     return false;
160                                 }
161                         }
162                     }
163                     break;
164                 case 'q':
165                     for (int j = i+1; j <s.length() ; j++) {
166                         switch (s.charAt(j)){
167                             case 'q':
168                                 if(distance[16]!=j-i-1){
169                                     return false;
170                                 }
171                         }
172                     }
173                     break;
174                 case 'r':
175                     for (int j = i+1; j <s.length() ; j++) {
176                         switch (s.charAt(j)){
177                             case 'r':
178                                 if(distance[17]!=j-i-1){
179                                     return false;
180                                 }
181                         }
182                     }
183                     break;
184                 case 's':
185                     for (int j = i+1; j <s.length() ; j++) {
186                         switch (s.charAt(j)){
187                             case 's':
188                                 if (distance[18]!=j-i-1){
189                                     return false;
190                                 }
191                         }
192                     }
193                     break;
194                 case 't':
195                     for (int j = i+1; j <s.length() ; j++) {
196                         switch (s.charAt(j)){
197                             case 't':
198                                 if (distance[19]!=j-i-1){
199                                     return false;
200                                 }
201                         }
202                     }
203                     break;
204                 case 'u':
205                     for (int j = i+1; j <s.length() ; j++) {
206                         switch (s.charAt(j)){
207                             case 'u':
208                                 if ( distance[20]!=j-i-1){
209                                     return false;
210                                 }
211                         }
212                     }
213                     break;
214                 case 'v':
215                     for (int j = i+1; j <s.length() ; j++) {
216                         switch (s.charAt(j)){
217                             case 'v':
218                                 if ( distance[21]!=j-i-1){
219                                     return false;
220                                 }
221                         }
222                     }
223                     break;
224                 case 'w':
225                     for (int j = i+1; j <s.length() ; j++) {
226                         switch (s.charAt(j)){
227                             case 'w':
228                                 if ( distance[22]!=j-i-1){
229                                     return false;
230                                 }
231                         }
232                     }
233                     break;
234                 case 'x':
235                     for (int j = i+1; j <s.length() ; j++) {
236                         switch (s.charAt(j)){
237                             case 'x':
238                                 if ( distance[23]!=j-i-1){
239                                     return false;
240                                 }
241                         }
242                     }
243                     break;
244                 case 'y':
245                     for (int j = i+1; j <s.length() ; j++) {
246                         switch (s.charAt(j)){
247                             case 'y':
248                                 if ( distance[24]!=j-i-1){
249                                     return false;
250                                 }
251                         }
252                     }
253                     break;
254                 case 'z':
255                     for (int j = i+1; j <s.length() ; j++) {
256                         switch (s.charAt(j)){
257                             case 'z':
258                                 if (distance[25]!=j-i-1){
259                                     return false;
260                                 }
261                         }
262                     }
263                     break;
264 
265 
266             }
267         }
268 
269         return true;
270     }

方法2（简化后的版本）

 

public boolean checkDistances(String s, int[] distance) {
        for (int i = 0; i <s.length()-1 ; i++) {
            for (int j = i+1; j <s.length() ; j++) {
                if (s.charAt(i)==s.charAt(j)){
                    int a=s.charAt(i)-97;
                    if (distance[a]!=j-i-1){
                        return false;
                    }
                }
            }
        }
        return true;
    }

 

唉，两种思路都是一样的，就我自己大蠢蛋！

posted @ 2022-09-20 15:32  牛杂刻师傅  阅读(45)  评论(0)    收藏  举报