Dizemos que uma string não é discriminatória se cada um dos caracteres da string aparecer o mesmo número de vezes e pelo menos duas vezes.

Exemplos

• "aa!1 1 !a !1"é não discriminatório , porque cada um dos personagens , !, ae 1aparecem três vezes.
• "abbaabb"não é discriminatório porque baparece com mais frequência do que a.
• "abc"também não é discriminatório porque os caracteres não aparecem pelo menos duas vezes.

Tarefa

Escreva um programa ou função não discriminante que retorne um valor verdadeiro se uma determinada string não for discriminatória e, caso contrário , um valor falso .

Ou seja, o programa executado em seu próprio código-fonte deve retornar um valor verdadeiro.

Cada envio deve poder manipular seqüências de caracteres não vazias que contenham ASCII imprimível , bem como todos os caracteres que aparecem no código-fonte do envio.

Casos de teste

Verdade:

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

Braquilog , 10 bytes

=ᵍbᵐbᵐlᵍ=l

Experimente online!

Explicação

=ᵍ                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 (contagem 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]);}

Experimente online.
Código usado para verificar as ocorrências dos caracteres , que foi minha resposta para esse desafio .

-5 bytes graças a @ OlivierGrégoire novamente, livrando-se do comentário e fazendo uma bagunça. ;)

Resposta antiga de 168 bytes (contagem 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::::{{{{{;;||||}}}}}>>

Experimente online.
Código usado para verificar as ocorrências dos caracteres, excluindo comentários , que foi minha resposta para esse desafio .

-6 bytes graças à remoção do @ OliverGrégoire< trocando as verificações por >.

Explicação do programa básico de golfe (98 bytes):
Experimente online.

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

Algumas coisas que fiz para reduzir a quantidade de caracteres usados:

• Os nomes das variáveis o, w, u, f, r, e eforam escolhidos de propósito para reutilizar personagens que já tinha (mas não superior a 6).
• 2222é usado em vez de 256.
• Mudou o se-check e>0&u!=e|u<2para !(e<2|u==e)|u<2remover 6x &.
• Removido os dois retornos separadas e utilizado uma bandeira f, e que devolve se ainda 0 é no final (isto significava que poderia remover a 6x bya partir de byteagora que usamos somente nem int6 vezes, em vez de 8).
• e<2e u<2alterado para 2>ee 2>upara remover 6x <.

O que fiz para reduzir a contagem de caracteres de 6 para 5:

• 2x intpara byteque a quantidade nusada seja 4 em vez de 6.
• Usado em x[0]vez de uma nova variável, f=0portanto, a quantidade =usada é 5 em vez de 6.
• Alterado 2222para 3333, a quantidade de 2usada é 2 em vez de 6.
• Variáveis ​​alteradas fe rnovamente para que não sejam mais 6.

O que o @ OlivierGrégoire fez para se livrar do comentário e, portanto, o 5x /:

• Adicionando variáveis ​​não utilizadas ,i,fe,fi,w;.
• Adicionando etiquetas não utilizadas: s:w:no0r3sswwyyy:.
• Adicionando não utilizado |2>2
• Adicionando em {}torno dos loops de for e ifs e adicionado um {}bloco não utilizado .
• Mudando !para !!!.
• Mudando |para ||.
• Alterando 333para +333-3|2se livrar dos operadores aritméticos restantes +-|e do 2.
• Mudando !(x[0]>0)para !!(0>--x[0]).

Geléia , 18 16 12 10 bytes

Ġ¬zḊḊ¬zĠȦȦ

Experimente online!

Como 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

Braquilog , 14 12 bytes

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

Experimente online!

Explicação

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

Solução alternativa de 12 bytes que reutiliza em tvez de ᵐ:

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

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

A entrada é via tabela preexistente FILLcom campo varchar STEW, de acordo com nossos padrões 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 fiquei tão satisfeito, mas horrorizado, com um pedaço de código.

Deve ser executado em um servidor ou banco de dados definido para um agrupamento que diferencia maiúsculas de minúsculas. Existem 10 cada um dos 32 caracteres diferentes, incluindo maiúsculas e minúsculas E(os comandos SQL não diferenciam maiúsculas de minúsculas, portanto, são necessários alguns), espaços e guias (as guias são mostradas como quebras de linha no código acima, para facilitar a leitura).

Encontrei maneiras de incluir 10 cada um dos outros símbolos + = ,no código, mas infelizmente não consegui encontrar uma maneira de fazer isso <, então tive que adicionar o caractere de comentário -.

Aqui está o código formatado antes de colocar todo o preenchimento extra:

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

A linha superior é um CTE recursivo que gera uma tabela numérica b, à qual juntamos a string de origem para separar por caractere. Esses caracteres são agrupados e contados, e a IIFinstrução retorna 0 ou 1, dependendo se a sequência de entrada não é discriminatória.

C (gcc) ,  333  168 bytes

Agradecemos a @ Kevin Cruijssen por salvar 9 bytes e a @Laikoni por salvar 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{{{{{{}}}}}}

Experimente online!

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

Mesmo o número de bytes não é discriminatório!

Experimente online!

05AB1E , 20 18 16 14 bytes

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

Experimente online!

O programa é essencialmente dividido em duas partes, onde o objetivo da primeira parte é realizar a tarefa real e o objetivo da segunda parte é usar as mesmas funções da primeira parte sem alterar o resultado.

Explicação (primeira 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

Explicação (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)

Casca , 14 bytes

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

Experimente online!

Explicação

As duas linhas curtas não são operacionais, pois a função principal nunca as chama.

§<ε#ε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,}}

A saída é via presença ou ausência de um erro. O erro é um ValueError (um ou mais caracteres ocorrem apenas uma vez) ou um NameError (a contagem de caracteres é desigual).

Experimente online!

Brachylog v2, 8 bytes (no conjunto de caracteres de Brachylog)

oḅ\k\koḅ

Experimente online!

Parece que houve uma guerra de golfe nessa questão em Brachylog, então pensei em participar, economizando alguns bytes na próxima melhor resposta.

Este é um programa completo que recebe a entrada como uma lista de códigos de caracteres. (Isso ocorre em parte porque o Brachylog parece ter alguns bugs muito bizarros relacionados a barras invertidas em strings e em parte porque o \comando não funciona em listas de strings.)

Explicação

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)

O koḅno final é irrelevante; ksempre terá um elemento para atuar oe ḅnão poderá falhar se receber uma lista como entrada.

O motivo da partida oḅdeve ser claro; particiona a lista de entrada por valor, por exemplo, [1,2,1,2,4,1]se tornaria [[1,1,1],[2,2],[4]]. Para que cada caractere apareça o mesmo número de vezes, cada uma dessas listas deve ter o mesmo comprimento, ou seja, a lista resultante é um retângulo. Podemos afirmar essa retangularidade usando \, que também transpõe as linhas e colunas como efeito colateral.

Agora temos um valor atual que consiste em várias cópias do conjunto de caracteres, por exemplo, se a entrada fosse [4,2,1,2,4,1]o valor atual [[1,2,4],[1,2,4]]. Se excluirmos uma cópia, a matriz resultante ainda será retangular, para que possamos voltar a usá-la \. No entanto, se a razão da matriz era retangular foi que todos os caracteres introduzidos eram distintos, a matriz resultante não terá elementos de esquerda, e \se não tratar uma matriz "0 × 0" como retangular (sim, ele falha). oḅ\k\Afirma tão efetivamente que cada caractere que aparece na entrada aparece o mesmo número de vezes e esse número de vezes não é 1.

Essa é toda a funcionalidade do nosso programa (como um programa completo, obtemos truese nenhuma falha de declaração ocorreu, falsese alguns ocorreram ). Porém, temos que obedecer à restrição de layout de origem, então adicionei um adicional koḅque não tem objetivo, mas que não pode falhar (ao contrário \, oe ḅé um prazer atuar em listas vazias).

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

Experimente online!

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)

Experimente online!

24 caracteres diferentes * 6 vezes cada

28 caracteres diferentes * 5 vezes cada

27 caracteres diferentes * 5 vezes cada

27 caracteres diferentes * 4 vezes cada

26 caracteres diferentes * 4 vezes cada

25 caracteres diferentes * 4 vezes cada

24 caracteres diferentes * 4 vezes cada

Explicação

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

Experimente online!

Foi muito divertido jogar golfe. A limitação era de $que precisamos no mínimo de quatro (um para a entrada $args, um para atribuir o resultado da computação $qe, um para verificar o último caractere $qe[-1]e outro para verificar o primeiro caractere $qe[0], de modo que esse era o número máximo de caracteres em funcionamento.

A partir daí, era uma questão de jogar golfe (e não jogar golfe, como ter um nome de variável de duas letras) para obter o programa divisível por quatro. Observe que temos um pequeno comentário (tudo a seguir a #) para explicar alguns elementos ausentes, mas tentei manter o comentário o menor possível.

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 personagem aparece 6 vezes. A sequência de entrada é tomada como uma lista de singleton .

Experimente online!

Para referência, versões antigas:

75 bytes, cada caractere 5 vezes

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

Experimente online!

90 bytes, cada caractere 3 vezes:

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

Experimente online!

Python 2 , 108 104 92 88 bytes

-12 bytes graças a Rod
-4 bytes graças a Kevin Cruijssen

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

Experimente online!

MATL , 12 bytes

q&=sqt&=tsvv

A entrada é uma cadeia de caracteres entre aspas simples. Aspas simples na cadeia de caracteres são escapadas pela duplicação.

A saída é uma matriz não vazia, que é verdadeira se não contém zeros e é falsa se contém pelo menos um zero.

Experimente online! Ou verifique todos os casos de teste , incluindo o teste padrão de veracidade / falsidade, por conveniência.

Como funciona

As declarações marcadas com (*)não são necessárias nem prejudiciais e foram incluídas apenas para tornar o código fonte não discriminatório.

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 personagem aparece 3 vezes. Apenas um single 1não faz nada

12 bytes adicionados a uma solução básica de 45 caracteres para criar

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

Experimente online!

R , 90 bytes

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

Experimente online!

Saídas TRUEpara uma sequência não discriminante e FALSEpara uma sequência discriminante. Escrevi muitos códigos feios para desafios neste site, mas acho que esse é o mais feio até agora.

45 caracteres, usados ​​duas vezes cada (incluindo alguns em um comentário). A melhor resposta R anterior era de 116 bytes , com 29 caracteres usados ​​4 vezes cada; Estou publicando isso separadamente, pois é substancialmente diferente.

O código é equivalente a

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

que converte a entrada em um vetor de números inteiros, calcula uma tabela yde contingência dos valores e verifica se todas as contagens nessa tabela são iguais à primeira contagem e se a primeira contagem é maior que 1.

A dificuldade inicial estava em usar apenas 2 pares de colchetes. Isso é alcançado redefinindo as funções unárias !e ?sendo utf8ToInte prodrespectivamente. (Não posso usar allporque preciso do a). Existem quatro tarefas: duas com =e duas com <-. Isso significa que o teste de igualdade entre ye znão pode usar y==znem y-z; y%in%zvem para o resgate.

A definição dessas funções usa todas as aspas possíveis: duas aspas duplas, duas aspas simples, e precisarei das duas reticulares no próximo parágrafo, então tive que recorrer ao readLines()invés de scan(,""). (As outras opções, como scan(,letters)ou scan(,month.abb)todas, usavam um precioso t que eu não poupava.)

Neste ponto, eu tinha a maioria dos blocos de construção: utf8ToInt, prod, table, readLines, %in%. Três personagens aparecem três vezes esses nomes: ent. Primeiro, descobri que table(foo)é equivalente a xtabs(~foo)salvar o arquivo e. Eu posso resgatar o ne o tcom o truque de código hex / octal ; a solução mais golfista é usar u\164f8ToI\x6Et(em backticks) para utf8ToInt.

Braquilog , 18 bytes

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

Experimente online!

Infelizmente, não consigo remover os feeds de linha, pois ḅem um número desencadeia uma falha.

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 vezes cada

Experimente online!

R, 132 116 bytes

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

Também não contém comentários ou seqüências supérfluas, embora provavelmente seja a minha única vez no código golf chamando uma função crudcardounenforceableuploads. Provavelmente existe um ótimo anagrama em algum lugar para o nome da função! Agradeço a John Dvorak por apontar um bom solucionador de anagramas, que usei para o nome.

Tabela 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

exemplos:

> 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***{}[[[]]]...--''

Essa linha de código recebe uma string stdin como entrada. "grep -o". coloca cada caractere em uma nova linha. "uniq -c" conta o uso de cada personagem. O script awk cria uma matriz com cada uso como um elemento diferente e gera true quando há apenas 1 índice da matriz e o valor é pelo menos 2. Cada caractere é usado 4 vezes, portanto, essa fonte retorna true

Stax , 26 24 18 bytes

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

Experimente online!

Até agora, a solução mais curta que usa apenas ASCIIs imprimíveis batidos por MATL.

Acho que estava abordando o problema da maneira errada. Repetir um bloco de trabalho não é nem golfe nem interessante. Agora, pelo menos, parece melhor ...

Explicação

:u{m* produz algum lixo que não afeta a saída.

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

Experimente online!

Explicação

Cada personagem ocorre duas vezes.

                        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

Versão alternativa de 22 bytes com 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 caracteres diferentes, repetidos 4 vezes cada.

Nenhum comentário foi usado (mas a expressão depois neXTnunca é realmente avaliada)

Script para verificar as respostas:

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

A saída estará vazia se falsa ou não vazia se for verdadeira.

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

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

Experimente online

Programa principal (39 bytes)

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

Explicação

Todo o programa principal está em um loop silencioso. O primeiro estágio classifica a entrada. O segundo estágio imprimirá a sequência atual se consistir em pares sucessivos de caracteres diferentes. O terceiro estágio remove a última ocorrência de cada caractere (removendo um de cada caractere na sequência).

Sobre o lixo no topo: a ordem é importante. Além de precisar ser sintaticamente válido, um ponto-e-vírgula deve estar após os asteriscos e antes dos backticks, contanto que *esteja na string de configuração, para que não seja impresso.

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

Experimente online!

Começou com minha resposta ES6, mas voltou a usar Array.every. 32 31 30 tokens a 3 cada

Pitão, 30 bytes

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

Espaços principais necessários.

Experimente online!

O programa atual é justo &q1lJ{hMrSz8<1hJ. Acabei de anexar a string "&8<MQSlqr{"para torná-la não discriminatória. Mas para que a sequência não fosse impressa, tive que adicionar um espaço, então adicionei 2 espaços.

&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) pega uma sequência e gera o comprimento de cada execução do mesmo caractere, ex. "aaabbcc"torna-se [[3, "a"], [2, "b"], [2, "c"]].

Portanto, isso pega a entrada, classifica-a para incluir a codificação de comprimento e pega o primeiro elemento de cada lista na lista resultante (por exemplo, o exemplo anterior se tornaria [3, 2, 2]). Isso fornece uma contagem de quantas vezes os caracteres ocorrem. Em seguida, é deduplicada (o exemplo anterior se tornaria [3, 2]) e J é definido para isso.

Em seguida, verifica se o comprimento é 1, ou seja, existe apenas 1 número único de vezes que um caractere ocorre, e se é> 1, ou seja, = = 2.

Pode haver um built-in para substituir rSz8ou hMrSz8mas não consigo encontrar um.

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

Experimente online!

Retorna o endereço da string como valor de verdade e zero 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  

Experimente online!

Acontece que a versão de três caracteres é um pouco menor que a de dois caracteres.