Esempio n. 1
1
 public static void main(String[] args) {
   Scanner scanner = new Scanner(System.in);
   int m = scanner.nextInt();
   assert 1 <= m && m <= 100 : "out of range, m: " + m;
   int s = scanner.nextInt();
   assert 0 <= s && s <= 900 : "out of range, s: " + s;
   if (s > 9 * m || (s == 0 && m > 1)) {
     System.out.println("-1 -1");
     return;
   }
   if (m == 1 && s == 0) {
     System.out.println("0 0");
     return;
   }
   StringBuilder sb = new StringBuilder();
   int l = 0;
   for (int i = 0; i < m; i++) {
     int d = (s >= 9) ? 9 : s;
     sb.append(d);
     s -= d;
     if (d != 0) {
       l = i;
     }
   }
   String large = sb.toString();
   if (sb.charAt(m - 1) == '0') {
     sb.setCharAt(l, (char) (sb.charAt(l) - 1));
     sb.setCharAt(m - 1, '1');
   }
   String small = sb.reverse().toString();
   System.out.printf("%s %s", small, large);
 }
  private void generateParens(
      ArrayList<String> list, int leftRem, int rightRem, StringBuilder sb, int index) {

    // number of left parentheses remaining cannot be less than 0
    // cannot possibly have a valid string having inserted more
    // right parentheses than left parentheses
    if (leftRem < 0 || rightRem < leftRem) return;

    if (leftRem == 0 && rightRem == 0) list.add(sb.toString());
    else {
      // add left parenthesis if any left
      if (leftRem > 0) {
        try {
          sb.setCharAt(index, '(');
        } catch (Exception e) {
          sb.insert(index, "(");
        }
        generateParens(list, leftRem - 1, rightRem, sb, index + 1);
      }

      // add right parenthesis if valid
      if (rightRem > leftRem) {
        try {
          sb.setCharAt(index, ')');
        } catch (Exception e) {
          sb.insert(index, ")");
        }
        generateParens(list, leftRem, rightRem - 1, sb, index + 1);
      }
    }
  }
Esempio n. 3
1
 @TCB
 private static void stripBannedCodeunits(StringBuilder sb, int start) {
   int k = start;
   for (int i = start, n = sb.length(); i < n; ++i) {
     char ch = sb.charAt(i);
     if (ch < 0x20) {
       if (IS_BANNED_ASCII[ch]) {
         continue;
       }
     } else if (0xd800 <= ch) {
       if (ch <= 0xdfff) {
         if (i + 1 < n) {
           char next = sb.charAt(i + 1);
           if (Character.isSurrogatePair(ch, next)) {
             sb.setCharAt(k++, ch);
             sb.setCharAt(k++, next);
             ++i;
           }
         }
         continue;
       } else if ((ch & 0xfffe) == 0xfffe) {
         continue;
       }
     }
     sb.setCharAt(k++, ch);
   }
   sb.setLength(k);
 }
 /** Return next string in the sequence "a", "b", ... "z", "aa", "ab", ... */
 static String getNextDirName(String old) {
   StringBuilder sb = new StringBuilder(old);
   // go through and increment the first non-'z' char
   // counts back from the last char, so 'aa'->'ab', not 'ba'
   for (int ii = sb.length() - 1; ii >= 0; ii--) {
     char curChar = sb.charAt(ii);
     if (curChar < 'z') {
       sb.setCharAt(ii, (char) (curChar + 1));
       return sb.toString();
     }
     sb.setCharAt(ii, 'a');
   }
   sb.insert(0, 'a');
   return sb.toString();
 }
Esempio n. 5
1
 /**
  * Replace given characters in a given string builder.
  * The number of characters to replace has to match to number of
  * characters serving as a replacement.
  *
  * @param sb string builder containing a string to be modified
  * @param from characters to replaced
  * @param to replacement characters
  * @return original string builder with replaced characters.
  */
 public static StringBuilder replace(StringBuilder sb, CharSequence from, CharSequence to) {
   assert from.length() == to.length();
   for (int i=0; i<sb.length(); i++)
     for (int j=0; j<from.length(); j++)
       if (sb.charAt(i)==from.charAt(j)) sb.setCharAt(i, to.charAt(j));
   return sb;
 }
Esempio n. 6
1
 public int ladderLength1(String beginWord, String endWord, Set<String> wordList) {
   Set<String> startList = new HashSet<String>();
   Set<String> endList = new HashSet<String>();
   startList.add(beginWord);
   endList.add(endWord);
   int result = 1;
   while (!startList.isEmpty() && !endList.isEmpty()) {
     if (startList.size() > endList.size()) {
       Set<String> k = startList;
       startList = endList;
       endList = k;
     }
     Set<String> newSet = new HashSet<String>();
     for (String word : startList) {
       for (int i = 0; i < word.length(); i++) {
         for (char a = 'a'; a <= 'z'; a++) {
           if (a == word.charAt(i)) continue;
           StringBuilder temp = new StringBuilder(word);
           temp.setCharAt(i, a);
           String newString = temp.toString();
           if (endList.contains(newString)) return result + 1;
           if (wordList.contains(newString)) {
             wordList.remove(newString);
             newSet.add(newString);
           }
         }
       }
     }
     startList = newSet;
     result++;
   }
   return 0;
 }
  /** @param args */
  public static void main(String[] args) {
    // TODO Auto-generated method stub
    Scanner input = new Scanner(System.in);
    int times = Integer.parseInt(input.next());
    for (int x = 0; x < times; x++) {
      String next = input.next();
      int pos = (next.length() - 1) / 2;
      String res = "";
      StringBuilder build = new StringBuilder(next);
      String middle = "";
      if (next.length() % 2 == 0) {
        boolean carry = false;

        for (; pos >= 0; pos--) {
          int left = Character.getNumericValue(build.charAt(pos));
          int right = Character.getNumericValue(build.charAt(build.length() - 1 - pos));
          if (left < right) {
            left++;
            build.setCharAt(pos, Character.forDigit(left, 10));
            break;
          } else {

          }
        }
      } else {

      }

      System.out.println(res);
    }
  }
Esempio n. 8
0
  public String encrypt(String input, int key) {
    StringBuilder encrypted = new StringBuilder(input);

    String shiftedAlphabetUp = alphabetUp.substring(key) + alphabetUp.substring(0, key);
    String shiftedAlphabetLow = alphabetLow.substring(key) + alphabetLow.substring(0, key);

    for (int i = 0; i < encrypted.length(); i++) {
      char currChar = encrypted.charAt(i);

      if (alphabetUp.indexOf(currChar) != -1) {
        int idx = alphabetUp.indexOf(currChar);

        if (idx != -1) {
          char newChar = shiftedAlphabetUp.charAt(idx);

          encrypted.setCharAt(i, newChar);
        }
      } else if (alphabetLow.indexOf(currChar) != -1) {
        int idx = alphabetLow.indexOf(currChar);

        if (idx != -1) {
          char newChar = shiftedAlphabetLow.charAt(idx);

          encrypted.setCharAt(i, newChar);
        }
      }
    }
    return encrypted.toString();
  }
Esempio n. 9
0
 /*
  * This problem contraints the word to be all lower-case character, which most likely means it requires
  * you to do stupid constant(26) time operations to the strings. Doing a graph construction, which is
  * more general, got Time Limit Exception because it is O(n^2) rather than O((26*n)^2).
  */
 public static int ladderLength(String beginWord, String endWord, Set<String> wordDict) {
   Queue<String> queue = new LinkedList<String>();
   queue.add(beginWord);
   wordDict.remove(beginWord);
   int ans = 1;
   while (!queue.isEmpty()) {
     for (int count = queue.size(); count > 0; --count) {
       String word = queue.poll();
       StringBuilder altWord = new StringBuilder(word);
       for (int i = 0; i < word.length(); ++i) {
         char w = altWord.charAt(i);
         for (char c = 'a'; c <= 'z'; ++c) {
           if (w == c) continue;
           altWord.setCharAt(i, c);
           if (altWord.toString().equals(endWord)) return ans + 1;
           if (wordDict.contains(altWord.toString())) {
             queue.add(altWord.toString());
             wordDict.remove(altWord.toString());
           }
           altWord.setCharAt(i, w);
         }
       }
     }
     ++ans;
   }
   return 0;
 }
  @Override
  public String prepareMessage(String string) {
    String[] commands = string.split(";");
    StringBuilder message = new StringBuilder("00000");

    for (String command : commands) {
      try {
        switch (Integer.parseInt(command)) {
          case 0:
            message.setCharAt(0, '1');
            break;
          case 1:
            message.setCharAt(1, '1');
            break;
          case 2:
            message.setCharAt(2, '1');
            break;
          case 3:
            message.setCharAt(3, '1');
            break;
          case 4:
            message.setCharAt(4, '1');
            break;
          default:
            break;
        }
      } catch (NumberFormatException e) {
        return message.toString();
      }
    }

    return message.toString();
  }
Esempio n. 11
0
 public static String initcap(Comparable<?> param) throws ParseException {
   if (param == null) {
     return null;
   }
   String inputStr = param.toString();
   StringBuilder output = new StringBuilder(inputStr);
   boolean needUpper = true;
   final int len = inputStr.length();
   for (int i = 0; i < len; i++) {
     char c = inputStr.charAt(i);
     if (needUpper && Character.isLetter(c)) {
       if (Character.isLowerCase(c)) {
         output.setCharAt(i, Character.toUpperCase(c));
       }
       needUpper = false;
     } else if (!needUpper) {
       if (!Character.isLetterOrDigit(c)) {
         needUpper = true;
       } else if (Character.isUpperCase(c)) {
         output.setCharAt(i, Character.toLowerCase(c));
       }
     }
   }
   return output.toString();
 }
Esempio n. 12
0
  private StringBuilder getNextPerm(StringBuilder s) {
    int n = s.length();

    // find the highest index i such that s[i] < s[i+1]
    int i = n;
    for (int t = 0; t < n - 1; t++) {
      if (s.charAt(t) < s.charAt(t + 1)) i = t;
    }

    // no such i, return null;
    if (i == n) return null;

    // find highest index j such that s[i] < s[j]. j exists as at least it's i+1
    int j = 0;
    for (int t = i + 1; t < n; t++) {
      if (s.charAt(i) < s.charAt(t)) j = t;
    }

    // swap s[i], s[j]
    char tmp = s.charAt(i);
    s.setCharAt(i, s.charAt(j));
    s.setCharAt(j, tmp);

    // now reverse char from i+1
    StringBuilder res =
        new StringBuilder(s.substring(0, i + 1))
            .append(new StringBuilder(s.substring(i + 1)).reverse());
    return res;
  }
Esempio n. 13
0
 public static String makePretty(String str) {
   char lastChar = ' ';
   StringBuilder sb = new StringBuilder(str);
   int whitespaceDist = 0;
   for (int i = 0; i < sb.length(); i++) {
     char nowChar = sb.charAt(i);
     if (nowChar != ' ' && nowChar != '.') {
       whitespaceDist += 1;
     } else {
       if (whitespaceDist == 2) {
         char b = sb.charAt(i - 1);
         char a = sb.charAt(i - 2);
         sb.setCharAt(i - 1, Character.toUpperCase(b));
         sb.setCharAt(i - 2, Character.toUpperCase(a));
       }
     }
     if (lastChar == ' ' || lastChar == '/') {
       sb.setCharAt(i, Character.toUpperCase(nowChar));
     } else {
       sb.setCharAt(i, Character.toLowerCase(nowChar));
     }
     lastChar = nowChar;
   }
   return sb.toString();
 }
Esempio n. 14
0
 public static void reverse(int i, int j, StringBuilder input) {
   char temp;
   for (; i < j; i++, j--) {
     temp = input.charAt(i);
     input.setCharAt(i, input.charAt(j));
     input.setCharAt(j, temp);
   }
 }
Esempio n. 15
0
  public boolean createEntity(Dao dao, Entity<?> en) {
    StringBuilder sb = new StringBuilder("CREATE TABLE " + en.getTableName() + "(");
    // 创建字段
    for (MappingField mf : en.getMappingFields()) {
      if (mf.isReadonly()) continue;
      sb.append('\n').append(mf.getColumnName());
      // 自增主键特殊形式关键字
      if (mf.isId() && mf.isAutoIncreasement()) {
        sb.append(" SERIAL");
      } else {
        sb.append(' ').append(evalFieldType(mf));
        // 非主键的 @Name,应该加入唯一性约束
        if (mf.isName() && en.getPkType() != PkType.NAME) {
          sb.append(" UNIQUE NOT NULL");
        }
        // 普通字段
        else {
          if (mf.isUnsigned()) sb.append(" UNSIGNED");
          if (mf.isNotNull()) sb.append(" NOT NULL");
          if (mf.isAutoIncreasement()) throw Lang.noImplement();
          if (mf.hasDefaultValue())
            sb.append(" DEFAULT '").append(getDefaultValue(mf)).append('\'');
        }
      }
      sb.append(',');
    }
    // 创建主键
    List<MappingField> pks = en.getPks();
    if (!pks.isEmpty()) {
      sb.append('\n');
      sb.append(
          String.format(
              "CONSTRAINT %s_pkey PRIMARY KEY (",
              en.getTableName().replace('.', '_').replace('"', '_')));
      for (MappingField pk : pks) {
        sb.append(pk.getColumnName()).append(',');
      }
      sb.setCharAt(sb.length() - 1, ')');
      sb.append("\n ");
    }

    // 结束表字段设置
    sb.setCharAt(sb.length() - 1, ')');

    // 执行创建语句
    dao.execute(Sqls.create(sb.toString()));

    // 创建索引
    dao.execute(createIndexs(en).toArray(new Sql[0]));

    // 创建关联表
    createRelation(dao, en);

    // 添加注释(表注释与字段注释)
    addComment(dao, en);

    return true;
  }
Esempio n. 16
0
  /**
   * Generates a crypt(3) compatible hash using the DES algorithm.
   *
   * <p>Using unspecified characters as salt results incompatible hash values.
   *
   * @param original plaintext password
   * @param salt a two character string drawn from [a-zA-Z0-9./] or null for a random one
   * @return a 13 character string starting with the salt string
   * @throws IllegalArgumentException if the salt does not match the allowed pattern
   */
  public static String crypt(final byte[] original, String salt) {
    if (salt == null) {
      final Random randomGenerator = new Random();
      final int numSaltChars = SALT_CHARS.length;
      salt =
          ""
              + SALT_CHARS[randomGenerator.nextInt(numSaltChars)]
              + SALT_CHARS[randomGenerator.nextInt(numSaltChars)];
    } else if (!salt.matches("^[" + B64.B64T + "]{2,}$")) {
      throw new IllegalArgumentException("Invalid salt value: " + salt);
    }

    final StringBuilder buffer = new StringBuilder("             ");
    final char charZero = salt.charAt(0);
    final char charOne = salt.charAt(1);
    buffer.setCharAt(0, charZero);
    buffer.setCharAt(1, charOne);
    final int eSwap0 = CON_SALT[charZero];
    final int eSwap1 = CON_SALT[charOne] << 4;
    final byte key[] = new byte[8];
    for (int i = 0; i < key.length; i++) {
      key[i] = 0;
    }

    for (int i = 0; i < key.length && i < original.length; i++) {
      final int iChar = original[i];
      key[i] = (byte) (iChar << 1);
    }

    final int schedule[] = desSetKey(key);
    final int out[] = body(schedule, eSwap0, eSwap1);
    final byte b[] = new byte[9];
    intToFourBytes(out[0], b, 0);
    intToFourBytes(out[1], b, 4);
    b[8] = 0;
    int i = 2;
    int y = 0;
    int u = 128;
    for (; i < 13; i++) {
      int j = 0;
      int c = 0;
      for (; j < 6; j++) {
        c <<= 1;
        if ((b[y] & u) != 0) {
          c |= 0x1;
        }
        u >>>= 1;
        if (u == 0) {
          y++;
          u = 128;
        }
        buffer.setCharAt(i, (char) COV2CHAR[c]);
      }
    }
    return buffer.toString();
  }
 @Override
 protected void setProductBits(final StringBuilder productBits, final Product product) {
   if (product == Product.HIGH_SPEED_TRAIN) {
     productBits.setCharAt(0, '1'); // Hochgeschwindigkeitszug
     productBits.setCharAt(1, '1'); // IC/EC
     productBits.setCharAt(2, '1'); // Fernverkehrszug
   } else if (product == Product.REGIONAL_TRAIN) {
     productBits.setCharAt(3, '1'); // Regionalverkehrszug
   } else if (product == Product.SUBURBAN_TRAIN) {
     productBits.setCharAt(4, '1'); // S-Bahn
   } else if (product == Product.SUBWAY) {
     productBits.setCharAt(7, '1'); // U-Bahn
   } else if (product == Product.TRAM) {
     productBits.setCharAt(8, '1'); // Stadtbahn
   } else if (product == Product.BUS) {
     productBits.setCharAt(5, '1'); // Bus
   } else if (product == Product.ON_DEMAND) {
     productBits.setCharAt(9, '1'); // Anruf-Sammel-Taxi
   } else if (product == Product.FERRY) {
     productBits.setCharAt(6, '1'); // Schiff
   } else if (product == Product.CABLECAR) {
   } else {
     throw new IllegalArgumentException("cannot handle: " + product);
   }
 }
Esempio n. 18
0
 // b
 static String upperToLower(String input) {
   StringBuilder sb = new StringBuilder(input);
   for (int i = 0; i < input.length(); i++) {
     char toChange = input.charAt(i);
     if (toChange >= 'a' && toChange <= 'z') {
       sb.setCharAt(i, Character.toUpperCase(toChange));
     } else if (toChange >= 'A' && toChange <= 'Z') {
       sb.setCharAt(i, Character.toLowerCase(toChange));
     }
   }
   return sb.toString();
 }
  /**
   * @param introspectedColumn
   * @param inMethod if true generates an "in" method, else generates a "not in" method
   * @return a generated method for the in or not in method
   */
  private Method getSetInOrNotInMethod(IntrospectedColumn introspectedColumn, boolean inMethod) {
    Method method = new Method();
    method.setVisibility(JavaVisibility.PUBLIC);
    FullyQualifiedJavaType type = FullyQualifiedJavaType.getNewListInstance();
    if (introspectedColumn.getFullyQualifiedJavaType().isPrimitive()) {
      type.addTypeArgument(
          introspectedColumn.getFullyQualifiedJavaType().getPrimitiveTypeWrapper());
    } else {
      type.addTypeArgument(introspectedColumn.getFullyQualifiedJavaType());
    }

    method.addParameter(new Parameter(type, "values")); // $NON-NLS-1$
    StringBuilder sb = new StringBuilder();
    sb.append(introspectedColumn.getJavaProperty());
    sb.setCharAt(0, Character.toUpperCase(sb.charAt(0)));
    sb.insert(0, "and"); // $NON-NLS-1$
    if (inMethod) {
      sb.append("In"); // $NON-NLS-1$
    } else {
      sb.append("NotIn"); // $NON-NLS-1$
    }
    method.setName(sb.toString());
    method.setReturnType(FullyQualifiedJavaType.getCriteriaInstance());
    sb.setLength(0);

    if (introspectedColumn.isJDBCDateColumn()) {
      sb.append("addCriterionForJDBCDate(\""); // $NON-NLS-1$
    } else if (introspectedColumn.isJDBCTimeColumn()) {
      sb.append("addCriterionForJDBCTime(\""); // $NON-NLS-1$
    } else if (stringHasValue(introspectedColumn.getTypeHandler())) {
      sb.append("add"); // $NON-NLS-1$
      sb.append(introspectedColumn.getJavaProperty());
      sb.setCharAt(3, Character.toUpperCase(sb.charAt(3)));
      sb.append("Criterion(\""); // $NON-NLS-1$
    } else {
      sb.append("addCriterion(\""); // $NON-NLS-1$
    }

    sb.append(MyBatis3FormattingUtilities.getAliasedActualColumnName(introspectedColumn));
    if (inMethod) {
      sb.append(" in"); // $NON-NLS-1$
    } else {
      sb.append(" not in"); // $NON-NLS-1$
    }
    sb.append("\", values, \""); // $NON-NLS-1$
    sb.append(introspectedColumn.getJavaProperty());
    sb.append("\");"); // $NON-NLS-1$
    method.addBodyLine(sb.toString());
    method.addBodyLine("return (Criteria) this;"); // $NON-NLS-1$

    return method;
  }
Esempio n. 20
0
  public List<HtlB2bIncrease> queryIncreasePrice(
      List<Long> hotelIdParams, List<Long> priceTypeIdParams, Date inDate, Date outDate) {
    StringBuilder sql =
        new StringBuilder(
            " select p.hotel_id,p.room_type_id,p.child_room_type_id,p.base_price,(p.sale_price - p.base_price) as COMMISSION,p.able_sale_date, ");
    sql.append(" i.INCREASE_RATE,p.currency ");
    sql.append(" from hwtemp_htl_price p, b2b_increase i ");
    sql.append(" where p.hotel_id = i.hotel_id ");
    sql.append(" and i.flag =1 ");
    sql.append(" and p.pay_method = 'pre_pay' ");
    sql.append(" and p.able_sale_date >=trunc(?) ");
    sql.append(" and p.able_sale_date <trunc(?) "); // 离店日期 应该只有小于不能等于
    sql.append(" and p.child_room_type_id in ( ");
    for (Long priceTypeIdParam : priceTypeIdParams) {
      sql.append(priceTypeIdParam).append(",");
    }
    sql.setCharAt(sql.length() - 1, ')');
    sql.append(" and p.hotel_id in ( ");
    for (Long hotelIdParam : hotelIdParams) {
      sql.append(hotelIdParam).append(",");
    }
    sql.setCharAt(sql.length() - 1, ')');
    // 这里封装对象
    List<Object[]> objects =
        super.queryByNativeSQL(sql.toString(), new Object[] {inDate, outDate}, null);
    List<HtlB2bIncrease> htlB2bIncreases = new ArrayList<HtlB2bIncrease>();

    for (Object[] obj : objects) {
      HtlB2bIncrease htlB2bIncrease = new HtlB2bIncrease();
      htlB2bIncrease.setHotelId(((BigDecimal) obj[0]).longValue()); // BigDeimal类型 需要转换
      htlB2bIncrease.setRoomTypeId(((BigDecimal) obj[1]).longValue());
      htlB2bIncrease.setPriceTypeId(((BigDecimal) obj[2]).longValue());
      htlB2bIncrease.setBasePrice(((BigDecimal) obj[3]).doubleValue());
      htlB2bIncrease.setCommission(((BigDecimal) obj[4]).doubleValue());
      htlB2bIncrease.setAbleSaleDate((Date) (obj[5]));
      double increaseRate = Double.valueOf(String.valueOf(obj[6]));
      if (increaseRate > 1) { // 设置加幅的是固定金额
        htlB2bIncrease.setIncreasePrice(
            htlB2bIncrease.getBasePrice()
                + increaseRate / CurrencyBean.getRateToRMB(String.valueOf(obj[7])));
        htlB2bIncrease.setCurrency(String.valueOf(obj[7]));
      } else { // 设置加幅的是比例
        htlB2bIncrease.setIncreasePrice(
            htlB2bIncrease.getBasePrice() + htlB2bIncrease.getCommission() * increaseRate);
        htlB2bIncrease.setCurrency(String.valueOf(obj[7]));
      }
      htlB2bIncreases.add(htlB2bIncrease);
    }

    return htlB2bIncreases;
  }
  private Method getSingleValueMethod(
      IntrospectedColumn introspectedColumn, String nameFragment, String operator) {
    Method method = new Method();
    method.setVisibility(JavaVisibility.PUBLIC);
    method.addParameter(
        new Parameter(introspectedColumn.getFullyQualifiedJavaType(), "value")); // $NON-NLS-1$
    StringBuilder sb = new StringBuilder();
    sb.append(introspectedColumn.getJavaProperty());
    sb.setCharAt(0, Character.toUpperCase(sb.charAt(0)));
    sb.insert(0, "and"); // $NON-NLS-1$
    sb.append(nameFragment);
    method.setName(sb.toString());
    method.setReturnType(FullyQualifiedJavaType.getCriteriaInstance());
    sb.setLength(0);

    if (introspectedColumn.isJDBCDateColumn()) {
      sb.append("addCriterionForJDBCDate(\""); // $NON-NLS-1$
    } else if (introspectedColumn.isJDBCTimeColumn()) {
      sb.append("addCriterionForJDBCTime(\""); // $NON-NLS-1$
    } else if (stringHasValue(introspectedColumn.getTypeHandler())) {
      sb.append("add"); // $NON-NLS-1$
      sb.append(introspectedColumn.getJavaProperty());
      sb.setCharAt(3, Character.toUpperCase(sb.charAt(3)));
      sb.append("Criterion(\""); // $NON-NLS-1$
    } else {
      sb.append("addCriterion(\""); // $NON-NLS-1$
    }

    sb.append(MyBatis3FormattingUtilities.getAliasedActualColumnName(introspectedColumn));
    sb.append(' ');
    sb.append(operator);
    sb.append("\", "); // $NON-NLS-1$

    if (introspectedColumn.getFullyQualifiedJavaType().isPrimitive()) {
      sb.append("new "); // $NON-NLS-1$
      sb.append(
          introspectedColumn.getFullyQualifiedJavaType().getPrimitiveTypeWrapper().getShortName());
      sb.append("(value)"); // $NON-NLS-1$
    } else {
      sb.append("value"); // $NON-NLS-1$
    }

    sb.append(", \""); // $NON-NLS-1$
    sb.append(introspectedColumn.getJavaProperty());
    sb.append("\");"); // $NON-NLS-1$
    method.addBodyLine(sb.toString());
    method.addBodyLine("return (Criteria) this;"); // $NON-NLS-1$

    return method;
  }
Esempio n. 22
0
  public void f2(StringBuilder ss) {
    for (int i = 0; i < ss.length(); i++) {
      char ch = ss.charAt(i);
      if (ch >= 'a' && ch <= 'z') {
        //				ss = ss.replace(ch, (char)(ch-32));
        ss.setCharAt(i, (char) (ch - 32));
      }
      if (ch >= 'A' && ch <= 'Z') {
        ss.setCharAt(i, (char) (ch + 32));
      }
    }

    System.out.println(ss);
  }
Esempio n. 23
0
  // TODO not tested!!
  public boolean createEntity(Dao dao, Entity<?> en) {
    StringBuilder sb = new StringBuilder("CREATE TABLE " + en.getTableName() + "(");
    // 创建字段
    for (MappingField mf : en.getMappingFields()) {
      sb.append('\n').append(mf.getColumnName());
      sb.append(' ').append(evalFieldType(mf));
      // 非主键的 @Name,应该加入唯一性约束
      if (mf.isName() && en.getPkType() != PkType.NAME) {
        sb.append(" UNIQUE NOT NULL");
      }
      // 普通字段
      else {
        if (mf.isNotNull() || mf.isPk()) sb.append(" NOT NULL");
        if (mf.hasDefaultValue()) sb.append(" DEFAULT '").append(getDefaultValue(mf)).append('\'');
        if (mf.isAutoIncreasement()) sb.append(" generated by default as identity ");
        if (mf.isPk() && en.getPks().size() == 1) {
          sb.append(" primary key ");
        }
      }
      sb.append(',');
    }
    // 结束表字段设置
    sb.setCharAt(sb.length() - 1, ')');

    // 执行创建语句
    dao.execute(Sqls.create(sb.toString()));

    // 创建联合主键
    if (en.getPks().size() > 1) {
      sb = new StringBuilder();
      sb.append("ALTER TABLE ").append(en.getTableName()).append(" ADD CONSTRAINT PK_");
      sb.append(makePksName(en));
      sb.append(" PRIMARY KEY (");
      for (MappingField mf : en.getPks()) {
        sb.append(mf.getColumnName()).append(",");
      }
      sb.setCharAt(sb.length() - 1, ')');
      dao.execute(Sqls.create(sb.toString()));
    }

    // 创建关联表
    createRelation(dao, en);
    // 创建索引
    dao.execute(createIndexs(en).toArray(new Sql[0]));
    // 添加注释(表注释与字段注释)
    addComment(dao, en);

    return true;
  }
  /**
   * This convenience wrapper function filters all real transformations that have to be undertaken
   * on the first string to transform the later into the second string. Both strings have to be
   * represented by a path that is yielded by the <code>levenshteinPath</code> method of an existing
   * <code>ComparedStrings</code> object.
   *
   * <p>All resulting transformations are represented by <code>String</code> objects that stand for
   * one step of the transformation. Any further transformation details described by the original
   * Levenshtein path are lost. Note that the number of transformations is strictly smaller than the
   * number of Levenshtein path nodes since <code>ACTION_START</code> and <code>ACTION_REMAIN</code>
   * nodes do not trigger a real transformation and are therefore filtered out.
   *
   * @param levenshteinPath The transformation path that alters one string into another
   * @param firstWord The first word that is represented by <code>levenshteinPath</code>
   * @param secondWord The second word that is represented by <code>levenshteinPath</code>
   * @return An array of strings that describes all transformation steps including in their order
   * @since jLevenshtein v0.2
   */
  public static String[] resultTransformation(
      Map<HashPoint, Integer> levenshteinPath, String firstWord, String secondWord) {

    StringBuilder sb = new StringBuilder(firstWord);
    char[] secondWordChars = secondWord.toCharArray();
    sb.ensureCapacity(secondWordChars.length);

    int firstWordIndexShifted = 0;
    List<String> transformations = new ArrayList<String>(levenshteinPath.size() - 1);
    transformations.add(firstWord);

    loop:
    for (Entry<HashPoint, Integer> entry :
        new TreeMap<HashPoint, Integer>(levenshteinPath).entrySet()) {

      switch (entry.getValue().intValue()) {
        case Levenshtein.ACTION_SUBSTITUTE:
          sb.setCharAt(
              entry.getKey().y - 1 + firstWordIndexShifted, secondWordChars[entry.getKey().x - 1]);
          break;

        case Levenshtein.ACTION_INSERT:
          sb.insert(
              entry.getKey().y + firstWordIndexShifted, secondWordChars[entry.getKey().x - 1]);
          firstWordIndexShifted++;
          break;

        case Levenshtein.ACTION_DELETE:
          sb.deleteCharAt(entry.getKey().y - 1 + firstWordIndexShifted);
          firstWordIndexShifted--;
          break;

        case Levenshtein.ACTION_SWAP:
          sb.setCharAt(
              entry.getKey().y - 1 + firstWordIndexShifted, secondWordChars[entry.getKey().x - 1]);
          sb.setCharAt(
              entry.getKey().y - 2 + firstWordIndexShifted, secondWordChars[entry.getKey().x - 2]);
          break;

        default:
          continue loop;
      }

      transformations.add(sb.toString());
    }

    return transformations.toArray(new String[0]);
  }
 private static void reverse(StringBuilder sb, int start, int end) {
   for (int i = start, j = end; --j > i; ++i) {
     char c = sb.charAt(i), d = sb.charAt(j);
     sb.setCharAt(i, d);
     sb.setCharAt(j, c);
   }
 }
Esempio n. 26
0
  public static StringBuilder toPascalCase(String name) {
    StringBuilder buffer = toCamelCase(name);
    char c = buffer.charAt(0);
    if (c > 96 && c < 123) buffer.setCharAt(0, (char) (c - 32));

    return buffer;
  }
Esempio n. 27
0
 protected List<Sql> createIndexs(Entity<?> en) {
   List<Sql> sqls = new ArrayList<Sql>();
   StringBuilder sb = new StringBuilder();
   List<EntityIndex> indexs = en.getIndexes();
   for (EntityIndex index : indexs) {
     sb.setLength(0);
     if (index.isUnique()) sb.append("Create UNIQUE Index ");
     else sb.append("Create Index ");
     if (index.getName().contains("$"))
       sb.append(TableName.render(new CharSegment(index.getName())));
     else sb.append(index.getName());
     sb.append(" ON ").append(en.getTableName()).append("(");
     for (EntityField field : index.getFields()) {
       if (field instanceof MappingField) {
         MappingField mf = (MappingField) field;
         sb.append(mf.getColumnNameInSql()).append(',');
       } else {
         throw Lang.makeThrow(
             DaoException.class,
             "%s %s is NOT a mapping field, can't use as index field!!",
             en.getClass(),
             field.getName());
       }
     }
     sb.setCharAt(sb.length() - 1, ')');
     sqls.add(Sqls.create(sb.toString()));
   }
   return sqls;
 }
Esempio n. 28
0
 public static String unaccentString(CharSequence charSequence) {
   if (charSequence == null) {
     return null;
   }
   StringBuilder sb = new StringBuilder(charSequence);
   int s = sb.length();
   for (int i = 0; i < s; i++) {
     char c = sb.charAt(i);
     if (c == ' ') {
       sb.setCharAt(i, '_');
     } else if (isAccented(c)) {
       sb.setCharAt(i, unaccented(c));
     }
   }
   return sb.toString();
 }
Esempio n. 29
0
  private static CharSequence ellipsizeFromCache(CharSequence str, int width, TextPaint paint) {
    // the TextUtils.ellipsize method is really expensive, so we can exploit
    // the fact that we're using monospace-style text
    // to just cache the correct number of characters given the width

    Integer maxLength = PreferenceHelper.ellipsisLengthsCache.get(width);

    if (maxLength != null) { // cached

      if (str.length() < maxLength) {
        return str;
      }

      // truncate and add ellipsis
      StringBuilder stringBuilder = new StringBuilder(str);
      if (stringBuilder.length() > maxLength) {
        stringBuilder.delete(maxLength, stringBuilder.length());
      }
      if (stringBuilder.length() > 0) {
        stringBuilder.setCharAt(stringBuilder.length() - 1, (char) 8230); // add
        // ellipsis
        // character
      }
      return stringBuilder;
    }

    CharSequence result = TextUtils.ellipsize(str, paint, width, TruncateAt.END);
    if (result.length() < str.length()) { // was ellipsized
      PreferenceHelper.ellipsisLengthsCache.put(width, result.length());
    }
    return result;
  }
Esempio n. 30
0
  public String bestmod(String s, int k) {
    String ret = s;
    StringBuilder sub = new StringBuilder(s);

    for (int i = 1, size = s.length(); i < size; ++i) {
      sub =
          new StringBuilder(
              sub.toString().substring(size - 1) + sub.toString().substring(0, size - 1));

      StringBuilder sub2 = new StringBuilder(sub);
      int count = k;

      for (int j = 1; j <= sub2.length() && count > 0; ++j) {
        if (sub2.charAt(j - 1) != 'a') {
          sub2.setCharAt(j - 1, 'a');
          --count;
        }
      }

      if (sub2.toString().compareTo(ret) < 0) {
        ret = sub2.toString();
      }
    }

    return ret;
  }