Programmation non discriminante

74

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>"
Laikoni
la source
4
@Laikoni pouvons-nous abuser des commentaires pour que cela fonctionne?
Urne magique Octopus
6
En passant, j'aime les défis où je peux utiliser d'autres entrées pour tester la validité de mon entrée.
Urne Magique Octopus
3
@MagicOctopusUrn Je pense qu'il a dit dans le bac à sable que c'est autorisé, car cela ne peut pas être déterminé de manière observable.
Erik l'Outgolfer
11
Exactement. Même si vous parvenez à interdire les commentaires de manière objective, qu'en est-il des littéraux de chaîne inutilisés, etc.? Quoi qu'il en soit, je pense que la notation incite à éviter les commentaires autant que possible.
Laikoni
4
Je comprends que ce n’est qu’un casse-tête, mais la confusion entre "non discriminant" et "tous les types de membres étiquetés identifiables existant exactement à parts égales" est légèrement inquiétante ... "discriminer" signifie "faire la différence entre" et " injustement, cela signifie traiter ou juger une personne injustement en la considérant différente de celle d'une autre classe de personnes. Bien sûr, continuez avec le plaisir!
ErikE

Réponses:

37

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
H.PWiz
la source
25

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]).
Kevin Cruijssen
la source
1
180 octets : tout changé<en>.
Olivier Grégoire
@ OlivierGrégoire Désolé, je suis déjà à 174 :) Mais on verra si ton astuce peut toujours être appliquée.
Kevin Cruijssen
La modification peut toujours s'appliquer pour enregistrer 6 octets.
Olivier Grégoire
Plus proche, je suis à 162 caractères (161 caractères) . J'essaie de supprimer le commentaire, mais je dois quand même mettre une virgule quelque part. Je ne trouve aucun endroit.
Olivier Grégoire
1
160 octets ( preuve ). Très probablement plus golfable.
Olivier Grégoire
15

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
Dennis
la source
13

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ℕ₂ℕ₂ọᵐ
Martin Ender
la source
13

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.

BradC
la source
11

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!

Steadybox
la source
Awwhh ... Je voulais être le premier abuseur de commentaires. Bien, j'aime bien la façon dont vous avez trié les caractères pour le commentaire ^ _ ^
Urne Magique Octopus
1
Vous pouvez abaisser à 324 octets en changeant à la fois le 128pour de 222sorte que le 8peut être abandonné.
Kevin Cruijssen
1
279 octets en renommant i, v, S, set Là des personnages qui apparaissent déjà dans les mots - clés char, foret return: essayer en ligne!
Laikoni
@Laikoni Merci! Je n'ai pas eu le temps de bien jouer au golf hier.
Steadybox
@MagicOctopusUrn Ils sont triés parce que j'étais trop paresseux pour les ajouter à la main .
Steadybox
9

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)
Emigna
la source
{γ€gDË*P≠qq{γ€gDË*P≠est un autre pour 20;).
Urne magique Octopus
1
@MagicOctopusUrn: Nice! J'en ai eu quelques autres à 20 ans également. J'en ai aussi un à 18 ans :)
Emigna
2
LA SORCELLERIE! Aucune autre explication!
Urne magique Octopus
1
¢... bonne idée, mec, je suis heureux de voir que c'était aussi utile que je pensais que c'était peut-être haha!
Urne Magique Octopus
9

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?
Zgarb
la source
Mais cela a plus que 'm', donc cela ne répond pas aux exigences.
WGroleau
@WGroleau mapparaît également deux fois: sur la première ligne et sur la deuxième ligne. L'explication n'inclut pas les deux lignes courtes car elles n'affectent pas le comportement du programme.
Zgarb
Je suppose que le PO devrait préciser si une explication du programme peut être numérisée avec le programme. Mais en fait, si vous incluez cela, vous avez alors quatre "u" et deux "m"
WGroleau
Ça ne fait rien; cela m'a confondu de la même manière qu'une autre réponse.
WGroleau
9

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!

Dennis
la source
L'astuce d'erreur de décalage négatif est soignée! J'aime la façon dont il profite de la faible préséance de l'opérateur de quart.
Vincent
1
{{e.dil:-tu,r.dil:-tu,}} Bon dieu qu'est-ce que c'est?
Adam Barnes
1
@AdamBarnes Un charabia à syntaxe valide qui renvoie une erreur NameError si elle est évaluée.
Dennis
Je ne comprends pas. J'ai essayé de l'échanger aet tout a éclaté. Pourriez-vous expliquer plus s'il vous plaît?
Adam Barnes
@AdamBarnes Cela devrait fonctionner, tant que vous laissez un espace après le or. Je vais ajouter une explication quand je suis devant un ordinateur.
Dennis
9

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

ais523
la source
1
C'est la langue de ce mois !
Erik l'Outgolfer
7

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!

Vincent
la source
+1 pour le code Python court ne générant pas d'erreur et notre utopie RAM;)
Shieru Asakoto
7

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.
Shieru Asakoto
la source
6

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.

AdmBorkBork
la source
6

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!

nimi
la source
6

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!

ovs
la source
1
Votre programme doit être non discriminant.
user202729
1
Le programme lui-même doit être non discriminant.
HyperNeutrino
@ user202729 Merci de me l'avoir dit, j'ai mis à jour ma réponse.
ovs
6

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
Luis Mendo
la source
5

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!

Ton Hospel
la source
5

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.

Robin Ryder
la source
C’est impressionnant de pouvoir distinguer les deux cas dans 90 octets (et un abus abusif de l’opérateur d’aide), mais hélas NAn’est pas considéré comme une valeur de vérité (dans R, si (NA) x sinon, y cause une erreur, de même NAni vérité ni falsey )
JDL le
1
@JDL Merci, tu as raison. La dernière modification corrige ce problème.
Robin Ryder le
1
@JDL, les commentaires suggèrent que des réponses cohérentes et distinctes sont acceptables pour la vérité et la fausseté.
Giuseppe
@ Giuseppe En fait, j'ai résolu ce problème il y a quelques secondes (voir la nouvelle version, qui est très différente mais compte le même nombre d'octets); affiche maintenant TRUE et FALSE.
Robin Ryder le
4

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.

Erik le golfeur
la source
Il est certainement possible de faire quelque chose de plus court qui n'exige pas de sauts de ligne (mais il se peut que vous deviez changer certaines choses);)
Fatalize
@Fatalize Pas de temps pour le moment, et oui j'ai lu cette discussion. :)
Erik the Outgolfer
4

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!

Asone Tuhid
la source
@nimi Merci de nous l'avoir signalé, je pense que c'était étrange avec getset ;. De toute façon, c'est plus court comme un lambda
Asone Tuhid,
3

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
JDL
la source
Je ne sais pas si le nombre d'octets est important, mais nous pouvons probablement supprimer les 2 et les >s en inversant la comparaison avec f. Aussi peut utiliser =au lieu de <<-. strsplitest probablement inévitable cependant, qui est la source de la plupart des autres personnages.
JDL
avez-vous besoin des espaces? vous pouvez également essayer utf8ToIntau lieu de strsplit, mais ne savez pas si cela vous aidera. Peut-être aussi inclure un lien vers TIO?
Giuseppe
aussi tout .semble être superflu.
Giuseppe
Il s'agit d'un code-golf , le nombre d'octets est donc important, selon votre commentaire.
Giuseppe
2
Quelques anagrammes possibles: pas de bureaucraties de placards; RIP trempette de livre carbonée au barbecue. Trouvé avec wordplays.com/anagrammer
John Dvorak
2

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

Caleb
la source
2

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
Weijun Zhou
la source
@WGroleau quels personnages apparaissent une fois? Avez-vous lu ma réponse assez attentivement?
Weijun Zhou
'#' apparaît plus souvent que ':' (juste un exemple). Oups, lecture erronée (voir autre commentaire)
WGroleau
@WGroleau Il y a exactement deux #et deux :s, avez-vous lu ma réponse à la deuxième ligne? Avez-vous juste ignoré le premier paragraphe de mon "Explication"?
Weijun Zhou
Désolé, je pensais que la ligne au-dessus de l'explication était tout.
WGroleau
1

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
DLosc
la source
1

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:

12Me21
la source
1

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

mbomb007
la source
Bien, ma réponse est plus courte, mais je ne suis pas sûr que cela corresponde bien à une résolution de 0/1, je vais donc l'ajouter ici au cas où cela vous aiderait
FryAmTheEggman
@FryAmTheEggman Je cherchais une solution purement regex pour faire correspondre des groupes de caractères de même longueur, mais je ne pouvais pas le comprendre.
mbomb007
@FryAmTheEggman a fait une grande amélioration! Je n'ai pas vraiment utilisé ce que vous aviez, mais je suis parti de zéro en essayant de trouver une meilleure méthode.
mbomb007
Bien fait! Et je n'avais pas assez réfléchi à mon programme, semble-t-il, mais au moins vous en avez trouvé un meilleur :)
FryAmTheEggman Le
1

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.

RK.
la source
1

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.
gastropner
la source
1

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.

Jo King
la source