编程题2

首先分析题目可知，i号房间的人数在分配完成后必然是最少的，先统计出最少的人数min（这说明循环了几轮），
让每个房间减去min以减少循环次数，从最后一个分配的房间循环往前推，记录次数count，在循环过程中第一个是0
的房间就是i号房间，其人数为min*n + count；
p.s要注意房间人数要用long int型

const [n,x] = readline().split(" ").map((v)=>parseInt(v))
let list = readline().split(" ").map((v)=>parseInt(v))
const min = Math.min(...list) //最小值代表最少进行几轮循环
const minIndex = list.findIndex((v)=>v === min)
let k = 0 // i房间里的所有人数
let flag = false // 结束标识
if(min !== 0 ){
    list = list.map((v) => v - min) //跳过完整无意义的循环
    k = min*n
}
for(let i = 0; i <= 2 && !flag; i++) {
    let start = null //开始循环下标
    if(i === 0) { //第一次从结束位置逆序开始循环
        start = x - 1
    }
    else {//其他时候直接从末尾逆序循环
        start = n - 1
    }
    for(start; start >= 0; start--) {
        list[start]-- 
        if(list[start] <0 ){ //如果出现负数说明找到了起始点
            list[start]+= 1
            list[start]+= k 
            flag = true
            break
        }
        k++
    } 
}
print(list.join(' '))

const rl = require('readline').createInterface({
    input: process.stdin,
    output: process.stdout
})
let home = -1, tag = -1

let after = []

rl.on('line', input => {
    if (home == -1) {
        let temp = input.split(' ')
        home = Number.parseInt(temp[0])
        tag = Number.parseInt(temp[1])
    } else {
        after = input.split(' ').map(it => Number.parseInt(it))

        let min = after.reduce((x, y) => x <= y ? x : y, after[0])

        // min 代表循环经过 i 多少次
        // tag 是最后停在的位置

        for (let i = 0; i < after.length; i++) {
            after[i] -= min
        }

        // 此时的情况等同于分配轮数还没到一圈
        let start = tag - 1, cnt = 0
        while (after[start] != 0) {
            // ...
            cnt++
            after[start]--

            start--
            if (start == -1) {
                start = after.length - 1
            }
        }

        after[start] = home * min + cnt

        console.log(after.join(' '))
    }
    
})

def room(n, x, a):
    b = a[x:] + a[:x]//x号房间之后表示最后一次循环没有分配人的房间号，x号之前表示最后一次循环分配了人的房间号
    b.reverse()//从最后一个分配的房间开始向前推算
    m = min(b)
    i = b.index(m)//人数最少的房间就是i号房间
    for j in range(n):
        b[j] -= m//每个房间的人数减去i号房间的人数，因为循环一次，i号房间的人数就加1
    for j in range(0,i):
        b[j] -= 1//在i号房间前面的房间就是循环的房间，即未完成整个循环的房间，这种房间人数减1
    b[i] = i+m*n//i号房间的人数等于循环次数+分配后的人数*房间个数
    b.reverse()
    b = b[n-x:] + b[:n-x]
    for i in b:
        print(i, end = ' ')

if __name__=="__main__":
    n,x=map(int,input().split())
    arr=list(map(int,input().split()))
    room(n,x,arr)

let [n, x] = readline().split(' ')
let arr = readline().split(' ')
let people = 0
let index = x - 1
let min = arr[0]
for (let i = 1; i < n; i ++) {
  if (Number(arr[i]) < Number(min)) {
    min = arr[i]
  }
}
arr = arr.map(item => item - min)
while(arr[index] !== 0 ) {
  arr[index] = arr[index] - 1
  people ++
  if (index === 0 ){
    index = n - 1
  } else {
    index --
  }
}
arr[index] = people + n*min
let res = ''
arr.forEach(item => {
   res += item + ' '
})
print(res)

var readline = require('readline');
const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
});
const lines = [];
var n = -1;
var x;
var rooms = [];
rl.on('line', function multiply(line){
    if (n == -1) {
        var temp = line.split(' ');
        n = Number(temp[0]);
        x = Number(temp[1]);
    } else {
        rooms = line.trim().split(' ');
        var min = Number(rooms[0]);
        for (let i = 0; i < rooms.length; i++) {
            if (Number(rooms[i]) < min) {
                min = Number(rooms[i]);
            }
        }
        rooms = rooms.map(function(item) {return item - min;});
        var count = 0;
        var previous = x;
        while (rooms[previous-1] != 0) {
            rooms[previous-1]--;
            count++;
            previous--;
            if (previous ==0) {
                previous = n;
            }
        } 
        rooms[previous-1] = count + min*n;
        var result = rooms.join(' ');
        console.log(result);
    }
});

var str=readline();
var arr=str.split(" ");
var houseCount=arr[0];//房间数
var lastHouse=arr[1];//最后一个人的房间
str=readline();
var houseArr=str.split(" ");
var people=0;//被分房间的人数
var index=lastHouse-1;//计算数组下标
while(houseArr[index]!=0){//倒推房间，直到有房间人数为0
    houseArr[index]=houseArr[index]-1;
    people++;
    index--;
    if(index<0){
        index=houseCount-1;//下标循环
    }
}
houseArr[index]=people;
var strOutput="";
for(var j=0;j<houseCount;j++){
    strOutput+=houseArr[j]+" "
}
console.log(strOutput);

}