-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathString-1.java
More file actions
417 lines (354 loc) · 11.9 KB
/
Copy pathString-1.java
File metadata and controls
417 lines (354 loc) · 11.9 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
// Given a string name, e.g. "Bob", return a greeting of the form "Hello Bob!".
public String helloName(String name)
{ return ("Hello " + name + '!'); }
// Given two strings, a and b, return the result of putting them together in the order abba,
// e.g. "Hi" and "Bye" returns "HiByeByeHi".
public String makeAbba(String a, String b)
{ return (a+b+b+a); }
// The web is built with HTML strings like "<i>Yay</i>" which draws Yay as italic text.
// In this example, the "i" tag makes <i> and </i> which surround the word "Yay".
// Given tag and word strings, create the HTML string with tags around the word, e.g. "<i>Yay</i>".
public String makeTags(String tag, String word)
{ return ('<' + tag + '>' + word + '<' + '/' + tag + '>'); }
// Given an "out" string length 4, such as "<<>>", and a word, return a new string
// where the word is in the middle of the out string, e.g. "<<word>>".
// Note: use str.substring(i, j) to extract the String starting at index i and going up to but not including index j.
public String makeOutWord(String out, String word)
{ return (out.substring(0, 2) + word + out.substring(2, 4)); }
// Given a string, return a new string made of 3 copies of the last 2 chars of the original string.
// The string length will be at least 2.
public String extraEnd(String str)
{
int len = str.length();
String temp = str.substring(len-2, len);
return (temp + temp + temp);
}
// Given a string, return the string made of its first two chars, so the String "Hello" yields "He".
// If the string is shorter than length 2, return whatever there is, so "X" yields "X",
// and the empty string "" yields the empty string "".Note that str.length() returns the length of a string.
public String firstTwo(String str)
{
if(str.length() >= 3)
return str.substring(0, 2);
return str;
}
// Given a string of even length, return the first half. So the string "WooHoo" yields "Woo".
public String firstHalf(String str)
{
return str.substring(0, str.length()/2);
}
// Given a string, return a version without the first and last char, so "Hello" yields "ell".
// The string length will be at least 2.
public String withoutEnd(String str)
{ return str.substring(1, str.length()-1); }
// Given 2 strings, a and b, return a string of the form short+long+short, with the shorter string on the outside
// and the longer string on the inside. The strings will not be the same length, but they may be empty (length 0).
public String comboString(String a, String b)
{
if(a.length() >= b.length())
return b+a+b;
return a+b+a;
}
// Given 2 strings, return their concatenation, except omit the first char of each.
// The strings will be at least length 1.
public String nonStart(String a, String b)
{ return (a.substring(1) + b.substring(1)); }
// Given a string, return a "rotated left 2" version where the first 2 chars are moved to the end.
// The string length will be at least 2.
public String left2(String str)
{ return (str.substring(2) + str.substring(0, 2));}
// Given a string, return a "rotated right 2" version where the last 2 chars are moved to the start.
// The string length will be at least 2.
public String right2(String str)
{
int len = str.length()-2;
return (str.substring(len) + str.substring(0, len));
}
// Given a string, return a string length 1 from its front, unless front is false,
// in which case return a string length 1 from its back. The string will be non-empty.
public String theEnd(String str, boolean front)
{
if(front)
return str.substring(0, 1);
return str.substring(str.length()-1);
}
// Given a string, return a version without both the first and last char of the string.
// The string may be any length, including 0.
public String withouEnd2(String str)
{
int len = str.length();
if(len >= 3)
return str.substring(1, len-1);
return "";
}
// Given a string of even length, return a string made of the middle two chars,
// so the string "string" yields "ri". The string length will be at least 2.
public String middleTwo(String str)
{
int half = str.length()/2-1;
return str.substring(half, half+2);
}
// Given a string, return true if it ends in "ly".
public boolean endsLy(String str)
{
int len = str.length();
if(len >= 2)
return (str.substring(str.length()-2).equals("ly"));
return false;
}
// Given a string and an int n, return a string made of the first and last n chars from the string.
// The string length will be at least n.
public String nTwice(String str, int n)
{ return (str.substring(0, n) + str.substring(str.length()-n)); }
// Given a string and an index, return a string length 2 starting at the given index.
// If the index is too big or too small to define a string length 2, use the first 2 chars.
// The string length will be at least 2.
public String twoChar(String str, int index)
{
if(index <= str.length()-2 && index >= 0)
return str.substring(index, index+2);
return str.substring(0, 2);
}
// Given a string of odd length, return the string length 3 from its middle,
// so "Candy" yields "and". The string length will be at least 3.
public String middleThree(String str)
{
int len = str.length()/2;
return str.substring(len-1,len+2);
}
// Given a string, return true if "bad" appears starting at index 0 or 1 in the string, such as with "badxxx" or
// "xbadxx" but not "xxbadxx". The string may be any length, including 0. Note: use .equals() to compare 2 strings.
public boolean hasBad(String str)
{
int len = str.length();
if(len == 3 && str.equals("bad"))
return true;
else if(len >= 4)
{
if(str.substring(0, 3).equals("bad"))
return true;
return str.substring(1, 4).equals("bad");
}
else
return false;
}
// Given a string, return a string length 2 made of its first 2 chars.
// If the string length is less than 2, use '@' for the missing chars.
public String atFirst(String str)
{
int len = str.length();
if(len >= 2)
return str.substring(0, 2);
else if(len == 1)
return (str.charAt(0)+"@");
else
return "@@";
}
// Given 2 strings, a and b, return a new string made of the first char of a and
// the last char of b, so "yo" and "java" yields "ya". If either string is length 0
// use '@' for its missing char.
public String lastChars(String a, String b)
{
int lenB = b.length();
String combStr = "";
combStr += (a.length() >= 1) ? a.charAt(0) : '@';
combStr += (lenB >= 1) ? b.charAt(lenB-1) : '@';
return combStr;
}
// Given two strings, append them together (known as "concatenation") and return the result.
// However, if the concatenation creates a double-char, then omit one of the chars, so "abc" and "cat" yields "abcat".
public String conCat(String a, String b)
{
int lenA = a.length();
int lenB = b.length();
if(lenA >= 1 && lenB >= 1)
{
if(a.charAt(lenA-1) == b.charAt(0))
return (a + b.substring(1));
else
return (a + b);
}
return (a + b);
}
// Given a string of any length, return a new string where the last 2 chars
// if present, are swapped, so "coding" yields "codign".
public String lastTwo(String str)
{
int len = str.length();
if(len >= 2)
return str.substring(0, len-2)+str.charAt(len-1)+str.charAt(len-2);
else
return str;
}
// Given a string, if the string begins with "red" or "blue" return that color string
// otherwise return the empty string.
public String seeColor(String str)
{
int len = str.length();
if(len >= 4)
{
if(str.substring(0, 4).equals("blue"))
return "blue";
else if(str.substring(0, 3).equals("red"))
return "red";
else
return "";
}
else if(len == 3)
{
if(str.substring(0, 3).equals("red"))
return "red";
else
return "";
}
else
return "";
}
// Given a string, return true if the first 2 chars in the string also appear
// at the end of the string, such as with "edited".
public boolean frontAgain(String str)
{
int len = str.length();
if(len >= 2)
return str.substring(0, 2).equals(str.substring(len-2, len));
else
return false;
}
// Given two strings, append them together (known as "concatenation") and return the result.
// However, if the strings are different lengths, omit chars from the longer string so it is the
// same length as the shorter string. So "Hello" and "Hi" yield "loHi". The strings may be any length.
public String minCat(String a, String b)
{
int lenA = a.length();
int lenB = b.length();
if(lenA >= lenB)
return (a.substring(lenA-lenB) + b);
else
return (a + b.substring(lenB-lenA));
}
// Given a string, return a new string made of 3 copies of the first 2 chars of the original string.
// The string may be any length. If there are fewer than 2 chars, use whatever is there.
public String extraFront(String str)
{
String temp;
if(str.length() >= 3)
temp = str.substring(0, 2);
else
temp = str;
return (temp + temp + temp);
}
// Given a string, if a length 2 substring appears at both its beginning and end,
// return a string without the substring at the beginning, so "HelloHe" yields "lloHe".
// The substring may overlap with itself, so "Hi" yields "". Otherwise, return the original string unchanged.
public String without2(String str)
{
int len = str.length();
if(len >= 2)
{
if(str.substring(0,2).equals(str.substring(len-2, len)))
return str.substring(2);
else
return str;
}
else
return str;
}
// Given a string, return a version without the first 2 chars. Except keep the first char
// if it is 'a' and keep the second char if it is 'b'. The string may be any length. Harder than it looks.
public String deFront(String str)
{
int len = str.length();
if(len >= 2)
{
StringBuilder stbuild = new StringBuilder(len);
if(str.charAt(0) == 'a')
stbuild.append('a');
if(str.charAt(1) == 'b')
stbuild.append('b');
stbuild.append(str.substring(2));
return stbuild.toString();
}
else if(len == 1 && str.charAt(0) == 'a')
return "a";
else
return "";
}
// OR
public String deFront(String str){
if(str.length() == 1 && str.charAt(0) != 'a')
return "";
if(str.length() >= 2) {
if(str.charAt(0) != 'a' && str.charAt(1) != 'b') {
return str.substring(2);
} else if(str.charAt(0) != 'a') {
return str.substring(1);
} else if(str.charAt(1) != 'b') {
return "a" + str.substring(2);
}
}
return str;
}
// Given a string and a second "word" string, we'll say that the word matches the string if it appears at
// the front of the string, except its first char does not need to match exactly. On a match, return the
// front of the string, or otherwise return the empty string. So, so with the string "hippo" the word
// "hi" returns "hi" and "xip" returns "hip". The word will be at least length 1.
public String startWord(String str, String word)
{
int lenStr = str.length();
int lenWord = word.length();
String temp;
if(lenStr >= lenWord)
{
temp = str.substring(1, lenWord);
if(word.substring(1).equals(temp))
return (str.charAt(0)+temp);
else
return "";
}
else
return "";
}
// Given a string, if the first or last chars are 'x', return the string without those 'x' chars,
// and otherwise return the string unchanged.
public String withoutX(String str)
{
int len = str.length();
if(len >= 2)
{
char ch = str.charAt(0);
StringBuilder stbuild = new StringBuilder(len);
if(ch != 'x')
stbuild.append(ch);
stbuild.append(str.substring(1, len-1));
ch = str.charAt(len-1);
if(ch != 'x')
stbuild.append(ch);
return stbuild.toString();
}
else if(len == 1 && str.charAt(0) == 'x')
return "";
else
return str;
}
// Given a string, if one or both of the first 2 chars is 'x', return the string without those 'x' chars
// and otherwise return the string unchanged. This is a little harder than it looks.
public String withoutX2(String str)
{
int len = str.length();
if(len >= 2)
{
char ch = str.charAt(0);
StringBuilder stbuild = new StringBuilder(len);
if(ch != 'x')
stbuild.append(ch);
ch = str.charAt(1);
if(ch != 'x')
stbuild.append(ch);
stbuild.append(str.substring(2));
return stbuild.toString();
}
else if(len == 1 && str.charAt(0) == 'x')
return "";
else
return str;
}