Advertisement
Guest User

Untitled

a guest
Feb 20th, 2020
97
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 8.34 KB | None | 0 0
  1. package ListsLab;
  2.  
  3. import java.util.ArrayList;
  4. import java.util.List;
  5. import java.util.Scanner;
  6.  
  7. public class Train {
  8. public static void main(String[] args) {
  9. Scanner scanner = new Scanner(System.in);
  10.  
  11. List<Integer> train = readIntList(scanner);
  12. int waggonCapacity = Integer.parseInt(scanner.nextLine());
  13. String input = scanner.nextLine();
  14. while (!"end".equals(input)) {
  15. String[] tokens = input.split(" ");
  16. if(tokens[0].equals("Add")){
  17. int ppl = Integer.parseInt(tokens[1]);
  18. train.add(ppl);
  19. }else{
  20. int ppl = Integer.parseInt(tokens[0]);
  21. for (int i = 0; i < train.size(); i++) {
  22. int currentWaggon = train.get(i);
  23. int totalCount = currentWaggon + ppl;
  24. if(totalCount <= waggonCapacity){
  25. train.set(i,totalCount);
  26. break;
  27. }
  28.  
  29. }
  30. }
  31.  
  32.  
  33. input=scanner.nextLine();
  34. }
  35. printTrain(train);
  36. }
  37.  
  38. private static void printTrain(List<Integer> train) {
  39. for (Integer element:train
  40. ) {
  41. System.out.print(element + " ");
  42.  
  43. }
  44. }
  45.  
  46. private static List<Integer> readIntList(Scanner scanner) {
  47. String[] input = scanner.nextLine().split("\\s+");
  48. List<Integer> outputList = new ArrayList<>();
  49.  
  50. for (String element :
  51. input) {
  52. outputList.add(Integer.parseInt(element));
  53. }
  54. return outputList;
  55. }
  56. }
  57.  
  58.  
  59. package ListsLab;
  60.  
  61. import java.util.ArrayList;
  62. import java.util.Arrays;
  63. import java.util.List;
  64. import java.util.Scanner;
  65.  
  66. public class ChangeList {
  67. public static void main(String[] args) {
  68. Scanner scanner = new Scanner(System.in);
  69.  
  70. String[] input = scanner.nextLine().split("\\s+");
  71. List<String> numbers = new ArrayList<>();
  72. for (String element : input) {
  73. numbers.add(element);
  74. }
  75. String in = scanner.nextLine();
  76. while (!"end".equals(in)) {
  77. String[] tokens = in.split("\\s+");
  78. switch (tokens[0]) {
  79. case "Delete":
  80. while (numbers.contains(tokens[1]))
  81. numbers.remove(tokens[1]);
  82. break;
  83. case "Insert":
  84. String element = tokens[1];
  85. int index = Integer.parseInt(tokens[2]);
  86. if(index < numbers.size()){
  87. numbers.add(index, element);
  88. }
  89.  
  90. break;
  91. }
  92. in = scanner.nextLine();
  93. }
  94. System.out.println(String.join(" ", numbers));
  95.  
  96. }
  97. }
  98.  
  99.  
  100.  
  101. import java.util.ArrayList;
  102. import java.util.List;
  103. import java.util.Scanner;
  104.  
  105. public class HouseParty {
  106. public static void main(String[] args) {
  107. @SuppressWarnings("resource")
  108.  
  109. Scanner sc = new Scanner(System.in);
  110. int n = Integer.parseInt(sc.nextLine());
  111.  
  112. List<String> names = new ArrayList<>();
  113.  
  114. for (int i = 1; i <= n; i++) {
  115. String inputData = sc.nextLine();
  116. String[] input = inputData.split("\\s+");
  117.  
  118. String name = input[0];
  119.  
  120. if (input.length == 3) {
  121. if (!names.contains(name)) {
  122. names.add(name);
  123. } else {
  124. System.out.printf("%s is already in the list!%n", name);
  125. }
  126. } else if (input.length == 4) {
  127. if (names.contains(name)) {
  128. names.remove(name);
  129. } else {
  130. System.out.printf("%s is not in the list!%n", name);
  131. }
  132. }
  133. }
  134.  
  135. String output = names.toString().replaceAll("\\[|,|\\]", "");
  136. System.out.println(output.replaceAll("\\s+", "\n"));
  137. }
  138. }
  139.  
  140.  
  141.  
  142. import java.util.Arrays;
  143. import java.util.List;
  144. import java.util.Scanner;
  145. import java.util.stream.Collectors;
  146.  
  147. public class ListOperations {
  148. public static void main(String[] args) {
  149.  
  150.  
  151. Scanner sc = new Scanner(System.in);
  152.  
  153. List<Integer> numbers = Arrays.stream(sc.nextLine().split("\\s+")).map(Integer::parseInt)
  154. .collect(Collectors.toList());
  155.  
  156. String input = "";
  157.  
  158. while (!"End".equals(input = sc.nextLine())) {
  159. String[] data = input.split("\\s+");
  160.  
  161. String command = data[0];
  162.  
  163. switch (command) {
  164. case "Add":
  165. numbers.add(Integer.parseInt(data[1]));
  166. break;
  167. case "Insert":
  168. int element = Integer.parseInt(data[1]);
  169. int index = Integer.parseInt(data[2]);
  170.  
  171. if (index >= 0 && index <= numbers.size()) {
  172. numbers.add(index, element);
  173. } else {
  174. System.out.println("Invalid index");
  175. }
  176.  
  177. break;
  178. case "Remove":
  179. int indexToRemove = Integer.parseInt(data[1]);
  180.  
  181. if (indexToRemove >= 0 && indexToRemove <= numbers.size()) {
  182. numbers.remove(indexToRemove);
  183. } else {
  184. System.out.println("Invalid index");
  185. }
  186.  
  187. break;
  188. case "Shift":
  189. if (numbers.size() > 0) {
  190. int count = Integer.parseInt(data[2]) % numbers.size();
  191. count = count % numbers.size();
  192.  
  193. if (data[1].equals("left")) {
  194. for (int i = 0; i < count; i++) {
  195. numbers.add(numbers.get(0));
  196. numbers.remove(0);
  197. }
  198.  
  199. } else {
  200. for (int i = 0; i < count; i++) {
  201. numbers.add(0, numbers.get(numbers.size() - 1));
  202. numbers.remove(numbers.size() - 1);
  203. }
  204. }
  205. }
  206. break;
  207. }
  208. }
  209.  
  210. System.out.println(numbers.toString().replaceAll("\\[|,|\\]", ""));
  211. }
  212. }
  213.  
  214. import java.util.Arrays;
  215. import java.util.List;
  216. import java.util.Scanner;
  217. import java.util.stream.Collectors;
  218.  
  219. public class BombNumbers {
  220. public static void main(String[] args) {
  221.  
  222.  
  223. Scanner sc = new Scanner(System.in);
  224.  
  225. List<Integer> numbers = Arrays.stream(sc.nextLine().split("\\s+")).map(Integer::parseInt)
  226. .collect(Collectors.toList());
  227.  
  228. String[] input = sc.nextLine().split("\\s+");
  229. int bombNumber = Integer.parseInt(input[0]);
  230. int bombPower = Integer.parseInt(input[1]);
  231.  
  232. int sum = 0;
  233.  
  234. while (numbers.contains(bombNumber)) {
  235. int indexBomb = numbers.indexOf(bombNumber);
  236.  
  237. int left = Math.max(0, indexBomb - bombPower);
  238. int right = Math.min(numbers.size() - 1, indexBomb + bombPower);
  239.  
  240. for (int i = right; i >= left; i--) {
  241. numbers.remove(i);
  242. }
  243. }
  244.  
  245. for (int i = 0; i < numbers.size(); i++) {
  246. sum += numbers.get(i);
  247. }
  248. System.out.println(sum);
  249.  
  250. }
  251. }
  252.  
  253.  
  254. import java.util.ArrayList;
  255. import java.util.Arrays;
  256. import java.util.List;
  257. import java.util.Scanner;
  258. import java.util.stream.Collectors;
  259.  
  260. public class AppendArrays {
  261. public static void main(String[] args) {
  262.  
  263. Scanner sc = new Scanner(System.in);
  264. List<String> input = Arrays.stream(sc.nextLine().split("\\|")).collect(Collectors.toList());
  265.  
  266. List<String> output = new ArrayList<>();
  267.  
  268. for (int i = input.size() - 1; i >= 0; i--) {
  269. String[] numbers = input.get(i).split("\\s+");
  270. for (int j = 0; j < numbers.length; j++) {
  271. if (!numbers[j].equals("")) {
  272. output.add(numbers[j]);
  273. }
  274. }
  275. }
  276.  
  277. String print = output.toString().trim();
  278. System.out.println(print.replaceAll("\\[|,|\\]", ""));
  279. }
  280. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement