var input = '';
process.stdin.resume();
process.stdin.setEncoding('utf8');
process.stdin.on('data', function(chunk) {
    input += chunk;
});
process.stdin.on('end', function() {
    main(input)
});

function main(arg){
    var mountains = arg.split('\n');console.log(mountains);
    mountains = mountains.map(function(x){ return parseInt(x); })

    var topMountains = [];

    iterateTopMountains(function init(i){
        topMountains[i] = 0;
    })

    for(var i = 0; i < mountains.length; i += 1){
        var mountain = mountains[i];

        iterateTopMountains(function displace(rank){
            if(mountain > topMountains[rank]){
                topMountains.splice(rank, 0, mountain);
                return true;
            }
        })

    }

    iterateTopMountains(function show(i){
        console.log(topMountains[i]);
    })
}

function iterateTopMountains(func){
    var numTopMountains = 3;
    for(var i = 0; i < numTopMountains; i += 1){
        var needBreak = func(i);

        if(needBreak){ break; }
    }
}

Global OOD problem IDs are disjoint from train, validation, and in-distribution test problem IDs.

List of Top 3 Hills

There is a data which provides heights (in meter) of mountains. The data is only for ten mountains.

Write a program which prints heights of the top three mountains in descending order.

Input

Height of mountain 1
Height of mountain 2
Height of mountain 3
.
.
Height of mountain 10

Constraints

0 ≤ height of mountain (integer) ≤ 10,000

Output

Height of the 1st mountain
Height of the 2nd mountain
Height of the 3rd mountain

Sample Input 1

1819
2003
876
2840
1723
1673
3776
2848
1592
922

Output for the Sample Input 1

3776
2848
2840

Sample Input 2

100
200
300
400
500
600
700
800
900
900

Output for the Sample Input 2

900
900
800

Submitted source-code file size, in bytes.

Execution CPU time reported by official Project CodeNet metadata, in milliseconds.

Peak memory usage reported by official Project CodeNet metadata, in kilobytes.


var input = [];
var max;
var maxIndex;
var temp;
var maxLength;
process.stdin.on('data', function(chunk){
    input.push(chunk);
});
process.stdin.on('end', function(){
    for (var m = 0; m < maxLength; m++) {
        temp = 0;
        for (var i = 0; i < input.length; i++) {
            if (i === 0) {
                temp = input[i];
            }else{
                if (temp < input[i]) {
                    temp = input[i];
                    maxIndex = i;
                }
            }
        }
        console.log(temp)
        input.splice(i,i);
    }
});


Digit Number

Write a program which computes the digit number of sum of two integers a and b.

Input

There are several test cases. Each test case consists of two non-negative integers a and b which are separeted by a space in a line. The input terminates with EOF.

Constraints

0 ≤ a, b ≤ 1,000,000

The number of datasets ≤ 200

Output

Print the number of digits of a + b for each data set.

Sample Input

5 7
1 99
1000 999

Output for the Sample Input

2
3
4


function Main(input) {
    input = input.split("\n");
    for(var i=0;;i++){
        if(typeof input[i]!="string")break;
        num = input[i].split(" ");
        for(var j=0;j<2;j++){
            num[j]= Int(num[j]);
        }
        console.log(Str(num[0]+num[1]).length);
    }
}
//??°????????????????????¢??°??¨(??????)
function ascendingOrder(val1,val2){
    return val1 - val2;
}
//??°????????????????????¢??°??¨(??????)
function descendingOrder(val1,val2){
    return val2 - val1;
}
//??°??????
function Int(str){
    return parseInt(str, 10);
}
//????????????
function Str(num){
    return num.toString(10);
}

//???????????°??¨
function debug(){
	var input = document.getElementById("input").value;
	Main(input);
}

//?????????????????\??????????????????
Main(require("fs").readFileSync("/dev/stdin", "utf8"));


var input = require('fs').readFileSync('/dev/stdin', 'utf8');
var Arr=(input.trim()).split("\n");
Arr.shift();
Arr.forEach(function(v){
var arr=v.split(" ").map(Number);
arr.sort(function(a,b){return b-a;});
var a=arr[0];
var b=arr[1];
var c=arr[2];
var str="";
str=(c*c==a*a+b*b)?"YES":"NO";
console.log(str);
});

Is it a Right Triangle?

Write a program which judges wheather given length of three side form a right triangle. Print "YES" if the given sides (integers) form a right triangle, "NO" if not so.

Input

Input consists of several data sets. In the first line, the number of data set, N is given. Then, N lines follow, each line corresponds to a data set. A data set consists of three integers separated by a single space.

Constraints

1 ≤ length of the side ≤ 1,000

N ≤ 1,000

Output

For each data set, print "YES" or "NO".

Sample Input

3
4 3 5
4 3 6
8 8 8

Output for the Sample Input

YES
NO
NO


process.stdin.resume();
process.stdin.setEncoding('utf8');

// Get lines from standard input.
var input = require('fs').readFileSync('/dev/stdin', 'utf8');
var lines = input.split("\n");

var number_of_datasets = lines.shift();

for (var dataset = 0; dataset < number_of_datasets; dataset++)
{
var value = "NO";
var values = lines[dataset].split(" ");

var a = parseInt(values[0]);
var b = parseInt(values[1]);
var c = parseInt(values[2]);

if ((a*a) + (b*b) === (c*c))
{
value = "YES";
}
if ((a*a) + (c*c) === (b*b))
{
value = "YES";
}
if ((c*c) + (b*b) === (a*a))
{
value = "YES";
}

console.log(value);
}


function Main(input){
    input = input.split("\n");
    var n = parseInt(input[0],10);

    for(var i = 0;i < n;i++){
        input[i + 1] = input[i + 1].split(' ');
        var a = input[i + 1][0];
        var b = input[i + 1][1];
        var c = input[i + 1][2];

        if(a > b){
            var ex = a;
            a = b;
            b = ex;
        }
        if(b > c){
            var ex = b;
            b = c;
            c = ex;
        }
        if(a * a + b * b === c * c)
            console.log("YES");
        else
            console.log("NO");
    }
}
Main(require("fs").readFileSync("/dev/stdin","utf8"));


(function(undefined){
	'use strict';
	(function init() {
		this.output = function() {
			console.log.apply( console, arguments );
		};
		this.stdin = process.openStdin();
		stdin.setEncoding('utf8');
		this.input_list = [];
		stdin.on('data', function(chunk){
			var result = chunk.match(/\d+/g);
			input_list = input_list.concat(result);
		});
		this.input_number = function() {
			return parseInt( input_list.splice(0,1)[0] );
		};
	}).call( this );
	(function solver(){
		function sq(x) {
			return x * x;
		}
		function check(v) {
			return sq(v.a)+sq(v.b)===sq(v.c)
			|| sq(v.b)+sq(v.c)===sq(v.a)
			|| sq(v.c)+sq(v.a)===sq(v.b);
		}
		setTimeout( function solve() {
			var n = input_number();
			var vertexes = [];
			while ( n -- )
				vertexes.push({
					a: input_number(),
					b: input_number(),
					c: input_number()
				});
			vertexes.forEach(function(vertex){
				output( check(vertex) ? 'YES' : 'NO' );
			});
		}, 0 );
	})();
}).call(global);


var SystemOfEquations = (function () {
    function SystemOfEquations(a, b, c, d, e, f) {
        this.a = a;
        this.b = b;
        this.c = c;
        this.d = d;
        this.e = e;
        this.f = f;
    }
    SystemOfEquations.prototype.lcm = function (a, b) {
        var alcm = 1;
        var blcm = 1;
        while (true) {
            if (Math.abs(a * alcm) === Math.abs(b * blcm)) {
                return [alcm, blcm];
            }
            if (Math.abs(a * alcm) > Math.abs(b * blcm)) {
                blcm++;
            } else {
                alcm++;
            }
        }
    };

    SystemOfEquations.prototype.solution = function () {
        var lcms = this.lcm(this.a, this.d);
        var b = this.b * lcms[0];
        var c = this.c * lcms[0];
        var e = this.e * lcms[1];
        var f = this.f * lcms[1];
        var g = b - (e < 0 ? -e : e);
        var h = c - (f < 0 ? -f : f);
        var y = h / g;
        var x = ((this.c - (this.b * y)) / this.a);
        return [x.toFixed(3), y.toFixed(3)];
    };
    return SystemOfEquations;
})();
process.stdin.resume();
process.stdin.setEncoding('utf8');
process.stdin.on('data', function (chunk) {
    chunk.trim().split('\n').forEach(function (line) {
        var items = line.trim().split(' ');
        if (items.length == 6) {
            var soe = new SystemOfEquations(+items[0], +items[1], +items[2], +items[3], +items[4], +items[5]);
            var solution = soe.solution();
            console.log(solution[0] + " " + solution[1]);
        }
    });
});

Simultaneous Equation

Write a program which solve a simultaneous equation:

ax + by = c

dx + ey = f

The program should print x and y for given a, b, c, d, e and f (-1,000 ≤ a, b, c, d, e, f ≤ 1,000). You can suppose that given equation has a unique solution.

Input

The input consists of several data sets, 1 line for each data set. In a data set, there will be a, b, c, d, e, f separated by a single space. The input terminates with EOF.

Output

For each data set, print x and y separated by a single space. Print the solution to three places of decimals. Round off the solution to three decimal places.

Sample Input 1

1 2 3 4 5 6
2 -1 -2 -1 -1 -5

Output for the Sample Input 1

-1.000 2.000
1.000 4.000

Sample Input 2

2 -1 -3 1 -1 -3
2 -1 -3 -9 9 27

Output for the Sample Input 2

0.000 3.000
0.000 3.000


process.stdin.on("data",function(c){
	(c+"").trim().split("\n").some(function(n,m,h){
		n=n.split(" "),m=+n[1],n=+n[0];
		var g=function(m,n,t){
			m<n&&(t=n,n=m,m=t);
			while(n=m%(m=n));
			return m;
		};
		console.log(h=g(n,m),n*m/h);
	});
}).resume();

GCD and LCM

Write a program which computes the greatest common divisor (GCD) and the least common multiple (LCM) of given a and b.

Input

Input consists of several data sets. Each data set contains a and b separated by a single space in a line. The input terminates with EOF.

Constraints

0 < a, b ≤ 2,000,000,000

LCM(a, b) ≤ 2,000,000,000

The number of data sets ≤ 50

Output

For each data set, print GCD and LCM separated by a single space in a line.

Sample Input

8 6
50000000 30000000

Output for the Sample Input

2 24
10000000 150000000


Reverse Sequence

Write a program which reverses a given string str.

Input

str (the size of str ≤ 20) is given in a line.

Output

Print the reversed str in a line.

Sample Input

w32nimda

Output for the Sample Input

admin23w


function reve(s) {
  return s.split('').reverse().join('');
}
var input = require('fs').readFileSync('/dev/stdin', 'utf8');
console.log(reve(input));


var input = require('fs').readFileSync('/dev/stdin', 'utf8');
function reverseStr(str) {
    var splitString = str.split("");
    var reverseArray = splitString.reverse();
    var joinArray = reverseArray.join("");
    return joinArray;
}
console.log(reverseStr(input));


function Main(input){
  var s=input.split('\n')[0];var i=s.length;
  var ans="";
  while(i--)ans+=s[i];
  console.log(ans);
}
Main(require("fs").readFileSync("/dev/stdin", "utf8"));


var input = require('fs').readFileSync('/dev/stdin', 'utf8');
var Arr=(input.trim()).split("\n");
var n=Arr.shift()-0;
while(n>0){
   var a=(Arr.shift()).split("").reverse().map(Number);
   var b=(Arr.shift()).split("").reverse().map(Number);
   var c=[];
   var max=Math.max(a.length,b.length);
   for(var i=0;i<max+1;i++)c[i]=0;
   for(var i=0;i<max;i++){
      var sum=0;
      if(a.length>i)sum+=a[i];
      if(b.length>i)sum+=b[i];
      c[i]+=sum;
   }
   for(var i=0;i<max;i++){
      if(c[i]>=10){
         c[i]-=10;
         c[i+1]++;
      }
   }
   if(c[c.length-1]==0)c.pop();
   var str=c.reverse().join("");
   console.log(str);
   n--;
}


// 標準入力
var fs = require('fs'),
length = fs.fstatSync(process.stdin.fd).size,
buffer = new Buffer(length),
bytesRead = fs.readSync(process.stdin.fd, buffer, 0, length, 0),
input = buffer.toString('utf8', 0, bytesRead).trim().split('\n');
main();

// ここから
function main(){
  var i = 1;
  for(var len = input[0] - 0;len--;){
    var x = input[i++].split('').reverse().join('').trim();
    var y = input[i++].split('').reverse().join('').trim();

    var loop = x.length > y.length ? x.length : y.length;
    var results = new Int8Array(loop + 1);
    for(var j = 0; j < loop; j++){
      var xj = x.length > j ? x[j] - 0 : 0;
      var yj = y.length > j ? y[j] - 0 : 0;
      var rj = results[j] - 0;
      var sum = xj + yj + rj;
      if(sum >= 10){
        sum -= 10;
        results[j + 1]++;
      }
      results[j] = sum;
    }

    var result = "";
    for(loop++;loop--;){
      result += results[loop];
    }
    result=result.replace(/^0/g, "");

    console.log(result.length > 80 ? 'overflow' : result);
  }
}


var input = require('fs').readFileSync('/dev/stdin', 'utf8');
var Arr=(input.trim()).split(" ").map(Number);
Arr.sort(function(a,b){return b-a;});
console.log(Arr.join(" "));

Sorting Five Numbers

Write a program which reads five numbers and sorts them in descending order.

Input

Input consists of five numbers a, b, c, d and e (-100000 ≤ a, b, c, d,e ≤ 100000). The five numbers are separeted by a space.

Output

Print the ordered numbers in a line. Adjacent numbers should be separated by a space.

Sample Input

3 6 9 7 5

Output for the Sample Input

9 7 6 5 3


var input = require('fs').readFileSync('/dev/stdin', 'utf8');
var Arr=(input.trim()).split("\n");
Arr.shift();
Arr.forEach(function(v){
var arr=v.split(" ").map(Number);
arr=arr.map(function(v){return v+100;});
var x="NO";
if(arr[2]-arr[0]!==0 && arr[2+4]-arr[0+4]!==0){
var ab=(arr[3]-arr[1])/(arr[2]-arr[0]);
var cd=(arr[3+4]-arr[1+4])/(arr[2+4]-arr[0+4]);
x=(ab==cd)?"YES":"NO";
}
console.log(x);
});

MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});

Parallelism

There are four points: $A(x_1, y_1)$, $B(x_2, y_2)$, $C(x_3, y_3)$, and $D(x_4, y_4)$. Write a program which determines whether the line $AB$ and the line $CD$ are parallel. If those two lines are parallel, your program should prints "YES" and if not prints "NO".

Input

Input consists of several datasets. In the first line, you are given the number of datasets $n$ ($n \leq 100$). There will be $n$ lines where each line correspondgs to each dataset. Each dataset consists of eight real numbers:

$x_1$ $y_1$ $x_2$ $y_2$ $x_3$ $y_3$ $x_4$ $y_4$

You can assume that $-100 \leq x_1, y_1, x_2, y_2, x_3, y_3, x_4, y_4 \leq 100$.
Each value is a real number with at most 5 digits after the decimal point.

Output

For each dataset, print "YES" or "NO" in a line.

Sample Input

2
0.0 0.0 1.0 1.0 1.0 0.0 2.0 1.0
3.0 2.0 9.0 6.0 13.0 5.0 7.0 9.0

Output for the Sample Input

YES
NO


(function(input) {
  var p = input.replace(/\n$/, '').split('\n');
  var n = Number(p.shift());
  var i = 0;
  while (i++ < n) {
    var args = p.shift().split(' ').map(Number);
    var x1 = args.shift();
    var y1 = args.shift();
    var x2 = args.shift();
    var y2 = args.shift();
    var x3 = args.shift();
    var y3 = args.shift();
    var x4 = args.shift();
    var y4 = args.shift();
    console.log(Math.floor((y2 - y1) / (x2 - x1)) === Math.floor((y4 - y3) / (x4 - x3)) ? 'YES' : 'NO');
  }
})(require('fs').readFileSync('/dev/stdin', 'utf8'));


var input = require('fs').readFileSync('/dev/stdin', 'utf8');
var Arr=(input.trim()).split("\n");
var n=Arr.shift()-0;
for(var i=0;i<n;i++){
   var arr=Arr.shift().split(" ").map(Number);
   (function(x1, y1, x2, y2, x3, y3, x4, y4){
      var k1=(x2-x1!=0)?(y2-y1)/(x2-x1):1;
      var k2=(x4-x3!=0)?(y4-y3)/(x4-x3):1;
      k1=Math.abs(k1.toFixed(6))
      k2=Math.abs(k2.toFixed(6))
      console.log((k1==k2)?"YES":"NO");
   }).apply(null,arr);
}


var fs = require('fs'),
length = fs.fstatSync(process.stdin.fd).size,
buffer = new Buffer(length),
bytesRead = fs.readSync(process.stdin.fd, buffer, 0, length, 0),
input = buffer.toString('utf8', 0, bytesRead).split('\n');
main();

function main(){
  for(var i = 1, len = input[0]-0; i <= len; i++){
    var c = input[i].split(' ');
    var x1 = c[0];
    var y1 = c[1];
    var x2 = c[2];
    var y2 = c[3];
    var x3 = c[4];
    var y3 = c[5];
    var x4 = c[6];
    var y4 = c[7];

    console.log(((x2-x1)/(y2-y1)).toFixed(6) == ((x4-x3)/(y4-y3)).toFixed(6) ? 'YES' : 'NO');
  }
}


(function () {
  var input = '';

  function main () {
    var i,
        dataSet,
        inputLen = input.length - 1;

    for (i = 1; i < inputLen; i += 1) {
      dataSet = input[i].split(' ');

      console.log(judgeParallelism(dataSet));
    }
  }

  function judgeParallelism (data) {
    var x1 = parseFloat(data[0]),
        y1 = parseFloat(data[1]),
        x2 = parseFloat(data[2]),
        y2 = parseFloat(data[3]),
        x3 = parseFloat(data[4]),
        y3 = parseFloat(data[5]),
        x4 = parseFloat(data[6]),
        y4 = parseFloat(data[7]);

    if ((y2 - y1) / (x2 - x1) === (y4 - y3) / (x4 - x3)) {
      return 'YES';
    } else {
      return 'NO';
    }
  }

  process.stdin.resume();
  process.stdin.setEncoding('utf8');
  process.stdin.on('data', function (chunk) {
    input += chunk;
  });

  process.stdin.on('end', function () {
    input = input.split('\n');
    main();
  });
}());


(function(input) {
  var p = input.replace(/\n$/, '').split('\n').map(Number);
  var n = p.length;
  var G = 9.8;
  for (var i = 0; i < n; i++) {
    var mv = p.shift();
    var t = mv / G;
    var N = (G / 2 * t * t + 5) / 5;
    console.log(Math.ceil(N));
  }
})(require('fs').readFileSync('/dev/stdin', 'utf8'));

MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});

Circles Intersection

You are given circle $A$ with radius $r_a$ and with central coordinate $(x_a, y_a)$ and circle $B$ with radius $r_b$ and with central coordinate $(x_b, y_b)$.

Write a program which prints:

"2" if $B$ is in $A$,

"-2" if $A$ is in $B$,

"1" if circumference of $A$ and $B$ intersect, and

"0" if $A$ and $B$ do not overlap.

You may assume that $A$ and $B$ are not identical.

Input

The input consists of multiple datasets. The first line consists of an integer $N$ ($N \leq 50$), the number of datasets. There will be $N$ lines where each line represents each dataset. Each data set consists of real numbers:

$x_a$ $y_a$ $r_a$ $x_b$ $y_b$ $r_b$

Output

For each dataset, print 2, -2, 1, or 0 in a line.

Sample Input

2
0.0 0.0 5.0 0.0 0.0 4.0
0.0 0.0 2.0 4.1 0.0 2.0

Output for the Sample Input

2
0


var input = require('fs').readFileSync('/dev/stdin', 'utf8');
var Arr=(input.trim()).split("\n").map(Number);
Arr.forEach(function(v){
var t=v/9.8;
var y=4.9*t*t;
var n=Math.ceil((y+5)/5);
console.log(n);
});

MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});

Physical Experiments

Ignoring the air resistance, velocity of a freely falling object $v$ after $t$ seconds and its drop $y$ in $t$ seconds are represented by the following formulas:

$ v = 9.8 t $

$ y = 4.9 t^2 $

A person is trying to drop down a glass ball and check whether it will crack. Your task is to write a program to help this experiment.

You are given the minimum velocity to crack the ball. Your program should print the lowest possible floor of a building to crack the ball. The height of the $N$ floor of the building is defined by $5 \times N - 5$.

Input

The input consists of multiple datasets. Each dataset, a line, consists of the minimum velocity v (0 < v < 200) to crack the ball. The value is given by a decimal fraction, with at most 4 digits after the decimal point. The input ends with EOF. The number of datasets is less than or equal to 50.

Output

For each dataset, print the lowest possible floor where the ball cracks.

Sample Input

25.4
25.4

Output for the Sample Input

8
8


x=require('fs').readFileSync('/dev/stdin','utf8').trim().split(/\s/);
yobi=new Array("Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday");
for(i=0;i<x.length-1;){
    console.log(yobi[new Date('2004/0'+x[i++]+'/0'+x[i++]).getDay()]);
}

What day is today?

Your task is to write a program which reads a date (from 2004/1/1 to 2004/12/31) and prints the day of the date. Jan. 1, 2004, is Thursday. Note that 2004 is a leap year and we have Feb. 29.

Input

The input is a sequence of datasets. The end of the input is indicated by a line containing one zero. Each dataset consists of two integers m and d separated by a single space in a line. These integers respectively represent the month and the day.

The number of datasets is less than or equal to 50.

Output

For each dataset, print the day (please see the following words) in a line.

Monday
Tuesday
Wednesday
Thursday
Friday
Saturday
Sunday

Sample Input

1 1
2 29
0 0

Output for the Sample Input

Thursday
Sunday


process.stdin.on("data",function(c){
	var k=[],m=1,t=0,p;
	(c+"").trim().split("\n").sort(function(a,b){
		return a-b;
	})
	.map(function(n){
		p==n?t++:((t>m?(k=[p],m=t):t==m?(k.push(p),m=t):0),(t=0));
		p=n;
	});
	console.log(k.join("\n"));
}).resume();

Mode Value

Your task is to write a program which reads a sequence of integers and prints mode values of the sequence.
The mode value is the element which occurs most frequently.

Input

A sequence of integers ai (1 ≤ ai ≤ 100). The number of integers is less than or equals to 100.

Output

Print the mode values. If there are several mode values, print them in ascending order.

Sample Input

5
6
3
5
8
7
5
3
9
7
3
4

Output for the Sample Input

3
5

For example, 3 and 5 respectively occur three times, 7 occurs two times, and others occur only one. So, the mode values are 3 and 5.


function main() {
  var
  i,
  word, longer, words,
  max, maxStr,
  words = input[0].split(' '),
  len = words.length,
  dict = {};
  for(i = 0; i < len; i++) {
    word = words[i].toLowerCase();
    dict[word] = (dict[word] || 0) + 1;
  }
  max = 0;
  longer = '';
  Object.keys(dict).forEach(function(word) {
    if(dict[word] > max) {
      max = dict[word];
      maxStr = word;
    }
    if(word.length > longer.length) {
      longer = word;
    }
  });
  console.log('%s %s', maxStr, longer);
}

var
input = '';

process.stdin.resume();
process.stdin.setEncoding('utf8');
process.stdin.on('data', function(chunk) {
  input += chunk;
});
process.stdin.on('end', function() {
  input = input.split('\n');
  main();
});

English Sentence

Your task is to write a program which reads a text and prints two words. The first one is the word which is arise most frequently in the text. The second one is the word which has the maximum number of letters.

The text includes only alphabetical characters and spaces. A word is a sequence of letters which is separated by the spaces.

Input

A text is given in a line. You can assume the following conditions:

The number of letters in the text is less than or equal to 1000.

The number of letters in a word is less than or equal to 32.

There is only one word which is arise most frequently in given text.

There is only one word which has the maximum number of letters in given text.

Output

The two words separated by a space.

Sample Input

Thank you for your mail and your lectures

Output for the Sample Input

your lectures


鉄道路線

複線（上りと下りが別の線路になっていてどこででもすれ違える）の鉄道路線があります。この路線には終端駅を含めて11 の駅があり、それぞれの駅と駅の間は図で示す区間番号で呼ばれています。

この路線の両方の終端駅から列車が同時に出発して、途中で停まらずに走ります。各区間の長さと2 本の列車の速度を読み込んで、それぞれの場合について列車がすれ違う区間の番号を出力するプログラムを作成してください。ただし、ちょうど駅のところですれ違う場合は、両側の区間番号のうち小さいほうの数字を出力します。また、列車の長さ、駅の長さは無視できるものとします。

Input

複数のデータセットが与えられる。各データセットは以下のような形式で与えられる。

l1,l2,l3,l4,l5,l6,l7,l8,l9,l10,v1,v2

li (1 ≤ li ≤ 2,000) は区間 i の長さ(km)を表す整数である。v1 は区間 1 側の終端駅を出発した列車の速度(km/h)、v2 は区間 10 側の終端駅を出発した列車の速度(km/h)を表す整数である (1 ≤ v1, v2 ≤ 2,000)。

データセットの数は 50 を超えない。

Output

データセットごとに、列車がすれちがう区間の番号を１行に出力する。

Sample Input

1,1,1,1,1,1,1,1,1,1,40,60
1,1,1,1,1,3,3,3,3,3,50,50
10,10,10,10,10,10,10,10,10,10,50,49

Output for the Sample Input

4
7
6


平面上の図形

縦 8、横 8 のマスからなる図 1 のような平面があります。

□

□

□

□

□

□

□

□

□

□

□

□

□

□

□

□

□

□

□

□

□

□

□

□

□

□

□

□

□

□

□

□

□

□

□

□

□

□

□

□

□

□

□

□

□

□

□

□

□

□

□

□

□

□

□

□

□

□

□

□

□

□

□

□

図１

この平面上に、以下の A から G の図形のどれかが一つだけ置かれています。

A

■

■

■

■

B

■

■

■

■

C

■

■

■

■

D

■

■

■

■

E

■

■

■

■

F

■

■

■

■

G

■

■

■

■

たとえば、次の図 2 の例では E の図形が置かれています。

□

□

□

□

□

□

□

□

□

□

□

□

□

□

□

□

□

■

■

□

□

□

□

□

□

□

■

■

□

□

□

□

□

□

□

□

□

□

□

□

□

□

□

□

□

□

□

□

□

□

□

□

□

□

□

□

□

□

□

□

□

□

□

□

図２

平面の中で図形が占めているマスを 1、占めていないマスを 0 で表現した数字の列を読み込んで、置かれている図形の種類（A〜G）を出力するプログラムを作成してください。

ただし、ひとつの平面に置かれている図形は必ず１つで、複数の図形が置かれていることはありません。また、A〜G で表される図形以外のものが置かれていることはありません。

Input

入力は複数のデータセットからなります。

１つのデータセットとして、平面の中で図形が占めているマスを 1、占めていないマスを 0 で表現した 8 文字からなる 8 つの文字列が与えられます。例えば、図 2 に対応する文字列の並びは次のようになります。

0

0

0

0

0

0

0

0

0

0

0

0

0

0

0

0

0

1

1

0

0

0

0

0

0

0

1

1

0

0

0

0

0

0

0

0

0

0

0

0

0

0

0

0

0

0

0

0

0

0

0

0

0

0

0

0

0

0

0

0

0

0

0

0

データセットの間は１つの空行で区切られています。データセットの数は 50 を超えません。

Output

各データセットごとに、平面に与えられた図形の種類（A〜G のいずれか）を１行に出力してください。

Sample Input

00000000
00000000
01100000
00110000
00000000
00000000
00000000
00000000

00011110
00000000
00000000
00000000
00000000
00000000
00000000
00000000

00000000
00000000
00110000
00110000
00000000
00000000
00000000
00000000

Output for the Sample Input

E
C
A


var abc="abcdefghijklmnopqrstuvwxyz".split("");

var input = require('fs').readFileSync('/dev/stdin', 'utf8');
var Arr=(input.trim()).split("\n");
var n=Arr.shift()-0;
for(var I=0;I<n;I++){
   var str=Arr[I];
   [1,3,5,7,9,11,15,17,19,21,23,25].forEach(function(A){
      for(var B=0;B<26;B++){
         var STR="";
         for(var i=0;i<str.length;i++){
            var index=abc.indexOf(str[i]);
            STR+=(index!=-1)?abc[(A*(index+B))%26]:" ";
         }
         if(STR.match(/this|that/))return console.log(STR);
      }
   });
}

MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});

アフィン暗号

簡単な暗号法の一つに、アフィン暗号というものがあります。まず、アルファベット a〜z を a = 0, b = 1, c = 2,..., x = 23, y = 24, z = 25 と 0〜25 の数字に置き換えます。そして、以下の式で、原文のアルファベットを置換します。

$F(\gamma) = (\alpha \cdot \gamma + \beta)$ mod $26$

ただし、mod 26 は 26 で割った余りを表します。例えば、$\alpha = 3, \beta = 2$ のとき、アルファベットの 'a' (=0) は、$F(0) = (3 \cdot 0 + 2)$ mod $26 = 2$ で 'c' に、アルファベットの 'n' (=13) は $F(13) = (3 \cdot 13 + 2)$ mod $26 = 15$ で 'p' に置換されます。
このとき、$\gamma$ に対する $F(\gamma)$ が必ず 1 対 1 で対応付けられるように、$\alpha$ と $\beta$ は慎重に選ばれているものとします（$\alpha$ と 26 が互いに素であることが条件）。$\alpha = 4, \beta = 7$ のときのように、$F('a') = 7, F('n') = 7$ と、'a' も 'n' も同じ 'h' に置換されるようなことはありません。また、アルファベット以外の文字は置換されません。

暗号化された文字列を元の文章に復号したものを出力するプログラムを作成してください。元の文章には、キーワードとして

that
this

のいずれかが必ず含まれているものとします。

Input

複数のデータセットが与えられます。１行目にデータセット数 $n$ ($n \leq 30$) が与えられます。続いて $n$ 行のデータが与えられます。各データセットに英小文字と空白からなる 256 文字以内の暗号化された文章が１行に与えられます。

Output

各データセットに対して、復号した元の文章を１行に出力して下さい。

Sample Input

1
y eazqyp pnop pngtg ye obmpngt xmybp mr lygw

Output for the Sample Input

i submit that there is another point of view


// 標準入力
var fs = require('fs'),
length = fs.fstatSync(process.stdin.fd).size,
buffer = new Buffer(length),
bytesRead = fs.readSync(process.stdin.fd, buffer, 0, length, 0),
input = buffer.toString('hex', 0, bytesRead).split('0a'); // hexでreadしたら早い？
main();

function main(){
  // 26と互いに素の値
  var multiply = new Int8Array([1,3,5,7,9,11,15,17,19,21,23,25]);
  var alphabets = new Int8Array(26);

FIRST:for(var i = 1, leni = input.length - 1; i < leni; i++){
    var inp = input[i];
    var c = inp.split('20');

    for(var j = 0, lenj = multiply.length; j < lenj; j++){
      var alpha = multiply[j];
      for(var beta = 26; beta--;){
        for(var conv = 26; conv--;){ // a-zの変換表作成
          alphabets[conv] = (conv * alpha + beta) % 26 + 97;
        }

        var thatIs = alphabets[19].toString(16) + alphabets[7].toString(16) + alphabets[0].toString(16) + alphabets[19].toString(16);
        var thisIs = alphabets[19].toString(16) + alphabets[7].toString(16) + alphabets[8].toString(16) + alphabets[18].toString(16);

        if(new RegExp("(" + thatIs + "|" + thisIs + ")").test(inp)){
          var convertTable = new Int8Array(123);
          for(var conv = 26; conv--;){
            var fromCode = alphabets[conv];
            convertTable[fromCode] = conv + 97; // key-valueの入れ替え
          }
          convertTable[20] = 20; // \nの入れ替え

          var result = "";
          for(var k = 0; k < inp.length; k+=2){
            result += String.fromCharCode(convertTable[parseInt(inp[k] + inp[k+1], 16)]);
          }
          console.log(result);
          continue FIRST;
        }

      }
    }

  }
}


// 標準入力
var fs = require('fs'),
length = fs.fstatSync(process.stdin.fd).size,
buffer = new Buffer(length),
bytesRead = fs.readSync(process.stdin.fd, buffer, 0, length, 0),
input = buffer.toString('utf8', 0, bytesRead).trim().split('\n');
main();

function main(){
  for(var i = 0, len = input.length; i < len; i++){
    var c = input[i].split('');

    var count = [0,0,0,0,0,0,0,0,0,0,0];
    for(var j = 0, jlen = c.length; j < jlen; j++){
      count[c[j]]++; // 入力の個数をカウント
    }

    var result = [];
  JLOOP:for(var j = 1; j <= 9; j++){
      // 引く牌のループ

      if(count[j] == 4 || (!count[j-1] && !count[j] && !count[j+1])){
        continue;
      }

      for(var k = 1; k <= 9; k++){
        if(count[k] == 0)
          continue;

        var count3 = count.slice(0);
        count3[j]++;
        count3[k] -= 2;

        for(var l = 1; l <= 9; l++){
          if(count3[l-1] >= 1 && count3[l] >= 1 && count3[l+1] >= 1){
            count3[l-1]--;
            count3[l]--;
            count3[l+1]--;
          }
          if(count3[l-1] >= 1 && count3[l] >= 1 && count3[l+1] >= 1){
            count3[l-1]--;
            count3[l]--;
            count3[l+1]--;
          }
          if(count3[l] >= 3){
            count3[l] -= 3;
          }
        }
        var sum = 0;
        for(var l = 1; l <=9; l++){
          sum += count3[l];
        }

        if(!sum){
          result.push(j);
          continue JLOOP;
        }
      }
    }

    console.log(result.length?result.join(' '):'0');

  }

}

パズル

1 〜 9 の数字を 14 個組み合わせて完成させるパズルがあります。与えられた 13 個の数字にもうひとつ数字を付け加えて完成させます。

パズルの完成条件は

同じ数字を２つ組み合わせたものが必ずひとつ必要です。

残りの12 個の数字は、３個の数字の組み合わせ４つです。

３個の数字の組み合わせ方は、同じ数字を３つ組み合わせたものか、または３つの連続する数字を組み合わせたものです。ただし、9 1 2 のような並びは連続する数字とは認められません。

同じ数字は4 回まで使えます。

13 個の数字からなる文字列を読み込んで、パズルを完成することができる数字を昇順に全て出力するプログラムを作成してください。なお、1〜9 のどの数字を付け加えてもパズルを完成させることができないときは 0 を出力してください。

例えば与えられた文字列が 3456666777999 の場合

「2」があれば、　234 567 666 77 999

「3」があれば、　33 456 666 777 999

「5」があれば、　345 567 666 77 999

「8」があれば、　345 666 678 77 999

というふうに、2 3 5 8 のいずれかの数字が付け加えられるとパズルは完成します。「6」でも整いますが、5 回目の使用になるので、この例では使えないことに注意してください。

Input

入力は複数のデータセットからなります。各データセットとして、13 個の数字が１行に与えられます。データセットの数は 50 を超えません。

Output

データセットごとに、パズルを完成させることができる数字を昇順に空白区切りで１行に出力します。

Sample Input

3649596966777
6358665788577
9118992346175
9643871425498
7755542764533
1133557799246

Output for the Sample Input

2 3 5 8
3 4
1 2 3 4 5 6 7 8 9
7 8 9
1 2 3 4 6 7 8
0


標高差

今まで登ったことのある山の標高を記録したデータがあります。このデータを読み込んで、一番高い山と一番低い山の標高差を出力するプログラムを作成してください。

Input

入力は以下の形式で与えられます。

山の高さ
...
...

山の高さが複数行に渡って与えられます。入力される値はすべて 0 以上 1,000,000 以下の実数です。入力される山の高さの数は 50 以下です。

Output

一番高い山と一番低い山の標高差を実数で出力する。出力は0.01以下の誤差を含んでもよい。

Sample Input

3776.0
1819.0
645.2
2004.1
1208.6

Output for the Sample Input

3130.8


var input = require('fs').readFileSync('/dev/stdin', 'utf8');
var Arr=(input.trim()).split("\n");
for(i=0;i<Arr.length;i++){
   var arr=Arr[i].split(" ").map(Number);
   (function(x1, y1, x2, y2, x3, y3, x4, y4){
      var k1;
      var k2;
      if(x2-x1!==0)k1=((y2-y1)/(x2-x1)).toFixed(10);
      else k1=Infinity;
      if(x4-x3!==0)k2=(y4-y3)/(x4-x3).toFixed(10);
      else k2=Infinity;
      var ans="NO";
      if(k1==0 && k2==Infinity)ans="YES";
      if(k2==0 && k1==Infinity)ans="YES";
      if(k1==(-1*k2) && (k1!=0 && k2!=0))ans="YES";
      console.log(ans);
   }).apply(null,arr);
}

MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});

直交判定

平面上の異なる 4 点、$A (x_A, y_A)$, $B (x_B, y_B)$, $C (x_C, y_C)$, $D (x_D, y_D)$ の座標を読み込んで、直線 $AB$ と $CD$ が直交する場合には YES、直交しない場合には NO と出力するプログラムを作成してください。ここで、「直線」とは線分のことではありません。以下の図を参考にして下さい。

Input

複数のデータセットが与えられます。各データセットの形式は以下のとおりです。

$x_A$ $y_A$ $x_B$ $y_B$ $x_C$ $y_C$ $x_D$ $y_D$

$x_A$, $y_A$, $x_B$, $y_B$, $x_C$, $y_C$, $x_D$, $y_D$ はそれぞれ -100 以上 100 以下であり、各値は小数点以下最大 5 桁までの数字を含む実数で与えられます。

データセットの数は 100 を超えません。

Output

各データセットに対して、YES または NO を１行に出力して下さい。

Sample Input

1.0 1.0 2.0 2.0 0.0 0.0 1.0 -1.0
0.0 0.0 2.0 0.0 -1.0 2.0 2.0 2.0
10.0 6.0 3.4 5.2 6.8 9.5 4.3 2.1
2.5 3.5 2.5 4.5 -3.3 -2.3 6.8 -2.3

Output for the Sample Input

YES
NO
NO
YES


var ans=0;
require("fs").readFileSync("/dev/stdin", "utf8").match(/\d+/g).forEach(function(elem){
	ans += parseInt(elem, 10);
});
console.log(ans);

暗証番号

新しい暗証番号は覚えにくいものです。メモするのはダメといわれましたが、覚えられそうにありません。そこで文章の中に数値を埋め込んで暗証番号をメモすることにしました。ここでは全ての数値の和が暗証番号になります。

メモされた文章を読み込んで、暗証番号を出力するプログラムを作成してください。

Input

正の整数が埋め込まれた文章が複数行にわたり与えられます。各行は半角英数字、記号、空白を含む文字列または空行です。
ただし、入力は 1 行あたり 80 文字以内で、暗証番号は 10,000 以下であることが保障されています。

Output

暗証番号（文章中の正の整数の合計）を１行に出力します。

Sample Input

Thereare100yenonthetable.Iam17yearsold.
Ishouldgohomeat6pm.

Output for the Sample Input

123


//設定値
var input = {};

//2次元長方形配列。 要素は-1(横棒の右側),0,1(横棒の左側)
var data = [];

//経路取得
var f = function(startLine, startStep){
	if(!startStep) startStep = 0;
	var now = startLine;
	var result = [now];
	for(var y=startStep; y<data.length; y++){
		now += data[y][now];
		result.push(now);
	}
	return result;
};
//ゴール指定時の経路取得 (経路はスタートから)
var rf = function(endLine){
	var now = endLine;
	var result = [now];
	for(var y=data.length-1; y>=0; y--){
		now += data[y][now];
		result.push(now);
	}
	return result.reverse();
};

var lines = [];
process.stdin.resume();
process.stdin.setEncoding('utf8');
process.stdin.on('data', function (chunk)
{
    chunk.trim().split('\n').forEach(function(line) {
        lines.push(line);
    });
});

process.stdin.on('end', function(){
	var result = "";

	//データ作成
	input = {};
	data = [];
	for(var i=0; i<lines.length; i++){
		var e = lines[i];
		if(e == "0") break;

		def = ["lines", "start", "end", "steps"];
		if(i<def.length){
			input[def[i]] = parseInt(e);
			continue;
		}

		//i>4
		var line = [];
		for(var i=0; i<input.lines-1; i++){
			var c = parseInt(e.charAt(i));
			if(i>0 && c==0 && line[i-1]==1) c = -1;
			line.push(c);
		}
		line.push((line[line.length-1]==1) ? -1 : 0);
		data.push(line);
	}
	input.start -= 1;
	input.end -= 1;

	var route = f(input.start);
	if(route[route.length-1] == input.end) {
		console.log("0");
		return;
	}
	var gRoute = rf(input.end);

	for(var y=0; y<input.steps; y++){
		if(Math.abs(route[y]-gRoute[y]) == 1 && data[y][route[y]]==0 && data[y][gRoute[y]]==0){ //隣り合っている
			result = (y+1) + " " + (Math.min(route[y], gRoute[y])+1);
			break;
		}
	}
	if(result == "") result = "1";

	console.log(result);
});

あみだくじ II

縦線が n 本のあみだくじがあります。このあみだくじは以下の条件を満たしています。

横線は真横に引きます。斜めに引くことはありません。

横線は必ず隣り合った縦線同士をつなぎます。つまり、横線が縦線をまたぐことはありません。

どの縦線についても同じ点から左右同時に横線が出ることはありません。つまり、横線が縦線を横切ることはありません。

当りはひとつだけです。

下図 に n = 5 のときの、あみだくじの例を示します。上側の数字は縦線の番号(左から1, 2, 3, 4, 5 ) を表します。☆が当たりです。

縦線の本数 n、選んだ縦線の番号 m、あみだくじの当りの場所、各段における横線の有無を読み込んで、当りにたどり着けるかどうかの判定を出力するプログラムを作成してください。ただし、与えられたあみだくじの任意の位置に1 本だけ横線を付け加えることができるものとします（付け加えなくてもかまいません）。横線を1 本付け加えた後のあみだくじも前述の条件を満たしていなければなりません。

Input

複数のデータセットが与えられます。各データセットは以下のとおりです：

１行目に、縦線の本数 n (1 < n ≤ 10) が書かれています。

２行目には、選んだ縦線の番号 m (1 ≤ m ≤ n) が書かれています。

３行目には、当りの場所（図でいう☆）が左から数えて何番目かが書かれています。

４行目には、あみだくじの段数 d (1 ≤ d ≤ 30) が書かれています。

５行目以降は、図に対応する数字の並びのように、あみだくじの上から順に、各縦線の間に横線があるときを 1、ないときを 0 として、n - 1 つの数字が並んでいます。

入力は１つの 0 が書かれた行で終わります。

Output

各データセットについて、選んだ縦線の番号 m から当りにたどり着けるかどうかに応じて以下の値を出力してください。

横線を引かなくても当りにたどり着けるときは 0 を出力してください。

横線を1 本引けば当りにたどり着けるときは、その中で最も出発側（図でみて上）に近い横線の位置を出力してください。出発側から数えて何段目（図 を参考にしてください）に、左から数えて何番目の縦線から右に向かって横線を引くかを半角の空白で区切って出力してください。

横線を1 本引いても当りにたどり着けないときには 1 を出力してください。

Sample Input

5
2
3
9
1010
1001
0100
1001
0010
1000
0100
0101
1010
0

Output for the Sample Input

6 4


function isLeapYear(y) {
  return y % 4 === 0 && (y % 100 !== 0 || y % 400 === 0);
}

function main() {
  var
  i,
  a, b, line,
  leaps,
  len = input.length;
  for(i = 0; i < len; i++) {
    line = input[i].split(' ').map(parseFloat);
    a = line[0]; b = line[1];
    if(a === 0 && b === 0) break;
    if(i !== 0) {
      console.log('');
    }
    leaps = [];
    for(; a <= b; a++) {
      if(isLeapYear(a)) leaps.push(a);
    }
    console.log(leaps.length ? leaps.join('\n') : 'NA');
  }
}

var
input = '';

process.stdin.resume();
process.stdin.setEncoding('utf8');
process.stdin.on('data', function(chunk) {
  input += chunk;
});
process.stdin.on('end', function() {
  input = input.split('\n');
  main();
});

うるう年

西暦 a 年から b 年までの間にあるすべてのうるう年を出力するプログラムを作成してください。

うるう年の条件は、次のとおりとします。ただし、0 < a ≤ b < 3,000 とします。与えられた期間にうるう年がない場合には "NA"と出力してください。

西暦年が 4 で割り切れる年であること。

ただし、100 で割り切れる年はうるう年としない。

しかし、400 で割り切れる年はうるう年である。

Input

複数のデータセットが与えられます。各データセットの形式は以下のとおりです：

a b

a, b がともに 0 のとき入力の終了とします。データセットの数は 50 を超えません。

Output

データセットごとに、西暦または NA を出力してください。

データセットの間に１つの空行を入れてください。

Sample Input

2001 2010
2005 2005
2001 2010
0 0

Output for the Sample Input

2004
2008

NA

2004
2008


process.stdin.resume();
process.stdin.setEncoding('utf8');
var input = '';
process.stdin.on('data', function (chunk) {
  input += chunk;
});
process.stdin.on('end', function () {
  var ab = input.split(' ');
  console.log(ab[0] * ab[1] / 3.305785);
});

坪面積の計算

土地の面積を表現する「○○坪」という単位を聞いたことはないでしょうか？ 古来、１人の武士が１日に食べるお米を作る面積を言いました。

a［m］× b［m］の土地があります。a と b を入力し、その土地の坪面積 S［坪］を出力するプログラムを作成してください。 1 坪 = 3.305785 [m2] とし、a と b は 100 以下の整数とします。

入力

a b

１つの空白で区切られた a と b が１行に与えられる。

出力

坪面積 S を１行に出力する。0.0001 以下の誤差が許される。

入力例1

15 25

出力例1

113.437508


var input = require('fs').readFileSync('/dev/stdin', 'utf8');
var arr=input.trim().split("\n");
var n=arr.shift()-0;
var yx=[];
var zero=[];
for(var i=0;i<n+1;i++)zero.push(0);
yx.push(zero);
for(var i=0;i<n;i++)yx.push(("0 "+arr.shift()).split(" ").map(Number));
n=n+1;
var sum=[];
for(var i=0;i<n;i++){
   sum[i]=[];
   sum[i][0]=yx[i][0];
}
for(var i=0;i<n;i++){
   for(var j=1;j<n;j++){
      sum[i][j]=sum[i][j-1]+yx[i][j];
   }
}
for(var i=1;i<n;i++){
   for(var j=0;j<n;j++){
      sum[i][j]=sum[i-1][j]+sum[i][j];
   }
}
var max=-Infinity;
for(var i=0;i<n;i++){
   for(var j=0;j<n;j++){
      for(var y=i;y<n;y++){
         for(var x=j;x<n;x++){
            max=Math.max(max,sum[y][x]-sum[i][x]-sum[y][j]+sum[i][j]);
         }
      }
   }
}
console.log(max);

Maximum Sum Sequence II

与えられた整数の行列

a1,1 a1,2 ... a1,n
a2,1 a2,2 ... a2,n
:
an,1 an,2 ... an, n

で、縦・横方向に１つ以上連続した項（部分行列）の和の最大値を出力して終了するプログラムを作成して下さい。

Input

入力データは以下の形式で与えられます。

n
a1,1 a1,2 ... a1,n
a2,1 a2,2 ... a2,n
:
an,1 an,2 ... an, n

n は 1 以上 100 以下、ai,j は -10000 以上 10000 以下です。

Output

最大値を 1 行に出力して下さい。

Sample Input 1

3
1 -2 3
-4 5 6
7 8 -9

Output for the Sample Input 1

16

この入力の場合、以下の部分行列の項の和が最大となります。

-4 5
7 8

Sample Input 2

4
1 3 -9 2
2 7 -1 5
-8 3 2 -1
5 0 -3 1

Output for the Sample Input 2

15

この入力の場合、以下の部分行列の項の和が最大となります。

7 -1 5
3 2 -1


var input = require('fs').readFileSync('/dev/stdin', 'utf8');
var Arr=(input.trim()).split("\n");
var obj={};
for(var i=0;i<Arr.length;i++){
var arr=Arr[i].split(" ").map(Number);
   if(i!=0 && arr.length==1){
      var keys=[];
      for(var k in obj)keys.push(k-0);
      keys.sort(function(a,b){return a-b;});
      var cnt=0
      for(var j=0;j<keys.length;j++){
         if(obj[keys[j+""]]>=1000000){console.log(keys[j+""]);cnt++;}
      }
      if(cnt==0)console.log("NA");
      if(arr[0]==0)break;
      obj={};
   }else if(arr.length==3){
       if(!obj.hasOwnProperty(arr[0]))obj[arr[0]]=arr[1]*arr[2];
       else obj[arr[0]]+=arr[1]*arr[2];
   }
}

Sale Result

There is data on sales of your company. Your task is to write a program which identifies good workers.

The program should read a list of data where each item includes the employee ID i, the amount of sales q and the corresponding unit price p. Then, the program should print IDs of employees whose total sales proceeds (i.e. sum of p × q) is greater than or equal to 1,000,000 in the order of inputting. If there is no such employees, the program should print "NA". You can suppose that n < 4000, and each employee has an unique ID. The unit price p is less than or equal to 1,000,000 and the amount of sales q is less than or equal to 100,000.

Input

The input consists of several datasets. The input ends with a line including a single 0. Each dataset consists of:

n (the number of data in the list)
i p q
i p q
:
:
i p q

Output

For each dataset, print a list of employee IDs or a text "NA"

Sample Input

4
1001 2000 520
1002 1800 450
1003 1600 625
1001 200 1220
2
1001 100 3
1005 1000 100
2
2013 5000 100
2013 5000 100
0

Output for the Sample Input

1001
1003
NA
2013


var input = require('fs').readFileSync('/dev/stdin', 'utf8');
var Arr=(input.trim()).split("\n");
var obj={};
for(var i=0;i<Arr.length;i++){
var arr=Arr[i].split(" ").map(Number);
   if(i!=0 && arr.length==1){
      var cnt=0;
      for(var k in obj){
         if(obj[k]>=1000000){console.log(k);cnt++;}
      }
      if(cnt==0)console.log("NA");
      if(arr[0]==0)break;
      obj={};
   }else if(arr.length==3){
       if(!obj.hasOwnProperty(arr[0]))obj[arr[0]]=arr[1]*arr[2];
       else obj[arr[0]]+=arr[1]*arr[2];
   }
}


var input = require('fs').readFileSync('/dev/stdin', 'utf8');
var Arr=(input.replace(/\n$/,"")).split("\n");
var n=Arr.shift();
for(var i=0;i<n;i++){
   if(/^>'(=+)#\1~$/.test(Arr[i]))console.log("A");
   else if(/^>\^(Q=)+~~$/.test(Arr[i]))console.log("B");
   else console.log("NA");
}

ヘビ

ある世界には，文字だけでできた不思議なヘビが住んでいます。このヘビには現在A種とB種の2種類が確認されていますが、それ以外の種類がいる可能性もあります。

A種は，">'"の後に"="が1個以上並んだ後、"#"が来て、さらに前と同じ個数の"="が来た後、"~"（半角チルダ）で終わります。

B種は，">^"の後に "Q="が1個以上並んだ後、"~~"で終わります。

A種の例： >'====#====~ >'==#==~

B種の例： >^Q=Q=Q=Q=~~ >^Q=Q=~~

ヘビを文字列データとして受け取り、それがどんな種類であるかを判別して、A種の場合は「A」、B種の場合は「B」、それ以外の種類の場合は「NA」を出力するプログラムを作成してください。

Input

入力は以下の形式で与えられます。

n
S1
S2
:
Sn

1 行目に判別されるヘビの数 n（1 ≤ n ≤ 10000）、続く n 行に i 匹目のヘビを表す文字列 Si (200文字以下の、空白を含まない文字列) がそれぞれ１行に与えられます。

Output

i 行目に i 匹目のヘビの種類 A、B または NA を出力してください。

Sample Input

3
>'======#======~
>^Q=Q=Q=Q=Q=Q=Q=Q=Q=~~
>'===#====~

Output for the Sample Input

A
B
NA


function bomb(y,x,z){
   if(yx[y][x]!="+")return;
   var dy=[-1,0,1,0];
   var dx=[0,1,0,-1];
   var Y=y+dy[z];
   var X=x+dx[z];
   if(Y<0 || X<0 || Y>=n || X>=n){
      z=(z+1)%4;
      bomb(y,x,z);
   }else{
      if(yx[Y][X]=="#"){
         yx[Y-dy[z]][X-dx[z]]="+";
         if(z==3)bomb(Y-2*dy[z]-1,X-2*dx[z],0);
         else if(z==0)bomb(Y-2*dy[z],X-2*dx[z]+1,1);
         else if(z==1)bomb(Y-2*dy[z]+1,X-2*dx[z],2);
         else if(z==2)bomb(Y-2*dy[z],X-2*dx[z]-1,3);
      }else{
         yx[y][x]="#";
         last=[y,x];
         bomb(Y,X,z);
      }
   }
}
var input = require('fs').readFileSync('/dev/stdin', 'utf8');
var arr=input.trim().split("\n").map(Number);
var d=arr.shift();
while(d--){
   var n=arr.shift();
   if(n==1){
      console.log(" ");
      continue;
   }
   var yx=[];
   for(var i=0;i<n;i++){
      yx[i]=[];
      for(var j=0;j<n;j++){
         yx[i][j]="+";
      }
   }
   var last=[];
   bomb(n-1,0,0);
   if(n%2==0)yx[last[0]][last[1]]="+";
   console.log(yx.join("\n").replace(/\,/g,"").replace(/\+/g," "));
}

ぐるぐる模様

「ぐるぐる模様」を表示するプログラムを作成することにしました。「ぐるぐる模様」は以下のようなものとします。

1 辺の長さが n の場合、n 行 n 列の文字列として表示する。

左下隅を基点とし，時計回りに回転する渦状の模様とする。

線のある部分は #（半角シャープ）、空白部分は " "（半角空白）で表現する。

線と線の間は空白を置く。

整数 n を入力とし，1 辺の長さが n の「ぐるぐる模様」を出力するプログラムを作成してください。

Input

入力は以下の形式で与えられます。

d
n1
n2
:
nd

１行目にデータセットの数 d (d ≤ 20)、続く d 行に i 個目のぐるぐる模様の辺の長さ ni (1 ≤ ni ≤ 100) がそれぞれ１行に与えられます。

Output

データセットごとに、ぐるぐる模様を出力してください。データセットの間に１行の空行を入れてください。

Sample Input

2
5
6

Output for the Sample Input

#####
# #
# # #
# # #
# ###

######
# #
# ## #
# # #
# # #
# ####


var fs = require('fs'),
    length = fs.fstatSync(process.stdin.fd).size,
    buffer = new Buffer(length),
    bytesRead = fs.readSync(process.stdin.fd, buffer, 0, length, 0),
    input = buffer.toString('utf8', 0, bytesRead).split('\n');
main();

function main(){

var seats = [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0];
var groupMembers = [2,5,2,2,2];
var eatTimes = [19,39,25,36,22,42];

var headGroup = -1;
var pastMinutes = 0;
var waitTime = [];

while(waitTime.length < 99){
  // たべおわる
  for(var i = 0; i < seats.length; i++){
    seats[i] = seats[i] == 0 ? 0 : seats[i] - 1;
  }

  // 来店
  if(headGroup == -1 && pastMinutes % 5 == 0){
    headGroup = pastMinutes / 5;
  }

  // ちゃくせき
  while(headGroup != -1){
    var needsSequencialSeats = groupMembers[headGroup % 5];
    var sequencialSeats = 0;
    var startIndex = -1;
    for(var i = 0; i < seats.length; i++){
      sequencialSeats = seats[i] == 0 ? sequencialSeats + 1 : 0;

      if(sequencialSeats == needsSequencialSeats){
        startIndex = i - (needsSequencialSeats - 1);
        break;
      }
    }

    if(startIndex != -1){
      // すわれたみたい
      waitTime[headGroup] = pastMinutes - (headGroup * 5);
      for(var i = startIndex; i < (needsSequencialSeats + startIndex); i++){
        seats[i] = eatTimes[headGroup % 6];
      }

      headGroup = (((headGroup + 1) * 5) <= pastMinutes) ? headGroup + 1 : -1;
    }else{
      // すわれなかったみたい
      break;
    }

  }

  pastMinutes++;

}

for(var i = 0; i < input.length; i++){
  console.log(waitTime[input[i]]);
}

}

福縞軒

「福縞軒」は行列のできる人気のラーメン屋です。でも最近、お客さんの間から「待ち時間が長いのに、店に入ったら空席があるのは許せない」という声が聞こえるようになってきました。どうしてそんな不満が出るのか調べたいのですが、お店が開いているあいだは忙しくて、実際の行列の様子を調べることができません。しかし、長年の経験からお客さんが来る間隔や人数は分かっているので、それをもとに待ち時間の分析をすることにしました。

店内にはカウンターに向かって 17 の席があります。開店時間は正午で、お客さんは次のようにやってきます。

0 番から 99 番までの 100 組のグループが来ます。

i 番目のグループは正午から 5i 分後にお店に到着します。

i 番目のグループの人数は i % 5 が 1 のとき 5 人、それ以外のときは 2 人です。

(x % yは x を y で割ったときの余りを表わします。)

i 番目のグループは、席に着くと 17(i % 2) + 3(i % 3) + 19 分間で食事を済ませます。

最初の 10 グループの到着時刻、人数、食事時間は次のようになります。

グループ番号

0

1

2

3

4

5

6

7

8

9

到着時刻(分後)

0

5

10

15

20

25

30

35

40

45

人数(人)

2

5

2

2

2

2

5

2

2

2

食事時間(分)

19

39

25

36

22

42

19

39

25

36

また、お客さんを席に案内するときには、次のようにしています。

席には 0 から 16 までの番号が付いています。

x 人のグループは連続して x 個あいている席があった時だけ着席できます。

また、座れる場所が複数あった場合は、席の番号が最も小さくなるところに座ります。例えば、0、1、2、4、5番の席だけが空いていた場合、5 人のグループは着席できません。2 人のグループであれば 0、1 番に着席します。

一度着席したら、席を移動してもらうことはしません。

お客さんは 1 分単位で出入りします。各時刻には次の順序でお客さんを案内します。

前のグループの離席と同時に次のグループの着席が可能となります。

お客さんを着席させる際には、行列の先頭にいるグループから順に、できる限り多くのグループを同じ時刻に着席させます。行列の順序を追い越すことはしません。つまり、先頭のグループが着席できなければ、行列内の他のグループが着席できたとしても、着席させません。

その時刻に到着したグループは、行列が残っている場合は行列の最後尾に並びます。行列が無く、着席できる場合は着席し、できない場合は並んで待ちます。例として最初の 10 グループが到着するまでの様子を示すと以下のようになります。各行の3つの欄は、左から時刻、座席の様子、行列の様子を示しています。座席は「_」が空席で、番号はその席にその番号のグループが座っていることを示しています。

時刻: 座席 行列
0: 00_______________:
5: 0011111__________:
10: 001111122________:
15: 00111112233______:
18: 00111112233______:
19: __111112233______:
20: 44111112233______:
25: 4411111223355____:
30: 4411111223355____: 66666 グループ6が到着
34: 4411111223355____: 66666
35: 4411111__3355____: 6666677 グループ7が到着
40: 4411111__3355____: 666667788 グループ8が到着
41: 4411111__3355____: 666667788
42: __11111__3355____: 666667788
43: __11111__3355____: 666667788
44: 6666677883355____: グループ6、7、8が着席
45: 666667788335599__: グループ9が到着、着席

例えば、時刻 40 では 8 番目のグループが到着しますが、着席できないので行列に加わります。4 番目のグループは時刻 41 まで食事をします。時刻 42 では、4 番目のグループの席が空きますが、連続した席数が足りないので 6 番目のグループはまだ着席できません。1 番目のグループは時刻 43 まで食事をします。時刻 44 で 1 番目のグループの席が空くので、6 番目のグループが着席し、同時に 7 番目、8 番目のグループも着席します。9 番目のグループは時刻 45 で到着し、席が空いているのでそのまま着席します。

これらの情報を基にして、0 以上 99 以下の整数 n を入力として、n 番目グループのお客さんが待つ時間(分単位)を出力するプログラムを作成してください。

Input

複数のデータセットが与えられます。各データセットは１つの整数 n からなります。

データセットの数は 20 を超えません。

Output

各データセットについて、n 番目のお客の分単位の待ち時間(0 以上の整数)を１行に出力してください。

Sample Input

5
6
7
8

Output for the Sample Input

0
14
9
4


var n, g;

function main(){
	while(1){
		var m = scan();
		n = scan();
		if(n == 0 && m == 0){
			break;
		}

		g = [];
		rep(n, function(i){
			g[i] = [];
		});
		rep(m, function(){
			var a = scan() - 1;
			var b = scan() - 1;
			var c = scan();
			var d = scan();
			g[a].push([c, d, b]);
			g[b].push([c, d, a]);
		});

		var q = scan();
		rep(q, function(){
			var start = scan() - 1;
			var goal = scan() - 1;
			var type = scan();
			print(dijkstra(start, goal, type));
		});
	}
}

function dijkstra(start, goal, type){
	var heap = [];

	function heap_push(x){
		var i = heap.length;
		while(i > 0){
			var p = (i - 1) >> 1;

			if(heap[p] <= x){
				break;
			}

			heap[i] = heap[p];
			i = p;
		}
		heap[i] = x;
	}

	function heap_pop(){
		var result = heap[0];

		var x = heap[heap.length - 1];
		var len = --heap.length;

		if(!len){
			return result;
		}

		var i = 0;
		while(i * 2 + 1 < len){
			var a = i * 2 + 1;
			var b = i * 2 + 2;

			if(b < len && heap[b] < heap[a]){
				a = b;
			}

			if(heap[a] >= x){
				break;
			}

			heap[i] = heap[a];
			i = a;
		}
		heap[i] = x;

		return result;
	}

	function heap_empty(){
		return !heap.length;
	}

	var d = [];
	rep(n, function(i){
		d[i] = Infinity;
	});

	d[start] = 0;
	heap_push([0, start]);
	while(!heap_empty()){
		var v = heap_pop();

		if(v[0] > d[v[1]]){
			continue;
		}

		rep(g[v[1]].length, function(i){
			var edge = g[v[1]][i];
			if(d[edge[2]] > d[v[1]] + edge[type]){
				d[edge[2]] = d[v[1]] + edge[type];
				heap_push([d[edge[2]], edge[2]]);
			}
		});
	}

	return d[goal];
}

function rep(a, b, c){
	if(c == null){
		c = b;
		b = a;
		a = 0;
	}
	for(var i = a; i < b; ++i){
		c(i);
	}
}

process.stdin.resume();
process.stdin.setEncoding('utf8');

var input = '';
var input_index = 0;

function scan(type){
	if(type === 'string'){
		return input[input_index++];
	}
	else{
		return +input[input_index++];
	}
}

function print(val){
	console.log(val);
}

process.stdin.on('data', function(chunk){
	input += chunk;
});
process.stdin.on('end', function(){
	input = input.split(/\s+/);
	main();
});

青春の片道切符

太郎君は夏休みに電車で長旅をする計画を立てています。しかし高校生の身である太郎君が一ヵ月しかない夏休みで可能な限り遠くに旅をするには、出来るだけ安い行き方と出来るだけ早い行き方をそれぞれ見つけなければうまく計画が立てられません。太郎君が素敵な旅を満喫できるように、太郎君の計画の助けになるプログラムを作ってあげましょう。

線路の情報、駅の数を入力とし、問い合わせに応じて、最小金額または最短時間を出力するプログラムを作成してください。

Input

複数のデータセットの並びが入力として与えられます。入力の終わりはゼロふたつの行で示されます。各データセットは以下の形式で与えられます。

n m
a1 b1 cost1 time1
a2 b2 cost2 time2
:
an bn costn timen
k
p1 q1 r1
p2 q2 r2
:
pk qk rk

1 行目に線路の情報の数 n (1 ≤ n ≤ 3000)と駅の数 m (1 ≤ m ≤ 100) が与えられます。

続く n 行に i 番目の路線の情報が与えられます。各路線の情報として、路線がつなぐ２つの駅の番号 ai, bi (1 ≤ ai, bi ≤ m)、料金 costi (1 ≤ costi ≤ 1000)、移動時間 timei (1 ≤ timei ≤ 1000) が与えられます。ただし、各駅は 1 から m まで順番に番号が付けられているものとします。
なお、ai と bi が線路でつながっていれば、ai から bi、 bi からai の両方の移動が同じ料金と時間で可能とします。

続く行に問い合わせの数 k (1 ≤ k ≤ 200) が与えられます。続く k 行に i 番目の問い合わせが与えられます。各問合わせとして、出発駅 pi 、到着駅 qi 、出力する値の種類 ri (0 または 1)が与えられます。なお、問い合わせには必ず経路があるものとします。

データセットの数は 50 を超えない。

Output

データセットごとに、最小金額もしくは最短時間を１行に出力します。ri が 0 の時は最小金額を、 1 の時は最短時間を出力します。

Sample Input

6 5
1 2 200 10
1 4 400 15
1 3 250 25
2 4 100 10
4 5 150 20
3 5 300 20
2
1 5 0
1 5 1
0 0

Output for the Sample Input

450
35


function main(){
  var i = 0;
  while(true){
    var fieldInfo = input[i].split(' ');
    var width = fieldInfo[0] - 0;//toInt
    var height = fieldInfo[1] - 0;//toInt

    // 0 0が入力された
    if(!width && !height){
      break;
    }

    var start;
    var goal;
    var elem = [[],[],[],[],[]];
    for(var ei = 0;ei < 5; ei++){
      elem[ei].length = 0;
    }

    for(var y = 0; y < height; y++){
      i++;//1行進める
      for(var x = 0; x < width; x++){
        var c = input[i][x];

        switch(c){
        case 'S':
          start = new Pos(x, y);
          break;
        case 'G':
          goal = new Pos(x, y);
          break;
        case '.':
          break;
        default : // 入力値が正しいので、絶対に属性
          elem[c-1][elem[c-1].length] = new Pos(x, y);
          break;
        }
      }
    }

    var bestElement = -1;
    var distance = Infinity;

    // 属性ごとにループ
    for (var startElem = 0; startElem < 5; startElem++) {
      // DPの初期化 DP[属性][同じ属性内の連番]
      var dp = [[],[],[],[],[]];
      for(var h = 0; h < 5; h++){
        var hLength = elem[h].length;
        dp[h].length = hLength;
        for(var hidx = 0; hidx < hLength; hidx++){
          dp[h][hidx] = Infinity;
        }
      }

      // 最初に選んだパチモンから次に捕まえられる属性番号
      var first = (startElem + 1) % 5;

      var firstLength = elem[first].length;
      for (var j = 0; j < firstLength; j++) {
        // s→e1を計算
        dp[first][j] = dist(start, elem[first][j]);
      }

      // s->1->2->3->4->g
      // なので、ループは間の-> * 3分まわす
      for (var e = 0; e < 3; e++) {
        // ex->e(x+1)
        var now = (first + e) % 5;
        var next = (now + 1) % 5;
        var nowLength = elem[now].length;
        var nextLength = elem[next].length;
        for (var j = 0; j < nowLength; j++) {
          for (var k = 0; k < nextLength; k++) {
            dp[next][k] = min(
              dp[next][k],
              dp[now][j] +
                  dist(elem[now][j], elem[next][k]));
          }
        }
      }

      var last = (first + 3) % 5;
      var lastLength = elem[last].length;
      for (var j = 0; j < lastLength; j++) {
        // e4->g
        var d = dp[last][j] +
                    dist(elem[last][j], goal);

        if (d < distance) {
          distance = d;
          bestElement = startElem + 1;
        }

      }

    }

    if (distance == Infinity) {
      console.log("NA");
    } else {
      console.log(bestElement + " " + distance);
    }

    i++;
  }

}

function dist(from, to){
  return Math.abs(from.x - to.x) + Math.abs(from.y - to.y)
}

function min(a1, a2){
  return a1 < a2 ? a1 : a2;
}

function Pos(a, b){
  this.x = a;
  this.y = b;
}

var
input = '';

process.stdin.resume();
process.stdin.setEncoding('utf8');
process.stdin.on('data', function(chunk) {
  input += chunk;
});
process.stdin.on('end', function() {
  input = input.split('\n');
  main();
});

パチモンクリーチャー

某国で大人気のゲーム、パチモンクリーチャーが日本でリメイクされて発売されました。 ゲームが大好きなあなたは、 このゲームを何度もプレイするうちにどうしたら最速でクリアできるのか考えるようになりました。しかし、いくら考えても最速の攻略方法がわからなかったあなたは、どれだけ早くゲームをクリアできるかを求めるプログラムを作成することにしました。

ゲームの詳細は以下の通りです。

パチモンクリーチャー(以下、パチクリ)という生物が多く存在する世界がゲームの舞台です。各パチクリは、火属性、氷属性、木属性、土属性、水属性の 5 種類の属性のいずれか１つの属性を持ちます。ゲームの主人公は、ゲーム開始時に好きな属性のパチクリ一匹を冒険のパートナーとして選びます。そのパチクリと共にゴールを目指し、ゴールにいるライバルを倒してパチクリマスターになることがゲームの目的です。

しかし、ライバルを倒すためには全属性のパチクリがいないと勝てないので、途中で全属性のパチクリを捕まえなければなりません。パチクリを捕まえるには属性がカギとなります。火属性のパチクリは氷属性のパチクリを捕まえることができ、同様に、氷属性は木属性、木属性は土属性、土属性は水属性、水属性は火属性を捕まえることができます。属性の関連は以下の図のようになります。

以下の図はゲームが行われるマップの一例を表しています。

主人公はパチクリを一匹もってスタート地点である「S」から出発し、一マスずつ移動しながらゴール地点である「G」を目指します。その途中で、最初に持っているパチクリ以外の 4 つの属性のパチクリを捕まえ、ゴール地点であるマス目に移動するとゲーム終了となります。

主人公は、今いるマス目から、辺を共有する隣のマス目に移動することができ、それを一回の移動と数えます。主人公がパチクリのいるマスに移動した場合、そのパチクリを捕まえられる属性のパチクリを持っていればそのパチクリを捕まえたことになります。そのマスにいるパチクリを捕まえられるかの可否にかかわらず、すべてのマスに何度でも移動することができます。

マップの大きさ(横方向の列数、縦方向の行数)とマップの初期状態を入力とし、初めに選んだパチクリの属性と、それ以外の 4 つの属性のパチクリを捕まえるのにかかる、スタート地点からゴール地点に至る最小移動数を出力するプログラムを作成してください。

Input

複数のデータセットの並びが入力として与えられます。入力の終りはゼロふたつの行で示されます。各データセットは以下の形式で与えられます。

W H
c11c12...c1W
c21c22...c2W
:
cH1cH2...cHW

1 行目にマップの横方向の列数 W と縦方向の行数 H (2 ≤ W, H ≤ 1000) が与えられます。続く H 行にマップの i 行目の情報が与えられます。入力されるマップには各マスの状態が与えられます。 「S」は主人公のスタート地点を、 「G」はゴール地点を、「1」「2」「3」「4」「5」はそこにいるパチクリの属性を( 1:火属性、 2:氷属性、 3:木属性、 4:土属性、 5:水属性 をそれぞれ表します)、 「.(ピリオド) 」は何もないマスをそれぞれ表します。
各属性のパチクリの数はそれぞれ 0 以上 1000 以下とします。

データセットの数は140 を超えません。また、データセットの 80 % について、W, H は100 を超えません。

Output

入力データセットごとに、最初に選んだパチクリの属性と最小移動数を１行に出力します。なお、どのように初めのパチクリを選んでも、どのような経路で移動してもそれら 4 つの属性のパチクリを捕まえることができない場合は NA と出力してください。 また、最小移動数が同じになるような最初のパチクリの選び方が複数ある場合は、属性の数字が小さいものを出力してください。

Sample Input

6 6
S.1..4
3..5..
..4.1.
4....5
.2.32.
5.1..G
3 2
...
S.G
0 0

Output for the Sample Input

2 10
NA


function main(){
  var i = 0;
  while(true){
    var fieldInfo = input[i].split(' ');
    var width = fieldInfo[0] - 0;//toInt
    var height = fieldInfo[1] - 0;//toInt

    // 0 0が入力された
    if(!width && !height){
      break;
    }

    var start;
    var goal;
    var elem = [[],[],[],[],[]];
    for(var ei = 0;ei < 5; ei++){
      elem[ei].length = 0;
    }

    for(var y = 0; y < height; y++){
      i++;//1行進める
      for(var x = 0; x < width; x++){
        var c = input[i][x];

        switch(c){
        case 'S':
          start = new Pos(x, y);
          break;
        case 'G':
          goal = new Pos(x, y);
          break;
        case '.':
          break;
        default : // 入力値が正しいので、絶対に属性
          elem[c-1][elem[c-1].length] = new Pos(x, y);
          break;
        }
      }
    }

    var bestElement = -1;
    var distance = Infinity;

    // 属性ごとにループ
    for (var startElem = 0; startElem < 5; startElem++) {
      // DPの初期化 DP[属性][同じ属性内の連番]
      var dp = [[],[],[],[],[]];
      for(var h = 0; h < 5; h++){
        var hLength = elem[h].length;
        dp[h].length = hLength;
        for(var hidx = 0; hidx < hLength; hidx++){
          dp[h][hidx] = Infinity;
        }
      }

      // 最初に選んだパチモンから次に捕まえられる属性番号
      var first = (startElem + 1) % 5;

      for (var j = 0, firstLength = elem[first].length; j < firstLength; j++) {
        // s→e1を計算
        dp[first][j] = dist(start, elem[first][j]);
      }

      // s->1->2->3->4->g
      // なので、ループは間の-> * 3分まわす
      for (var e = 0; e < 3; e++) {
        // ex->e(x+1)
        var now = (first + e) % 5;
        var next = (now + 1) % 5;

        for (var j = 0, nowLength = elem[now].length; j < nowLength; j++) {
          for (var k = 0, nextLength = elem[next].length; k < nextLength; k++) {
            dp[next][k] = min(
              dp[next][k],
              dp[now][j] +
                  dist(elem[now][j], elem[next][k]));
          }
        }
      }

      var last = (first + 3) % 5;
      var lastLength = elem[last].length;
      for (var j = 0; j < lastLength; j++) {
        // e4->g
        var d = dp[last][j] +
                    dist(elem[last][j], goal);

        if (d < distance) {
          distance = d;
          bestElement = startElem + 1;
        }

      }

    }

    if (distance == Infinity) {
      console.log("NA");
    } else {
      console.log(bestElement + " " + distance);
    }

    i++;
  }

}

function dist(from, to){
  return Math.abs(from.x - to.x) + Math.abs(from.y - to.y)
}

function min(a1, a2){
  return a1 < a2 ? a1 : a2;
}

function Pos(a, b){
  this.x = a;
  this.y = b;
}

var
input = '';

process.stdin.resume();
process.stdin.setEncoding('utf8');
process.stdin.on('data', function(chunk) {
  input += chunk;
});
process.stdin.on('end', function() {
  input = input.split('\n');
  main();
});


function main(){
  var i = 0;
  while(true){
    var fieldInfo = input[i].split(' ');
    var width = fieldInfo[0] - 0;//toInt
    var height = fieldInfo[1] - 0;//toInt

    // 0 0が入力された
    if(!width && !height){
      break;
    }

    var start;
    var goal;
    var elem = [[],[],[],[],[]];

    var c;
    for(var y = height; y--;){
      i++;//1行進める
      var ni = input[i];
      for(var x = width; x--;){
        c = ni[x];

        if(c === '.'){
          // ドットが一番多いはずなので、先にひっかけてしまう
        }else if(c === '1' || c === '2' || c === '3' || c === '4' || c === '5'){
          // 次に多いはずの属性を潰す
          // FIXME:判定条件は最適化できそう
          var e = elem[c - 1];
          e[e.length] = pos(x, y);
        }else if(c === 'S'){
          start = pos(x, y);
        }else{
          goal = pos(x, y);
        }

      }
    }

    var INF = 1 << 27;
    var bestElement = -1;
    var distance = INF;

    // 属性ごとにループ
    for (var startElem = 0; startElem < 5; startElem++) {
      // DPの初期化 DP[属性][同じ属性内の連番]
      var dp = [[],[],[],[],[]];
      for(var h = 5; h--;){
        var hLength = elem[h].length;
        dp[h].length = hLength;
        var initdph = dp[h];
        for(; hLength--;){
          initdph[hLength] = INF;
        }
      }

      // 最初に選んだパチモンから次に捕まえられる属性番号
      var first = (startElem + 1) % 5;

      var firstLength = elem[first].length;
      var dpf = dp[first];
      var elemf = elem[first];
      for (var j = 0; j < firstLength; j++) {
        // s→e1を計算
        dpf[j] = dist(start, elemf[j]);
      }

      // s->1->2->3->4->g
      // なので、ループは間の-> * 3分まわす
      for (var e = 0; e < 3; e++) {
        // ex->e(x+1)
        var now = (first + e) % 5;
        var next = (now + 1) % 5;
        var dpnw = dp[now];
        var dpnx = dp[next];
        var elnw = elem[now];
        var elnx = elem[next];
        var nowLength = elnw.length;
        var nextLength = elnx.length;
        for (var j = 0; j < nowLength; j++) {
          var dpnwj = dpnw[j];
          var elnwj = elnw[j];
          for (var k = 0; k < nextLength; k++) {
            dpnx[k] = min(
              dpnx[k],
              dpnwj +
                  dist(elnwj, elnx[k]));
          }
        }
      }

      var last = (first + 3) % 5;
      var lastLength = elem[last].length;
      var dpl = dp[last];
      var ell = elem[last];
      for (var j = 0; j < lastLength; j++) {
        // e4->g
        var d = ((dpl[j] + dist(ell[j], goal)) << 3) + startElem;

        distance = min(d, distance);
      }

    }

    if (distance === INF) {
      console.log("NA");
    } else {
      console.log(((distance & 7) + 1) + " " + (distance >> 3));
    }

    i++;
  }

}

function dist(from, to){
  // x座標とy座標の切り出し(11ビット右シフトでxを、2047(下位10ビット1)とのAND演算でyを取り出す)
  return abs((from >> 11) - (to >> 11)) + abs((from & 2047) - (to & 2047));
}

function min(a, b){
  // ビット演算で高速化
  var t = a - b;
 return b + (t & (t >> 31));
}

function pos(a, b){
  // 2^10 = 1024なので、下位10ビットでy座標を、上位ビットでx座標を表す
  return (a << 11) + b;
}

function abs(a){
 // ビット演算で高速化
 var mask = a >> 31;
 return (a ^ mask) - mask;
}

var
input = '';

process.stdin.resume();
process.stdin.setEncoding('utf8');
process.stdin.on('data', function(chunk) {
  input += chunk;
});
process.stdin.on('end', function() {
  input = input.split('\n');
  main();
});


var fs = require('fs'),
    length = fs.fstatSync(process.stdin.fd).size,
    buffer = new Buffer(length),
    bytesRead = fs.readSync(process.stdin.fd, buffer, 0, length, 0),
    input = buffer.toString('utf8', 0, bytesRead).split('\n');
main();
function main(){
  var i = 0;
  while(true){
    var fieldInfo = input[i].split(' ');
    var width = fieldInfo[0] - 0;//toInt
    var height = fieldInfo[1] - 0;//toInt

    // 0 0が入力された
    if(!width && !height){
      break;
    }

    var start,
    goal,
    elem = [[],[],[],[],[]],
    c;

    for(var y = height; y--;){
      i++;//1行進める
      var ni = input[i];
      for(var x = width; x--;){
        c = ni[x];

        if(c == '.'){
          // ドットが一番多いはずなので、先にひっかけてしまう
        }else if(c == '1' || c == '2' || c == '3' || c == '4' || c == '5'){
          // 次に多いはずの属性を潰す
          var e = elem[c - 1];
          e[e.length] = pos(x, y);
        }else if(c == 'S'){
          start = pos(x, y);
        }else{
          goal = pos(x, y);
        }

      }
    }

    var INF = 1 << 30;
    var bestElement = -1;
    var distance = INF;

    // 属性ごとにループ
    for (var startElem = 0; startElem < 5; startElem++) {
      // DPの初期化 DP[属性][同じ属性内の連番]
      var dp = [[],[],[],[],[]];
      for(var h = 5; h--;){
        var hLength = elem[h].length;
        dp[h].length = hLength;
        var initdph = dp[h];
        for(; hLength--;){
          initdph[hLength] = INF;
        }
      }

      // 変数宣言をまとめると安い（らしい）
      var first = (startElem + 1) % 5,
      idxf,
      firstLength = elem[first].length,
      dpf = dp[first],
      elemf = elem[first],
      now = first,
      dpnw = dpf,
      elnw = elemf,
      nowLength = elnw.length,
      next,
      dpnx,
      elnx,
      nextLength,
      dpnwj,
      elnwj,
      idxj,
      idxk,
      inxl,
      tdist;

      // 最初に選んだパチモンから次に捕まえられる属性番号
      for (idxf = firstLength; idxf--;) {
        // s→e1を計算
        dpf[idxf] = dist(start, elemf[idxf]);
      }

      // s->1->2->3->4->g
      // なので、ループは間の-> * 3分まわす
      for (var e = 0; e < 3; e++) {
        // ex->e(x+1)
        next = (now + 1) % 5;
        dpnx = dp[next];
        elnx = elem[next];
        nextLength = elnx.length;
        for (idxj = nowLength; idxj--;) {
          dpnwj = dpnw[idxj];
          elnwj = elnw[idxj];
          for (idxk = nextLength; idxk--;) {
            dpnx[idxk] = min(
              dpnx[idxk],
              dpnwj +
                  dist(elnwj, elnx[idxk]));
          }
        }
        now = next;
        dpnw = dpnx;
        elnw = elnx;
        nowLength = elnw.length;
      }

      for (idxl = 0; idxl < nextLength; idxl++) {
        // e4->g
        tdist = dpnx[idxl] + dist(elnx[idxl], goal);

        if (tdist < distance) {
          distance = tdist;
          bestElement = startElem + 1;
        }

      }

    }

    if (distance == INF) {
      console.log("NA");
    } else {
      console.log(bestElement + " " + distance);
    }

    i++;
  }

}

function dist(from, to){
  // x座標とy座標の切り出し(11ビット右シフトでxを、2047(下位10ビット1)とのAND演算でyを取り出す)
  return abs((from >> 11) - (to >> 11)) + abs((from & 2047) - (to & 2047));
}

function min(a, b){
  // ビット演算で高速化
 return b + ((a - b) & ((a - b) >> 31));// 変数宣言よりもこっちの方が高速
}

function pos(a, b){
  // 2^10 = 1024なので、下位10ビットでy座標を、上位ビットでx座標を表す
  return (a << 11) + b;
}

function abs(a){
 // ビット演算で高速化
 return (a ^ (a >> 31)) - (a >> 31);// これも
}


var fs = require('fs'),
    length = fs.fstatSync(process.stdin.fd).size,
    buffer = new Buffer(length),
    bytesRead = fs.readSync(process.stdin.fd, buffer, 0, length, 0),
    input = buffer.toString('utf8', 0, bytesRead).split('\n');
main();
function main(){
  var i = 0;
  while(true){
    var fieldInfo = input[i].split(' ');
    var width = fieldInfo[0] - 0;//toInt
    var height = fieldInfo[1] - 0;//toInt

    // 0 0が入力された
    if(!width && !height){
      break;
    }

    var start;
    var goal;
    var elem = [[],[],[],[],[]];

    var c;
    for(var y = height; y--;){
      i++;//1行進める
      var ni = input[i];
      for(var x = width; x--;){// なぜか順列アクセスの方が早い
        c = ni[x];

        if(c == '.'){
          // ドットが一番多いはずなので、先にひっかけてしまう
        }else if(c == '1' || c == '2' || c == '3' || c == '4' || c == '5'){
          // 次に多いはずの属性を潰す
          var e = elem[c - 1];
          e[e.length] = pos(x, y);
        }else if(c == 'S'){
          start = pos(x, y);
        }else{
          goal = pos(x, y);
        }

      }
    }

    var INF = 1 << 26;
    var bestElement = -1;
    var distance = INF;
    var elemSize = 5;
    var startIdx = 0;
    // 属性ごとにループ
    for (var startElem = startIdx; startElem < 5; startElem++) {
      // DPの初期化 DP[属性][同じ属性内の連番]
      var dp = [[],[],[],[],[]];
      for(var h = elemSize; h--;){
        var hLength = elem[h].length;
        dp[h].length = hLength;
        var initdph = dp[h];
        for(; hLength--;){
          initdph[hLength] = INF;
        }
      }

      // 最初に選んだパチモンから次に捕まえられる属性番号
      var first = (startElem + 1) % elemSize;

      var firstLength = elem[first].length;
      var dpf = dp[first];
      var elemf = elem[first];
      for (var j = startIdx; j < firstLength; j++) {
        // s→e1を計算
        dpf[j] = dist(start, elemf[j]);
      }

      // s->1->2->3->4->g
      // なので、ループは間の-> * 3分まわす
      var now = first;
      var dpnw = dpf;
      var elnw = elemf;
      var nowLength = elnw.length;
      var next;
      var dpnx;
      var elnx;
      var nextLength;
      for (var e = startIdx; e < 3; e++) {
        // ex->e(x+1)
        next = (now + 1) % elemSize;
        dpnx = dp[next];
        elnx = elem[next];
        nextLength = elnx.length;
        for (var j = startIdx; j < nowLength; j++) {
          var dpnwj = dpnw[j];
          var elnwj = elnw[j];
          for (var k = startIdx; k < nextLength; k++) {
            dpnx[k] = min(
              dpnx[k],
              dpnwj +
                  dist(elnwj, elnx[k]));
          }
        }
        now = next;
        dpnw = dpnx;
        elnw = elnx;
        nowLength = elnw.length;
      }

      for (var j = startIdx; j < nextLength; j++) {
        // e4->g
        distance = min(distance, ((dpnx[j] + dist(elnx[j], goal)) << 3) + startElem);
      }

    }

    if (distance == INF) {
      console.log("NA");
    } else {
      console.log(((distance & 7) + 1) + " " + (distance >> 3));
    }

    i++;
  }

}

function dist(from, to){
  // x座標とy座標の切り出し(11ビット右シフトでxを、2047(下位10ビット1)とのAND演算でyを取り出す)
  return abs((from >> 11) - (to >> 11)) + abs((from & 2047) - (to & 2047));
}

function min(a, b){
  // ビット演算で高速化
 return b + ((a - b) & ((a - b) >> 31));// 変数宣言よりもこっちの方が高速
}

function pos(a, b){
  // 2^10 = 1024なので、下位10ビットでy座標を、上位ビットでx座標を表す
  return (a << 11) + b;
}

function abs(a){
 // ビット演算で高速化
 return (a ^ (a >> 31)) - (a >> 31);// これも
}


// 標準入力
var fs = require('fs'),
    length = fs.fstatSync(process.stdin.fd).size,
    buffer = new Buffer(length),
    bytesRead = fs.readSync(process.stdin.fd, buffer, 0, length, 0),
    input = buffer.toString('utf8', 0, bytesRead).split('\n');
main();

// ここから
function main(){
  var readLines = 0;
  while(true){
    var fieldInfo = input[readLines].split(' ');
    var width = fieldInfo[0] - 0;//toInt
    var height = fieldInfo[1] - 0;//toInt

    // 0 0が入力された
    if(!width && !height){
      break;
    }

    // 変数宣言纏めたら早い？
    var start;
    var goal;
    var elem = [[],[],[],[],[]]; // 場にいるパチモン[属性][属性内連番]
    var c;
    var rowData;
    var elemCache;
    var y;
    var x;

    for(y = height; y--;){// reverse loop
      readLines++;//1行進める
      rowData = input[readLines];
      for(x = width; x--;){// reverse loop
        c = rowData[x];

        if(c == '.'){
          // ドットが一番多いはずなので、先にひっかけてしまう
        }else if(c == '1' || c == '2' || c == '3' || c == '4' || c == '5'){
          // 次に多いはずの属性を潰す
          elemCache = elem[c - 1];
          elemCache[elemCache.length] = pos(x, y);
        }else if(c == 'S'){
          start = pos(x, y);
        }else{
          goal = pos(x, y);
        }

      }
    }

    // ブロックスコープが無いから変数宣言をまとめる
    var INF = 1 << 30;
    var bestElement = -1;
    var currentDisance;
    var nearestDistance = INF;
    var dp; // 距離[属性][同じ属性内の連番]
    var i; // loop index
    var j;
    var e;
    var len;
    var dpCacheNow; // cache of dp[i] for loop
    var dpCacheNowi; // cache of dp[now][i]
    var dpCacheNext; // cache of dp[i + 1] for loop
    var elemCacheNow;
    var elemCacheNowi; // cache of elem[now][i]
    var elemCacheNext;
    var now;
    var nowLength;
    var next;
    var nextLength;

    // 最初に選ぶ属性ごとにループ
    for (var selectElem = 0; selectElem < 5; selectElem++) {
      dp = [[],[],[],[],[]]; // 距離[属性][同じ属性内の連番]

      for(i = 5; i--;){// reverse loop
        len  = elem[i].length;
        dp[i].length = len;
        dpCache = dp[i];
        while(len--){// reverse loop
          dpCache[len] = INF;
        }
      }

      now = (selectElem + 1) % 5;
      nowLength = elem[now].length;
      dpCacheNow = dp[now];
      elemCacheNow= elem[now];

      for (i = 0; i < nowLength; i++) {
        // s→e1を計算
        dpCacheNow[i] = dist(start, elemCacheNow[i]);
      }

      // s->1->2->3->4->g
      // なので、ループは間の-> * 3分まわす
      for (e = 0; e < 3; e++) {
        // e(x)->e(x+1)
        next = (now + 1) % 5;
        dpCacheNext = dp[next];
        elemCacheNext = elem[next];
        nextLength = elemCacheNext.length;
        for (i = 0; i < nowLength; i++) {
          dpCacheNowi = dpCacheNow[i];
          elemCacheNowi = elemCacheNow[i];

          if(dpCacheNowi >= nearestDistance){
            // 既に決まっている最短距離を超えたら絶対に候補ではない
            continue;
          }

          for (j = 0; j < nextLength; j++) {
            dpCacheNext[j] = min(dpCacheNext[j], dpCacheNowi + dist(elemCacheNowi, elemCacheNext[j])); // メモと新しい経路の最短
          }
        }

        now = next;
        dpCacheNow = dpCacheNext;
        elemCacheNow = elemCacheNext;
        nowLength = nextLength;
      }

      for (i = 0; i < nextLength; i++) {
        // e4->g
        currentDistance = dpCacheNext[i] + dist(elemCacheNext[i], goal);

        if (currentDistance < nearestDistance) {
          nearestDistance = currentDistance;
          bestElement = selectElem;
        }

      }

    }

    if (nearestDistance == INF) {
      console.log("NA");
    } else {
      console.log((bestElement + 1) + " " + nearestDistance);
    }

    readLines++;
  }

}

function dist(from, to){
  // x座標とy座標の切り出し(11ビット右シフトでxを、2047(下位10ビット1)とのAND演算でyを取り出す)
  return abs((from >> 11) - (to >> 11)) + abs((from & 2047) - (to & 2047));
}

function min(a, b){
  // ビット演算で高速化
  var t = a - b;
  return b + (t & (t >> 31));
}

function pos(a, b){
  // オブジェクトのインスタンス作るよりもプリミティブの方が早い
  // 2^10 = 1024なので、下位10ビットでy座標を、上位ビットでx座標を表す
  return (a << 11) + b;
}

function abs(a){
  // ビット演算で高速化
  var t = a >> 31;
  return (a ^ t) - t;
}


// 標準入力
var fs = require('fs'),
length = fs.fstatSync(process.stdin.fd).size,
buffer = new Buffer(length),
bytesRead = fs.readSync(process.stdin.fd, buffer, 0, length, 0),
input = buffer.toString('utf8', 0, bytesRead).split('\n');
main();

// ここから
function main(){
  var readLines = 0;
  while(true){
    var fieldInfo = input[readLines].split(' ');
    var width = fieldInfo[0] - 0;//toInt
    var height = fieldInfo[1] - 0;//toInt

    // 0 0が入力された
    if(!width && !height){
      break;
    }

    var start;
    var goal;
    var elem = [[],[],[],[],[]]; // 場にいるパチモン[属性][属性内連番]
    var c;
    var cIdx;
    var rowData;
    var elemCache;
    var y;
    var x;

    for(y = height; y--;){// reverse loop
      readLines++;//1行進める
      rowData = input[readLines];
      for(x = width; x--;){// reverse loop
        c = rowData[x];

        if(c == '.'){
          // ドットが一番多いはずなので、先にひっかけてしまう
        }else if(c == '1' || c == '2' || c == '3' || c == '4' || c == '5'){
          // 次に多いはずの属性を潰す
          cIdx = c - 1;
          elemCache = elem[cIdx];
          elemCache[elemCache.length] = pos(x, y);
        }else if(c == 'S'){
          start = pos(x, y);
        }else{
          goal = pos(x, y);
        }

      }
    }

    // TypedArrayを採用して高速化
    for(var elemInit = 5; elemInit--;){
      elem[elemInit] = new Int32Array(elem[elemInit]);
    }

    // ブロックスコープが無いから変数宣言をまとめる
    var INF = 1 << 30;
    var bestElement = -1;
    var currentDisance;
    var nearestDistance = INF;
    var dp; // 距離[属性][同じ属性内の連番]
    var i; // loop index
    var j;
    var e;
    var len;
    var dpCacheNow; // cache of dp[i] for loop
    var dpCacheNowi; // cache of dp[now][i]
    var dpCacheNext; // cache of dp[i + 1] for loop
    var elemCacheNow;
    var elemCacheNowi; // cache of elem[now][i]
    var elemCacheNext;
    var now;
    var nowLength;
    var next;
    var nextLength;

    // 最初に選ぶ属性ごとにループ
    for (var selectElem = 0; selectElem < 5; selectElem++) {
      dp = new Array(5); // 距離[属性][同じ属性内の連番]

      for(i = 5; i--;){// reverse loop
        len  = elem[i].length;
        dpCache = dp[i] = new Int32Array(len); // ここもTypedArray
        while(len--){// reverse loop
          dpCache[len] = INF;
        }
      }

      now = (selectElem + 1) % 5;
      nowLength = elem[now].length;
      dpCacheNow = dp[now];
      elemCacheNow= elem[now];

      for (i = 0; i < nowLength; i++) {
        // s→e1を計算
        dpCacheNow[i] = dist(start, elemCacheNow[i]);
      }

      // s->1->2->3->4->g
      // なので、ループは間の-> * 3分まわす
      for (e = 0; e < 3; e++) {
        // e(x)->e(x+1)
        next = (now + 1) % 5;
        dpCacheNext = dp[next];
        elemCacheNext = elem[next];
        nextLength = elemCacheNext.length;
        for (i = 0; i < nowLength; i++) {
          dpCacheNowi = dpCacheNow[i];
          elemCacheNowi = elemCacheNow[i];

          if(dpCacheNowi >= nearestDistance){
            // 既に決まっている最短距離を超えたら絶対に候補ではない
            continue;
          }

          for (j = 0; j < nextLength; j++) {
            dpCacheNext[j] = min(dpCacheNext[j], dpCacheNowi + dist(elemCacheNowi, elemCacheNext[j])); // メモと新しい経路の最短
          }
        }

        now = next;
        dpCacheNow = dpCacheNext;
        elemCacheNow = elemCacheNext;
        nowLength = nextLength;
      }

      for (i = 0; i < nextLength; i++) {
        // e4->g
        currentDistance = dpCacheNext[i] + dist(elemCacheNext[i], goal);

        if (currentDistance < nearestDistance) {
          nearestDistance = currentDistance;
          bestElement = selectElem;
        }

      }

    }

    if (nearestDistance == INF) {
      console.log("NA");
    } else {
      console.log((bestElement + 1) + " " + nearestDistance);
    }

    readLines++;
  }

}

function dist(from, to){
  // x座標とy座標の切り出し(11ビット右シフトでxを、2047(下位10ビット1)とのAND演算でyを取り出す)
  return abs((from >> 11) - (to >> 11)) + abs((from & 2047) - (to & 2047));
}

function min(a, b){
  // ビット演算で高速化
  return b + ((a - b) & ((a - b) >> 31));// 変数宣言よりもこっちの方が高速
}

function pos(a, b){
  // オブジェクトのインスタンス作るよりもプリミティブの方が早い
  // 2^10 = 1024なので、下位10ビットでy座標を、上位ビットでx座標を表す
  return (a << 11) + b;
}

function abs(a){
  // ビット演算で高速化
  return (a ^ (a >> 31)) - (a >> 31);// これも
}


process.stdin.resume();
process.stdin.setEncoding('utf8');
var input = '';
process.stdin.on('data', function (chunk) {
  input += chunk;
});
process.stdin.on('end', function () {
  var lines = input.split('\n');
  var l = 0;
  while (true) {
    var w = Number(lines[l++]);
    if (w === -1) {
      break;
    }
    var ans = 1150;
    if (w > 10) {
      ans += Math.min(10, w - 10) * 125;
    }
    if (w > 20) {
      ans += Math.min(10, w - 20) * 140;
    }
    if (w > 30) {
      ans += (w - 30) * 160;
    }
    console.log(4280 - ans);
  }
});

水道料金

松平さんは、普段からエコに気を付けて生活をしています。先月の水道料金が 4280 円となり、いつも目標としている 4000 円を超えてしまったので、今月は節水に努めてきました。先月と比べて水道料金はどのくらい節約できたのでしょうか。

今月の使用水量 w [m3] を入力とし、先月の水道料金である 4280 円と比較して、どのくらい水道料金を節約できたかを出力するプログラムを作成してください。

なお、水道料金は次のように計算されます。

(水道料金) = (基本料金) + (水量による料金)

水量による料金は下表のように使用量に応じて計算されます。

段階

水量

料金

第 1 段階料金

10 [m3] まで

基本料金 1150 円

第 2 段階料金

10 [m3] 超過 20 [m3] まで

1 [m3] あたり 125 円

第 3 段階料金

20 [m3] 超過 30 [m3] まで

1 [m3] あたり 140 円

第 4 段階料金

30 [m3] 超過分

1 [m3] あたり 160 円

例えば、使用水量 40 [m3] の場合は、
基本料金 1150 円(第 1 段階) + 10 [m3] × 125 円(第 2 段階) + 10 [m3] × 140 円(第 3 段階) + 10 [m3] × 160 円(第 4 段階) = 5400 円

となります。

Input

複数のデータセットの並びが入力として与えられます。入力の終わりは -1 ひとつの行で示されます。

各データセットとして、 今月の使用水量を表す整数 w (0 ≤ w ≤ 100) が１行に与えられます。

データセットの数は 200 を超えません。

Output

入力データセットごとに、先月の水道料金との差を1行に出力します。

Sample Input

29
40
0
-1

Output for the Sample Input

620
-1120
3130


var input = require('fs').readFileSync('/dev/stdin', 'utf8');
var arr=input.trim().split("\n");
while(true){
   var nm=arr.shift().split(" ").map(Number);
   if(nm.join(" ")=="0 0")break;
   var n=nm[0];
   var m=nm[1];
   var c=2;
   var s=1;
   var d=n;
   var ary=[];
   for(var i=0;i<m;i++)ary.push(arr.shift().split(" ").map(Number));
   var dp=[];
   for(var i=0;i<=n;i++){
      dp[i]=[];
      for(var j=0;j<=c;j++){
         dp[i][j]=Infinity;
      }
   }
   dp[s][0]=0;
   var bomb=[s];
   var obj={};
   while(true){
      if(bomb.length==0)break;
      var S=bomb.shift();
      if(obj.hasOwnProperty(S))continue;
      obj[S]=true;
      ary.forEach(function(v){
         var a=v[0];
         var b=v[1];
         var f=v[2];
         if(a==S){
            dp[b][0]=Math.min(dp[b][0],dp[a][0]+f);
            dp[b][1]=Math.min(dp[b][1],dp[a][0]);
            dp[b][2]=Math.min(dp[b][2],dp[a][1]);
            dp[b][2]=Math.min(dp[b][2],dp[a][2]+f);
            bomb.push(b);
         }else if(b==S){
            dp[a][0]=Math.min(dp[a][0],dp[b][0]+f);
            dp[a][1]=Math.min(dp[a][1],dp[b][0]);
            dp[a][2]=Math.min(dp[a][2],dp[b][1]);
            dp[a][2]=Math.min(dp[a][2],dp[b][2]+f);
            bomb.push(a);
         }
         dp[d][1]=Infinity;
      });
   }
   var ans=Infinity;
   dp[d].forEach(function(v,i){
      ans=Math.min(ans,v);
   });
   console.log(ans);
}

温泉旅行

温泉好きのたけしさんは、次の長期休暇を利用してとある温泉地への旅行を計画しています。移動は長距離バスを乗り継ぎ、なるべくお金をかけずに目的地へたどり着きたいと思っています。貯金があるとはいえ、資金に心許ないたけしさんは、おじいさんに相談することにしました。計画を聞いて感心したおじいさんは、たけしさんに特別な切符を渡しました。

その切符は、長距離バスの連続した2区間を1回だけ無料で乗れるというものでした。使いようによってはかなりの移動費削減が見込めますが、より大きな効果を発揮させるためにはしっかりした計画を練る必要があります。

出発地と目的地、及び中継地点が合わせて n 個、2つの地点を結ぶ路線が m 個与えられます。各地点にはそれぞれ 1 から n までの数字が割り振られています。出発地は 1、目的地は n です。路線の情報は、その路線が結ぶ2つの地点 a と b、及びその料金 c で表されます。特別な切符の効力により、任意の地点から、一度だけ連続した2つの路線を料金0で通過することができます。ただし、途中で目的地を通過しても、目的地にたどり着いたことにはなりません。

出発地、目的地、及び中継地点の総数 n と路線の数 m、各路線の情報を入力とし、料金の最小値を出力するプログラムを作成してください。ただし、必ず出発地から目的地へと到達する経路が存在するものとします。

入力

複数のデータセットが与えられます。入力の終わりはゼロふたつの行で示されます。各データセットは以下の形式で与えられます。

n m
a1 b1 c1
a2 b2 c2
:
am bm cm

1行目に出発地、目的地、及び中継地点の総数 n (2 ≤ n ≤ 100)と路線の数 m (1 ≤ m ≤ 300)が与えられます。続く m 行に各路線の情報 ai, bi, ci (1 ≤ ci ≤ 1000) が与えられます。

データセットの数は 40 を超えません。

出力

入力データセットごとに、料金の最小値を1行に出力します。

入力例

2 1
1 2 5
3 2
1 2 5
2 3 5
6 9
1 2 7
1 3 9
1 5 14
2 3 10
2 4 15
3 4 11
3 5 2
4 5 9
4 6 8
0 0

出力例

5
0
7


var input = require('fs').readFileSync('/dev/stdin', 'utf8');
var arr=input.trim().split("\n");
var nmp=arr.shift().split(" ").map(Number);
var n=nmp[0]-1;
var m=nmp[1];
var p=nmp[2];
var ary=[];
for(var i=0;i<m;i++){
   var d=arr.shift()-0;
   if(d!=p)ary.push(d);
}
ary=ary.concat(p);
ary.sort(function(a,b){return a-b;});
var min=Infinity;

if(ary.length==2){
min=Math.min(min,ary[1]-ary[0]);
min=Math.min(min,n+1-(ary[1]-ary[0]));
}

ary.forEach(function(v,i){
if(v<p){
   if(i!=0)min=Math.min(min,(p-v)*2+(n-p+1)+ary[i-1]);
}
if(p==v){
   if(i==0)min=Math.min(min,ary[ary.length-1]-v);
   if(i==ary.length-1)min=Math.min(min,v-ary[0]);
   if(i!=ary.length-1)min=Math.min(min,p+n-ary[i+1]+1);
   if(i!=0)min=Math.min(min,n-p+1+ary[i-1]);
}
if(p<v){
   if(i!=ary.length-1)min=Math.min(min,(v-p)*2+p+(n-ary[i+1]+1));
}
});
console.log(min*100);

鉄道路線II

わたしの住む街には、図のような N 個の駅からなる円環状の鉄道路線があります。この路線の各駅には 0 から N-1 までの番号が順番に割り当てられていて、隣の駅まで100 円で移動することができます。移動はどちらの方向にでも可能です。

わたしはこの路線上のいくつかの駅で買い物をしたいと思っています。そこで、プログラムを作成して移動費を計算することにしました。ある駅を始点として、買い物をするすべての駅を訪問する最小の費用（円）を求めるプログラムを作成してください。ただし、同じ駅を何度訪問しても良く、どのような順番で駅を訪問しても構いません。

入力

入力は以下の形式で与えられる。

N M p
d1
d2
:
dM

1行目に駅の数 N (2 ≤ N ≤ 100000)、買い物をする駅の数 M (1 ≤ M ≤ 10000 かつ M < N)、出発する駅の番号 p (0 ≤ p ≤ N-1) が与えられる。続く M 行に買い物をする駅の番号 di (0 ≤ di ≤ N-1) が与えられる。ただし、diは全て異なり、p もまたどの di とも異なるものとする。

出力

最小の費用を１行に出力する。

入出力例

入力例１

5 4 0
1
2
3
4

出力例１

400

入力例２

7 2 1
6
2

出力例２

400


var input = require('fs').readFileSync('/dev/stdin', 'utf8');
var arr = input.trim().split(" ").map(Number);
arr.sort(function(a,b){
   return a - b;
});
var sum=0;
if(arr[0] == arr[1] && arr[1] == arr[2] && arr[2] == arr[3])sum++;
if(arr[0+4] == arr[1+4] && arr[1+4] == arr[2+4] && arr[2+4] == arr[3+4])sum++;
if(arr[0+8] == arr[1+8] && arr[1+8] == arr[2+8] && arr[2+8] == arr[3+8])sum++;
console.log((sum==3)?"yes":"no");

MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});

棒で作る直方体

アイヅ放送協会の教育番組(ＡＨＫ教育)では、子ども向けの工作番組「あそんでつくろ」を放送しています。今回は棒で箱を作る回ですが、用意した１２本の棒を使って直方体ができるかを確かめたいと思います。ただし、棒は切ったり折ったりしてはいけません。

１２本の棒の長さが与えられるので、それらすべてを辺とする直方体が作れるかどうか判定するプログラムを作成せよ。

Input

入力は以下の形式で与えられる。

e1 e2 ... e12

入力は１行からなり、各棒の長さを表す整数 ei (1 ≤ ei ≤ 100) が与えられる。

Output

直方体を作成できる場合には「yes」を、作成できない場合には「no」を出力する。ただし、立方体は直方体の一種なので、立方体の場合でも「yes」と出力する。

Sample Input 1

1 1 3 4 8 9 7 3 4 5 5 5

Sample Output 1

no

Sample Input 2

1 1 2 2 3 1 2 3 3 3 1 2

Sample Output 2

yes


var input = require('fs').readFileSync('/dev/stdin', 'utf8');
var Arr=(input.trim()).split("\n");
while(Arr.length>1){
   var AL=Arr.shift();
   var hash={};
   for(var i=0;i<AL;i++){
      var arr=(Arr[i].trim()).split(" ");
      hash[arr[0]]=arr[1];
   }
   Arr=Arr.slice(AL,Arr.length+1);
   var AL=Arr.shift();
   var str="";
   for(var i=0;i<AL;i++){
      var k=Arr[i].trim();
      str+=(hash.hasOwnProperty(k))?hash[k]:k;
   }
   Arr=Arr.slice(AL,Arr.length+1);
   console.log(str);
   if(Arr[0]=="0")break;
}

与えられた変換表にもとづき，データを変換するプログラムを作成しなさい．

データに使われている文字は英字か数字で，英字は大文字と小文字を区別する．変換表に現れる文字の順序に規則性はない．

変換表は空白をはさんで前と後ろの 2 つの文字がある(文字列ではない)．変換方法は，変換表のある行の前の文字がデータに現れたら，そのたびにその文字を後ろの文字に変換し出力する．変換は 1 度だけで，変換した文字がまた変換対象の文字になっても変換しない．変換表に現れない文字は変換せず，そのまま出力する．

入力ファイルには，変換表（最初の n + 1 行）に続き変換するデータ（n + 2 行目以降）が書いてある． 1 行目に変換表の行数 n，続く n 行の各行は，空白をはさんで 2 つの文字，さらに続けて， n + 2 行目に変換するデータの行数 m，続く m 行の各行は 1 文字である． m ≤ 105 とする．出力は，出力例のように途中に空白や改行は入れず 1 行とせよ．

入力例

3

A a

0 5

5 4

10

A

B

C

0

1

4

5

a

b

A

出力例

aBC5144aba

入力

入力は複数のデータセットからなる．n が 0 のとき入力が終了する．データセットの数は 5 を超えない．

出力

データセットごとに、変換後の文字列を１行に出力する．

入力例

3
A a
0 5
5 4
10
A
B
C
0
1
4
5
a
b
A
3
A a
0 5
5 4
10
A
B
C
0
1
4
5
a
b
A
0

出力例

aBC5144aba
aBC5144aba

各データセットの出力（変換後の文字列）の後に改行を入れること．

上記問題文と自動審判に使われるデータは、情報オリンピック日本委員会が作成し公開している問題文と採点用テストデータです。


"use strict"
function KP(callback) {
    this.data = [];
    this.reader = require('readline').createInterface({
        input: process.stdin,
        output: process.stdout
    });
    this.id = 0;
    this.start = function(callback) {
        self.reader.on('line', function(line) {
            var dt = line.split(" ");
            for (var i = 0; i < dt.length; ++i) {
                self.data.push(dt[i]);
            }
        });
        self.reader.on('close', function() {
            callback(self);
        });
    }
    this.input = function() {
        var id = self.id++;
        if (id >= self.data.length) {
            self.error("reached eof");
        }
        return self.data[id];
    }
    this.output = function(data) {
        if (arguments.length > 1) {
            data = [];
            for (var i = 0; i < arguments.length; ++i) {
                data[i] = arguments[i];
            }
        }
        else if (typeof data !== "object") {
            data = [data];
        }
        console.log(data.join(" "));
    }
    this.error = function(err) {
        console.error(err);
        console.abort();
    }
    var self = this;
};

new KP().start(function(kp) {
    while (true) {
        var n = +kp.input();
        var M = +kp.input();
        if (n == 0 && M == 0) break;
        var a = [];
        for (var i = 0; i < n; ++i) {
            a.push(+kp.input());
        }
        var ans = 0;
        var update_ans = function(val) {
            if (val > M) return;
            ans = Math.max(ans, val);
        };
        var v = [0];
        for (var i = 0; i < n; ++i) {
            v.push(a[i]);
            for (var j = 0; j < n; ++j) {
                v.push(a[i]+a[j]);
                update_ans(a[i]+a[j]);
            }
        }
        v = v.sort();
        for (var i = 0; i < v.length; ++i) {
            var l = 0, r = v.length;
            for (var t = 0; t < 50; ++t) {
                var m = Math.floor((l + r) / 2);
                if (v[i] + v[m] <= M) {
                    l = m;
                }
                else {
                    r = m;
                }
            }
            update_ans(v[i]+v[l]);
        }
        kp.output(ans);
    }
    process.exit(0);
});

ダーツ

問題

あなたは以下のルールでダーツゲームをすることになった.

あなたは,矢を的(まと)に向かって 4 本まで投げることができる.必ずしも 4 本全てを投げる必要はなく,1 本も投げなくてもかまわない.的は N 個の部分に区切られていて,各々の部分に点数 P1,..., PN が書か れている.矢が刺さった場所の点数の合計 S があなたの得点の基礎となる.S があらかじめ決められたある点数 M 以下の場合は S がそのままあなたの得点となる.しかし,S が M を超えた場合はあなたの得点は 0 点となる.

的に書かれている点数と M の値が与えられたとき,あなたが得ることのできる点数の最大値を求めるプログラムを作成せよ.

入力

入力は複数のデータセットからなる．各データセットは以下の形式で与えられる．

1 行目には,整数 N (1 ≤ N ≤ 1000) と M (1 ≤ M ≤ 200000000 = 2 × 108)がこの順に空白区切りで書かれている.2 行目以降の第 1 + i 行目 (1 ≤ i ≤ N ) には, Pi (1 ≤ Pi ≤ 100000000 = 108 ) が書かれている.

採点用データのうち, 配点の 20% 分は N ≤ 100 を満たし,配点の 50% 分はN ≤ 300 を満たす.

N, M がともに 0 のとき入力の終了を示す. データセットの数は 10 を超えない．

出力

データセットごとにあなたが得ることのできる点数の最大値を１行に出力する.

入出力例

入力例

4 50
3
14
15
9
3 21
16
11
2
0 0

出力例

48
20

1つ目の例では,15 点の部分に 3 本,3 点の部分に 1 本の矢が刺さった場合にあなたの得点は最大になり,その得点は 48 点である.

2つ目の例では,16 点の場所に 1 本,2 点の場所に 2 本の矢が刺さった場合にあなたの得点は最大になり,その得点は 20 点である.

上記問題文と自動審判に使われるデータは、情報オリンピック日本委員会が作成し公開している問題文と採点用テストデータです。


var input = require('fs').readFileSync('/dev/stdin', 'utf8');
var Arr=(input.trim()).split("\n");
while(true){
   var Sum=Arr.shift()-0;
   if(Sum==0)break;
   var sum=0;
   for(var i=0;i<9;i++)sum+=(Arr.shift()-0);
   console.log(Sum-sum);
}

レシート

問題

太郎君は10冊の本を購入した．
後日，
レシートをもとに価格を調べようとしたが，
レシートには汚れがあり，
ある本の価格が読み取れなかった．
その本の価格を，
10冊の総額と他の9冊の価格から計算することにした．

価格が読み取れなかった本の価格を出力するプログラムを書け．
なお，本の価格はすべて正の整数である．
また，消費税を考慮する必要はない．

入力

入力は複数のデータセットからなる．各データセットは以下の形式で与えられる．

各データセットは10行からなり，1行に1つずつ正の整数が書かれている．
1行目の整数は10冊の総額を，
2行目から10行目の整数は読み取れた価格を表している．
なお，10冊の総額は10000以下である．

総額 が 0 のとき入力の終了を示す.データセットの数は 5 を超えない．

出力

データセットごとに，価格が読み取れなかった本の価格を1 行に出力する．

入出力例

入力例

9850
1050
800
420
380
600
820
2400
1800
980
0

出力例

600

上記問題文と自動審判に使われるデータは、情報オリンピック日本委員会が作成し公開している問題文と採点用テストデータです。


var input = require('fs').readFileSync('/dev/stdin', 'utf8');
var str=input.trim();
var arr=[0];
str.replace(/(J+)(O+)(I+)/g,function(s,s1,s2,s3){
   if(s1.length>=s2.length && s3.length>=s2.length)arr.push(s2.length);
   return "";
});
console.log(Math.max.apply(null,arr));

JJOOII (JJOOII)

JOI (日本情報オリンピック) の本選に向けてプログラミングの練習をしていたあなたは，今年度のJOI の予選の問題には数値を扱う問題ばかりが出題され，文字列を扱う問題がなかったことに気がついた．そこであなたは，こっそり文字列の問題に強くなってライバルたちに差をつけることにした．

JOI の過去問を眺めていると，J, O, I の3 種類の文字からなる文字列に慣れておく必要がありそうなことがわかった．そこで，そのような文字列について考えよう．あなたは「与えられた文字列がJOI という部分文字列をもつかどうかを答えよ」という問題を思いついたものの，これはすぐに解けてしまった．もっとレベルの高い問題を解きたいあなたは，以下のような問題を作った．

文字列t が文字列s の部分文字列であるとは，t の先頭および末尾に何文字か(0 文字でもよい) を付け足すとs になることである．たとえば，JJOOII はOJJOOIIOJOI の部分文字列である．一方，JOI はJOOI の部分文字列ではない．

また，0 以上の整数k に対し，レベルk のJOI 列とは，k 個の文字J，k 個の文字O，k 個の文字I をこの順に並べた文字列のことであるとする．たとえば，JJOOII はレベル2 のJOI 列である．与えられた文字列の部分文字列であるJOI 列のうち，レベルが最大のものを求めたい．

課題

J, O, I の3 種類の文字からなる長さN の文字列S が与えられたとき，レベルk のJOI 列がS の部分文字列であるような最大のk の値を求めるプログラムを作成せよ．

制限

1 ≤ N ≤ 1000000 (= 106)   S の長さ

入力

標準入力から以下のデータを読み込め．

1 行目にはJ, O, I の3 種類の文字からなる文字列S が書かれている．

出力

標準出力に，レベルk のJOI 列がS の部分文字列であるような最大のk の値を表す整数を1 行で出力せよ．

採点基準

採点用データのうち，配点の20%分については，N ≤ 100 を満たす．

入出力例

入力例 1

OJJOOIIOJOI

出力例 1

2

OJJOOIIOJOI はレベル2 のJOI 列であるJJOOII を部分文字列として含んでおり，レベル3 以上のJOI列は部分文字列として含まない．

入力例 2

IJJIIJJJ

出力例 2

0

入力例 3

JOIJOIJOIJOIJOI

出力例 3

1

入力例 4

OOJJJJJJJOOOOIIIII

出力例 4

4

問題文と自動審判に使われるデータは、情報オリンピック日本委員会が作成し公開している問題文と採点用テストデータです。


var input = require('fs').readFileSync('/dev/stdin', 'utf8');
var str=input.trim();
var arr=[0];
str.replace(/(J*)(O*)(I*)/g,function(s,s1,s2,s3){
   if(s1.length>=s2.length && s3.length>=s2.length)arr.push(s2.length);
   return "";
});
console.log(Math.max.apply(null,arr));


var input = require('fs').readFileSync('/dev/stdin', 'utf8');
var arr = input.trim().replace(/W/g, "0").replace(/B/g, "1").replace(/R/g, "2").split("\n");
var nm = arr.shift().split(" ").map(Number);
var n = nm[0];
var m = nm[1];
var wbr = arr.map(function(v) {
   var color = [m, m, m];
   for (var i = 0; i < m; i++) color[v[i]]--;
   return color;
});
var min = 2500;
for (var i = 0; i < n ; i++) {
   for (var j = 0; j < n ; j++) {
      var flag  = [0,0,0];
      var cost = 0;
      var a = 0;
      while(a<i){
         flag[0] = 1;
         cost += wbr[a][0];
         a++;
      }
      while(a<j){
         flag[1] = 1;
         cost += wbr[a][1];
         a++;
      }
      while(a<n){
         flag[2] = 1;
         cost += wbr[a][2];
         a++;
      }
      if (flag[0] + flag[1] + flag[2] == 3)min = Math.min(cost,min);
   }
}
console.log(min);

ロシアの旗 (Russian Flag)

問題

K 理事長はロシアで開催される IOI 2016 に合わせて旗を作ることにした．K 理事長はまず倉庫から古い旗を取り出してきた．この旗は N 行 M 列のマス目に分けられていて，それぞれのマスには白・青・赤のいずれかの色が塗られている．

K 理事長はこの旗のいくつかのマスを塗り替えてロシアの旗にしようとしている．ただし，この問題でいうロシアの旗とは以下のようなものである．

上から何行か (1 行以上) のマスが全て白で塗られている．

続く何行か (1 行以上) のマスが全て青で塗られている．

それ以外の行 (1 行以上) のマスが全て赤で塗られている．

K 理事長が古い旗をロシアの旗にするために塗り替える必要のあるマスの個数の最小値を求めよ．

入力

入力は 1 + N 行からなる．

1 行目には，2 つの整数 N, M (3 ≦ N ≦ 50, 3 ≦ M ≦ 50) が空白を区切りとして書かれている．これは，旗が N 行 M 列のマス目に区切られていることを表す．

続く N 行にはそれぞれ M 文字からなる文字列が書かれており，古い旗のマス目に塗られている色の情報を表す．N 行のうちの i 行目の j 文字目 (1 ≦ i ≦ N, 1 ≦ j ≦ M) は，古い旗のマス目の i 行目 j 列目のマスの色を表す 'W', 'B', 'R' のいずれかの文字である．
'W' は白，'B' は青，'R' は赤を表す．

出力

K 理事長が古い旗をロシアの旗にするために塗り替える必要のあるマスの個数の最小値を 1 行で出力せよ．

入出力例

入力例 1

4 5
WRWRW
BWRWB
WRWRW
RWBWR

出力例 1

11

入力例 2

6 14
WWWWWWWWWWWWWW
WBBBWWRRWWBBBW
WWBWWRRRRWWBWW
BWBWWRRRRWWBWW
WBBWWWRRWWBBBW
WWWWWWWWWWWWWW

出力例 2

44

入出力例 1 において，古い旗には下図のように色が塗られている．

下図において，'X' の書かれた 11 個のマスを塗り替える．

これにより下図のようなロシアの旗にすることができる．

11 個未満のマスを塗り替えることではロシアの旗にすることはできないため，11 を出力する．

入出力例 2 においては，古い旗には下図のように色が塗られている．

情報オリンピック日本委員会作 『第 15 回日本情報オリンピック JOI 2015/2016 予選競技課題』


var input = require('fs').readFileSync('/dev/stdin', 'utf8');
var [a, b, c] = input.trim().split(" ").map(Number);
var time = Math.ceil(c/a)
        var sum = 0
        while(time > 6){

            sum = sum + 7
            c = c-(b+7*a)
            time = Math.ceil(c/a)
        }

console.log(sum + (time > 0 ? time: 0))

ソーシャルゲーム (Social Game)

問題文

JOI 君は明日から新たにソーシャルゲームを始めることにした．

このソーシャルゲームでは，1 日につき 1 回までログインすることができ，ログインするたびに A 枚のコインが得られる．

また，月曜日から日曜日まで 7 日連続でログインすると，そのたびに，追加で B 枚のコインが得られる．

これ以外にコインがもらえることはない．

明日は月曜日である．JOI 君が少なくとも C 枚のコインを得るためにログインしなければならない回数の最小値を求めよ．

制約

1 ≦ A ≦ 1000

0 ≦ B ≦ 1000

1 ≦ C ≦ 1000000 (= 10^6)

入力・出力

入力

入力は以下の形式で標準入力から与えられる．

A B C

出力

JOI 君が少なくとも C 枚のコインを得るためにログインしなければならない回数の最小値を出力せよ．

入出力例

入力例 1

3 0 10

出力例 1

4

1 回のログインあたり 3 枚のコインが得られ，10 枚のコインを集めたい．

JOI 君は，月曜日から連続 4 日間ログインすることで 12 枚のコインが得られる．

3 回以下のログインで 10 枚以上のコインを得ることはできないので，JOI 君がログインしなければならない回数の最小値は 4 である．従って，4 を出力する．

入力例 2

1 2 10

出力例 2

8

1 回のログインあたり 1 枚のコインが得られる．それとは別に，1 週間連続でログインすることで 2 枚のコインが得られる．10 枚のコインを集めたい．

月曜日から日曜日まで連続でログインすると，日々のコイン 7 枚に加えて，2 枚のコインが得られるため，合計 9 枚のコインが得られる．従って，更にもう 1 回ログインすることにより，10 枚のコインが得られる．

7 回以下のログインで 10 枚以上のコインを得ることはできないので，JOI 君がログインしなければならない回数の最小値は 8 である．従って，8 を出力する．

情報オリンピック日本委員会作 『第 18 回日本情報オリンピック JOI 2018/2019 予選競技課題』


A + B Problem

Compute A + B.

Input

The input will consist of a series of pairs of integers A and B separated by a space, one pair of integers per line. The input will be terminated by EOF.

Output

For each pair of input integers A and B, you must output the sum of A and B in one line.

Constraints

-1000 ≤ A, B ≤ 1000

Sample Input

1 2
10 5
100 20

Output for the Sample Input

3
15
120

Sample Program

#include<stdio.h>

int main(){
int a, b;
while( scanf("%d %d", &a, &b) != EOF ){
printf("%d\n", a + b);
}
return 0;
}


process.stdin.resume();
process.stdin.setEncoding("utf8");

process.stdin.on("data", function(chunk) {
    var reg = /([\d]+) ([\d]+)/;
    var result = reg.exec(chunk);
    if(result && result.length === 3) {
        process.stdout.write((parseInt(result[1]) + parseInt(result[2])).toString());
        process.stdout.write("\n");
    }
});

process.stdin.on("end", function() {
});


var readline = require("readline");
var rl = readline.createInterface({
    input : process.stdin,
    output: process.stdout
});

rl.on("line", function(text) {
    var reg = /([\d]+) ([\d]+)/;
    var data = reg.exec(text);

    if(data !== null && data.length === 3) {
        var a = parseInt(data[1]);
        var b = parseInt(data[2]);
        console.log(a + b);
    }
});


var input = require('fs').readFileSync('/dev/stdin', 'utf8');
var arr=input.trim().split("\n");
while(true){
var nab=arr.shift();
   if(nab=="0 0 0")break;
   nab=nab.split(" ").map(Number);
   var n=nab[0];
   var ab=[nab[1],nab[2]];
   var dp=[];
   for(var i=0;i<=n;i++)dp[i]=false;
   dp[0]=true;
   for(var i=0;i<ab.length;i++){
      for(var j=0;j<=n;j++){
         if(dp[j])dp[j+ab[i]]=true;
      }
   }
   var cnt=0;
   dp.forEach(function(v){
      if(v==false)cnt++;
   });
   console.log(cnt);
}

Unable Count

I would, if I could,

If I couldn't how could I?

I couldn't, without I could, could I?

Could you, without you could, could ye?

Could ye? could ye?

Could you, without you could, could ye?

It is true, as this old rhyme says, that we can only DO what
we can DO and we cannot DO what we cannot DO. Changing some of
DOs with COUNTs, we have another statement that we can only COUNT
what we can DO and we cannot COUNT what we cannot DO, which looks
rather false. We could count what we could do as well as we could
count what we couldn't do. Couldn't we, if we confine ourselves
to finite issues?

Surely we can count, in principle, both what we can do and
what we cannot do, if the object space is finite. Yet, sometimes
we cannot count in practice what we can do or what we cannot do.
Here, you are challenged, in a set of all positive integers up
to (and including) a given bound n, to count
all the integers that cannot be represented by a formula of
the form a*i+b*j, where a and
b are given positive integers and i and j
are variables ranging over non-negative integers. You are requested
to report only the result of the count, i.e. how many integers
are not representable.
For example, given n = 7, a = 2, b = 5,
you should answer 2, since 1 and 3 cannot be represented in a
specified form, and the other five numbers are representable as follows:

2 = 2*1 + 5*0, 4 = 2*2 + 5*0, 5 = 2*0 + 5*1,
6 = 2*3 + 5*0, 7 = 2*1 + 5*1.

Input

The input is a sequence of lines. Each line consists of three integers,
n, a and b, in this order, separated by a
space. The integers n, a and b are
all positive and at most one million, except those in the last
line. The last line consists of three zeros.

Output

For each input line except the last one, your program should
write out a line that contains only the result of the count.

Sample Input

10 2 3
10 2 5
100 5 25
0 0 0

Output for the Sample Input

1
2
80