Desafío:

Entradas:

• Una cadena que contiene ASCII imprimible (excluyendo espacios, tabulaciones y nuevas líneas)
• Un booleano †

Salida:

Las partes de la cadena se dividen en cuatro grupos:

• Letras minusculas
• Letras mayúsculas
• Dígitos
• Otro

Con base en el valor booleano, mostramos la aparición más alta de uno (o varios) de estos cuatro grupos, o la más baja, reemplazando todo lo demás con espacios.

Por ejemplo:

Entrada: "Just_A_Test!"
Contiene:
- 3 letras mayúsculas: JAT
- 6 letras minúsculas: ustest
- 0 dígitos
- 3 otros:__!

Estos serían los resultados para trueo false:

true:   " ust    est "

// digits have the lowest occurrence (none), so everything is replaced with a space
false:  "            "

(Nota: puede ignorar los espacios finales, por lo que las salidas también pueden ser " ust est"y ""respectivamente).

Reglas de desafío:

• La entrada nunca estará vacía o contendrá espacios, y solo consistirá en ASCII imprimible en el rango 33-126o a '!'través '~'.
• Se le permite tomar la entrada y / o salida como matriz de caracteres o lista si lo desea.
• † Se permiten dos valores consistentes y distintos para el booleano: true/ false; 1/ 0; 'H'/ 'L'; "highest"/ "lowest"; ¡Tenga en cuenta que estos valores distintos deben usarse (algo) como un valor booleano! Por lo tanto, no está permitido ingresar dos programas completos, uno que proporcione el resultado correcto para truey el otro para false, y luego que solo tenga su código real <run input with parameter>. La nueva laguna predeterminada relevante que he agregado, aunque todavía puede usar una gran cantidad de ajustes con respecto a las definiciones.
• Si la ocurrencia de dos o más grupos es la misma, mostramos todas esas ocurrencias.
• Los espacios finales necesarios son opcionales, y una nueva línea final también es opcional. Los espacios iniciales necesarios son obligatorios. Y no se permiten otros espacios iniciales o nuevas líneas.

Reglas generales:

• Este es el código de golf , por lo que la respuesta más corta en bytes gana.
  No permita que los lenguajes de code-golf lo desanimen a publicar respuestas con lenguajes que no sean codegolfing. Trate de encontrar una respuesta lo más breve posible para 'cualquier' lenguaje de programación.
• Se aplican reglas estándar para su respuesta, por lo que puede usar STDIN / STDOUT, funciones / método con los parámetros adecuados, programas completos. Tu llamada.
• Las lagunas predeterminadas están prohibidas.
• Si es posible, agregue un enlace con una prueba para su código.
• Además, agregue una explicación si es necesario.

Casos de prueba:

Inputs:                              Output:

"Just_A_Test!", true                 " ust    est "     (or " ust    est")
"Just_A_Test!", false                "            "     (or "")
"Aa1!Bb2@Cc3#Dd4$", either           "Aa1!Bb2@Cc3#Dd4$"
"H@$h!n9_!$_fun?", true              " @$ !  _!$_   ?"
"H@$h!n9_!$_fun?", false             "H     9        "  (or "H     9")
"A", true                            "A"
"A", false                           " "                (or "")
"H.ngm.n", true                      "  ngm n"
"H.ngm.n", false                     "       "          (or "")
"H.ngm4n", false                     "H.   4 "          (or "H.   4")

Casco , 27 26 24 22 bytes

-2 bytes gracias a Zgarb

-2 bytes gracias a Leo

Toma ' 'as Falsey 'a'as True(en Husk, los espacios en blanco en Fasly y todos los demás personajes son Truthy)

Fż▲→ġ#¬Ö#≡⁰Ṫḟë½D±o¬□m;

Pruébalo en línea!

¿Como funciona?

Fż▲→ġ#¬Ö#≡⁰Ṫḟë½D±o¬□m;   Function, takes a character c and a string S as arguments
                    m;   Wrap each character in S into it's own string
             ë           List of four functions returning booleans:
              ½D±o¬      Lower case?,Upper case?,Digit?,Not alphanumeric?
           Ṫḟ            Outer product with find†
       Ö#≡⁰              Sort on how many characters have the same Truthyness as c
    ġ#¬                  Group strings with equal numbers of spaces
   →                     Take the last group
Fż▲                      Squash it all into one list

† ḟ es una función que toma un predicado py una lista Ly devuelve el primer elemento Lque satisface p. Si ningún elemento satisface, pse devuelve un argumento predeterminado. En este caso ' '. Al aplicar ḟa una cadena de un carácter, estamos diciendo esencialmente if p c then c else ' '.

ṪEs la función que toma una función fy dos listas L1, L2. Devuelve una tabla de faplicado sobre todos los pares de L1y L2. En este caso fes ḟ, L1es nuestra lista de 4 funciones, y L2es la lista de cadenas de un carácter.

Después Ṫḟ tenemos una lista de cadenas donde cada cadena es el resultado de reemplazar caracteres que no satisfacen una de las reglas con a ' '.

Nota: en las versiones más nuevas de Husk, ġ#¬Ö#≡⁰se puede reemplazar por k#≡⁰un ahorro de 3 bytes.

Jalea , 31 bytes

ØṖḟØBṭØBUs26¤f€³Lİ⁴¡$ÐṀFf
¹⁶Ç?€

Pruébalo en línea!

Los valores booleanos son 2y 1(o cualquier otro par positivo / impar positivo), que representanTrue y Falserespectivamente. Intentaré agregar una explicación después de seguir jugando al golf.

¡Gracias a caird coinheringaahing por guardar 2 bytes, y a Lynn por guardar 4 bytes! Gracias a uno de los trucos de Erik. , que me inspiró a ahorrar 4 bytes!

Cómo funciona

Tenga en cuenta que esta es la explicación de la versión de 35 bytes. El nuevo hace más o menos lo mismo (pero Lynn lo modificó un poco), así que no lo cambiaré.

ØBUs26f€³µ³ḟØBW,µẎLİ⁴¡$ÐṀF - Niladic helper link.
ØB                         - String of base digits: '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ
                             abcdefghijklmnopqrstuvwxyz'. 
  U                        - Reverse.
   s26                     - Chop into sublists of length 26, preserving shorter
                             trailing substrings.
      f€³                  - For each, keep the common characters with the input.
            ØB             - Base digits.
          ³ḟ               - Get the signs in the input. Filter the characters of the
                             input that aren't alphanumeric.
              W,µẎ         - Concatenate (wrap, two element list, tighten).
                       ÐṀ  - Keep the elements with maximal link value.
                  L        - Length.
                    ⁴¡     - Do N times, where N is the second input.
                   İ       - Inverse. Computes 1 ÷ Length. 2 maps to the length itself,
                             because 1 ÷ (1 ÷ Length) = length; 1 yields
                             (1 ÷ Length), swapping the maximal numbers with minimal ones.
                         F - Flatten.

¹⁶e¢$?€ - Main link.
      € - For each character.
   e¢?  - If it is contained by the last link (called niladically), then:
¹       - Identity, the character itself, else:
 ⁶      - A space.

Python 2 , 166 158 bytes

t=lambda c:('@'<c<'[','`'<c<'{','/'<c<':',1-c.isalnum())
def f(s,b):x=map(sum,zip(*map(t,s)));print''.join([' ',c][x[t(c).index(1)]==sorted(x)[-b]]for c in s)

Pruébalo en línea!

R , 193 186 179 158 bytes

-7 bytes gracias a NofP y su sugerencia de cbind

-6 bytes usando outer, -1 byte de conmutación[^a-zA-Z0-9] con[[:punct:]]

-21 bytes gracias a MickyT por señalar una lista de caracteres está permitido

function(S,B){y=outer(c("[a-z]","[A-Z]","\\d","[[:punct:]]"),S,Vectorize(grepl))
S[!colSums(y[(s=rowSums(y))=="if"(B,max,min)(s),,drop=F])]=" "
cat(S,sep='')}

Verificar todos los casos de prueba

Toma 1/Tcomo verdadero ( max) y 0/Fcomo falsey ( min), y tomaS como una lista de caracteres individuales.

Pruébalo en línea!

En mi versión original (con las sugerencias de NofP), la matriz yse construye evaluando grepl(regex, S)para cada uno regex, luego concatenándolos juntos como columnas de una matriz. Esto da como resultado múltiples llamadas a grepl, pero, como Sse solucionó, parecía que había que hacer algo más. Como señalé:

Hay enfoques potencialmente más cortos; mapply, por ejemplo:

y=mapply(grepl,c("[a-z]","[A-Z]","\\d","[^a-zA-Z0-9]"),list(S))

desafortunadamente, esto no se simplificará como una matriz en el ejemplo de 1 carácter de "A".

Utilicé en outerlugar de mapply, que siempre devuelve una matriz (una matriz en este caso), y me vi obligado a hacerlo Vectorize grepl, que en realidad es solo unmapply envoltura a su alrededor.

También descubrí el grupo de caracteres predefinido [:punct:]que coincide con los caracteres de puntuación (sin espacio, no alfanuméricos).

Casco , 31 29 28 bytes

SMS?' `ṁ§foSM≠?▲▼⁰M#Kë½D±o¬□

Utiliza 0 para mínimos y 1 para recuentos de caracteres máximos. Pruébalo en línea!

Explicación

Las listas de funciones son geniales.

SMS?' `ṁ§foSM≠?▲▼⁰M#Kë½D±o¬□  Inputs are bit B and string S.
                     ë        Make a list L of the four functions
                      ½       is-lowercase-letter,
                       D      is-uppercase-letter,
                        ±     is-digit, and
                         o¬□  not is-alphanumeric.
                  M#          For each of them, take number of matches in S,
              ?▲▼⁰            take maximum or minimum depending on B,
          oSM≠                and mark those entries that are not equal to it.
        §f          K         Remove from L the functions that correspond to marked entries, call the result L2.
                              These functions test whether a character should be replaced by a space.
SM                            Do this for each character C in S:
      `ṁ                      Apply each function in L2 to C and sum the results.
  S?'                         If the result is positive, return space, otherwise return C.

Python 2 , 140 bytes

g=lambda x:x.isalnum()-~(x>'Z')*x.isalpha()
def f(s,m):k=map(g,s).count;print''.join([' ',c][k(g(c))==sorted(map(k,range(4)))[m]]for c in s)

Pruébalo en línea!

Jonathan Frech guardó un byte. ¡Gracias!

Más alto es m=-1, más bajo es m=0.

Jalea , 35 bytes

ØWṖs26µẎØṖḟW⁸;
¢ċ@€S¥€N⁹¡Mị¢Ẏ⁸f€ȯ€⁶

Pruébalo en línea!

Java (OpenJDK 8) , 448 439 432 362 361 354 352 348 343 320 bytes

s->b->{int w[]=new int[4],m=0,n=-1>>>1,l;s.chars().forEach(c->{if(c>96&c<123)w[0]++;else if(c>64&c<91)w[1]++;else if(c>47&c<58)w[2]++;else++w[3];});for(int W:w){m=W>m?W:m;n=W<n?W:n;}l=m-n;m=b?m:n;return l<1?s:s.replaceAll("["+(w[0]!=m?"a-z":"")+(w[1]!=m?"A-Z":"")+(w[2]!=m?"\\d]":"]")+(w[3]!=m?"|[^a-zA-Z0-9]":"")," ");}

Pruébalo en línea!

rubí ,118 116 bytes

Toma 0 (lowest) or -1 (highest) for its second argument.

-2 bytes gracias a Lynn.

->s,t{s.gsub(/./){|c|[/\d/,/[a-z]/,/[A-Z]/,/[^\da-z]/i].group_by{|x|s.scan(x).size}.sort[t][1].any?{|x|x=~c}?c:" "}}

Pruébalo en línea!

Sin golf

->s,t{
  s.gsub(/./) {|c|
    [ /\d/,
      /[a-z]/,
      /[A-Z]/,
      /[^\da-z]/i
    ]
    .group_by {|x| s.scan(x).size }
    .sort[t][1]
    .any? {|x| x =~ c } ? c : " "
  }
}

Python 2, 190 183 174 173 bytes

Thanks to Jonathan Frech for shortening it

from re import*
def f(i,c):
 q='[a-z]','[A-Z]','\d','[\W_]';l=[len(set(finditer(p,i)))for p in q]
 for j,k in enumerate(l):
	if k-eval(c):i=compile(q[j]).sub(' ',i)
 print i

This takes the strings 'max(l)' and 'min(l)' as true and false. (I don't think this breaks the rules...?) This is longer than the other two python answers but different so I thought I'd post it. I'm not a great golfer so I'm guessing this could be improved further but all the things I tried didn't work.

Try it online!

JavaScript (ES6), 151 149 bytes

g=
(s,f,a=[/\d/,/[A-Z]/,/[a-z]/,/[_\W]/],b=a.map(r=>s.split(r).length))=>s.replace(/./g,c=>b[a.findIndex(r=>r.test(c))]-Math[f?"max":"min"](...b)?' ':c)

<input id=s oninput=o.textContent=g(s.value,f.checked)><input id=f type=checkbox onclick=o.textContent=g(s.value,f.checked)><pre id=o>

Sadly the rules probably don't allow me to pass Math.max or Math.min as the flag. Edit: Saved 2 bytes thanks to @JustinMariner.

Jelly, 37 bytes

ØWṖs26µẎØṖḟW⁸;
¢f@³L$ÐṂFe@Ѐ³¬¹⁴?a³o⁶

Try it online!

-6 bytes "borrowing" from Erik's post :D

Java (OpenJDK 8), 307 + 34 306 + 27 295 bytes

My "interesting" take on the challenge.

Thanks to Kevin Cruijssen for cutting down the import bytes removing the import entirely!

s->b->{String t=s.replaceAll("\\d","2").replaceAll("[a-z]","0").replaceAll("[A-Z]","1").replaceAll("\\D","3"),v="";int a[]={0,0,0,0},i=0,z=0,y=-1>>>1;t.chars().forEach(j->{a[j%4]++;});for(int x:a){z=x>z?x:z;y=x<y?x:y;}for(;i<s.length();i++)v+=a[t.charAt(i)%4]!=(b?z:y)?" ":s.charAt(i);return v;}

Try it online!

Explanation:

String t=s.replaceAll("\\d","2")
          .replaceAll("[a-z]","0")
          .replaceAll("[A-Z]","1")
          .replaceAll("\\D","3")

First replaces each group with an integer between 0 and 3 using some simple regex and stores this in a new String.

int a[]={0,0,0,0},m,i=0,z=0,y=-1>>>1;

Initialises an array of integers as well as a couple of other integers to use later. Sets the y variable to the max int size using unsigned right bit shift.

t.chars().forEach(j->{a[j%4]++;});

For each character in the modified string, this uses its ASCII value modulo 4 to calculate the index of the aforementioned array to increment.

for(int x:a){
    z=x>z?x:z;
    y=x<y?x:y;
}

This then loops through the counts of each group stored in the array and calculates the minimum (y) and the maximum (z).

for(;i<s.length();i++)
    v+=a[t.charAt(i)%4]!=(b?z:y)?" ":s.charAt(i);

Loops through every character in the String again, checking if the group of that characters group is equal to the min/max (using the modulo trick mentioned earlier). If it isn't equal, then a space is added to the new String in the characters place, otherwise the original character is added.

return v;

Finally return the new String!

Bash, 229 227 212 bytes

LANG=C;g="A-Z a-z 0-9 !A-Za-z0-9";declare -A H
f()(((i=$2?99:-1));r=$1;for h in $g;{ t=${r//[$h]};t=${#t};(($2?t<i:t>i))&&i=$t&&H=([$h]=1);((t-i))||H[$h]=1;};for h in $g;{((${H[$h]}))||r=${r//[$h]/ };};echo "$r")

Try it Online

PHP, 161 158 bytes

for([,$s,$z]=$argv;~$c=$s[$i++];)foreach([punct,upper,lower,digit]as$f)(ctype_.$f)($c)?$$i=$f:$g[$f]++;while(~$c=$s[$k++])echo$g[$$k]-($z?min:max)($g)?" ":$c;

Run with -nr or try it online.

• first loop: for each position, remember the group of the character
  and count the occurences of groups that the current character is not in.
  (that negation saved 3 bytes)
• depending on second parameter, pick min non-count for truthy, max non-count for falsy.
• second loop: if (group of current character) non-count differs
  from min/max non-count then print space, else print character.

JavaScript (ES6), 139 bytes

s=>b=>s.map(c=>++a[g(c)]&&c,a=[0,0,0,0],g=c=>c>-1?0:/[a-z]/i.test(c)?c<"a"?2:1:3).map(c=>a.map(v=>v-Math[b?"max":"min"](...a))[g(c)]?" ":c)

Input and output is an array of characters. Takes actual boolean values for input.

A different approach from @Neil's answer; almost avoiding regular expressions. Instead, I used a series of checks to determine the category of each character:

• Digits return true for c>-1 because non-digits fail mathematical comparisons
• Uppercase letters match the regex /[a-z]/i and have codepoints less than "a"
• Lowercase letters match that regex but have codepoints not less than "a"
• Symbols pass none of those tests

Test Cases

f=
s=>b=>s.map(c=>++a[g(c)]&&c,a=[0,0,0,0],g=c=>c>-1?0:/[a-z]/i.test(c)?c<"a"?2:1:3).map(c=>a.map(v=>v-Math[b?"max":"min"](...a))[g(c)]?" ":c)

;[["Just_A_Test!", true],["Just_A_Test!", false],["Aa1!Bb2@Cc3#Dd4$", true],["Aa1!Bb2@Cc3#Dd4$", false],["H@$h!n9_!$_fun?", true],["H@$h!n9_!$_fun?", false],["A", true],["A", false],["H.ngm.n", true],["H.ngm.n", false],["H.ngm4n", false]]
.forEach(([S,B])=>console.log(`"${S}", ${B} -> "${f(S.split``)(B).join``}"`))

.as-console-wrapper{max-height:100%!important}