Prémisse:

Votre réputation est sous forme d'échange de pile si elle peut être représentée en décomposant vos décomptes de médailles (or, argent et bronze comptés séparément) dans leurs chiffres de base 10 et en les joignant dans un ordre donné, avec quelques mises en garde.

Pendant la décomposition, chaque

• Le chiffre de la médaille d'or vaut trois chiffres.
• L'argent vaut deux chiffres.
• Le bronze est à un chiffre.
• De plus, puisque SE n'affiche pas de type de médaille si vous n'en avez pas, un nombre de 0 médailles pour un type ne donnera pas a [0].

Exemple:

• [1 Gold, 2 Silvers, 3 Bronzes]va se décomposer en [1,1,1,2,2,3]. 321112 et 213121 sont deux exemples d'un numéro de formulaire SE pour ces médailles.
• [20 Golds, 0 Silvers, 20 Bronzes]va se décomposer en [2,2,2,0,0,0,2,0]. 20002022 est un numéro de formulaire SE.
• [11 Golds, 0 Silvers, 0 Bronzes]va se décomposer en [1,1,1,1,1,1]. 111111 est le seul numéro de formulaire SE pour cela.

Il n'y aura pas de 0 en tête lors de l'examen d'un numéro SE. Par exemple, dans le 2ème exemple ci-dessus, 00002222 -> 2222ne serait pas considéré comme un numéro de formulaire SE pour [20,0,20].

Entrée sortie:

L'entrée est une liste / tuple / tableau / quels [reputation, gold_medals, silver_medals, bronze_medals]que soient tous les entiers non négatifs. Il s'agit de l'ordre supposé mais peut être modifié. Faites simplement une note dans votre réponse si vous le faites.

La sortie est deux valeurs cohérentes pour vrai et faux.

Règles:

• L'entrée sera toujours valide
• Vous aurez toujours au moins 1 représentant
• Vous ne pouvez pas avoir de médailles du tout, ce qui devrait toujours retourner faux alors.
• Le décompte des médailles n'a aucune incidence sur la réalité. Avoir plusieurs centaines d'or et pas de bronzes, c'est bien.
• C'est le code-golf, donc la réponse la plus courte en octets gagne.

Cas de test:

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

∞×0KJ‚€{íË

Prend l'entrée des médailles dans l'ordre [bronze, silver, gold]comme première entrée et reputationcomme deuxième entrée.

-1 octet grâce à @Grimy .

Essayez-le en ligne ou vérifiez tous les cas de test .

Explication:

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

Prend l'entrée comme (['gold','silver','bronze'])('rep'). Renvoie une valeur booléenne.

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

Essayez-le en ligne!

JavaScript (ES6), 74 octets

Prend l'entrée comme (gold, silver, bronze, 'rep'). Renvoie une valeur booléenne.

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

Essayez-le en ligne!

MATL , 28 octets 20 octets 16 octets 13 octets

Renvoie 0 pour faux et 1 pour vrai. Cela peut certainement être joué au golf.

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

Jusqu'à 16 octets si le score de réputation peut être pris séparément, et l'ordre est [bronze, argent, or], réputation
jusqu'à 13 octets grâce à Luis Mendo

3:Y"XzVXzY@Um

Essayez-le en ligne!

Rubis , 69 octets

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

Essayez-le en ligne!

J , ^{38 34} 31 octets

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

Essayez-le en ligne!

Japt , 14 13 12 octets

íp fn ¬á øUg

Prend l'entrée comme [rep, bronze, silver, gold]

Essayez-le ou vérifiez tous les cas de test

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 octets

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

Essayez-le en ligne! Le lien inclut une suite de tests. Explication:

,0
,

Supprimer les scores zéro.

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

Développez les scores d'or et d'argent et convertissez le séparateur en nouvelle ligne.

%O`.

Triez séparément la réputation et les scores étendus.

^(.+)¶\1$

Comparez les chiffres triés.

Gelée , 10 octets

xJ$¹ƇV,Ṣ€E

Essayez-le en ligne!

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

Raquette, 149 107 98 octets

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

Essayez-le en ligne!

Golf pour la première fois en raquette, donc toujours à la recherche d'améliorations ...

Explication (de la version originale plus longue, mais même idée):

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

Fusain , 24 octets

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

Essayez-le en ligne!Le lien est vers la version détaillée du code. Prend entrée dans l'ordre représentant, bronze, argent, or et sorties 1si le représentant est valide. Explication:

1

Supposons que le représentant est valide.

Ｆ⁴Ｆ↨ＮχＦι⊞υκ

Faites une boucle sur les quatre valeurs d'entrée. Appuyez sur chaque chiffre de chaque valeur ifois où iest l'index indexé 0 de la valeur. La conversion de base numérique est utilisée ici car elle convertit0 en un tableau vide.

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

Vérifiez que le nombre de chaque chiffre du tableau correspond à celui de la première entrée. En cas de divergence, nettoyez la toile.

Gelée , 18 octets

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

Essayez-le en ligne!

c'est un peu mauvais

Python 2 , 80 79 77 68 octets

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

Essayez-le en ligne!

Prend l'entrée comme rep, gold, silver, bronze.

Perl 5 -lF , 62 octets

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

Essayez-le en ligne!

Prend l'entrée sur des lignes séparées comme

reputation
bronze
silver
gold