前提：

如果可以通过将您的奖牌数（金，银，铜牌分别计数）分解为以10为底的数字，并以任意给定的顺序加入它们，并加一些警告，则表示您的声望采用堆栈交换形式。

分解时，每个

• 金牌数字代表三位数。
• 银牌价值两位数。
• 青铜是一位数字。
• 此外，如果您没有SE，则SE不会显示奖牌类型，因此类型的0个奖牌计数不会产生[0]。

例：

• [1 Gold, 2 Silvers, 3 Bronzes]将分解为[1,1,1,2,2,3]。321112和213121是这些奖牌的SE形式编号的两个示例。
• [20 Golds, 0 Silvers, 20 Bronzes]将分解为[2,2,2,0,0,0,2,0]。20002022是SE格式的编号。
• [11 Golds, 0 Silvers, 0 Bronzes]将分解为[1,1,1,1,1,1]。111111是唯一的SE形式编号。

考虑SE号时，不会有前导0。例如，在上述第二个示例中，00002222 -> 2222不会将视为SE格式的编号[20,0,20]。

输入输出：

输入是一个列表/元组/数组/ [reputation, gold_medals, silver_medals, bronze_medals]所有都是非负整数。这是假定的顺序，但可以更改。如果您做的话，只需在答案中做个注释即可。

输出是true和false的任何两个一致值。

规则：

• 输入将始终有效
• 您将始终至少有1个代表
• 您根本没有奖牌，那么那应该总是返回false。
• 奖牌数与现实无关。有几百个金牌，没有青铜器是很好的。
• 这是代码高尔夫球，因此最短答案以字节为单位。

测试用例：

#[Rep, Gold, Silver, Bronze] -> Output
[4, 0, 0, 4]       -> True
[1447, 0, 4, 17]   -> True
[74414, 4, 0, 17]  -> True
[4444, 4, 0, 4]    -> True
[4455, 0, 54, 0]   -> True
[5355, 5, 0, 3]    -> True
[53535, 5, 3, 0]   -> True
[4444, 0, 0, 4444] -> True
[444, 4, 0, 0]     -> True
[1234, 0, 0, 1234] -> True
[1234, 0, 0, 4321] -> True

[4444, 1, 0, 1]      -> False
[5555, 5, 0, 55]     -> False
[1234, 1, 23, 4]     -> False
[1, 0, 0, 0]         -> False
[1001001, 0, 10, 10] -> False

05AB1E，16 14 13 11 10 字节

∞×0KJ‚€{íË

按顺序将奖牌输入[bronze, silver, gold]作为第一输入，reputation作为第二输入。

-1个字节感谢@Grimy。

在线尝试或验证所有测试用例。

说明：

∞           # Push an infinite positive list: [1,2,3,...]
 ×          # Repeat the values in the (implicit) input-list that many times as string
            # (since the input-list contains just 3 values, the rest of the infinite
            #  list is ignored)
  0K        # Remove all 0s (so all "0", "00" and "000")
    J       # Join the strings in the list together
     ‚      # Pair this string with the (implicit) second input
      €{í   # Sort the digits in both strings in descending order
         Ë  # And check if both are now equal
            # (after which the result is output implicitly as result)

JavaScript（ES6）， 92  74字节

将输入作为(['gold','silver','bronze'])('rep')。返回一个布尔值。

b=>r=>[...b.map((n,i)=>n.repeat(+n&&3-i)).join``].sort()+''==[...r].sort()

在线尝试！

JavaScript（ES6），74个字节

将输入作为(gold, silver, bronze, 'rep')。返回一个布尔值。

(g,s,b,r)=>(F=s=>[...s].sort()+0)(r)==F([g,g,g,s,s,b].filter(x=>x).join``)

在线尝试！

MATL，28字节 20字节 16字节 13字节

返回0表示false，1表示true。这绝对可以打败。

[1,3,2,1]Y"t2:7)XzVXzY@Ums0>

如果信誉分数可以单独获取，则减少到16个字节，并且顺序为[青铜，白银，黄金]，信誉
由于Luis Mendo，减少到13个字节

3:Y"XzVXzY@Um

在线尝试！

红宝石，69字节

->r,g,s,b{([g,g,g,s,s,b]-[0]).flat_map(&:digits).sort==r.digits.sort}

在线尝试！

J，^{38 34} 31字节

-:&(/:~)&":3 2 1;@#*#&.><@":"0 

在线尝试！

Japt，14 13 12字节

íp fn ¬á øUg

输入为 [rep, bronze, silver, gold]

尝试或验证所有测试用例

Sample input: U = [1447, 17, 4, 0]
íp            Repeats each value of U by it's index amount e.g. ["","17","44","000"]
  fn          Remove all falsy values when converted to a number e.g. ["17","44"]
    ¬         Concatenate e.g. "1744"
     á        All permutations e.g. ["1744","1744","1474","1447","1474","1447","7144","7144","7414","7441","7414","7441","4174","4147","4714","4741","4417","4471","4174","4147","4714","4741","4417","4471"]
      øUg     Does it contain the first item of the input? 

视网膜0.8.2，45字节

,0
,
,(\d*),(\d*),
¶$1$1$1$2$2
%O`.
^(.+)¶\1$

在线尝试！链接包括测试套件。说明：

,0
,

删除零分。

,(\d*),(\d*),
¶$1$1$1$2$2

扩展金和银的分数，并将分隔符转换为换行符。

%O`.

分别对声誉和扩展分数进行排序。

^(.+)¶\1$

比较排序的数字。

果冻，10字节

xJ$¹ƇV,Ṣ€E

在线尝试！

参数1：[Bronze, Silver, Gold]
参数2：Rep

球拍，149个 107 98字节

(λ(r b s g[h(λ x(sort(string->list(apply ~a(remq*'(0)x)))char<?))])(equal?(h r)(h b s s g g g)))

在线尝试！

第一次在球拍打高尔夫球，因此仍在寻求改进...

说明（原始的较长版本，但想法相同）：

(λ(r b                              ; take rep and badges as arguments
     [g(λ(x)                        ; helper function g which takes a string
         (sort                      ; and returns the sorted
           (string->list x)         ; list of characters
           char<?))])               ; (sort by ascii code)
  (equal?                           ; compare...
    (g(~a r))                       ; g called on the rep converted to string
    (g                              ; and g called on...
      (string-join                  ; the concatenation of
        (map ~a                     ; the stringified elements of
             (append*               ; the flattened list given by
               (filter              ; the elements of the following list where
                 (λ(x)(>(car x)0))  ; the badge count is nonzero:
                 (map make-list     ; repeat the badge counts
                      '(1 2 3)b)))) ; 1, 2, and 3 times respectively
        ""))))

木炭，24字节

1Ｆ⁴Ｆ↨ＮχＦι⊞υκＦχ¿⁻№υι№θＩι⎚

在线尝试！链接是详细版本的代码。以rep，青铜，银，金的顺序输入，1如果rep有效，则输出。说明：

1

假设该代表是有效的。

Ｆ⁴Ｆ↨ＮχＦι⊞υκ

循环输入四个输入值。每个推值的每一位i倍，其中i是值的0索引的索引。此处使用数字基数转换，因为它可以转换0为空数组。

Ｆχ¿⁻№υι№θＩι⎚

检查数组中每个数字的计数是否与第一个输入中的数字匹配。如果有任何不同，请清除画布。

果冻，18字节

DẋṠƊ€ẋ"3RU¤FṢ⁼⁴DṢ¤

在线尝试！

这有点不好

Python 2中，80个 79 77 68字节

lambda r,g,s,b:S((g>0)*3*`g`+(s>0)*2*`s`+(b>0)*`b`)==S(`r`)
S=sorted

在线尝试！

将输入作为rep, gold, silver, bronze。

Perl -lF 5，62个字节

map{@r=sort/./g,@r if($_=<>x$_)>0}1..3;@F=sort@F;say"@r"eq"@F"

在线尝试！

将单独的行上的输入作为

reputation
bronze
silver
gold