挑战：

输入：

• 包含可打印ASCII的字符串（不包括空格，制表符和换行符）
• 布尔†

输出：

字符串的部分分为四组：

• 小写字母
• 大写字母
• 位数
• 其他

基于布尔值，我们要么输出这四个组中一个（或多个）中出现次数最高的一个，要么输出最低的，将所有其他内容替换为空格。

例如：

输入："Just_A_Test!"
包含：
-3个大写字母：JAT
-6个小写字母：ustest
-0个数字
-3个其他：__!

这些将是true或的输出false：

true:   " ust    est "

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

（注意：您可以忽略尾随空格，因此输出也可以分别为" ust est"和""。）

挑战规则：

• 输入将永远不会为空或包含空格，并且只能由范围为33-126或'!'到的可打印ASCII组成'~'。
• 如果需要，可以将输入和/或输出作为字符数组或列表。
• †允许布尔值有两个一致且不同的值：true/ false; 1/ 0; 'H'/ 'L'; "highest"/ "lowest"; 等。请注意，这些不同的值应（以某种方式）用作布尔值！所以它不允许输入两个完整的程序，一个给出了正确的结果true，另一个false，然后让你的实际代码只<run input with parameter>。我添加了相关的新默认漏洞，尽管它仍然可以对定义进行很多微调。
• 如果两个或多个组的出现相同，我们将输出所有这些出现。
• 必需的尾随空格是可选的，并且单个尾随换行符也是可选的。必需的前导空格是强制性的。不允许使用其他任何前导空格或换行符。

通用规则：

• 这是代码高尔夫球，因此最短答案以字节为单位。
  不要让代码高尔夫球语言阻止您发布使用非代码高尔夫球语言的答案。尝试针对“任何”编程语言提出尽可能简短的答案。
• 标准规则适用于您的答案，因此允许您使用STDIN / STDOUT，具有适当参数的函数/方法，完整程序。你的来电。
• 默认漏洞是禁止的。
• 如果可能的话，请添加一个带有测试代码的链接。
• 另外，如有必要，请添加说明。

测试用例：

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

外壳，27 26 24 22字节

-2个字节，感谢Zgarb

-2个字节，感谢Leo

取' 'as False和'a'as True（在Husk中，Fasly中的空白和所有其他字符均为Truthy）

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

在线尝试！

它是如何工作的？

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

† ḟ是一个函数，该函数带有一个谓词p和一个列表，L并返回L满足条件的第一个元素p。如果没有元素满足，p则返回默认参数。在这种情况下' '。通过应用ḟ一个字符串，我们实际上是在说if p c then c else ' '。

Ṫ是带有一个函数f和两个列表的函数L1，L2。它返回的表格f应用在所有的边L1和L2。在这种情况下f是ḟ，L1是我们的4个功能列表，L2是一个字符串列表。

在Ṫḟ我们得到一个字符串列表之后，其中每个字符串都是用替换不满足其中一个规则的字符的结果' '。

注意：在较新的Husk版本中，ġ#¬Ö#≡⁰可以用替换以k#≡⁰节省3个字节！

果冻，31 个字节

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

在线尝试！

布尔值是2和1（或任何其他正偶数/奇数对），分别代表True和False。在进一步打高尔夫球之后，我将尝试添加一个解释。

感谢caird coinheringaahing节省了2个字节，并感谢Lynn节省了4个字节！感谢Erik的花样之一，这启发了我节省4个字节！

怎么运行的

请注意，这是对35字节版本的说明。新版本的功能大致相同（但Lynn进行了一些调整），因此我不会对其进行更改。

Ø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字节

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)

在线尝试！

[R ，193个 186 179 158字节

-7个字节，感谢NofP和他的建议 cbind

-6字节使用outer，-1字节的切换[^a-zA-Z0-9]与[[:punct:]]

-21字节，感谢MickyT指出允许的字符列表

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='')}

验证所有测试用例

接受1/T为真（max）和0/F伪（min），并S作为单个字符的列表。

在线尝试！

在我的原始版本中（根据NofP的建议），矩阵y是通过grepl(regex, S)对每个矩阵求值而构建的regex，然后将它们串联在一起作为矩阵的列。这样会导致对的多次调用grepl，但是正如S所确定的，似乎还需要做其他事情。正如我指出的：

可能有更短的方法；mapply， 例如：

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

不幸的是，在的1个字符的示例中，这不会简化为矩阵"A"。

我使用outer而不是mapply，它总是返回一个数组（在这种情况下为矩阵），并被强制为Vectorize grepl，这实际上只是一个mapply包装。

我还发现了[:punct:]与标点符号（非空格，非字母数字）匹配的预定义字符组。

外壳，31 29 28字节

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

使用0表示最小字符数，使用1表示最大字符数。 在线尝试！

说明

功能列表很酷。

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个字节

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)

在线尝试！

乔纳森·弗雷希（Jonathan Frech）保存了一个字节。谢谢！

最高是m=-1，最低是m=0。

果冻，35个字节

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

在线尝试！

的Java（OpenJDK的8） ，448 439 432 362 361个 354 352 348 343 320字节

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

在线尝试！

红宝石，118116字节

将0（最低）或-1（最高）作为第二个参数。

-2个字节，感谢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:" "}}

在线尝试！

不打高尔夫球

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

感谢Jonathan Frech缩短了它

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

这需要串'max(l)'并'min(l)'为真假。（我不认为这会违反规则...？）这比其他两个python答案更长，但有所不同，所以我认为我会发布它。我不是一个出色的高尔夫球手，所以我想这可能会进一步改善，但是我尝试过的所有方法都没有效果。

在线尝试！

的JavaScript（ES6），151个 149字节

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>

可悲的是，这些规则可能不允许我通过Math.max或Math.min作为标志。编辑：由于@JustinMariner，节省了2个字节。

果冻，37个字节

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

在线尝试！

从Erik的帖子中借用-6个字节：D

Java（OpenJDK 8），307 + 34 34306 + 27295字节

我的“有趣”承担了挑战。

感谢凯文Cruijssen为削减进口字节彻底消除了进口！

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

在线尝试！

说明：

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

首先，使用一些简单的正则表达式将每个组替换为0到3之间的整数，并将其存储在新的String中。

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

初始化一个整数数组以及几个其他整数，以供以后使用。y使用无符号右移将变量设置为最大int大小。

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

对于修改后的字符串中的每个字符，这将使用其ASCII值模4来计算上述要递增的数组的索引。

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

然后循环遍历存储在数组中的每个组的计数，并计算最小值（y）和最大值（z）。

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

再次循环遍历String中的每个字符，检查该字符组的组是否等于最小值/最大值（使用前面提到的模数技巧）。如果不相等，则在字符位置的新String中添加一个空格，否则添加原始字符。

return v;

最后返回新的字符串！

击，229个 227 212字节

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

在线尝试

PHP，161个 158字节

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;

运行-nr或在线尝试。

• 第一循环：对于每个位置，记住角色的组
  并计算当前角色不在的组的出现出现。
  （该否定操作节省了3个字节）
• 根据第二个参数，选择最小非计数为真，最大非计数为虚假。
• 第二个循环：如果（当前字符组）非计数与
  最小/最大非计数不同，则打印空间，否则打印字符。

JavaScript（ES6），139个字节

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)

输入和输出是字符数组。接受实际的布尔值作为输入。

与@Neil的答案不同的方法；几乎避免使用正则表达式。相反，我使用了一系列检查来确定每个字符的类别：

• 数字之所以返回true，c>-1是因为非数字未能通过数学比较
• 大写字母与正则表达式匹配，/[a-z]/i并且代码点小于"a"
• 小写字母与该正则表达式匹配，但代码点不少于 "a"
• 符号没有通过这些测试

测试用例

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}