git reimport

archive/2016.08/2016.08.04 - unsorted/GroupedWord.java

@@ -0,0 +1,115 @@
+package chelper;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+import io.InputReader;
+import io.OutputWriter;
+
+public class GroupedWord {
+
+  public void solve(int testNumber, InputReader in, OutputWriter out) {
+    int n = in.nextInt();
+    String[] a = in.nextStringArray(n);
+
+    out.println(restore(a));
+  }
+
+  String restore(String[] a) {
+    List<String> list = new ArrayList<>();
+    Collections.addAll(list, a);
+
+    for (char c = 'a'; c <= 'z'; c++) {
+      List<String> interesting = new ArrayList<>();
+      for (int i = 0; i < list.size();) {
+        if (list.get(i).contains("" + c)) {
+          interesting.add(list.get(i));
+          list.remove(i);
+        } else {
+          i++;
+        }
+      }
+
+      if (interesting.isEmpty()) {
+        continue;
+      }
+
+      String result = combine(c, interesting);
+      if (result == null) {
+        return "IMPOSSIBLE";
+      }
+      list.add(result);
+    }
+
+    if (list.size() > 1) {
+      return "MANY";
+    }
+    return list.get(0);
+  }
+
+  boolean isInvalid(String s) {
+    for (int i = 0; i < s.length(); i++) {
+      for (int j = i + 1; j < s.length(); j++) {
+        if (s.charAt(i) == s.charAt(j) && s.charAt(i) != s.charAt(i + 1)) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+
+  String combine(char c, List<String> interesting) {
+    List<String> only = new ArrayList<>();
+    List<String> starts = new ArrayList<>();
+    List<String> ends = new ArrayList<>();
+    List<String> middle = new ArrayList<>();
+
+    for (String s : interesting) {
+      if (isInvalid(s)) {
+        return null;
+      }
+
+      boolean doesStart = s.charAt(0) == c;
+      boolean doesEnd = s.charAt(s.length() - 1) == c;
+
+      if (doesStart) {
+        if (doesEnd) {
+          only.add(s);
+        } else {
+          starts.add(s);
+        }
+      } else {
+        if (doesEnd) {
+          ends.add(s);
+        } else {
+          middle.add(s);
+        }
+      }
+    }
+
+    if (starts.size() > 1 || ends.size() > 1 || middle.size() > 1) {
+      return null;
+    }
+
+    if (!middle.isEmpty()) {
+      if (only.isEmpty() && starts.isEmpty() && ends.isEmpty()) {
+        return middle.get(0);
+      } else {
+        return null;
+      }
+    }
+
+    StringBuilder sb = new StringBuilder();
+    for (String s : ends) {
+      sb.append(s);
+    }
+    for (String s : only) {
+      sb.append(s);
+    }
+    for (String s : starts) {
+      sb.append(s);
+    }
+    return sb.toString();
+  }
+}

archive/2016.08/2016.08.04 - unsorted/GroupedWord.task

@@ -0,0 +1,55 @@
+11 GroupedWord
+6 SINGLE
+8 STANDARD
+9 input.txt
+8 STANDARD
+10 output.txt
+5
+0
+14 4
+abab
+bb
+bc
+k
+10 IMPOSSIBLE
+0
+1
+10 3
+aaa
+a
+aa
+6 aaaaaa
+1
+2
+8 2
+ab
+bba
+10 IMPOSSIBLE
+1
+3
+7 2
+te
+st
+4 stte
+1
+4
+8 3
+te
+s
+t
+4 MANY
+1
+11 src/chelper
+16 -Xmx256m -Xss64m
+4 Main
+19 chelper.GroupedWord
+39 net.egork.chelper.checkers.TokenChecker
+0 
+0
+10 2016.08.04
+0 
+1
+14 io.InputReader
+15 io.OutputWriter
+0
+0

archive/2016.08/2016.08.04 - unsorted/Sazanka2N.java

@@ -0,0 +1,150 @@
+package chelper;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.TreeSet;
+
+import io.InputReader;
+import io.OutputWriter;
+
+
+public class Sazanka2N {
+
+  public void solve(int testNumber, InputReader in, OutputWriter out) {
+    int n = in.nextInt();
+    StringBuilder[] strings = new StringBuilder[n];
+    for (int i = 0; i < n; i++) {
+      strings[i] = new StringBuilder(in.nextString());
+    }
+
+    List<StringBuilder> same = new ArrayList<>();
+    List<StringBuilder> notSame = new ArrayList<>();
+
+    for (int i = 0; i < n; i++) {
+      if (sameChars(strings[i])) {
+        same.add(strings[i]);
+      } else {
+        notSame.add(strings[i]);
+      }
+    }
+
+    for (int i = 0; i < notSame.size(); i++) {
+      char need = notSame.get(i).charAt(notSame.get(i).length() - 1);
+      for (int j = same.size() - 1; j >= 0; j--) {
+        if (same.get(j).charAt(0) == need) {
+          notSame.set(i, notSame.get(i).append(same.get(j)));
+          same.remove(j);
+        }
+      }
+    }
+
+
+    for (int i = 0; i < same.size(); i++) {
+      char need = same.get(i).charAt(0);
+      for (int j = notSame.size() - 1; j >= 0; j--) {
+        if (notSame.get(j).charAt(0) == need) {
+          same.set(i, same.get(i).append(notSame.get(j)));
+          notSame.remove(j);
+        }
+      }
+    }
+    ArrayList<StringBuilder> all = new ArrayList<>();
+    all.addAll(same);
+    all.addAll(notSame);
+
+    for (int i = 0; i < all.size(); i++) {
+      for (int j = 0; j < all.size(); j++) {
+        char need = all.get(i).charAt(all.get(i).length() - 1);
+        if (i == j) {
+          continue;
+        }
+        if (all.get(j).charAt(0) == need) {
+          all.set(i, all.get(i).append(all.get(j)));
+          all.remove(j);
+          j = 0;
+        }
+      }
+    }
+
+    if (all.size() > 1) {
+      if (isOkWords(all)) {
+        out.print("MANY");
+      } else {
+        out.print("IMPOSSIBLE");
+      }
+    } else if (isOkWord(all.get(0))) {
+      out.print(all.get(0));
+    } else {
+      out.print("IMPOSSIBLE");
+    }
+  }
+
+  private boolean sameChars(StringBuilder string) {
+    char need = string.charAt(0);
+    for (int i = 1; i < string.length(); i++) {
+      if (string.charAt(i) != need) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  boolean isOkWords(ArrayList<StringBuilder> strings) {
+    Set<Character> chars = new HashSet<>();
+    for (int i = 0; i < strings.size(); i++) {
+      if (isOkWord(strings.get(i))) {
+        Set<Character> c = charsInWord(strings.get(i));
+        int size1 = chars.size();
+        int size2 = c.size();
+        chars.addAll(c);
+        if (size1 + size2 != chars.size()) {
+          return false;
+        }
+      }
+    }
+    return true;
+  }
+
+  boolean isOkWord(StringBuilder stringBuilder) {
+    Set<Character> chars = new HashSet<>();
+    char prev = stringBuilder.charAt(0);
+    chars.add(prev);
+    for (int i = 1; i < stringBuilder.length(); i++) {
+      while (i < stringBuilder.length() && stringBuilder.charAt(i) == prev) {
+        i++;
+      }
+      if (i >= stringBuilder.length()) {
+        break;
+      }
+      if (!chars.contains(stringBuilder.charAt(i))) {
+        chars.add(stringBuilder.charAt(i));
+        prev = stringBuilder.charAt(i);
+      } else {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  Set<Character> charsInWord(StringBuilder stringBuilder) {
+    Set<Character> chars = new HashSet<>();
+    char prev = stringBuilder.charAt(0);
+    chars.add(prev);
+    for (int i = 1; i < stringBuilder.length(); i++) {
+      while (i < stringBuilder.length() && stringBuilder.charAt(i) == prev) {
+        i++;
+      }
+      if (i >= stringBuilder.length()) {
+        break;
+      }
+      if (!chars.contains(stringBuilder.charAt(i))) {
+        chars.add(stringBuilder.charAt(i));
+      } else {
+        return new TreeSet<>();
+      }
+    }
+    return chars;
+  }
+}

archive/2016.08/2016.08.04 - unsorted/Sazanka2N.task

@@ -0,0 +1,40 @@
+9 Sazanka2N
+6 SINGLE
+8 STANDARD
+9 input.txt
+8 STANDARD
+10 output.txt
+3
+0
+14 4
+abab
+bb
+bc
+k
+-1
+1
+1
+6 1
+abab
+-1
+1
+2
+9 2
+abab
+bb
+-1
+1
+11 src/chelper
+16 -Xmx256m -Xss64m
+4 Main
+17 chelper.Sazanka2N
+39 net.egork.chelper.checkers.TokenChecker
+0 
+0
+10 2016.08.04
+0 
+1
+14 io.InputReader
+15 io.OutputWriter
+0
+0