Decimos que una cadena no discrimina si cada uno de los caracteres de la cadena aparece la misma cantidad de veces y al menos dos veces.

Ejemplos

• "aa!1 1 !a !1"es no discriminatorio , porque cada uno de los personajes , !, ay 1aparecerá tres veces.
• "abbaabb"no es discriminatorio porque baparece con más frecuencia que a.
• "abc"es también no no discriminatorio porque los personajes no aparecen al menos dos veces.

Tarea

Escriba un programa o función no discriminatorio que devuelva un valor verdadero si una cadena dada no es discriminatoria y un valor falso de lo contrario.

Es decir, el programa ejecutado en su propio código fuente debería devolver un valor verdadero.

Cada envío debe poder manejar cadenas no vacías que contengan ASCII imprimible , así como todos los caracteres que aparecen en el código fuente del envío.

Casos de prueba

Verdad:

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

=ᵍbᵐbᵐlᵍ=l

Pruébalo en línea!

Explicación

=ᵍ                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 bytes (recuento de caracteres 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]);}

Pruébalo en línea.
Código utilizado para verificar las ocurrencias de los personajes , que fue mi respuesta para este desafío .

-5 bytes gracias a @ OlivierGrégoire nuevamente al deshacerse del comentario y hacer un desastre. ;)

Antigua respuesta de 168 bytes (recuento de caracteres 6) :

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

Pruébalo en línea.
Código utilizado para verificar las ocurrencias de los caracteres, excluyendo el comentario , que fue mi respuesta para este desafío .

-6 bytes gracias a la eliminación de @ OliverGrégoire< cambiando los cheques a >.

Explicación del programa de golf base (98 bytes):
Pruébelo en línea.

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

Algunas cosas que hice para reducir la cantidad de caracteres utilizados:

• Los nombres de variables o, w, u, f, r, y efueron escogidos a propósito personajes para reutilizar los que ya teníamos (pero no superior a 6).
• 2222se usa en lugar de 256.
• Se ha cambiado el caso a comprobar e>0&u!=e|u<2a !(e<2|u==e)|u<2quitar 6x &.
• Eliminado los dos retornos separados y se utiliza una bandera f, y volvemos si todavía 0 se encuentra en el extremo (esto significaba que podía quitar la 6x bydesde byteahora que sólo utilizamos nen int6 veces en lugar de 8).
• e<2y u<2cambiado a 2>ey 2>upara eliminar 6x <.

Lo que hice para reducir la cuenta de char 6 a 5:

• 2 veces intpara byteque la cantidad de nuso sea 4 en lugar de 6.
• Se utiliza en x[0]lugar de una nueva variable, f=0por lo que la cantidad =utilizada es 5 en lugar de 6.
• Cambió 2222a por 3333lo que la cantidad de 2uso es 2 en lugar de 6.
• Variables cambiadas fy de rnuevo para que ya no sean 6 tampoco.

Lo que hizo @ OlivierGrégoire para deshacerse del comentario y, por lo tanto, el 5x /:

• Agregar variables no utilizadas ,i,fe,fi,w;.
• Adición de las etiquetas no utilizadas: s:w:no0r3sswwyyy:.
• Agregar sin usar |2>2
• Agregando {}alrededor de los bucles for y ifs, y agregó un {}bloque no utilizado.
• Cambiando !a !!!.
• Cambiando |a ||.
• Cambiar 333a +333-3|2para deshacerse de los operadores aritméticos sobrantes +-|y el 2.
• Cambiando !(x[0]>0)a !!(0>--x[0]).

Jalea , 18 16 12 10 bytes

Ġ¬zḊḊ¬zĠȦȦ

Pruébalo en línea!

Cómo funciona

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

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

Pruébalo en línea!

Explicación

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

Solución alternativa de 12 bytes que se reutiliza en tlugar de ᵐ:

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

T-SQL, 320 bytes (32 caracteres x 10 cada uno)

La entrada es a través de una tabla preexistente FILLcon campo varchar STEW, según nuestros estándares de 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)----------<<<<<<

Nunca he estado más complacido, pero horrorizado, por un fragmento de código.

Debe ejecutarse en un servidor o base de datos establecida en una intercalación entre mayúsculas y minúsculas. Hay 10 cada uno de los 32 caracteres diferentes, incluidos mayúsculas y minúsculas E(los comandos SQL no distinguen entre mayúsculas y minúsculas, por lo que se invierten algunos según sea necesario), espacios y pestañas (las pestañas se muestran como saltos de línea en el código anterior, para facilitar la lectura).

Encontré formas de incluir 10 de cada uno de los otros símbolos + = ,en el código, pero desafortunadamente no pude encontrar una manera de hacerlo <, así que tuve que agregar el carácter de comentario -.

Aquí está el código formateado antes de meter todo el relleno adicional:

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 línea superior es un CTE recursivo que genera una tabla de números b, que unimos a la cadena de origen para separar por carácter. Esos caracteres se agrupan y cuentan, y la IIFinstrucción devuelve 0 o 1 dependiendo de si la cadena de entrada no es discriminatoria.

C (gcc) ,  333168  bytes

¡Gracias a @Kevin Cruijssen por guardar 9 bytes y gracias a @Laikoni por guardar 45 bytes!

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

Pruébalo en línea!

C, 333 bytes

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

¡Incluso el bytecount no es discriminatorio!

Pruébalo en línea!

05AB1E , 20 18 16 14 bytes

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

Pruébalo en línea!

El programa se divide esencialmente en 2 partes donde el objetivo de la primera parte es hacer la tarea real y el objetivo de la segunda parte es utilizar las mismas funciones que la primera parte sin alterar el resultado.

Explicación (primera 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

Explicación (segunda 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)

Casco , 14 bytes

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

Pruébalo en línea!

Explicación

Las dos líneas cortas no funcionan, ya que la función principal nunca las llama.

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

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

La salida es por presencia o ausencia de un error. El error es un ValueError (uno o más caracteres aparecen solo una vez) o un NameError (los recuentos de caracteres son desiguales).

Pruébalo en línea!

Brachylog v2, 8 bytes (en el conjunto de caracteres de Brachylog)

oḅ\k\koḅ

Pruébalo en línea!

Parece que ha habido una guerra de golf por esta pregunta en Brachylog, así que pensé en unirme, ahorrando un par de bytes en la siguiente mejor respuesta.

Este es un programa completo que toma la entrada como una lista de códigos de caracteres. (Esto se debe en parte a que Brachylog parece tener algunos errores muy extraños relacionados con las barras invertidas en las cadenas, y en parte porque el \comando no funciona en las listas de cadenas).

Explicación

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)

El koḅfinal es irrelevante; ksiempre tendrá un elemento para actuar oy ḅno puede fallar si se le da una lista como entrada.

La razón para comenzar oḅdebe ser clara; divide la lista de entrada por valor, por ejemplo, [1,2,1,2,4,1]se convertiría en [[1,1,1],[2,2],[4]]. Para que cada carácter aparezca la misma cantidad de veces, cada una de estas listas debe tener la misma longitud, es decir, la lista resultante es un rectángulo. Podemos afirmar esta rectangularidad usando \, que también transpone las filas y columnas como un efecto secundario.

Ahora tenemos un valor actual que consiste en múltiples copias del conjunto de caracteres, por ejemplo, si la entrada fuera [4,2,1,2,4,1]el valor actual sería [[1,2,4],[1,2,4]]. Si eliminamos una copia, la matriz resultante sigue siendo rectangular, por lo que podemos volver a usarla \. Sin embargo, si la razón por la matriz era rectangular fue que todos los caracteres introducidos eran distintos, la matriz resultante tendrá ningún elemento de la izquierda, y \no no tratar a una matriz "0 × 0" como rectangular (más bien, se produce un error). De oḅ\k\manera tan efectiva afirma que cada carácter que aparece en la entrada aparece la misma cantidad de veces, y esa cantidad de veces no es 1.

Esa es toda la funcionalidad de nuestro programa (como un programa completo, obtenemos truesi no se produjeron fallas de aserción, falsesi alguna ocurrió). Sin embargo, tenemos que obedecer la restricción de diseño de la fuente, así que agregué un adicional koḅque no tiene ningún propósito pero que no puede fallar (a diferencia \, oy ḅestamos felices de actuar en listas vacías).

Python 2 , 84 80 bytes

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

Pruébalo en línea!

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

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

Pruébalo en línea!

24 personajes diferentes * 6 veces cada uno

28 caracteres diferentes * 5 veces cada uno

27 caracteres diferentes * 5 veces cada uno

27 caracteres diferentes * 4 veces cada uno

26 caracteres diferentes * 4 veces cada uno

25 personajes diferentes * 4 veces cada uno

24 personajes diferentes * 4 veces cada uno

Explicación

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 bytes

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

Pruébalo en línea!

Esto fue muy divertido para el golf. La limitación era $, que necesitamos cuatro como mínimo (uno para la entrada $args, uno para asignar el resultado del cálculo $qe, uno para verificar el último carácter $qe[-1]y otro para verificar el primer carácter $qe[0], por lo que ese era el número máximo de caracteres en funcionamiento.

A partir de ahí, se trataba de jugar al golf (y no jugar al golf, como tener un nombre de variable de dos letras) para que el programa sea divisible por cuatro. Tenga en cuenta que tenemos un pequeño comentario (todo lo que sigue al #) para tener en cuenta algunos elementos faltantes, pero intenté mantener el comentario lo más pequeño posible.

Haskell, 90 75 72 bytes

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

Cada personaje aparece 6 veces. La cadena de entrada se toma como una lista singleton .

Pruébalo en línea!

Como referencia, versiones anteriores:

75 bytes, cada char 5 veces

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

Pruébalo en línea!

90 bytes, cada char 3 veces:

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

Pruébalo en línea!

Python 2 , 108 104 92 88 bytes

-12 bytes gracias a Rod
-4 bytes gracias a Kevin Cruijssen

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

Pruébalo en línea!

MATL , 12 bytes

q&=sqt&=tsvv

La entrada es una cadena entre comillas simples. Las comillas simples en la cadena se escapan duplicando.

La salida es una matriz no vacía, que es verdadera si no contiene ceros, y es falsa si contiene al menos un cero.

Pruébalo en línea!O verifique todos los casos de prueba , incluida la prueba estándar de veracidad / falsedad para mayor comodidad.

Cómo funciona

Las declaraciones marcadas con (*)no son necesarias ni dañinas, y se han incluido solo para que el código fuente no sea 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 bytes

Cada personaje aparece 3 veces. Solo una1 no hace nada

Se agregaron 12 bytes a una solución básica de 45 caracteres para hacer que no sea discriminatorio

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

Pruébalo en línea!

R , 90 bytes

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

Pruébalo en línea!

Salidas TRUEpara una cadena no discriminatoria, yFALSE para una cadena discriminante. He escrito mucho código feo para desafíos en este sitio, pero creo que este es el más feo hasta ahora.

45 caracteres, utilizados dos veces cada uno (incluidos algunos en un comentario). La mejor respuesta R anterior fue de 116 bytes , con 29 caracteres utilizados 4 veces cada uno; Estoy publicando esto por separado ya que es sustancialmente diferente.

El código es equivalente a

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

que convierte la entrada en un vector de enteros, calcula una tabla de contingencia y de de los valores, luego verifica que todos los recuentos en esa tabla sean iguales al primer recuento, y que el primer recuento sea mayor que 1.

La dificultad inicial fue usar solo 2 pares de paréntesis. Esto se logra redefiniendo las funciones unarias !y ?to be utf8ToInty prodrespectivamente. (No puedo usar allporque necesito el a). Hay cuatro tareas: dos con =y dos con <-. Esto significa que la prueba de igualdad entre yy zno puede usar y==zni y-z;y%in%zviene al rescate

La definición de estas funciones utiliza todas las comillas posibles: dos comillas dobles, dos comillas simples, y necesitaré los dos backticks en el siguiente párrafo, así que tuve que recurrir a en readLines()lugar de scan(,""). (Las otras opciones, como scan(,letters)o scan(,month.abb)todas, usaban un precioso t que no podía ahorrar).

En este punto, tenía la mayor parte de los componentes básicos: utf8ToInt, prod, table, readLines, %in%. Tres personajes aparecen tres veces en esos nombres: ent. Primero, descubrí que table(foo)es equivalente a xtabs(~foo)guardar el e. Puedo rescatar el ny el tcon el truco de código hexadecimal / octal ; la solución más golfista es usar u\164f8ToI\x6Et(en backticks) para utf8ToInt.

Brachylog , 18 bytes

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

Pruébalo en línea!

Desafortunadamente, no puedo eliminar los avances de línea, ya que ḅen un número se activa un error.

Ruby , 87 78 bytes

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

26 caracteres repetidos 3 veces cada uno

Pruébalo en línea!

R, 132116 bytes

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

Tampoco contiene comentarios ni cadenas superfluas, aunque probablemente este sea mi único momento en el código de golf llamando a una función crudcardounenforceableuploads. ¡Probablemente haya un gran anagrama en alguna parte para el nombre de la función! Gracias a John Dvorak por señalar un buen solucionador de anagramas, que usé para el nombre.

Tabla de caracteres:

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

ejemplos:

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

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

Esta línea de código toma una cadena estándar como entrada. "grep -o". pone a cada personaje en una nueva línea. "uniq -c" cuenta el uso de cada personaje. El script awk crea una matriz con cada uso como un elemento diferente, y genera verdadero cuando solo hay 1 índice de matriz y el valor es al menos 2. Cada carácter se usa 4 veces, por lo que esta fuente devuelve verdadero

Stax , 26 24 18 bytes

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

Pruébalo en línea!

La solución más corta hasta ahora que solo utiliza ASCII imprimibles Beaten by MATL .

Supongo que me estaba acercando al problema por el camino equivocado. Repetir un bloque de trabajo no es golf ni interesante. Ahora al menos se ve mejor ...

Explicación

:u{m* produce algo de basura que no afecta la salida.

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

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

Pruébalo en línea!

Explicación

Cada personaje aparece dos veces.

                        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

Versión alternativa de 22 bytes con menos no-ops:

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

SmileBASIC, 164 152 148 140 bytes

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 personajes diferentes, repetidos 4 veces cada uno.

No se utilizaron comentarios (pero la expresión posterior neXTnunca se evalúa realmente)

Guión para verificar las respuestas:

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

La salida estará vacía si es falsa o no vacía si es verdadera.

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

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

Pruébalo en línea

Programa principal (39 bytes)

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

Explicación

Todo el programa central está en un bucle silencioso. La primera etapa ordena la entrada. La segunda etapa imprimirá la cadena actual si consta de pares sucesivos de caracteres diferentes. La tercera etapa elimina la última aparición de cada carácter (eliminando uno de cada carácter en la cadena).

Sobre la basura en la parte superior: el orden es importante. Además de la necesidad de ser sintácticamente válido, debe haber un punto y coma después de los asteriscos y antes de los puntos de retroceso, siempre que *esté en la cadena de configuración, para que no se imprima.

CoffeeScript 1 , 96 93 90 bytes

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

Pruébalo en línea!

Comencé con mi respuesta ES6 pero volví a usar Array.every. 32 31 30 fichas @ 3 cada una

Pyth, 30 bytes

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

Espacios principales necesarios.

Pruébalo en línea!

El programa actual es justo &q1lJ{hMrSz8<1hJ. Acabo de anteponer la cadena "&8<MQSlqr{"para que no sea discriminatoria. Pero para que la cadena no se imprima, tuve que agregar un espacio, así que agregué 2 espacios.

&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) toma una secuencia y genera la longitud de cada ejecución del mismo carácter, ej. "aaabbcc"se convierte [[3, "a"], [2, "b"], [2, "c"]].

Entonces esto toma la entrada, la ordena para ponerla en codificación de longitud y toma el primer elemento de cada lista en la lista resultante (por ejemplo, el ejemplo anterior sería [3, 2, 2]). Esto da un recuento de cuántas veces aparecen los caracteres. Luego se deduplica (el ejemplo anterior sería [3, 2]), y J está configurado para eso.

Luego verifica si la longitud es 1, es decir, solo hay 1 número único de veces que ocurre un carácter, y si es> 1, es decir,> = 2.

Puede haber un reemplazo para reemplazar rSz8o hMrSz8no puedo encontrar uno.

C (gcc) , 153 bytes

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

Pruébalo en línea!

Devuelve la dirección de la cadena como valor verdadero y cero como falso.

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 bytes

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

Pruébalo en línea!

Resulta que la versión de tres caracteres es ligeramente más corta que la de dos caracteres.