Premessa:

La tua reputazione è in forma di scambio di stack se può essere rappresentata decomponendo i conteggi delle medaglie (oro, argento e bronzo conteggiati separatamente) nelle loro cifre di base 10 e unendoli in qualsiasi ordine dato, con alcuni avvertimenti.

Durante la decomposizione, ciascuno

• La cifra della medaglia d'oro vale tre cifre.
• L'argento vale due cifre.
• Il bronzo è una cifra.
• Inoltre, poiché SE non mostra un tipo di medaglia se non ne hai, un conteggio di 0 medaglie per un tipo non produrrà a [0].

Esempio:

• [1 Gold, 2 Silvers, 3 Bronzes]si decompone in [1,1,1,2,2,3]. 321112 e 213121 sono due esempi di un numero di modulo SE per queste medaglie.
• [20 Golds, 0 Silvers, 20 Bronzes]si decompone in [2,2,2,0,0,0,2,0]. 20002022 è un numero di modulo SE.
• [11 Golds, 0 Silvers, 0 Bronzes]si decompone in [1,1,1,1,1,1]. 111111 è l'unico numero di modulo SE per questo.

Non ci saranno 0 iniziali quando si considera un numero SE. Ad esempio, nel secondo esempio sopra, 00002222 -> 2222non sarebbe considerato un numero di modulo SE per [20,0,20].

Input Output:

L'input è un elenco / tupla / matrice / qualunque dei [reputation, gold_medals, silver_medals, bronze_medals]quali siano tutti numeri interi non negativi. Questo è l'ordine ipotizzato ma può essere modificato. Se lo fai, prendi nota nella tua risposta.

L'output è due valori coerenti per true e false.

Regole:

• L'input sarà sempre valido
• Avrai sempre almeno 1 rappresentante
• Non puoi avere medaglie, che dovrebbe sempre restituire false.
• Il conteggio delle medaglie non ha alcuna attinenza con la realtà. Avere diverse centinaia di ori e niente bronzi va bene.
• Questo è code-golf, quindi la risposta più breve in byte vince.

Casi 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 byte

∞×0KJ‚€{íË

Prende le medaglie inserite nell'ordine [bronze, silver, gold]come primo input e reputationcome secondo input.

-1 byte grazie a @Grimy .

Provalo online o verifica tutti i casi di test .

Spiegazione:

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

Accetta input come (['gold','silver','bronze'])('rep'). Restituisce un valore booleano.

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

Provalo online!

JavaScript (ES6), 74 byte

Accetta input come (gold, silver, bronze, 'rep'). Restituisce un valore booleano.

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

Provalo online!

MATL , 28 byte 20 byte 16 byte 13 byte

Restituisce 0 per falso e 1 per vero. Questo può sicuramente essere risolto.

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

Fino a 16 byte se il punteggio di reputazione può essere preso separatamente e l'ordine è [bronzo, argento, oro], reputazione
fino a 13 byte grazie a Luis Mendo

3:Y"XzVXzY@Um

Provalo online!

Rubino , 69 byte

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

Provalo online!

J , ^{38 34} 31 byte

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

Provalo online!

Japt , 14 13 12 byte

íp fn ¬á øUg

Accetta input come [rep, bronze, silver, gold]

Provalo o Verifica tutti i casi di 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 byte

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

Provalo online! Il link include la suite di test. Spiegazione:

,0
,

Elimina zero punteggi.

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

Espandi i punteggi di oro e argento e converti il ​​separatore in una nuova riga.

%O`.

Ordinare la reputazione e i punteggi espansi separatamente.

^(.+)¶\1$

Confronta le cifre ordinate.

Gelatina , 10 byte

xJ$¹ƇV,Ṣ€E

Provalo online!

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

Racchetta, 149 107 98 byte

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

Provalo online!

Giocare a golf per la prima volta in Racchetta, quindi alla ricerca di miglioramenti ...

Spiegazione (della versione originale più lunga, ma stessa 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
        ""))))

Carbone , 24 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Riceve input nell'ordine rep, bronzo, argento, oro e output 1se il rappresentante è valido. Spiegazione:

1

Supponiamo che il rappresentante sia valido.

Ｆ⁴Ｆ↨ＮχＦι⊞υκ

Passa attraverso i quattro valori di input. Premere ogni cifra di ciascun valore per ogni ivolta che si itrova l'indice 0-indicizzato del valore. La conversione numerica di base viene utilizzata qui in quanto converte 0in un array vuoto.

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

Verificare che il conteggio di ciascuna cifra dell'array corrisponda a quello del primo input. Se presenti differenze, cancella la tela.

Gelatina , 18 byte

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

Provalo online!

questo è un po ' male

Python 2 , 80 79 77 68 byte

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

Provalo online!

Accetta input come rep, gold, silver, bronze.

Perl 5 -lF , 62 byte

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

Provalo online!

Accetta input su righe separate come

reputation
bronze
silver
gold