Google Foobar 解决方案适用于 Jupyter 笔记本，但不适用于 Google 终端

Question

我在 Google Foobar 的第 3 级，我编写的代码在 Jupyter 笔记本中工作，但是当我在 Foobar 命令行中运行它时，没有一个测试用例通过。 当我在 Foobar 中运行它时没有任何错误，它只是说答案不正确。

Doomsday Fuel
=============

Making fuel for the LAMBCHOP's reactor core is a tricky process because of the exotic matter involved. It starts as raw ore, then during processing, begins randomly changing between forms, eventually reaching a stable form. There may be multiple stable forms that a sample could ultimately reach, not all of which are useful as fuel. 

Commander Lambda has tasked you to help the scientists increase fuel creation efficiency by predicting the end state of a given ore sample. You have carefully studied the different structures that the ore can take and which transitions it undergoes. It appears that, while random, the probability of each structure transforming is fixed. That is, each time the ore is in 1 state, it has the same probabilities of entering the next state (which might be the same state).  You have recorded the observed transitions in a matrix. The others in the lab have hypothesized more exotic forms that the ore can become, but you haven't seen all of them.

Write a function solution(m) that takes an array of array of nonnegative ints representing how many times that state has gone to the next state and return an array of ints for each terminal state giving the exact probabilities of each terminal state, represented as the numerator for each state, then the denominator for all of them at the end and in simplest form. The matrix is at most 10 by 10. It is guaranteed that no matter which state the ore is in, there is a path from that state to a terminal state. That is, the processing will always eventually end in a stable state. The ore starts in state 0. The denominator will fit within a signed 32-bit integer during the calculation, as long as the fraction is simplified regularly. 

For example, consider the matrix m:
[
  [0,1,0,0,0,1],  # s0, the initial state, goes to s1 and s5 with equal probability
  [4,0,0,3,2,0],  # s1 can become s0, s3, or s4, but with different probabilities
  [0,0,0,0,0,0],  # s2 is terminal, and unreachable (never observed in practice)
  [0,0,0,0,0,0],  # s3 is terminal
  [0,0,0,0,0,0],  # s4 is terminal
  [0,0,0,0,0,0],  # s5 is terminal
]
So, we can consider different paths to terminal states, such as:
s0 -> s1 -> s3
s0 -> s1 -> s0 -> s1 -> s0 -> s1 -> s4
s0 -> s1 -> s0 -> s5
Tracing the probabilities of each, we find that
s2 has probability 0
s3 has probability 3/14
s4 has probability 1/7
s5 has probability 9/14
So, putting that together, and making a common denominator, gives an answer in the form of
[s2.numerator, s3.numerator, s4.numerator, s5.numerator, denominator] which is
[0, 3, 2, 9, 14].

Languages
=========

To provide a Java solution, edit Solution.java
To provide a Python solution, edit solution.py

Test cases
==========
Your code should pass the following test cases.
Note that it may also be run against hidden test cases not shown here.

-- Java cases --
Input:
Solution.solution({{0, 2, 1, 0, 0}, {0, 0, 0, 3, 4}, {0, 0, 0, 0, 0}, {0, 0, 0, 0,0}, {0, 0, 0, 0, 0}})
Output:
    [7, 6, 8, 21]

Input:
Solution.solution({{0, 1, 0, 0, 0, 1}, {4, 0, 0, 3, 2, 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}})
Output:
    [0, 3, 2, 9, 14]

-- Python cases --
Input:
solution.solution([[0, 2, 1, 0, 0], [0, 0, 0, 3, 4], [0, 0, 0, 0, 0], [0, 0, 0, 0,0], [0, 0, 0, 0, 0]])
Output:
    [7, 6, 8, 21]

Input:
solution.solution([[0, 1, 0, 0, 0, 1], [4, 0, 0, 3, 2, 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]])
Output:
    [0, 3, 2, 9, 14]

我的解决方案如下：

import numpy as np
import pandas as pd
from fractions import Fraction

def solution(m):
    if m == [[0]]:
        return [1, 1]
    else:
        return run_matrix_computation(m)

def run_matrix_computation(starting_ore_matrix):
    numpy_matrix = convert_to_numpy_matrix(starting_ore_matrix)
    ordered_matrix = order_matrix(numpy_matrix)
    absorption_matrix, split_index = create_absorption_matrix(ordered_matrix)
    R, Q = store_R_and_Q(absorption_matrix, split_index)
    FR = compute_FR(R, Q)
    first_row = get_first_row_of_FR(FR)
    common_denominator, fraction_list = calculate_common_denominator(first_row)
    return return_int_array(common_denominator, fraction_list)

def convert_to_numpy_matrix(original_matrix):
    return np.asarray(original_matrix)

def order_matrix(numpy_matrix):
    labeled_dataframe = pd.DataFrame(data=numpy_matrix)
    index_order = labeled_dataframe.sum(axis=1).sort_values(ascending=True).index
    converted_matrix = convert_matrix_to_fractions(labeled_dataframe)
    return converted_matrix.iloc[index_order, index_order]

def convert_matrix_to_fractions(original_matrix):
    for i in range(len(original_matrix.index)):
        sum = original_matrix.sum(axis=1).iloc[i]
        if sum != 0:
            for j in range(len(original_matrix.columns)):
                if original_matrix.iloc[i, j]:
                    original_matrix.iloc[i, j] = original_matrix.iloc[i, j] / sum
    return original_matrix

def create_absorption_matrix(sorted_matrix):
    count = 0
    for i in range(len(sorted_matrix.index)):
        if not(sorted_matrix.sum(axis=1).iloc[i]):
            sorted_matrix.iloc[i, i] = 1
            count = count + 1
    return sorted_matrix, count

def store_R_and_Q(absorption_matrix, split_index):
    return split_into_new_matrices(absorption_matrix, split_index)

def split_into_new_matrices(absorption_matrix, split_index):
    numpy_matrix = absorption_matrix.to_numpy()
    R = numpy_matrix[split_index:, :split_index]
    Q = numpy_matrix[split_index:, split_index:]
    return R, Q

def calculate_F(R, Q):
    num_rows, num_cols = Q.shape
    I = np.identity(num_rows)
    IQ = I - Q
    return np.linalg.inv(IQ)

def compute_FR(R, Q):
    F = calculate_F(R, Q)
    return np.matmul(F, R)

def get_first_row_of_FR(FR):
    return FR[0, :]

def calculate_common_denominator(list):
    fraction_list = convert_to_fractions(list)
    list_denominators = get_denominators(fraction_list)
    GCD = calculate_greatest_common_denominator(list_denominators)
    return GCD, fraction_list

def convert_to_fractions(list):
    fraction_list = []
    for i in range(len(list)):
        fraction_list.append(Fraction(list[i]).limit_denominator())
    return fraction_list

def get_denominators(fractions):
    denominators = []
    for i in range(len(fractions)):
        denominators.append(fractions[i].denominator)
    return denominators

def calculate_greatest_common_denominator(denominators):
    GCD = 0
    if len(denominators) == 1:
        return denominators
    else:
        for i in range(len(denominators) - 1):
            cur_GCD = np.lcm(denominators[i], denominators[i + 1])
            if cur_GCD > GCD:
                GCD = cur_GCD
    return GCD

def return_int_array(denominator, fractions):
    final_list = []
    for i in range(len(fractions)):
        if(not fractions[i].numerator):
            final_list.append(0)
        else:
            multiplier = denominator/fractions[i].denominator
            final_list.append(int(fractions[i].numerator * multiplier))
    final_list.append(int(denominator))
    return final_list

使用此代码运行任何测试用例都有效，但 Foobar 上的每个测试都失败。 是否存在某种格式错误？ 我检查了返回的 object 的类型与 Foobar 正在寻找的 object 的类型，它们都是 int 列表。 据我所知，我的代码中的所有内容都由 Foobar 使用的 Python 2.7.13 支持。 我使用的库也是允许的。

Answer 1

我认为您应该先尝试检查库，如果它们已安装和版本。 然后你应该使用repli或其他东西与确切的环境。 最后，您的代码是否在解决方案 class 上？

Answer 2

我迟到了，但我相信问题在于 python 2.7 如何处理除法。 通过将它放在我的文件的开头，它为我修复了。

from __future__ import division