Nous disons qu'une chaîne est non discriminante si chacun des caractères de la chaîne apparaît le même nombre de fois et au moins deux fois.

Exemples

• "aa!1 1 !a !1"est non-discrimination parce que chacun des personnages , !, aet 1apparaissent trois fois.
• "abbaabb"n'est pas non discriminant car bapparaît plus souvent que a.
• "abc"n'est pas non plus discriminant car les caractères n'apparaissent pas au moins deux fois.

Tâche

Ecrivez un programme ou une fonction non discriminante qui retourne une valeur de vérité si une chaîne donnée est non discriminante , et une valeur de faux sinon.

Autrement dit, le programme exécuté sur son propre code source devrait renvoyer une valeur de vérité.

Chaque soumission doit pouvoir gérer des chaînes non vides contenant de l' ASCII imprimable , ainsi que tous les caractères figurant dans le code source de la soumission.

Cas de test

Vérité

<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"

Fausseté:

"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 octets

=ᵍbᵐbᵐlᵍ=l

Essayez-le en ligne!

Explication

=ᵍ                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 160 octets (nombre de caractères 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]);}

Essayez-le en ligne.
Code utilisé pour vérifier les occurrences des caractères , ce qui a été ma réponse à ce défi .

-5 octets à nouveau à @ OlivierGrégoire en supprimant le commentaire et en semant le désordre. ;)

Ancien 168 octets (nombre de caractères 6), répondez :

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::::{{{{{;;||||}}}}}>>

Essayez-le en ligne.
Code utilisé pour vérifier les occurrences des caractères sans les commentaires , ce qui a été ma réponse à ce défi .

-6 octets grâce à la suppression de @ OliverGrégoire< en échangeant les chèques en >.

Explication du programme de base joué au golf (98 octets):
Essayez-le en ligne.

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

Certaines choses que j'ai faites pour réduire le nombre de caractères utilisés:

• Les noms de variables o, w, u, f, ret eont été choisis sur le but de réutiliser les caractères que nous avions déjà (mais ne dépassant pas 6).
• 2222est utilisé à la place de 256.
• Changement de if-check e>0&u!=e|u<2en !(e<2|u==e)|u<2pour supprimer 6x &.
• Suppression des deux déclarations séparées et utilisé un drapeau f, et nous reviendrons si elle est toujours 0 à la fin (ce qui voulait dire que je pouvais retirer le 6x byde bytemaintenant que nous utilisons nen int6 fois au lieu de 8).
• e<2et u<2changé pour 2>eet 2>upour supprimer 6x <.

Ce que j'ai fait pour réduire le nombre de personnages 6 à 5:

• 2x intpour byteque la quantité nutilisée soit 4 au lieu de 6.
• Utilisé à la x[0]place d'une nouvelle variable f=0, la quantité =utilisée est de 5 au lieu de 6.
• Changé 2222en 3333donc la quantité 2utilisée est 2 au lieu de 6.
• Variables modifiées fet rencore une fois, elles ne sont plus 6 non plus.

Ce que @ OlivierGrégoire a fait pour se débarrasser du commentaire, et donc du 5x /:

• Ajout de variables inutilisées ,i,fe,fi,w;.
• Ajout d' étiquettes inutilisées: s:w:no0r3sswwyyy:.
• Ajout de non utilisé |2>2
• Ajout {}autour des for-boucles et if, et ajout d'un {}bloc inutilisé .
• Changer !pour !!!.
• Changer |pour ||.
• Changer 333pour +333-3|2se débarrasser des opérateurs arithmétiques restants +-|et du 2.
• Changer !(x[0]>0)pour !!(0>--x[0]).

Jelly , 18 16 12 10 octets

Ġ¬zḊḊ¬zĠȦȦ

Essayez-le en ligne!

Comment ça fonctionne

Ġ¬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 octets

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

Essayez-le en ligne!

Explication

ọ   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.

Solution alternative à 12 octets qui réutilise tau lieu de ᵐ:

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

T-SQL, 320 octets (32 caractères x 10 chacun)

La saisie s'effectue via une table pré-existante FILLavec un champ varchar STEW, conformément à nos normes 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)----------<<<<<<

Je n'ai jamais été aussi heureux, encore horrifié, par un morceau de code.

Doit être exécuté sur un serveur ou une base de données défini pour un classement sensible à la casse. Il y a 10 caractères différents sur 32, y compris les majuscules et les minuscules E(les commandes SQL ne sont pas sensibles à la casse; vous pouvez donc en inverser quelques-unes), les espaces et les tabulations (les tabulations sont représentées par des sauts de ligne dans le code ci-dessus, par souci de lisibilité).

J'ai trouvé des moyens d'inclure 10 chacun des autres symboles + = ,dans le code, mais malheureusement <, je n'ai pas trouvé le moyen de le faire , j'ai donc dû ajouter le caractère de commentaire -.

Voici le code formaté avant de me fourrer dans tout le filler supplémentaire:

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 ligne du haut est un CTE récursif qui génère une table numérique bque nous joignons à la chaîne source pour la séparer par caractère. Ces caractères sont regroupés et comptés, et l' IIFinstruction renvoie 0 ou 1 selon que la chaîne d'entrée est non discriminante.

C (gcc) ,  333  168 octets

Merci à @Kevin Cruijssen pour la sauvegarde de 9 octets et à @Laikoni pour la sauvegarde de 45 octets!

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{{{{{{}}}}}}

Essayez-le en ligne!

C, 333 octets

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{{{{{{{}}}}}}}

Même le décompte est non discriminant!

Essayez-le en ligne!

05AB1E , 20 18 16 14 octets

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

Essayez-le en ligne!

Le programme est essentiellement divisé en 2 parties, l’objectif de la première partie étant de s’acquitter de la tâche proprement dite et celui de la seconde partie, d’utiliser les mêmes fonctions que la première partie sans modifier le résultat.

Explication (première partie)

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

Explication (deuxième partie)

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)

Husk , 14 octets

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

Essayez-le en ligne!

Explication

Les deux lignes courtes sont des no-ops, car la fonction principale ne les appelle jamais.

§<ε#ε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 octets

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

La sortie s'effectue via la présence ou l'absence d'une erreur. L'erreur est soit une ValueError (un ou plusieurs caractères n'apparaissent qu'une seule fois) ou un NameError (le nombre de caractères n'est pas égal ).

Essayez-le en ligne!

Brachylog v2, 8 octets (dans le jeu de caractères de Brachylog)

oḅ\k\koḅ

Essayez-le en ligne!

On dirait qu'il y a eu une guerre de golf sur cette question dans Brachylog, alors j'ai pensé y participer, en économisant quelques octets au lieu de la meilleure réponse.

C'est un programme complet qui prend en entrée une liste de codes de caractères. (Ceci est dû en partie au fait que Brachylog semble présenter des bogues très bizarres liés aux barres obliques inverses dans les chaînes et en partie au fait que la \commande ne fonctionne pas sur les listes de chaînes.)

Explication

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)

Le koḅà la fin est sans importance; kaura toujours un élément d'agir sur et oet ḅne peut manquer si on leur donne une liste en entrée.

La raison du départ oḅdevrait être claire; il partitionne la liste d'entrées par valeur, par exemple [1,2,1,2,4,1]deviendrait [[1,1,1],[2,2],[4]]. Pour que chaque caractère apparaisse le même nombre de fois, chacune de ces listes doit avoir la même longueur, c'est-à-dire que la liste résultante est un rectangle. Nous pouvons affirmer cette circularité en utilisant \, qui transpose également les lignes et les colonnes comme un effet secondaire.

Nous avons maintenant une valeur actuelle composée de plusieurs copies du jeu de caractères, par exemple si l'entrée était [4,2,1,2,4,1]la valeur actuelle [[1,2,4],[1,2,4]]. Si nous supprimons une copie, la matrice résultante est toujours rectangulaire, nous pouvons donc la retourner avec \. Cependant, si la matrice était rectangulaire parce que tous les caractères saisis étaient distincts, la matrice résultante ne comportera plus aucun élément et \ne traitera pas une matrice "0 × 0" comme rectangulaire (elle échouera plutôt). Si oḅ\k\efficacement affirme que chaque caractère qui apparaît dans l'entrée apparaît le même nombre de fois, et ce nombre de fois n'est pas 1.

C'est toute la fonctionnalité de notre programme (en tant que programme complet, nous obtenons truesi aucun échec d'assertion ne s'est produit, falsesi certains l'ont fait). Cependant, nous devons obéir à la restriction de mise en page source, alors j’en ai ajouté un supplémentaire koḅqui n’a aucun but, mais qui ne peut pas échouer (contrairement à ce \qui se passe oet nous nous ferons un ḅplaisir d’agir sur des listes vides).

Python 2 , 84 80 octets

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

Essayez-le en ligne!

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

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

Essayez-le en ligne!

24 personnages différents * 6 fois chacun

28 personnages différents * 5 fois chacun

27 personnages différents * 5 fois chacun

27 personnages différents * 4 fois chacun

26 personnages différents * 4 fois chacun

25 personnages différents * 4 fois chacun

24 personnages différents * 4 fois chacun

Explication

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 octets

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

Essayez-le en ligne!

C'était très amusant de jouer au golf. La limite était $, nous avons besoin d'au moins quatre (un pour l'entrée $args, un pour assigner le résultat du calcul $qe, un pour vérifier le dernier caractère $qe[-1]et un pour vérifier le premier caractère $qe[0], donc c'était le nombre maximum de caractères de travail.

À partir de là, il fallait jouer au golf (et non au golf, comme si on avait un nom de variable à deux lettres) pour que le programme soit bien divisible par quatre. Notez que nous avons un petit commentaire (tout ce qui suit le #) pour prendre en compte certains éléments manquants, mais j'ai essayé de garder le commentaire le plus petit possible.

Haskell, 90 75 72 octets

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

Chaque personnage apparaît 6 fois. La chaîne d'entrée est considérée comme une liste de singleton .

Essayez-le en ligne!

Pour référence, anciennes versions:

75 octets, chaque caractère 5 fois

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

Essayez-le en ligne!

90 octets, chaque caractère 3 fois:

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

Essayez-le en ligne!

Python 2 , 108 104 92 88 octets

-12 octets grâce à Rod
-4 octets grâce à Kevin Cruijssen

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

Essayez-le en ligne!

MATL , 12 octets

q&=sqt&=tsvv

L'entrée est une chaîne entre guillemets simples. Les guillemets simples dans la chaîne sont échappés par la duplication.

La sortie est une matrice non vide, ce qui est vrai si elle ne contient pas de zéros et falsifiée si elle contient au moins un zéro.

Essayez-le en ligne! Ou vérifiez tous les cas de test , y compris le test standard vérité / fausseté pour plus de commodité.

Comment ça fonctionne

Les déclarations marquées avec (*)ne sont ni nécessaires ni nuisibles et ont été incluses uniquement pour rendre le code source non discriminant.

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 octets

Chaque personnage apparaît 3 fois. Un seul 1ne fait rien

12 octets ajoutés à une solution de base de 45 caractères à effectuer de manière non discriminante

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

Essayez-le en ligne!

R , 90 octets

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

Essayez-le en ligne!

Sorties TRUEpour une chaîne non discriminante et FALSEpour une chaîne discriminante. J'ai écrit beaucoup de codes laids pour les défis sur ce site, mais je pense que c'est le plus laid jusqu'à présent.

45 caractères, utilisés deux fois chacun (dont quelques-uns dans un commentaire). La meilleure réponse précédente était de 116 octets , avec 29 caractères utilisés 4 fois chacun; Je poste ceci séparément car il est substantiellement différent.

Le code est équivalent à

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

qui convertit l’entrée en un vecteur d’entiers, calcule un tableau yde contingence des valeurs, puis vérifie que tous les comptes de ce tableau sont égaux au premier compte et que le premier compte est supérieur à 1.

La difficulté initiale consistait à n'utiliser que 2 paires de crochets. Ceci est réalisé en redéfinissant les fonctions unaires !et ?d'être utf8ToIntet prodrespectivement. (Je ne peux pas utiliser allparce que j'ai besoin de a). Il y a quatre missions: deux avec =et deux avec <-. Cela signifie que le test d'égalité entre yet zne peut pas utiliser y==zni y-z; y%in%zvient à la rescousse.

La définition de ces fonctions utilise toutes les citations possibles: deux guillemets doubles, deux guillemets simples, et j'aurai besoin des deux guillemets du paragraphe suivant. J'ai donc dû recourir à la readLines()place de scan(,""). (Les autres options, telles que scan(,letters)ou scan(,month.abb)utilisent toutes un précieux t que je ne pouvais pas épargner.)

À ce stade, j'avais la plupart des blocs de construction: utf8ToInt, prod, table, readLines, %in%. Trois personnages apparaissent trois fois dans ces noms: ent. Tout d’abord, j’ai découvert que cela table(foo)revenait à xtabs(~foo)sauver le fichier e. Je peux sauver le net tavec le code hexadécimal / octal astuce ; la solution la plus risquée est d’utiliser u\164f8ToI\x6Et(en backticks) pour utf8ToInt.

Brachylog , 18 octets

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

Essayez-le en ligne!

Malheureusement, je ne peux pas supprimer les sauts de ligne, car ḅun certain nombre de fois déclenche un échec.

Ruby , 87 78 octets

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

26 caractères répétés 3 fois chacun

Essayez-le en ligne!

R, 132 116 octets

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

Il ne contient pas non plus de commentaires, ni de chaînes superflues, bien que ce soit probablement la seule fois où j'appelle une fonction dans le code golf crudcardounenforceableuploads. Il y a probablement une excellente anagramme quelque part pour le nom de la fonction! Merci à John Dvorak pour nous avoir signalé un joli solveur d’anagrammes, que j’avais utilisé pour le nom.

Table de caractères:

- , ; ! " ( ) [ ] { } & < 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

exemples:

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

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

Cette ligne de code prend une chaîne stdin en entrée. "grep -o." met chaque caractère sur une nouvelle ligne. "uniq -c" compte l'utilisation de chaque responsable. Le script awk crée un tableau avec chaque utilisation en tant qu'élément différent et renvoie true lorsqu'il n'y a qu'un index de tableau et que la valeur est au moins égale à 2. Chaque caractère est utilisé 4 fois. Cette source renvoie donc true

Stax , 26 24 18 octets

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

Essayez-le en ligne!

La solution la plus courte à ce jour qui utilise uniquement des fichiers ASCII imprimables Battus par MATL.

J'imagine que j'abordais le problème de la mauvaise façon. Répéter un bloc de travail n'est ni amusant ni intéressant. Maintenant au moins ça a l'air mieux ...

Explication

:u{m* produit des déchets qui n’affectent pas la sortie.

_{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 octets

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

Essayez-le en ligne!

Explication

Chaque personnage apparaît deux fois.

                        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

Version alternative à 22 octets avec moins de no-ops:

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

SmileBASIC, 164 152 148 140 octets

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 personnages différents, répétés 4 fois chacun.

Aucun commentaire n'a été utilisé (mais l'expression après neXTn'est jamais réellement évaluée)

Script pour vérifier les réponses:

//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 octets

La sortie sera vide si faux ou non vide si vrai.

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

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

Essayez-le en ligne

Programme principal (39 octets)

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

Explication

L'ensemble du programme de base est dans une boucle silencieuse. La première étape trie les entrées. La deuxième étape imprimera la chaîne en cours si elle se compose de paires successives de caractères différents. La troisième étape supprime la dernière occurrence de chaque caractère (en supprimant un de chaque caractère de la chaîne).

À propos de la malbouffe en haut: l'ordre est important. En plus de devoir être valide du point de vue de la syntaxe, un point-virgule doit figurer après les astérisques et avant les backticks, tant qu'il *est dans la chaîne de configuration, pour ne pas être imprimé.

CoffeeScript 1 , 96 93 90 octets

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

Essayez-le en ligne!

Commencé à partir de ma réponse ES6 mais retourné à utiliser Array.every. 32 31 30 jetons @ 3 chacun

Pyth, 30 octets

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

Premiers espaces nécessaires.

Essayez-le en ligne!

Le programme actuel est juste &q1lJ{hMrSz8<1hJ. Je viens "&8<MQSlqr{"de préparer la chaîne pour la rendre non discriminante. Mais pour que la chaîne ne s'imprime pas elle-même, j'ai dû ajouter un espace, donc j'ai ajouté 2 espaces.

&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_encodehere ( r <any> 8) prend une séquence et affiche la longueur de chaque passage du même caractère, ex. "aaabbcc"devient [[3, "a"], [2, "b"], [2, "c"]].

Donc, cela prend l’entrée, le trie pour le mettre en longueur, et prend le premier élément de chaque liste dans la liste résultante (par exemple, l’exemple précédent deviendrait [3, 2, 2]). Cela donne le nombre de fois où il y a des caractères. Ensuite, il est dédupliqué (l’exemple précédent deviendrait [3, 2]), et J est réglé sur cela.

Ensuite, il vérifie si la longueur est 1, c'est-à-dire qu'il n'y a qu'un seul nombre de fois qu'un caractère se produit, et si c'est> 1, c'est-à-dire> = 2.

Il se peut qu’il y ait une fonction intégrée à remplacer rSz8ou à laquelle hMrSz8je ne parviens pas.

C (gcc) , 153 octets

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);}}}}}}}

Essayez-le en ligne!

Retourne l'adresse de la chaîne en tant que valeur de vérité et zéro en tant que falsie.

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 octets

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

Essayez-le en ligne!

Il s'avère que la version à trois caractères est légèrement plus courte que celle à deux caractères.