Java 如何解决画册下面的问题

哈克朗克问题绘图书

布里的绘画老师让全班同学把书打开一个页码。布里可以从书的正面或背面开始翻页。她总是一页一页地翻。当她打开书时，第一页总是在右边：

当她翻到第1页时，她看到了第2页和第3页。每一页，最后一页除外 页面将始终在两面打印。最后一页可能只有 根据书的长度，印在正面。如果这本书是n 页长，她想翻到p页，最小的页数是多少 她会翻多少页？她可以在比赛开始或结束时开始 这本书

给定n和p，找到并打印Brie必须翻页的最小页数 为了到达第p页

功能描述

在下面的编辑器中完成pageCount函数。它应该会回来 Brie必须翻页的最小页数

pageCount具有以下参数：

n:书的页数 p：要转到的页码 输入格式

第一行包含一个整数n，即书中的页数。 第二行包含一个整数p，布里的老师希望她翻到的页面

约束条件

输出格式

打印一个整数，表示Brie必须翻过的最小页数，才能进入第p页

样本输入0

样本输出0

样本输入1

样本输出1

---

=========================================================================

一个人应该意识到2页构成一个单元，使用整数除以2

您没有使用整数除法的余数，其中12/7==1

static int pagesTurnCount(int n, int p) {
    n /= 2; // >>= 1
    p /= 2;
    return Math.min(p, n - p); // From front, from back
}

       p
 0  >  1  <  2  <  3      page pairs
- 1   2 3   4 5   6 -     pages

基于零的程序员应该知道，双页的最后一个索引

---

实际上是页数n除以2。

每次翻页时，多看到两页。因此，这意味着在最坏的情况下，教师需要n/2圈才能从第一页转到最后一页。然而，由于她也被允许从书的末尾翻身，她可以在n/4个翻转中完成最坏的情况

---

所以，如果她的页码是p，这是我的解决方案

fun pageCount(n: Int, p: Int): Int {
    val pages = IntArray(n) { it }
    val pairs = mutableListOf<Pair<Int, Int>>()
    for (i in 0..n - 1 step 2) {
        val lastItem = if (pages[i] + 1 >= pages.size) 0 else 1
        pairs.add(pages[i] to pages[i + lastItem])
    }
    
    var forwardTurns = 0
    var backwardTurns = 0
    pairs.apply {
        this.forEach { pair ->
            if (pair.first == p || pair.second == p) return@apply else forwardTurns++
        }
    }
    for (i in pairs.size - 1 downTo 0) {
        if (pairs[i].first == p || pairs[i].second == p) break else backwardTurns++
    }
    return Math.min(forwardTurns, backwardTurns)
}

5
4

0

static int pagesTurnCount(int n, int p) {
    n /= 2; // >>= 1
    p /= 2;
    return Math.min(p, n - p); // From front, from back
}

       p
 0  >  1  <  2  <  3      page pairs
- 1   2 3   4 5   6 -     pages

uint32_t pageCount(uint32_t n, uint32_t p) {
    return std::min(p / 2, (n/2) - (p/2));
}

int pageCount(int n, int p) {
    return Math.min(p / 2, (n/2) - (p/2));
}

def pageCount(n, p):
    if p==n or p==1:
        c=0
    elif n%2!=0 and p==n-1:
        c=0
    else:
        if p%2==0:
            if n%2==0:
                c=min(p/2,(n-p)/2)
            else:
                c=min(p/2,(n-p-1)/2)
        else:
            if n%2==0:
                c=min((p-1)/2,(n-p+1)/2)
            else:
                c=min((p-1)/2,(n-p)/2)
return int(c)

fun pageCount(n: Int, p: Int): Int {
    val pages = IntArray(n) { it }
    val pairs = mutableListOf<Pair<Int, Int>>()
    for (i in 0..n - 1 step 2) {
        val lastItem = if (pages[i] + 1 >= pages.size) 0 else 1
        pairs.add(pages[i] to pages[i + lastItem])
    }
    
    var forwardTurns = 0
    var backwardTurns = 0
    pairs.apply {
        this.forEach { pair ->
            if (pair.first == p || pair.second == p) return@apply else forwardTurns++
        }
    }
    for (i in pairs.size - 1 downTo 0) {
        if (pairs[i].first == p || pairs[i].second == p) break else backwardTurns++
    }
    return Math.min(forwardTurns, backwardTurns)
}