Diciamo che una stringa non è discriminatoria se ciascuno dei caratteri della stringa appare lo stesso numero di volte e almeno due volte.

Esempi

• "aa!1 1 !a !1"è non discriminante , perché ciascuno dei personaggi , !, ae 1appaiono tre volte.
• "abbaabb"non è non discriminatorio perché bappare più spesso di a.
• "abc"inoltre non è discriminatorio perché i personaggi non appaiono almeno due volte.

Compito

Scrivere un programma o una funzione non discriminante che restituisca un valore di verità se una determinata stringa non è discriminatoria e un valore di falsa in caso contrario.

Cioè, il programma eseguito sul proprio codice sorgente dovrebbe restituire un valore di verità.

Ogni invio deve essere in grado di gestire stringhe non vuote contenenti ASCII stampabile , nonché tutti i caratteri che compaiono nel codice sorgente dell'invio.

Casi test

Truthy:

<your program's source code>
"aaaa"
"aa!1 1 !a !1"
"aabbccddeeffgg"
"1Q!V_fSiA6Bri{|}tkDM]VjNJ=^_4(a&=?5oYa,1wh|R4YKU #9c!#Q T&f`:sm$@Xv-ugW<P)l}WP>F'jl3xmd'9Ie$MN;TrCBC/tZIL*G27byEn.g0kKhbR%>G-.5pHcL0)JZ`s:*[x2Sz68%v^Ho8+[e,{OAqn?3E<OFwX(;@yu]+z7/pdqUD"

Falsy:

"a"
"abbaabb"
"abc"
"bQf6ScA5d:4_aJ)D]2*^Mv(E}Kb7o@]krevW?eT0FW;I|J:ix %9!3Fwm;*UZGH`8tV>gy1xX<S/OA7NtB'}c u'V$L,YlYp{#[..j&gTk8jp-6RlGUL#_<^0CCZKPQfD2%s)he-BMRu1n?qdi/!5q=wn$ora+X,POzzHNh=(4{m`39I|s[+E@&y>"

Brachylog , 10 byte

=ᵍbᵐbᵐlᵍ=l

Provalo online!

Spiegazione

=ᵍ                Group all equal elements together
  bᵐbᵐ            Remove the first element of each group twice. This fails if
                  there are fewer than 2 elements
      lᵍ          Group elements together that have the same length
        =         Are all elements of that list equal? This only succeeds if the
                  list has one element
         l        Length. This will always succeed

Java 8, 198 192 186 174 168 165 160 byte (conteggio caratteri 6 5)

o->{byte x[]=new byte[+333-3|2],u=-0,i,fe,fi,w; s:w:no0r3sswwyyy:for(int s:o){{u=++x[s];}};for(int b:x){if(!!!(2>b||u==b)|2>u|2>2){x[0]++;}}return!!(0>--x[0]);}

Provalo online.
Il codice utilizzato per verificare le occorrenze dei personaggi , che è stata la mia risposta a questa sfida .

-5 byte grazie a @ OlivierGrégoire di nuovo eliminando il commento e facendo casino. ;)

I vecchi 168 byte (numero di caratteri 6) rispondono :

o->{int w[]=new int[2222],u=0,f=0;for(int r:o)u=++w[r];for(int e:w)if(!(2>e|u==e)|2>u)f++;return!(f>0);}//[[[]]]  !!!!e(i)++,,,,-----oo////000tuww::::{{{{{;;||||}}}}}>>

Provalo online.
Il codice utilizzato per verificare le occorrenze dei caratteri escluso il commento , che è stata la mia risposta a questa sfida .

-6 byte grazie alla rimozione di @ OliverGrégoire< scambiando i controlli in >.

Spiegazione del programma di golf base (98 byte):
Provalo online.

s->{                     // Method with character-array parameter and boolean return-type
  int a[]=new int[256],  //  Occurrences integer-array containing 256 zeroes
      t=0,               //  Temp integer, starting at 0
      f=0;               //  Flag integer, starting at 0
  for(int c:s)           //  Loop over the input
    t=++a[c];            //   Increase the occurrence-counter of the current character
                         //   And set the temp integer to this value
  for(int i:a)           //  Loop over the integer-array
    if(i>1               //   If the value is filled (not 0) and at least 2,
       &i!=t             //   and it's not equal to the temp integer
       |t<2)             //   Or the temp integer is lower than 2
      f++;               //    Increase the flag-integer by 1
  return f<1;}           //  Return whether the flag integer is still 0

Alcune cose che ho fatto per ridurre la quantità di personaggi usati:

• I nomi delle variabili o, w, u, f, r, e esono stati scelti apposta per riutilizzare i personaggi che abbiamo già avuto (ma non superiore a 6).
• 2222viene utilizzato al posto di 256.
• Modificato l'if-check e>0&u!=e|u<2in !(e<2|u==e)|u<2per rimuovere 6x &.
• Rimossi i due ritorni separati e usato un flag f, e restituiamo se è ancora 0 alla fine (questo significa che potrei rimuovere il 6x byda byteora che usiamo solo nin int6 volte invece di 8).
• e<2e u<2modificato in 2>ee 2>uper rimuovere 6x <.

Cosa ho fatto per ridurre il conteggio dei caratteri da 6 a 5:

• 2x inta bytecosì la quantità di nusato è 4 invece di 6.
• Usato al x[0]posto di una nuova variabile, f=0quindi la quantità di =utilizzo è 5 anziché 6.
• Modificato 2222in 3333modo che la quantità di 2usato sia 2 invece di 6.
• Variabili modificate fe di rnuovo quindi non sono più 6.

Cosa ha fatto @OlivierGrégoire per sbarazzarsi del commento, e quindi del 5x /:

• Aggiunta di variabili non utilizzate ,i,fe,fi,w;.
• L'aggiunta di etichette non utilizzate: s:w:no0r3sswwyyy:.
• Aggiunta inutilizzata |2>2
• Aggiunta {}intorno ai for-loop e ifs e aggiunta un {}blocco inutilizzato .
• Passare !a !!!.
• Passare |a ||.
• Cambiando 333in +333-3|2per sbarazzarsi degli operatori aritmetici rimanenti +-|e del 2.
• Passare !(x[0]>0)a !!(0>--x[0]).

Gelatina , 18 16 12 10 byte

Ġ¬zḊḊ¬zĠȦȦ

Provalo online!

Come funziona

Ġ¬zḊḊ¬zĠȦȦ  Main link. Argument: s (string)

Ġ           Group the indices of s by their corresponding elements.
            "abcba" -> [[1, 5], [2, 4], [3]]

 ¬          Take the logical NOT of each 1-based(!) index.
            [[1, 5], [2, 4], [3]] -> [[0, 0], [0, 0], [0]]

   Ḋ        Dequeue; yield s without its fist element.
            "abcba" -> "bcba"

  z         Zip-longest; zip the elements of the array to the left, using the
            string to the right as filler.
            ([[0, 0], [0, 0], [0]], "bcba") -> [[0, 0, 0], [0, 0, "bcba"]]

    Ḋ       Dequeue; remove the first array of the result.
            This yields an empty array if s does not contain duplicates.
            [[0, 0, 0], [0, 0, "bcba"]] -> [[0, 0, "bcba"]]

    ¬       Take the logical NOT of all zeros and characters.
            [[0, 0, "bcba"]] -> [[1, 1, [0, 0, 0, 0]]]

      Ġ     Group.

     z      Zip-longest. Since all arrays in the result to the left have the same
            number of elements, this is just a regular zip.
            [[1, 1, [0, 0, 0, 0]]] -> [[1], [1], [[0, 0, 0, 0]]

       Ȧ    Any and all; test if the result is non-empty and contains no zeroes,
            at any depth. Yield 1 if so, 0 if not.
            [[1], [1], [[0, 0, 0, 0]] -> 0

        Ȧ   Any and all.
            0 -> 0

Brachylog , 14 12 byte

ọtᵐℕ₂ᵐ==tℕ₂ọ

Provalo online!

Spiegazione

ọ   Occurrences. Gives a list of [char, count] pairs for the entire input.
tᵐ  Map "tail" over this list, giving each character count.
ℕ₂ᵐ Make sure that each count is at least 2.
=   Make sure that all counts are equal.
    At this point we're done with the actual code, but we need another copy
    of each character (except ᵐ). We can just put them after this, as long as
    we make sure that they can never cause the predicate to fail.
=   Make sure that all counts are equal, again...
t   Extract the last count.
ℕ₂  Make sure that it's at least 2, again...
ọ   Get the digit occurrences in that count, this can't fail.

Soluzione alternativa a 12 byte che riutilizza tinvece di ᵐ:

ọtᵐ==tℕ₂ℕ₂ọᵐ

T-SQL, 320 byte (32 caratteri x 10 ciascuno)

L'input avviene tramite tabella preesistente FILLcon campo varchar STEW, secondo i nostri standard IO .

WITH BUMPF AS(SeLeCT GYP=1
UNION ALL
SeLeCT GYP+1FROM BUMPF
WHeRe GYP<=1000)SeLeCT
IIF(MIN(WAXBY)<MAX(WAXBY)OR
MAX(WAXBY)<=1,+0,+1)FROM(SeLeCT
WAXBY=COUNT(1),WHICH=+1+0,HEXCHANGE=+01,HUNG=+0+1,CHLUB=+0,GEFF=+0FROM
BUMPF,FILL WHERE
GYP<=LEN(STEW)GROUP BY
SUBSTRING(STEW,GYP,1))CHEXX
OPTION(MAXRECURSION 0)----------<<<<<<

Non sono mai stato più contento, eppure inorridito, da un pezzo di codice.

Deve essere eseguito su un server o database impostato su regole di confronto sensibili al maiuscolo / minuscolo. Esistono 10 caratteri 32 ciascuno, inclusi maiuscolo e minuscolo E(i comandi SQL non fanno distinzione tra maiuscole e minuscole , quindi ne capovolgono alcuni se necessario), spazi e tabulazioni (le tabulazioni vengono visualizzate come interruzioni di riga nel codice sopra, per leggibilità).

Ho trovato il modo di includere 10 ciascuno degli altri simboli + = ,nel codice, ma sfortunatamente non sono riuscito a trovare un modo per farlo <, quindi ho dovuto aggiungere il carattere di commento -.

Ecco il codice formattato prima di riempire tutto il filler extra:

WITH b AS (SELECT g=1 UNION ALL SELECT g+1 FROM b WHERE g<1000)
SELECT IIF(MIN(w)<MAX(w) OR MAX(w)<1+1,0,1)
FROM(
    SELECT w=COUNT(1), --extra constant fields here are ignored
    FROM b, fill
    WHERE g < 1+LEN(stew)
    GROUP BY SUBSTRING(stew,g,1)
)a OPTION(MAXRECURSION 0)

La riga superiore è un CTE ricorsivo che genera una tabella numerica b, che uniamo alla stringa di origine per separare per carattere. Questi caratteri vengono raggruppati e conteggiati e l' IIFistruzione restituisce 0 o 1 a seconda che la stringa di input non sia discriminatoria.

C (gcc) ,  333  168 byte

Grazie a @Kevin Cruijssen per aver salvato 9 byte e grazie a @Laikoni per aver salvato 45 byte!

f(r,h,a){char*o=r,c[222]={!o};for(a=!o;*o;)++c[*o++];for(h=!o;222/++h;c[h]&&c[h]!=a&&(a=!*c))!a&&c[h]&&(a=c[h]);r=!(2/2/a);}/////!(())****++,,,,,[[]]fffffrr{{{{{{}}}}}}

Provalo online!

C, 333 byte

i,v;f(S){char*s=S,L[128]={0};for(v=0;*s;)++L[*s++];for(i=-1;++i<128;L[i]&&L[i]-v?v=-1:0)!v&&L[i]?v=L[i]:0;return-v<-1;}/////////!!!!!!!!&&&&&(((((())))))******+++,,,,,,,----00000111122222228888888:::::::<<<<<<<===???????LLLSSSSSSS[[[]]]aaaaaaaacccccccceeeeeeeeffffffhhhhhhhhiinnnnnnnnooooooorrrrssssssttttttttuuuuuuuuvv{{{{{{{}}}}}}}

Anche il bytecount non è discriminatorio!

Provalo online!

05AB1E , 20 18 16 14 byte

S¢Z≠sË*sZ¢≠SË*

Provalo online!

Il programma è essenzialmente diviso in 2 parti in cui l'obiettivo della prima parte è svolgere il compito effettivo e l'obiettivo della seconda parte è utilizzare le stesse funzioni della prima parte senza alterare il risultato.

Spiegazione (prima parte)

S          # push input split into list of chars
 ¢         # count the occurrence of each char in input
  Z≠       # check that the max count is not 1
    sË     # check if all counts are equal
      *    # multiply

Spiegazione (seconda parte)

s          # swap input to top of stack
 Z¢        # count the number of occurrences of the largest element
   ≠       # check that the count isn't 1
    SË     # split into list and check that each element are equal (always true)
      *    # multiply (as it is with 1, the original result is left unchanged)

Buccia , 14 byte

§<ε#εu§m#u
m
<

Provalo online!

Spiegazione

Le due linee brevi non sono operative, poiché la funzione principale non le chiama mai.

§<ε#εu§m#u  Implicit input, say S = "asasdd"
         u  Remove duplicates: "asd"
      §m#   For each, get number of occurrences in S: [2,2,2]
     u      Remove duplicates: L = [2]
   #ε       Number of elements in L that are at most 1: 0
  ε         1 if L is a singleton, 0 otherwise: 1
§<          Is the former value smaller than the latter?

Python 2 , 75 69 byte

def f(s):len({2<<s.count(c)-2for c,in s})<2or{{e.dil:-tu,r.dil:-tu,}}

L'output avviene tramite presenza o assenza di un errore. L'errore è un ValueError (uno o più caratteri si presentano una sola volta) o un NameError (il conteggio dei caratteri non è uguale).

Provalo online!

Brachylog v2, 8 byte (nel set di caratteri di Brachylog)

oḅ\k\koḅ

Provalo online!

Sembra che ci sia stata una guerra del golf in corso su questa domanda in Brachylog, quindi ho pensato di unirmi, salvando un paio di byte sulla prossima migliore risposta.

Questo è un programma completo che accetta input come un elenco di codici carattere. (Questo in parte perché Brachylog sembra avere alcuni bizzarri bug relativi alle barre rovesciate nelle stringhe e in parte perché il \comando non funziona su elenchi di stringhe.)

Spiegazione

oḅ\k\koḅ
o          Sort {standard input}
 ḅ         Group identical adjacent values
  \        Assert rectangular; if it is, swap rows and columns
   k       Delete last element
    \      Assert rectangular; (rest of the program is irrelevant)

Il koḅalla fine è irrilevante; kavrà sempre un elemento su cui agire oe ḅnon può fallire se viene fornito un elenco come input.

La ragione per l'avvio oḅdovrebbe essere chiara; suddivide l'elenco di input in base al valore, ad esempio [1,2,1,2,4,1]diventerebbe [[1,1,1],[2,2],[4]]. Affinché ogni personaggio appaia lo stesso numero di volte, ognuna di queste liste deve avere la stessa lunghezza, ovvero l'elenco risultante è un rettangolo. Possiamo affermare questa rettangolarità usando \, che traspone anche le righe e le colonne come effetto collaterale.

Ora abbiamo un valore corrente costituito da più copie del set di caratteri, ad esempio se l'input fosse [4,2,1,2,4,1]il valore corrente sarebbe [[1,2,4],[1,2,4]]. Se eliminiamo una copia, la matrice risultante è ancora rettangolare, quindi possiamo tornare indietro usando \. Tuttavia, se il motivo la matrice era rettangolare era che tutti i caratteri immessi erano distinte, la matrice risultante non hanno elementi di sinistra, e \non non trattare una matrice "0 × 0" come rettangolare (piuttosto, fallisce). oḅ\k\Afferma così efficacemente che ogni carattere che appare nell'input appare lo stesso numero di volte e quel numero di volte non è 1.

Questa è l'intera funzionalità del nostro programma (come programma completo, otteniamo truese non si sono verificati errori di asserzione, falsese alcuni lo hanno fatto). Dobbiamo obbedire alla restrizione del layout di origine, tuttavia, quindi ho aggiunto un ulteriore koḅche non ha scopo ma che non può fallire (a differenza di \, oe ḅsono felice di agire su liste vuote).

Python 2 , 84 80 byte

x=input()
c=map(x.count,x)
print max(c)==min(c)>1
1. or our>ram>>utopia,
1., 1.,

Provalo online!

JavaScript (Node.js) , 144 ... 100 96 byte

o=>!(a=o.split``.map(i=>o.split(i||aeehhhlmmnnnpst)[`length`]-1)).some(g=>![g>1][-!1]||a[-!1]-g)

Provalo online!

24 caratteri diversi * 6 volte ciascuno

28 caratteri diversi * 5 volte ciascuno

27 personaggi diversi * 5 volte ciascuno

27 personaggi diversi * 4 volte ciascuno

26 personaggi diversi * 4 volte ciascuno

25 personaggi diversi * 4 volte ciascuno

24 personaggi diversi * 4 volte ciascuno

Spiegazione

o=>!(
 a=o.split``.map(                            // Split the input into character array and
  i=>o.split(i||aeehhhlmmnnnpst)[`length`]-1 // count the occurrences of each character.
 )
).some(                                      // Then check
 g=>![g>1][-!1]                              // If each character appears at least twice
 ||a[-!1]-g                                  // and the counts are all the same number.
)                                            

More to add:
1. Using {s.split``} instead of {[...s]} is to reduce the number of {.} that dominates
   the count.
2. Using {!c.some} instead of {c.every} to reduce the number of inefficient characters 
   (v,r,y in every)
3. Still one unavoidable inefficient character left ({h}).

Update:
1. Got rid of one {.} by replacing {.length} by {["length"]}.
2. Got rid of one {=} by replacing {c[-!1]!=g} by {c[-!1]-g}.
3. Got rid of one {()} by replacing {!(g>1)} by {![g>1][-!1]}.
4. Finally, because count per character is now 4, the backslashes can be taken out.

Update:
1. Got rid of all {"} by replacing {"length"} by {`length`} and exploiting shortcut
   evaluation. 
   {aaaeehhhlmmnnnpst} is not defined but is not evaluated either because of {c} which
   must be evaluated to true.

Update:
1. Got rid of all {c} by shortcutting the undefined variable at {split(i)} and replacing 
   all {c} by {a}.
   Since {i} is never an empty string, it is always evaluated true (except compared 
   directly to true).

Update:
1. Got rid of all {,} by moving the assignment after the argument list. The {()} at the
   front can therefore be moved to the assignment, retaining same number of {()}s.

PowerShell , 104 byte

($qe=$args[0]| group |sort count|% count)[0]-eq$qe[-1]-and$qe[0]-gt1####((()))%%%pppddd===aaccss11nu|0gr

Provalo online!

È stato molto divertente giocare a golf. Il limite era $, di cui abbiamo bisogno di almeno quattro (uno per l'input $args, uno per assegnare il risultato del calcolo $qe, uno per il controllo dell'ultimo carattere $qe[-1]e uno per il controllo del primo carattere $qe[0], quindi quello era il numero massimo di caratteri funzionante.

Da lì, è stata una questione di golf (e non golf, come avere un nome variabile di due lettere) per rendere il programma ben divisibile per quattro. Si noti che abbiamo un piccolo commento (tutto ciò che segue #) per tenere conto di alcuni elementi mancanti, ma ho cercato di mantenere il commento il più piccolo possibile.

Haskell, 90 75 72 byte

a[i]|d:n<-[[i|n<-i,n==a]|a<-i]=and[[i]<d,[d|i<-n]==n]--aadd,,,,:::::<=||

Ogni personaggio appare 6 volte. La stringa di input viene considerata come un elenco singleton .

Provalo online!

Per riferimento, vecchie versioni:

75 byte, ogni carattere 5 volte

n(l)|d<-[[0|n<-l,n==a]|a<-l]=and[[0]<d!!0,all(==d!!0)d]--an!((())),,,0<[]||

Provalo online!

90 byte, ogni carattere 3 volte:

a x|h:u<-[sum[1|d<-x,not(d/=c)]|c<-x],"  \"\\&,../1::>acdlmmnosst">[]=h>1&&all(not.(/=h))u

Provalo online!

Python 2 , 108 104 92 88 byte

-12 byte grazie a Rod
-4 byte grazie a Kevin Cruijssen

s=input();c=s.count;print[all(c(s[[]>[1]])==c(o)>1. for o in s)];aaafffillpprrtuu>1.>1.;

Provalo online!

MATL , 12 byte

q&=sqt&=tsvv

L'input è una stringa racchiusa tra virgolette singole. Le virgolette singole nella stringa vengono salvate duplicando.

L'output è una matrice non vuota, che è veritiera se non contiene zeri ed è falsa se contiene almeno uno zero.

Provalo online! Oppure verifica tutti i casi di test , incluso il test di veridicità / falsità standard per praticità.

Come funziona

Le dichiarazioni contrassegnate con (*)non sono né necessarie né dannose e sono state incluse solo per rendere il codice sorgente non discriminatorio.

q     % Implicit input. Convert chars to code points and subtract 1 from each (*)
&=    % Square matrix of all pairwise equality comparisons
s     % Sum of each column. Gives a row vector
q     % Subtract 1 from each value. An entry equal to 0 indicates the input string
      % is discriminating because some character appears only once
t     % Duplicate
&=    % Square matrix of all pairwise equality comparisons. An entry equal to 0
      % indicates the input string is discriminating because some character is
      % more repeated than some other
t     % Duplicate (*)
s     % Sum of each column (*) (all those sums will be positive if the previous
      % matrix doesn't contain zeros)
v     % Vertically concatenate the matrix and the vector of its column sums
v     % Vertically concatenate the resulting matrix with nothing (*)
      % Implicit display

Perl 5 , -p57 byte

Ogni personaggio appare 3 volte. Solo un singolo 1non fa nulla

12 byte aggiunti a una soluzione base di 45 caratteri per renderli non discriminatori

s{.}[@m[@1{$&}+=$.].=g]eg;$\=s()(e@m;1)&&m[e(\sg+)\1+;]}{

Provalo online!

R , 90 byte

"?"=`u\164f8ToI\x6Et`;'!'=prod;!{y<-xtabs(~?readLines())}%in%{z<-y[1]}&z>T##&[]>~48bEfILpu

Provalo online!

Output TRUEper una stringa non discriminante e FALSEper una stringa discriminante. Ho scritto un sacco di brutti codici per le sfide su questo sito, ma penso che questo sia il più brutto finora.

45 caratteri, usati due volte ciascuno (inclusi alcuni in un commento). La migliore risposta R precedente era di 116 byte , con 29 caratteri usati 4 volte ciascuno; Sto pubblicando questo separatamente poiché è sostanzialmente diverso.

Il codice è equivalente a

y = table(utf8ToInt(readLines()))
z = y[1]
all(y == z) & (z > 1)

che converte l'input in un vettore di numeri interi, calcola una tabella ydi contingenza dei valori, quindi verifica che tutti i conteggi in quella tabella siano uguali al primo conteggio e che il primo conteggio sia maggiore di 1.

La difficoltà iniziale era di usare solo 2 coppie di parentesi. Questo si ottiene ridefinendo le funzioni unarie !e ?di essere utf8ToInte prodrispettivamente. (Non posso usare allperché ho bisogno di a). Ci sono quattro compiti: due con =e due con <-. Ciò significa che il test di uguaglianza tra ye znon può usare y==zné y-z; y%in%zviene in soccorso.

La definizione di queste funzioni utilizza tutte le virgolette possibili: due virgolette doppie, due virgolette singole e nel paragrafo successivo avrò bisogno dei due backtick, quindi ho dovuto ricorrere a readLines()invece di scan(,""). (Le altre opzioni, come scan(,letters)o scan(,month.abb)tutte hanno usato un prezioso t che non potevo risparmiare.)

A questo punto, ho avuto la maggior parte degli elementi costitutivi: utf8ToInt, prod, table, readLines, %in%. Tre personaggi appaiono tre volte in quei nomi: ent. Innanzitutto, ho scoperto che table(foo)equivale a xtabs(~foo), salvando il file e. Posso salvare il ne il tcon il trucco del codice esadecimale / ottale ; la soluzione più golfosa è usare u\164f8ToI\x6Et(nei backtick) per utf8ToInt.

Brachylog , 18 byte

oḅlᵐ=h≥2
oḅlᵐ=h≥2

Provalo online!

Sfortunatamente, non riesco a rimuovere gli avanzamenti di riga, poiché ḅsu un numero provoca un errore.

Rubino , 87 78 byte

c=->m{y=m.chars;x=y.map{|d|y.count d}|[];x[-1]>1and not x[1]};->{pushrortpush}

26 caratteri ripetuti 3 volte ciascuno

Provalo online!

R, 132 116 byte

crudcardounenforceableuploads<-function(b){{pi&&pi[[1-!1]];;;"";{1<{f<<-table(strsplit(b,"",,,)[[1]])}}&&!!!sd(-f)}}

Non contiene commenti o stringhe superflue, anche se questa sarà probabilmente la mia unica volta nel golf del codice che chiama una funzione crudcardounenforceableuploads. C'è probabilmente un grande anagramma lì dentro da qualche parte per il nome della funzione! Grazie a John Dvorak per avermi segnalato un bel risolutore di anagrammi, che ho usato per il nome.

Tabella dei caratteri:

- , ; ! " ( ) [ ] { } & < 1 a b c d e f i l n o p r s t u 
4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4

esempi:

> crudcardounenforceableuploads("aaabbbccc")
[1] TRUE
> crudcardounenforceableuploads("aaabbbcc")
[1] FALSE
> crudcardounenforceableuploads("abc")
[1] FALSE
> crudcardounenforceableuploads("crudcardounenforceableuploads<-function(b){{pi&&pi[[1-!1]];;;\"\";{1<{f<<-table(strsplit(b,\"\",,,)[[1]])}}&&!!!sd(-f)}}")
[1] TRUE

BASH 144 byte

grep -o .|sort|uniq -c|awk '{s=$1}{e[s]=1}END{print((s>1)*(length(e)==1))}##>>>#|'#wwwuuutrqqqppooNNNnlllkkkiihhhggEEEDDDcccaaa1***{}[[[]]]...--''

Questa riga di codice accetta una stringa stdin come input. "grep -o." mette ogni personaggio su una nuova riga. "uniq -c" conta l'utilizzo di ogni capitolo. Lo script awk crea un array con ogni utilizzo come elemento diverso e restituisce true quando esiste un solo indice di array e il valore è almeno 2. Ogni carattere viene utilizzato 4 volte, quindi questa sorgente restituisce true

Stax , 26 24 18 byte

:u{m*_{y#m:u_hy#h*

Provalo online!

La soluzione più breve finora che utilizza solo ASCII stampabili battuti da MATL.

Suppongo che stavo affrontando il problema nel modo sbagliato. Ripetere un blocco di lavoro non è né goloso né interessante. Ora almeno sembra meglio ...

Spiegazione

:u{m* produce alcuni rifiuti che non influiscono sull'output.

_{y#m:u_hy#h*
_{y#m           map each character to its number of occurences in the string
     :u         all counts are equal (result 1)
       _hy#     get the count of appearance for the first character
           h    halve it and take the floor, so that 1 becomes 0(result 2)
            *   multiply the two results

Pip , 22 byte

I1&MY$=_Y_NaMa$=y&1NIy

Provalo online!

Spiegazione

Ogni personaggio si presenta due volte.

                        a is first command-line argument
I1&MY$=_                No-ops to make the program non-discriminating
            Ma          Map this function to the characters of a:
         _Na             Count occurrences of each character in a
        Y               Yank the result into y
              $=y       Fold y on equals: truthy if all elements are equal
                 &      Logical and
                  1NIy  1 is not in y
                        Autoprint the result of the last expression

Versione alternativa a 22 byte con meno no-op:

$&MY_Y_NaMa$=y&--1=1Ny

SmileBASIC, 164 152 148 140 byte

DeF M(X)DIM W[#R]WHILE""<X
INC w[ASC(x)]X[n]=""wEND
FOR F=e#TO--nOT-LEN(W)U=w[F]H=H||U&&U<MAx(W)neXT-!!!AASSS#&&Oxx||CCLL<<wIM#
RETURN!H
enD

35 personaggi diversi, ripetuti 4 volte ciascuno.

Non sono stati utilizzati commenti (ma l'espressione dopo neXTnon viene mai effettivamente valutata)

Script per controllare le risposte:

//javascript is a convenient language that I love using!
var input=document.getElementById("input");
var button=document.getElementById("button");
var output=document.getElementById("output");

button.onclick=function(){
  var text=input.value;
  var freqs={};
  for(var i=0;i<text.length;i++){
    var letter=text.charAt(i);
    if (freqs[letter]==undefined) freqs[letter]=0
    freqs[letter]++
  }
  sorted=Object.keys(freqs).sort(function(a,b){return freqs[b]-freqs[a]})
  var out="";
  var min=Infinity,max=0;
  for (var i in sorted) {
    var letter=sorted[i];
    var count=freqs[letter];
    if(count<min)min=count;
    if(count>max)max=count;
    out+="\n"+letter+":"+count;
  }
  output.textContent="min:"+min+"\nmax:"+max+"\nunique:"+sorted.length+"\nlength:"+text.length+out;
}

<textarea id="input" placeholder="code here"></textarea>
<button id="button"butt>count</button>
<pre id="output">...</pre>

Retina 0.8.2 , 168 90 byte

L'output sarà vuoto se falso o non vuoto se vero.

***???;;;;```!!$$$$MMMMOOOO..1111ssss222{{{{\^^^^

s;{O`.
M!*\`^((.)\2(?!\2))*$
(.)(?!\1)

Provalo online

Programma principale (39 byte)

s;{O`.
M!*\`^((.)\2(?!\2))*$
(.)(?!\1)

Spiegazione

L'intero programma principale è in un ciclo silenzioso. Il primo stadio ordina l'ingresso. Il secondo stadio stamperà la stringa corrente se è composta da coppie successive di caratteri diversi. Il terzo stadio rimuove l'ultima occorrenza di ogni carattere (rimuovendo uno di ogni carattere nella stringa).

Informazioni sulla spazzatura in alto: l'ordine è importante. Oltre a dover essere sintatticamente valido, un punto e virgola deve essere dopo gli asterischi e prima dei backtick, purché *si trovi nella stringa di configurazione, affinché non venga stampato.

CoffeeScript 1 , 96 93 90 byte

(q,a=q.split(h).length-1for h in[q][0])->a.every (w,s,pplitnggffoorsvvyy)->w>1&&a[0&10]==w

Provalo online!

Iniziato dalla mia risposta ES6 ma tornato all'utilizzo Array.every. 32 31 30 token @ 3 ciascuno

Pyth, 30 byte

  "&8<MQSlqr{"&q1lJ{hMrSz8<1hJ

Spazi guida necessari.

Provalo online!

Il programma attuale è giusto &q1lJ{hMrSz8<1hJ. Ho appena anteposto la stringa "&8<MQSlqr{"per renderla non discriminatoria. Ma per evitare che la stringa si stampasse da sola, ho dovuto aggiungere uno spazio, quindi ho aggiunto 2 spazi.

&q1lJ{hMrSz8<1hJ

 q1l                (1 == len(
    J{                  J = deduplicate(
      hM                  map(lambda a: a[0],
        r  8                length_encode(
         Sz                   sorted(input())
                            )
                          )
                        )
                    )
&                     and
            <1hJ    (1 < J[0])

length_encodequi ( r <any> 8) prende una sequenza e produce la lunghezza di ogni corsa dello stesso carattere, es. "aaabbcc"diventa [[3, "a"], [2, "b"], [2, "c"]].

Quindi, questo accetta l'input, lo ordina per inserire la codifica in lunghezza e accetta il primo elemento di ciascun elenco nell'elenco risultante (ad esempio, l'esempio precedente diventerebbe [3, 2, 2]). Questo fornisce un conteggio di quante volte si verificano i personaggi. Quindi viene deduplicato (l'esempio precedente sarebbe diventato [3, 2]) e J è impostato su quello.

Quindi controlla se la lunghezza è 1, ovvero c'è solo 1 numero univoco di volte in cui si verifica un carattere e se questo è> 1, ovvero> = 2.

Potrebbe esserci un built-in da sostituire rSz8o hMrSz8ma non riesco a trovarne uno.

C (gcc) , 153 byte

f(h,a,c,f){{{{{{{char*o=f=h,*r;for(a=!h;*o;o++){for(c=!h,r=h;*r;c+=!(*r++^*o)){}f*=!!(c^!!h)*(!a+!(a^c));a=c;}(a^c^c^f^f^h)+o,a+r,o,o,+h^*r;(a=f);}}}}}}}

Provalo online!

Restituisce l'indirizzo della stringa come valore di verità e zero come falsa.

f(
h,                              Address of string.
a,                              # instances of previous character
c,                              # instances of current character
f                               Return value
){{{{{{{                        
char*o=f=h,*r;                  Point o to string, while giving f a non-zero value.
for(a=!h;*o;o++){               Set previous char count to 0, and then traverse the string.
for(c=!h,r=h;*r;                Set current char count to 0 and r to string,
                                and start counting instances of current character.
c+=!(*r++^*o))                  Add to counter if current character matches.
{}                              Lower the amount of semi-colons
f*=                             Multiply (AND) return value with:
   !!(c^!!h)                    Is current count not 1? (Must be 2 or above.)
            *(!a+!(a^c));       AND, is previous count valid (meaning this is not the first
                                character counted), and matches current count?
a=c;}                           Previous count = current count.
(a^c^c^f^f^h)+o,a+r,o,o,+h^*r;  Spend surplus characters to make source code valid.
(a=f);}}}}}}}                   Return value.

Perl 6 , 58 57 byte

{.max==.min>()**()}o{(bag .comb){*}}###=>>abccggiinnoxx  

Provalo online!

Si scopre che la versione a tre personaggi è leggermente più corta di quella a due personaggi.