Programação não discriminatória


74

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

4
@Laikoni somos capazes de abusar dos comentários para que isso funcione?
Octopus mágico Urn

6
Como observação lateral, adoro desafios em que posso usar outras entradas para testar a validade da minha entrada.
Octopus mágico Urn

3
@MagicOctopusUrn Acho que ele disse na caixa de areia que é permitida, pois não pode ser observada de maneira determinada.
Erik the Outgolfer

11
Exatamente. Mesmo que você consiga banir os comentários de maneira objetiva, o que dizer dos literais de string não utilizados? Enfim, acho que a pontuação incentiva a evitar comentários o máximo possível.
Laikoni

4
Entendo que é apenas um quebra-cabeça, mas a fusão de "não discriminante" com "todos os tipos de membros rotulados identificáveis ​​existentes em partes exatamente iguais" é levemente perturbadora ... "Discriminar" significa "diferenciar" e injustamente, isso significa tratar ou julgar injustamente alguém com base em vê-lo como diferente de outra classe de pessoas. Claro, continue com a diversão!
ErikE

Respostas:


37

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

25

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

1
180 bytes : mudou tudo<para>.
Olivier Grégoire

@ OlivierGrégoire Desculpe, eu já estou com 174 :) Mas vou ver se o seu truque ainda pode ser aplicado.
Kevin Cruijssen

A alteração ainda pode ser aplicada para salvar 6 bytes.
Olivier Grégoire

Eu sou o mais próximo de 162 caracteres (161 caracteres) . Estou tentando remover o comentário, mas ainda preciso colocar uma vírgula em algum lugar. Eu simplesmente não consigo encontrar nenhum lugar.
Olivier Grégoire

1
160 bytes ( prova ). Muito provavelmente mais jogável.
Olivier Grégoire

15

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

13

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ℕ₂ℕ₂ọᵐ

13

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.


11

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!


Awwhh ... eu queria ser o primeiro abusador de comentários. Nice one, porém, eu gosto de como você ordenados os caracteres pelo comentário ^ _ ^
Magia Octopus Urna

1
Você pode reduzi-lo para 324 bytes , alterando os dois 128para 222para que 8possam ser descartados.
Kevin Cruijssen 01/03/19

1
279 bytes, renomeando i, v, S, se Lpara personagens que já aparecem nas palavras-chave char, fore return: Tente-lo online!
Laikoni

@Laikoni Thanks! Ontem não tive tempo de jogar golfe adequadamente.
Steadybox

@MagicOctopusUrn Eles são classificados porque eu estava com preguiça de adicioná-los manualmente .
Steadybox #

9

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)

{γ€gDË*P≠qq{γ€gDË*P≠é outro para 20;).
Octopus mágico Urn

1
@MagicOctopusUrn: Nice! Eu tinha alguns outros aos 20 também. Eu tenho um de 18, bem como agora :)
Emigna

2
FEITIÇARIA! Nenhuma outra explicação!
Octopus mágico Urn

1
¢... boa ideia cara, também estou feliz em ver que foi tão útil quanto pensei que fosse haha!
Urna Mágica do Polvo

9

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?

Mas isso tem 'u' mais que 'm', portanto não atende aos requisitos.
WGroleau

O @WGroleau mtambém ocorre duas vezes: na primeira linha e na segunda linha. A explicação não inclui as duas linhas curtas porque elas não afetam o comportamento do programa.
Zgarb

Eu acho que o OP deve esclarecer se uma explicação sobre o programa podem ser digitalizados, juntamente com o program.but na verdade, se você incluir isso, então você tem quatro 'u' e dois 'm'
WGroleau

Deixa pra lá; isso me confundiu da mesma maneira que outra resposta.
WGroleau 02/03

9

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!


O truque de erro de deslocamento negativo é legal! Eu gosto de como ele tira vantagem da baixa precedência do operador de turno.
Vincent

1
{{e.dil:-tu,r.dil:-tu,}} Bom Deus, o que é isso?
22618 Adam Barnes #

1
@AdamBarnes Sem sentido válido sintaticamente que gera um NameError se avaliado.
Dennis

Eu não entendo. Tentei trocá-lo ae tudo quebrou. Você poderia explicar mais, por favor?
Adam Barnes

@AdamBarnes Isso deve funcionar, desde que você deixe um espaço após o or. Vou adicionar uma explicação quando estiver no computador.
Dennis

9

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




7

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.

6

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.


6

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!


6

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!


1
Seu programa deve ser não discriminatório.
precisa saber é o seguinte

1
O programa em si deve ser não discriminatório.
HyperNeutrino #

@ user202729 Obrigado por me informar, atualizei minha resposta.
OVS



6

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

5

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!


5

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.


É impressionante que você possa discriminar os dois casos em 90 bytes (e abuso abusivo do operador de ajuda), mas, infelizmente, NAnão é considerado um valor verdadeiro (em R, se (NA) x else y causar um erro, também NAnão é verdade nem falsey )
JDL

1
@JDL Obrigado, você está certo. A edição mais recente corrige esse problema.
Robin Ryder em

1
@JDL os comentários sugerem que respostas consistentes e distintas são válidas para verdade e falsidade.
Giuseppe

@ Giuseppe Na verdade, eu resolvi esse problema segundos atrás (veja a nova versão, que é bem diferente, mas com a mesma contagem de bytes); agora gera VERDADEIRO e FALSO.
Robin Ryder em

4

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.


É definitivamente possível fazer algo mais curto que não requer linefeeds (mas você pode precisar de mudar algumas coisas);)
Fatalize

@Fatalize Não há tempo para atualmente, e sim eu li essa discussão. :)
Erik the Outgolfer

4

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!


@ nimi Obrigado por apontar, acho que isso foi um pouco estranho com getse ;. Mudou, é mais curto como um lambda de qualquer maneira
Asone Tuhid

3

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

não sabemos se a contagem de bytes é importante, mas provavelmente podemos remover os 2s e os >, alternando a comparação com f. Também pode usar em =vez de <<-. strsplitprovavelmente é inevitável, que é a fonte da maioria dos outros personagens.
JDL

você precisa dos espaços? você também pode tentar utf8ToIntem vez de strsplit, mas não tenho certeza se isso vai ajudar. Talvez também inclua um link para o TIO?
Giuseppe

também todos .parecem supérfluos.
Giuseppe

Isso é código-golfe , portanto, a contagem de bytes é importante, de acordo com seu comentário.
Giuseppe

2
alguns anagramas possíveis: sem burocracias no armário; RIP mergulho libra carbonácea grelhada. Encontrado usando wordplays.com/anagrammer
John Dvorak #

2

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


2

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

@WGroleau quais caracteres aparecem uma vez? Você leu minha resposta com atenção suficiente?
Weijun Zhou

'#' aparece com mais frequência que ':' (apenas um exemplo). Opa, interpretando mal (ver outro comentário)
WGroleau

@WGroleau Existem exatamente dois #e dois :segundos, você leu minha resposta na segunda linha? Você acabou de pular o primeiro parágrafo da minha "Explicação"?
Weijun Zhou

Desculpe, pensei que a linha acima da explicação fosse a coisa toda.
WGroleau

1

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

1

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:


1

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.


Bom, minha resposta é mais curta, mas não tenho certeza se a escala é boa para ser corrigida para 0/1 como saída, por isso vou adicioná-la aqui, caso isso ajude você: tio.run/##K0otycxLNPz/…
FryAmTheEggman

@FryAmTheEggman Eu estava procurando uma solução de regex pura para combinar grupos de caracteres do mesmo comprimento, todos seguidos, mas não consegui descobrir.
mbomb007

@FryAmTheEggman Fez uma grande melhoria! Eu realmente não usei o que você tinha, mas comecei do zero tentando pensar em um método melhor.
Mbomb007 02/0318

Bem feito! E eu não tinha pensado o suficiente sobre o meu programa, parece, mas pelo menos você encontrou um melhor :) :)
FryAmTheEggman


1

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.


1

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.

Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.