Premisa:

Su reputación está en forma de intercambio de pila si se puede representar descomponiendo sus recuentos de medallas (oro, plata y bronce contados por separado) en sus dígitos de base 10 y uniéndolos en cualquier orden dado, con algunas advertencias.

Mientras se descompone, cada

• El dígito de la medalla de oro vale tres dígitos.
• La plata vale dos dígitos.
• El bronce es un dígito.
• Además, dado que SE no muestra un tipo de medalla si no tiene ninguno, un recuento de 0 medallas para un tipo no arrojará a [0].

Ejemplo:

• [1 Gold, 2 Silvers, 3 Bronzes]se descompondrá en [1,1,1,2,2,3]. 321112 y 213121 son dos ejemplos de un número de formulario SE para estas medallas.
• [20 Golds, 0 Silvers, 20 Bronzes]se descompondrá en [2,2,2,0,0,0,2,0]. 20002022 es un número de formulario SE.
• [11 Golds, 0 Silvers, 0 Bronzes]se descompondrá en [1,1,1,1,1,1]. 111111 es el único número de formulario SE para esto.

No habrá ceros al considerar un número SE. Por ejemplo, en el segundo ejemplo anterior, 00002222 -> 2222no se consideraría un número de formulario SE para [20,0,20].

De entrada y salida:

La entrada es una lista / tupla / matriz / cualquiera de los [reputation, gold_medals, silver_medals, bronze_medals]cuales son todos enteros no negativos. Este es el orden asumido pero se puede cambiar. Solo haz una nota en tu respuesta si lo haces.

La salida es dos valores consistentes para verdadero y falso.

Reglas:

• La entrada siempre será válida
• Siempre tendrás al menos 1 representante
• No puede tener medallas en absoluto, que siempre deberían ser falsas en ese momento.
• Los recuentos de medallas no tienen relación con la realidad. Tener varios cientos de oros y ningún bronce está bien.
• Este es el código de golf, por lo que la respuesta más corta en bytes gana.

Casos de prueba:

#[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 bytes

∞×0KJ‚€{íË

Toma la entrada de medallas en el orden [bronze, silver, gold]como primera entrada, yreputation como segunda entrada.

-1 byte gracias a @Grimy .

Pruébelo en línea o verifique todos los casos de prueba .

Explicación:

∞           # 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 bytes

Toma entrada como (['gold','silver','bronze'])('rep'). Devuelve un valor booleano.

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

Pruébalo en línea!

JavaScript (ES6), 74 bytes

Toma entrada como (gold, silver, bronze, 'rep'). Devuelve un valor booleano.

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

Pruébalo en línea!

MATL , 28 bytes 20 bytes 16 bytes 13 bytes

Devuelve 0 para falso y 1 para verdadero. Esto definitivamente se puede jugar al golf.

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

Hasta 16 bytes si la puntuación de reputación se puede tomar por separado, y el orden es [bronce, plata, oro], reputación
Hasta 13 bytes gracias a Luis Mendo

3:Y"XzVXzY@Um

Pruébalo en línea!

Rubí , 69 bytes

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

Pruébalo en línea!

J , ^{38 34} 31 bytes

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

Pruébalo en línea!

Japt , 14 13 12 bytes

íp fn ¬á øUg

Toma entrada como [rep, bronze, silver, gold]

Pruébelo o verifique todos los casos de prueba

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? 

Retina 0.8.2 , 45 bytes

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

Pruébalo en línea! El enlace incluye un conjunto de pruebas. Explicación:

,0
,

Eliminar cero puntajes.

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

Expanda los puntajes de oro y plata, y convierta el separador en una nueva línea.

%O`.

Ordene la reputación y las puntuaciones ampliadas por separado.

^(.+)¶\1$

Compara los dígitos ordenados.

Jalea , 10 bytes

xJ$¹ƇV,Ṣ€E

Pruébalo en línea!

Argumento 1: [Bronze, Silver, Gold]
Argumento 2:Rep

Raqueta, 149 107 98 bytes

(λ(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)))

Pruébalo en línea!

Golf por primera vez en Racket, así que sigo buscando mejoras ...

Explicación (de la versión original más larga, pero la misma idea):

(λ(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
        ""))))

Carbón de leña , 24 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Toma entrada en el representante de la orden, bronce, plata, oro y salidas1 si el representante es válido. Explicación:

1

Suponga que el representante es válido.

Ｆ⁴Ｆ↨ＮχＦι⊞υκ

Pase sobre los cuatro valores de entrada. Empuje cada dígito de cada valor imultiplicado por iel índice indexado 0 del valor. La conversión de base numérica se usa aquí ya que convierte0 en una matriz vacía.

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

Verifique que el recuento de cada dígito en la matriz coincida con el de la primera entrada. Si alguno difiere, limpie el lienzo.

Jalea , 18 bytes

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

Pruébalo en línea!

esto es un poco malo

Pitón 2 , 80 79 77 68 bytes

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

Pruébalo en línea!

Toma entrada como rep, gold, silver, bronze.

Perl 5 -lF , 62 bytes

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

Pruébalo en línea!

Toma entrada en líneas separadas como

reputation
bronze
silver
gold