Programación no discriminatoria

74

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>"
Laikoni
fuente
44
@Laikoni, ¿podemos abusar de los comentarios para que esto funcione?
Magic Octopus Urn
66
Como nota al margen, me encantan los desafíos en los que puedo usar otras entradas para probar la validez de mi entrada.
Magic Octopus Urn
3
@MagicOctopusUrn Creo que lo dijo en el sandbox permitido, ya que no se puede determinar de manera observable.
Erik the Outgolfer
11
Exactamente. Incluso si de alguna manera logras prohibir los comentarios de manera objetiva, ¿qué pasa con los literales de cadena no utilizados ect? De todos modos, creo que la puntuación da un incentivo para evitar los comentarios tanto como sea posible.
Laikoni
44
Entiendo que es solo un enigma, pero la combinación de "no discriminar" con "todos los tipos de miembros etiquetados identificables que existen en partes exactamente iguales" es levemente perturbadora ... "discriminar" significa "decir la diferencia entre" y hacer esto injustamente significa tratar o juzgar injustamente a alguien basándose en verlo como diferente de otra clase de personas. ¡Por supuesto, sigue adelante con la diversión!
ErikE

Respuestas:

37

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

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]).
Kevin Cruijssen
fuente
1
180 bytes : cambiado todo<a>.
Olivier Grégoire
@ OlivierGrégoire Lo siento, ya estoy en 174 :) Pero veré si tu truco aún se puede aplicar.
Kevin Cruijssen
El cambio aún puede aplicarse para guardar 6 bytes.
Olivier Grégoire
Lo más cerca que estoy de 162 caracteres (161 caracteres) . Estoy tratando de eliminar el comentario, pero aún necesito poner una coma en alguna parte. Simplemente no puedo encontrar ningún lugar.
Olivier Grégoire
1
160 bytes ( prueba ). Muy probablemente más golfable.
Olivier Grégoire
15

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
Dennis
fuente
13

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

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.

BradC
fuente
11

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!

Steadybox
fuente
Awwhh ... quería ser el primer abusador de comentarios. Bueno, me gusta cómo ordenó los caracteres para el comentario ^ _ ^
Urna de pulpo mágico el
1
Puede reducirlo a 324 bytes cambiando ambos 128a 222para que 8se pueda descartar.
Kevin Cruijssen
1
279 bytes por el cambio de nombre i, v, S, sy Lde personajes que ya aparecen en las palabras clave char, fory return: probar en línea!
Laikoni
@Laikoni ¡Gracias! No tuve tiempo de jugar golf correctamente ayer.
Steadybox
@MagicOctopusUrn Están ordenados porque era demasiado vago para agregarlos a mano .
Steadybox
9

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)
Emigna
fuente
{γ€gDË*P≠qq{γ€gDË*P≠es otro para 20;).
Urna de pulpo mágico el
1
@MagicOctopusUrn: ¡Qué bueno! Tuve un par de otros a los 20 también. Tengo uno a los 18 ahora también :)
Emigna
2
¡BRUJERÍA! ¡Ninguna otra explicación!
Magic Octopus Urn
1
¢... buena idea hombre, también me alegra ver que fue tan útil como pensé que podría ser jaja.
Magic Octopus Urn
9

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?
Zgarb
fuente
Pero esto tiene 'u' más que 'm', por lo que no cumple con los requisitos.
WGroleau
@WGroleau mtambién aparece dos veces: en la primera línea y en la segunda línea. La explicación no incluye las dos líneas cortas porque no afectan el comportamiento del programa.
Zgarb
Supongo que el OP debería aclarar si se puede escanear una explicación del programa junto con el programa. Pero en realidad, si incluye eso, entonces tiene cuatro 'u' y dos 'm'
WGroleau
No importa; Esto me confundió de la misma manera que otra respuesta.
WGroleau
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,}}

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!

Dennis
fuente
¡El truco del error de cambio negativo es bueno! Me gusta cómo se aprovecha la baja prioridad del operador de turno.
Vincent
1
{{e.dil:-tu,r.dil:-tu,}} Dios mío, ¿qué es eso?
Adam Barnes
1
@AdamBarnes Galimatías sintácticamente válidas que arrojan un NameError si se evalúa.
Dennis
No lo entiendo Traté de cambiarlo ay todo se rompió. ¿Podría explicar más por favor?
Adam Barnes
@AdamBarnes Eso debería funcionar, siempre y cuando dejes un espacio después del or. Agregaré una explicación cuando esté en una computadora.
Dennis
9

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

ais523
fuente
1
¡Es el idioma de este mes !
Erik the Outgolfer
7

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!

Vincent
fuente
+1 para el código corto de Python que no produce errores y nuestra utopía ram;)
Shieru Asakoto
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)

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

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.

AdmBorkBork
fuente
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 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!

nimi
fuente
6

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!

ovs
fuente
1
Su programa debe ser no discriminatorio.
usuario202729
1
El programa en sí debe ser no discriminatorio.
HyperNeutrino
@ user202729 Gracias por decirme, actualicé mi respuesta.
ovs
6

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
Luis Mendo
fuente
5

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!

Ton Hospel
fuente
5

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.

Robin Ryder
fuente
Es impresionante que pueda discriminar los dos casos en 90 bytes (y un buen abuso del operador de ayuda), pero NAlamentablemente no se considera un valor verdadero (en R, si (NA) x más y causa un error, por NAlo que no es ni verdadero ni falso) )
JDL
1
@JDL Gracias, tienes razón. La última edición corrige este problema.
Robin Ryder
1
@JDL los comentarios sugieren que las respuestas consistentes y distintas están bien para la verdad y la falsedad.
Giuseppe
@Giuseppe En realidad, resolví este problema hace unos segundos (vea la nueva versión, que es bastante diferente pero el mismo número de bytes); ahora genera VERDADERO y FALSO.
Robin Ryder
4

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.

Erik el Outgolfer
fuente
Definitivamente es posible hacer algo más corto que no requiera avances de línea (pero es posible que deba cambiar algunas cosas);)
Fatalize
@Fatalize No hay tiempo para actualmente, y sí, leí esa discusión. :)
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 veces cada uno

Pruébalo en línea!

Asone Tuhid
fuente
@nimi Gracias por señalarlo, creo que fue algo extraño con getsy ;. Lo cambié, de todos modos es más corto como una lambda
Asone Tuhid
3

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
JDL
fuente
no sé si el recuento de bytes es importante, pero probablemente podamos eliminar los 2 y los >s, cambiando la comparación con f. También se puede usar en =lugar de <<-. strsplitSin embargo, es inevitable, que es la fuente de la mayoría de los otros personajes.
JDL
necesitas los espacios? También podría intentarlo en utf8ToIntlugar de hacerlo strsplit, pero no estoy seguro de si eso ayudará. ¿También puede incluir un enlace a TIO?
Giuseppe
También todo .parece ser superfluo.
Giuseppe
Este es el código de golf , por lo que el conteo de bytes es importante, según su comentario.
Giuseppe
2
algunos anagramas posibles: no hay burocracias de armarios unidos por pip; RIP de salsa de libra asada a la brasa carbonosa. 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***{}[[[]]]...--''

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

Caleb
fuente
2

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
Weijun Zhou
fuente
@WGroleau, ¿qué personajes aparecen una vez? ¿Leíste mi respuesta con suficiente cuidado?
Weijun Zhou
'#' aparece con más frecuencia que ':' (solo un ejemplo). Oops, lectura errónea (ver otro comentario)
WGroleau
@WGroleau Hay exactamente dos #y dos :s, ¿leíste mi respuesta en la segunda línea? ¿Te saltaste el primer párrafo de mi "Explicación"?
Weijun Zhou
Lo siento, pensé que la línea sobre la explicación era todo.
WGroleau
1

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
DLosc
fuente
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 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:

12Me21
fuente
1

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.

mbomb007
fuente
Bien, mi respuesta es más corta, pero no estoy seguro de que se ajuste bien a 0/1 como salida, así que solo la agregaré
FryAmTheEggman
@FryAmTheEggman Estaba buscando una solución de expresión regular pura para unir grupos de caracteres de la misma longitud, pero no pude resolverlo.
mbomb007
@FryAmTheEggman ¡Hizo una gran mejora! Realmente no usé lo que tenías, pero comencé desde cero tratando de pensar en un método mejor.
mbomb007
¡Bien hecho! Parece que no había pensado lo suficiente sobre mi programa, pero al menos has encontrado uno mejor :)
FryAmTheEggman
1

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.

RK.
fuente
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);}}}}}}}

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.
gastropner
fuente
1

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.

Jo King
fuente