Ocorrências mais altas ou mais baixas?

13

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 é , 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")
Kevin Cruijssen
fonte
É aceitável produzir o máximo / mínimo possível como entradas separadas? Por exemplo, para o caso de teste "hashing is fun", pode "H "e " 9 "(com espaços apropriados) ser emitido em vez de "H 9"?
AdmBorkBork
@AdmBorkBork Não entendi o que você quer dizer; ambos He 9são parte do "menor número".
Erik the Outgolfer
O valor de entrada booleano pode ser "max"/ "min", que é usado Math[b]para se referir a Math.maxou Math.min?
Justin Mariner
@ JustinMariner Você sabe .. eu mudei de idéia desculpe por isso. Eu acho que é para JS? Eu acho que muitas linguagens de programação podem utilizar algo assim, então muitas das respostas existentes devem ser alteradas. Então, desculpe, você tem que manter a b?"max":"min"sua resposta .. É uma linha tênue eu acho, talvez eu deveria usar apenas um valor truthy / Falsey próxima vez ..
Kevin Cruijssen

Respostas:

3

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!

H.PWiz
fonte
Por curiosidade: por que ' 'e 'a'? Talvez eu entenda melhor quando a explicação for adicionada, porque não consigo ler Husk. ;)
Kevin Cruijssen
Agradável! Aqui estão 24 bytes usando .
Zgarb 31/10/19
@Zgarb Thanks! Eu realmente não entendo o que Mmmestava fazendo eu mesmo :)
H.PWiz
Infelizmente, isso realmente não ajuda no golfe, mas S`?' pode ser mais simples como?IK'
Leo
Eu costumo evitar o uso I, às vezes isso leva o intérprete para sempre. Também parece um desperdício.
H.PWiz
7

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.
Mr. Xcoder
fonte
40 bytes
caird coinheringaahing
@cairdcoinheringaahing Thanks! :) Eu queria jogar essa parte desde que publiquei a resposta, mas não consegui descobrir por que não funcionou ... Eu tinha um µD estranho :
Sr. Xcoder
31 bytes : gere as classes como ØṖḟØBṭØBUs26¤e teste a associação com fe em Çvez de e¢$.
Lynn
5

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!

TFeld
fonte
158 bytes
Sr. Xcoder
@ Mr.Xcoder Obrigado; Acabei de conseguir isso também :) #
TFeld 31/07
5

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

Giuseppe
fonte
1
Se você substituir a matriz por uma cbind, poderá reduzir para 186 bytes: y = cbind (g ("[az]", S), g ("[AZ]", S), g ("\\ d", S), g ("[^ a-zA-Z0-9]", S))
NofP
@ NofP oh, muito bom. Além disso, você pode colocar o código com reticulares (`) para exibi-lo like this. :)
Giuseppe
As regras dizem que você pode usar uma matriz de caracteres ou lista como entrada, para que você provavelmente poderia remover oS=el(strsplit(G,""))
MickyT
@ RickyT ah, eu esqueci isso, obrigado.
11787 Giuseppe #
4

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.
Zgarb
fonte
4

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.

Lynn
fonte
1
Eu acho que você pode salvar um byte substituindo +x.isalpha()*-~(x>'Z')por -~(x>'Z')*x.isalpha().
Jonathan Frech
3

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!

Roberto Graham
fonte
366 bytes
Kevin Cruijssen 31/10
É possível remover o +em \\|+$para um -1 byte adicional.
Kevin Cruijssen 31/10
Você pode salvar mais três bytes alterando a última parte para String r=(w[0]!=m?"[a-z]|":"")+(w[1]!=m?"[A-Z]|":"")+(w[2]!=m?"[0-9]|":"")+(w[3]!=m?"[^a-zA-Z0-9]|":"");return r.isEmpty()?s:s.replaceAll(r.replaceAll(".$","")," ");}.
Kevin Cruijssen 31/10
Ah, e n=s.length()pode ter n=-1>>>1um -4 adicional.
Kevin Cruijssen 31/10
Ah, mais uma coisa pequena para o golfe: [0-9]->\\d
Kevin Cruijssen
3

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 : " "
  }
}
Jordânia
fonte
Resposta muito legal! Você pode usar -1como o valor "mais alto" e substituir minmax[t]por sort[t].
Lynn
3

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!

dylnan
fonte
Olá e bem-vindo ao site! Quando tento executar isso, obtenho erros e não sei ao certo por quê. Uma razão pode ser que sum(1for m...deve ser sum(1 for m..., mas acho que há outros problemas também. Você poderia fornecer um link para um intérprete on-line (como tio ) para demonstrar como você está chamando isso e mostrar que não está errado?
James
@DJMcMayhem Acabei de adicionar um link, obrigado por fornecer o link. Não sabia ao certo como fazê-lo. Não estou recebendo um erro quando o executo lá.
precisa saber é o seguinte
Ah, eu não sabia dizer que você estava inserindo max(l)e min(l)como strings, é por isso que eu estava recebendo erros. Obrigado por esclarecer isso! Embora agora, isso esteja à beira da violação da regra # 3, `Observe que esses valores distintos devem ser usados ​​(um pouco) como um booleano`, mas é definitivamente um pouco de uma área cinza.
James
BTW, aqui está uma dica profissional do TIO: se você colocar suas chamadas de função no campo de rodapé , elas não serão contabilizadas na contagem de bytes, para que você possa ver facilmente quanto tempo sua resposta é: Experimente on-line!
James
@DJMcMayhem Ah thanks. Concordo que é uma espécie de área cinzenta. Eu poderia pegar 'max' e 'min' como true false e eval (c + '(l)'), que adiciona 6 bytes e parece mais aceitável, mas até que OP desative minha resposta, estou assumindo que está tudo bem.
dylnan
2

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.

Neil
fonte
1

Geléia , 37 bytes

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

Experimente online!

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

HyperNeutrino
fonte
Lol preservar os espaços é essencialmente metade do programa: D
Sr. Xcoder
Você poderia adicionar uma explicação ou ainda está trabalhando no golfe primeiro?
Kevin Cruijssen 31/10
@KevinCruijssen Golfing first: D
HyperNeutrino
1

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!

Luke Stevens
fonte
1
Boa resposta, +1 de mim! Duas pequenas coisas para o golfe: import java.util.stream.IntStream;pode ser import java.util.stream.*;e ,ipode ser ,i=0depois do qual você pode remover i=0do loop for. Ah, e (s,b)->pode ser s->b->.
Kevin Cruijssen 31/10
@KevinCruijssen Thanks! Eu não sabia que você podia amarrar lambdas
Luke Stevens
É chamado de curry. :) Você pode fazer assim java.util.function.Function<String, java.util.function.Function<Boolean, String>> g = s->b->{...};.
Kevin Cruijssen 31/10
1
Ah, e outra coisa para o golfe: IntStream z=IntStream.of(a);m=(b?z.max():z.min()).getAsInt();pode ser l=s.length(),x=0,y=le for(int x:a){z=x>z?x:z;y=x<y?x:y;}e (b?z:y), assim você não precisa mais da importação. Juntar tudo se torna: 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,l=s.length(),z=0,y=l;t.chars().forEach(j->{a[j%4]++;});for(int x:a){z=x>z?x:z;y=x<y?x:y;}for(;i<l;i++)v+=a[t.charAt(i)%4]!=(b?z:y)?" ":s.charAt(i);return v;}( 294 bytes ) .
Kevin Cruijssen 31/10
1
@KevinCruijssen Oooooh nice thinking! Eu posso esperar um pouco antes de alterá-lo, caso você encontre outra coisa;)
Luke Stevens
1

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

Nahuel Fouilleul
fonte
Não tenho certeza de como os espaços ao redor de colchetes e blocos quadrados funcionam no Bash, mas ainda parece funcionar sem o espaço emf(){(( .
Kevin Cruijssen 31/10
1
sim, o espaço é obrigatória geral, exceto para (, também 2 bytes poderiam ser salvas usando (em vez de {, desempenho degradante porque a criação de um subnível
Nahuel FOUILLEUL
1

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.
Titus
fonte
1
@KevinCruijssen Verifique se a versão mais recente do PHP (7.1.0) foi selecionada.
Titus
1

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

Justin Mariner
fonte