Desafio:

Entradas:

• Uma sequência contendo ASCII imprimível (excluindo espaços, tabulações e novas linhas)
• Um booleano †

Resultado:

As partes da String são divididas em quatro grupos:

• Letras minúsculas
• Letras maiúsculas
• Dígitos
• De outros

Com base no booleano, produzimos a ocorrência mais alta de um (ou vários) desses quatro grupos, ou o menor, substituindo todo o resto por espaços.

Por exemplo:

Entrada: "Just_A_Test!"
Contém:
- 3 letras maiúsculas: JAT
- 6 letras minúsculas: ustest
- 0 dígitos
- 3 outras:__!

Estes seriam os resultados para trueou false:

true:   " ust    est "

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

(Nota: Você tem permissão para ignorar espaços à direita, para que as saídas também possam ser " ust est"e ""respectivamente.)

Regras do desafio:

• A entrada nunca estará vazia ou conterá espaços e consistirá apenas em ASCII imprimível no intervalo 33-126ou '!'através dele '~'.
• Você pode receber as entradas e / ou saídas como matriz ou lista de caracteres, se desejar.
• † São permitidos dois valores consistentes e distintos para o booleano: true/ false; 1/ 0; 'H'/ 'L'; "highest"/ "lowest"; etc. Observe que esses valores distintos devem ser usados ​​(um pouco) como um booleano! Portanto, não é permitido inserir dois programas completos, um que forneça o resultado correto truee o outro para false, e apenas ter o seu código real <run input with parameter>. Nova brecha padrão relevante que eu adicionei, embora ainda possa usar muitas afinações nas definições.
• Se a ocorrência de dois ou mais grupos for a mesma, produzimos todas essas ocorrências.
• Os espaços à direita necessários são opcionais, e uma única nova linha à direita também é opcional. Os espaços de liderança necessários são obrigatórios. E quaisquer outros espaços à esquerda ou novas linhas não são permitidos.

Regras gerais:

• Isso é código-golfe , então a resposta mais curta em bytes vence.
  Não permita que idiomas com código de golfe o desencorajem a postar respostas com idiomas que não sejam codegolf. Tente encontrar uma resposta o mais curta possível para 'qualquer' linguagem de programação.
• As regras padrão se aplicam à sua resposta, para que você possa usar STDIN / STDOUT, funções / método com os parâmetros adequados, programas completos. Sua chamada.
• As brechas padrão são proibidas.
• Se possível, adicione um link com um teste para o seu código.
• Além disso, adicione uma explicação, se necessário.

Casos de teste:

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

Casca , 27 26 24 22 bytes

-2 bytes graças ao Zgarb

-2 bytes graças a Leo

Toma ' 'comoFalse e 'a'como True(em Husk, espaço em branco em Fasly e todos os outros caracteres são Truthy)

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

Experimente online!

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

† ḟ é uma função que recebe um predicado pe uma listaL e retorna o primeiro elemento Lque satisfaz p. Se nenhum elemento atender, pum argumento padrão será retornado. Nesse caso ' '. Ao aplicar ḟa uma cadeia de um caracter, estamos essencialmente dizendoif p c then c else ' ' .

ṪÉ uma função que recebe uma função fe duas listas L1,L2 . Retorna uma tabela de faplicada sobre todos os pares de L1e L2. Neste caso fé ḟ, L1é a nossa lista de 4 funções, e L2é a lista de um cadeias de caracteres.

Depois de Ṫḟ , temos uma lista de cadeias em que cada cadeia é o resultado da substituição de caracteres que não satisfazem uma das regras por a ' '.

NB: Nas versões mais recentes do Husk, ġ#¬Ö#≡⁰pode ser substituído pork#≡⁰ uma economia de 3 bytes!

Gelatina , 31 bytes

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

Experimente online!

Os valores booleanos são 2e1 (ou qualquer outro par par / ímpar positivo), que representam Truee Falserespectivamente. Vou tentar adicionar uma explicação depois de mais golfe.

Agradecemos a caird coinheringaahing por salvar 2 bytes e a Lynn por salvar 4 bytes! Graças a um dos truques de Erik , que me inspiraram a economizar 4 bytes!

Como funciona

Observe que esta é a explicação para a versão de 35 bytes. O novo faz aproximadamente o mesmo (mas aprimorado um pouco por Lynn), então não vou mudar.

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

Experimente online!

R , 193 186 179 158 bytes

-7 bytes graças ao NofP e sua sugestão de cbind

-6 bytes usando outer-1 comutação de bytes [^a-zA-Z0-9]com[[:punct:]]

-21 bytes graças ao MickyT por apontar uma lista de caracteres é 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='')}

Verifique todos os casos de teste

Toma 1/Tcomo verdade ( max) e 0/Fcomo falsey ( min) e levaS como uma lista de caracteres únicos.

Experimente online!

Na minha versão original (com sugestões da NofP), a matriz yé construída avaliando grepl(regex, S)cada uma delas regexe concatenando-as juntas como colunas de uma matriz. Isso resulta em várias chamadas para grepl, mas como Sé corrigido, parecia que algo mais precisava ser feito. Como observei:

Existem abordagens potencialmente mais curtas; mapply, por exemplo:

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

infelizmente, isso não será simplificado como uma matriz no exemplo de 1 caractere de "A".

Eu usei, outere não mapply, que sempre retorna uma matriz (neste caso, uma matriz) e fui forçado aVectorize grepl , o que é realmente apenas ummapply invólucro em torno dela.

Também descobri o grupo de caracteres predefinido [:punct:]que corresponde aos caracteres de pontuação (não espaço, não alfanumérico).

Casca , 31 29 28 bytes

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

Usa 0 para o mínimo e 1 para o número máximo de caracteres. Experimente online!

Explicação

Listas de funções são legais.

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)

Experimente online!

Jonathan Frech salvou um byte. Obrigado!

Maior é m=-1, menor é m=0.

Geléia , 35 bytes

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

Experimente online!

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]":"")," ");}

Experimente online!

Ruby , 118 116 bytes

Aceita 0(mais baixo) ou -1(mais alto) para seu segundo argumento.

-2 bytes graças 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:" "}}

Experimente online!

Ungolfed

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

Obrigado a Jonathan Frech por reduzi-lo

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

Isso leva as cordas 'max(l)'e 'min(l)'como verdadeiro e falso. (Eu não acho que isso viole as regras ...?) Isso é mais longo que as outras duas respostas python, mas diferente, então pensei em publicá-la. Eu não sou um grande jogador de golfe, então acho que isso poderia ser melhorado, mas todas as coisas que tentei não funcionaram.

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

Infelizmente as regras provavelmente não me permitem passar Math.maxou Math.mincomo bandeira. Editar: salvou 2 bytes graças a @JustinMariner.

Geléia , 37 bytes

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

Experimente online!

-6 bytes "emprestando" da postagem de Erik: D

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

Minha "interessante" assumir o desafio.

Agradecemos a Kevin Cruijssen por reduzir os bytes de importação, removendo a importação totalmente!

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

Experimente online!

Explicação:

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

Primeiro, substitui cada grupo por um número inteiro entre 0 e 3 usando alguma regex simples e armazena isso em uma nova String.

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

Inicializa uma matriz de números inteiros, bem como alguns outros números inteiros para usar posteriormente. Define a yvariável para o tamanho máximo int usando deslocamento de bit direito não assinado.

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

Para cada caractere na cadeia modificada, isso usa seu valor ASCII módulo 4 para calcular o índice da matriz acima mencionada para incrementar.

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

Em seguida, ele percorre as contagens de cada grupo armazenado na matriz e calcula o mínimo ( y) e o máximo ( z).

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

Repete cada caractere na String novamente, verificando se o grupo desse grupo de caracteres é igual ao mínimo / máximo (usando o truque de módulo mencionado anteriormente). Se não for igual, um espaço será adicionado à nova String no lugar dos caracteres, caso contrário, o caractere original será adicionado.

return v;

Finalmente, retorne a nova 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")

Experimente 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;

Correr com -nr ou experimente online .

• primeiro loop: para cada posição, lembre-se do grupo do personagem
  e conte as ocorrências de grupos nos quais o personagem atual não é .
  (essa negação salvou 3 bytes)
• dependendo do segundo parâmetro, escolha min sem contagem para verdade, max sem contagem para falsidade.
• segundo loop: se (grupo de caracteres atuais) a contagem não for diferente
  da contagem mínima / máxima, em seguida, imprima o espaço, caso contrário, imprima o caractere.

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)

Entrada e saída é uma matriz de caracteres. Toma valores booleanos reais para entrada.

Uma abordagem diferente da resposta de @ Neil ; quase evitando expressões regulares. Em vez disso, usei uma série de verificações para determinar a categoria de cada personagem:

• Retorno dígitos truepara c>-1porque não dígitos falhar comparações matemáticas
• Letras maiúsculas correspondem ao regex /[a-z]/ie possuem pontos de código menores que"a"
• Letras minúsculas correspondem a essa expressão regular, mas têm pontos de código não inferiores a "a"
• Os símbolos não passam em nenhum desses testes

Casos de teste

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}