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);
}
/** 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();
}
/**
* 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;
}
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;
}
private void markFiltered(
StringBuilder text,
int start,
int end,
Token filtered,
Map<Integer, Token> filteredTokenMap) {
for (int i = start; i < end; i++) {
filteredTokenMap.put(i, filtered);
text.setCharAt(i, PREDEFINED_TOKEN_REPLACEMENT);
}
}
/**
* Converts a map of results to a String JSON representation for it
*
* @param map a map that matches properties with an ArrayList of values
* @return the JSON representation for the map, as a String
*/
private String mapToString(Map<String, ArrayList<String>> map) {
StringBuilder result = new StringBuilder("{");
for (Map.Entry<String, ArrayList<String>> entry : map.entrySet()) {
ArrayList<String> value = entry.getValue();
if (value.size() == 1)
result.append(String.format("\"%s\" : %s,\n", entry.getKey(), value.get(0)));
else result.append(String.format("\"%s\" : %s,\n", entry.getKey(), value.toString()));
}
result.setCharAt(result.length() - 2, '}');
return result.toString();
}
// *******initialize******* domain with cells
void resetCells() {
// int radius=50; dont think this is used
Cells = new int[size][size];
carriedmutation = new int[size][size];
// Fill the domain with healthy cells 0's first.
for (int i = 0; i < size; i++)
for (int j = 0; j < size; j++) {
Cells[i][j] = 0;
carriedmutation[i][j] = 0;
}
Cells[centre][centre] = 1; // initialize with a stem cell if you like
carriedmutation[centre][centre] = 1; // the first cancer cell carries the tag '1' to start
genomeToMod = new StringBuilder(carriedGenome[centre][centre]);
genomeToMod.setCharAt(mutationNum - 1, '1'); // daughter carries new carriedGenome
carriedGenome[centre][centre] = genomeToMod;
// genomeToMod = carriedGenome[centre][centre];
}
public WcsCoverage(GridDataset.Gridset coverage, WcsDataset dataset) {
this.dataset = dataset;
if (this.dataset == null) {
log.error("WcsCoverage(): non-null dataset required.");
throw new IllegalArgumentException("Non-null dataset required.");
}
this.coverage = coverage;
if (this.coverage == null) {
log.error("WcsCoverage(): non-null coverage required.");
throw new IllegalArgumentException("Non-null coverage required.");
}
this.coordSys = coverage.getGeoCoordSystem();
if (this.coordSys == null) {
log.error("WcsCoverage(): Coverage must have non-null coordinate system.");
throw new IllegalArgumentException("Non-null coordinate system required.");
}
this.name = this.coordSys.getName();
this.label = this.coordSys.getName();
this.range = new HashMap<String, WcsRangeField>();
StringBuilder descripSB =
new StringBuilder("All parameters on the \"")
.append(this.name)
.append("\" coordinate system: ");
for (GridDatatype curField : this.coverage.getGrids()) {
String stdName = curField.findAttValueIgnoreCase("standard_name", "");
descripSB.append(stdName.length() == 0 ? curField.getFullName() : stdName).append(",");
WcsRangeField field = new WcsRangeField(curField);
range.put(field.getName(), field);
}
descripSB.setCharAt(descripSB.length() - 1, '.');
this.description = descripSB.toString();
this.nativeCRS = EPSG_OGC_CF_Helper.getWcs1_0CrsId(this.coordSys.getProjection());
this.defaultRequestCrs = "OGC:CRS84";
this.supportedCoverageFormatList = new ArrayList<WcsRequest.Format>();
// this.supportedCoverageFormatList = "application/x-netcdf";
this.supportedCoverageFormatList.add(WcsRequest.Format.GeoTIFF);
this.supportedCoverageFormatList.add(WcsRequest.Format.GeoTIFF_Float);
this.supportedCoverageFormatList.add(WcsRequest.Format.NetCDF3);
}
// main CELL CA loop************
public boolean iterateCells() {
/*
// modify consumption matrix
for (int i=0;i<size;i++)
for (int j=0;j<size;j++) consumption[i][j] = consumptionBasal[Cells[i][j]];
*/
//
if (cellList == null) cellList = new Bag(size * size);
for (int i = 0; i < size; i++)
for (int j = 0; j < size; j++) {
if (Cells[i][j]
< 4) { // All tumour cell types have Cell > 0, now 0 corresponds to 'healthy cells' that
// consume at basal rate only
int[] p = new int[2];
p[0] = i;
p[1] = j;
cellList.add(p);
if (Cells[i][j] == 1) {
stem_cells_this_TS++;
} else if (Cells[i][j] == 2 || Cells[i][j] == 3) {
non_stem_cells_this_TS++;
}
}
}
while (cellList.size() != 0) {
// Select the next lattice element at random
int randomElemIndex = 0;
if (cellList.size() > 1) randomElemIndex = random.nextInt(cellList.size() - 1);
int[] point = (int[]) cellList.get(randomElemIndex);
int rI = point[0];
int rJ = point[1];
cellList.remove(randomElemIndex); // Remove it from the cell list
int cell = Cells[rI][rJ];
// Cell death
// if ((Oxygen[rI][rJ]<hypoxia)) {
if ((random.nextFloat() < deathprob) && Cells[rI][rJ] > 0) { // x% chances of dying
Age[rI][rJ] = 0;
if (Cells[rI][rJ] == 1) stemDeathCounter[rI][rJ]++;
if (Cells[rI][rJ] < 4) {
// TACDeathCounter[rI][rJ]++;
Cells[rI][rJ] = 4; // was 0, now making necrotic area (truly empty)
deaths++;
stemBirthCounter[rI][rJ] = 0;
carriedmutation[rI][rJ] = 0; // empty space now has no mutations
carriedGenome[rI][rJ] = initGenome; // empty space now has no mutations
}
} else if ((cell == 3)
&& (Age[rI][rJ]
> 100 * maxMatureCellAge)) { // added * to allow for an update each celltimestep/x
// **************************
Age[rI][rJ] = 0;
Cells[rI][rJ] = 4; // was 0, now making necrotic area (truly empty)
// TACDeathCounter[rI][rJ]++;
deaths++;
} else if ((radiotherapy) && (cell == 2) && (random.nextFloat() > Oxygen[rI][rJ])) {
// Radiotherapy
Age[rI][rJ] = 0;
if (Cells[rI][rJ] == 1) stemDeathCounter[rI][rJ]++;
if ((Cells[rI][rJ] == 2) || (Cells[rI][rJ] == 3))
// TACDeathCounter[rI][rJ]++;
Cells[rI][rJ] = 4; // make necrotic
stemBirthCounter[rI][rJ] = 0;
deaths++;
}
// healthy division
else if ((cell == 0) && (vacantSites(rI, rJ) > 0)) {
if (proliferation[cell]
>= random.nextFloat()) { // If tossing the coin we are to proliferate...
// if (Oxygen[rI][rJ]>prolifThreshold) { // AND the oxygen concentration is enough for
// division..
// consumption[rI][rJ]=consumptionDivision[Cells[rI][rJ]];
int[] daughter = findEmptySite(rI, rJ);
births++;
Cells[daughter[0]][daughter[1]] = 0;
carriedmutation[daughter[0]][daughter[1]] = 0;
carriedGenome[daughter[0]][daughter[1]] =
initGenome; // resetting space to healthy cell with no mutations
}
}
// }
// cancer division
else if ((vacantSitesCancer(rI, rJ) > 0) && (cell > 0))
if (proliferation[cell]
>= random.nextFloat()) { // If tossing the coin we are to proliferate...
if ((cell == 1)
|| ((cell == 2)
&& (Age[rI][rJ] < maxProDivisions))) { // AND the cell is stem or TAC ...
// if (Oxygen[rI][rJ]>prolifThreshold) { // AND the oxygen concentration is enough for
// division..
// consumption[rI][rJ]=consumptionDivision[Cells[rI][rJ]];
int[] daughter = findEmptySiteCancer(rI, rJ); // and there is space (for cancer)
// if ((daughter[0]==0) || (daughter[0]==size) ||
// (daughter[1]==0)||(daughter[1]==size)) {simulationFinished=true;} // stop sim if a
// cell hits the edge
births++;
if (cell == 1) { // stem cell
stemBirthsTotal[rI][rJ]++;
stemBirthCounter[rI][rJ]++;
if (asymmetricRatio > random.nextFloat()) {
Cells[daughter[0]][daughter[1]] = 1; // placing the stem daughter
stemBirthCounter[daughter[0]][daughter[1]] =
stemBirthCounter[rI][rJ]; // update stem birth counter
carriedmutation[daughter[0]][daughter[1]] =
carriedmutation[rI][rJ]; // inherit mutational status of parent
carriedGenome[daughter[0]][daughter[1]] =
carriedGenome[rI][rJ]; // inherit mutational status of parent
if (mutfreq > random.nextFloat()) { // small chance of mutation
mutationNum++; // advance mutation number
System.out.println(
+carriedmutation[rI][rJ]
+ ", "
+ mutationNum
+ ", "
+ stem_cells_this_TS
+ ", "
+ non_stem_cells_this_TS
+ ", "
+ timestep); // print (parent,child) pair
// tree.put(carriedmutation[rI][rJ], mutationNum);
// timeTree.put(mutationNum, timestep); // hash table stuff
if (0.5 > random.nextFloat()) {
carriedmutation[daughter[0]][daughter[1]] = mutationNum;
genomeToMod = new StringBuilder(carriedGenome[daughter[0]][daughter[1]]);
genomeToMod.setCharAt(
mutationNum - 1, '1'); // daughter carries new carriedGenome
carriedGenome[daughter[0]][daughter[1]] = genomeToMod;
// System.out.println (carriedGenome[rI][rJ]);
// System.out.println (carriedGenome[daughter[0]][daughter[1]]);
} // 50:50 mutate new position daughter
else {
carriedmutation[rI][rJ] = mutationNum; // else mutate original position daughter
genomeToMod = new StringBuilder(carriedGenome[rI][rJ]);
// genomeToMod = carriedGenome[rI][rJ];
carriedGenome[rI][rJ] = genomeToMod;
genomeToMod.setCharAt(
mutationNum - 1, '1'); // original carries new carriedGenome
// System.out.println (carriedGenome[rI][rJ]);
// System.out.println (carriedGenome[daughter[0]][daughter[1]]);
}
}
} else {
Cells[daughter[0]][daughter[1]] = 2; // asymmetric division, daughter is TAC
stemBirthCounter[daughter[0]][daughter[1]] = 0; // reset stem counter
carriedmutation[daughter[0]][daughter[1]] =
carriedmutation[rI][rJ]; // TAC carries parental mutation flag
carriedGenome[daughter[0]][daughter[1]] = carriedGenome[rI][rJ];
} // TAC carries parental genome
// } // redundant from above
// else { // Only if there's hypoxia induced change of symmetric division ratio
// float newASR=asymmetricRatio+0*(hypoxia-Oxygen[rI][rJ]);
// currently OFF by way of 0 the ^^ multiplier.
// if (newASR>random.nextFloat())
// {Cells[daughter[0]][daughter[1]]=1;stemBirthCounter[daughter[0]][daughter[1]]=stemBirthCounter[rI][rJ];}
// else
// {Cells[daughter[0]][daughter[1]]=2;stemBirthCounter[daughter[0]][daughter[1]]=0;}
// // Otherwise differentiate
// }
} else if (cell == 2) { // non-stem division
// TACBirthCounter[rI][rJ]++;
if (Age[rI][rJ] < maxProDivisions - 1) {
Cells[daughter[0]][daughter[1]] = 2;
Age[rI][rJ]++;
Age[daughter[0]][daughter[1]] = Age[rI][rJ];
carriedmutation[daughter[0]][daughter[1]] =
carriedmutation[rI][rJ]; // TAC carries parental mutation flag
carriedGenome[daughter[0]][daughter[1]] =
carriedGenome[rI][rJ]; // TAC carries parental genome
} else {
Cells[daughter[0]][daughter[1]] = 3;
Cells[rI][rJ] = 3;
Age[rI][rJ] = 0;
Age[daughter[0]][daughter[1]] = Age[rI][rJ];
carriedmutation[daughter[0]][daughter[1]] =
carriedmutation[rI][rJ]; // TAC carries parental mutation flag
carriedGenome[daughter[0]][daughter[1]] =
carriedGenome[rI][rJ]; // TAC carries parental genome
}
}
}
} else if (pMotility > random.nextFloat()) { // Migration = not in use
int[] daughter = findEmptySite(rI, rJ);
Cells[daughter[0]][daughter[1]] = cell;
Cells[rI][rJ] = 0;
Age[daughter[0]][daughter[1]] = Age[rI][rJ];
Age[rI][rJ] = 0;
System.err.println("moving " + rI + ", " + rJ);
}
// Aging for mature cells
if (cell == 3) Age[rI][rJ]++;
}
return true;
}