Herausforderung:

Eingänge:

• Eine Zeichenfolge mit druckbarem ASCII (ohne Leerzeichen, Tabulatoren und Zeilenumbrüche)
• Ein Boolescher †

Ausgabe:

Die Teile der Zeichenfolge sind in vier Gruppen unterteilt:

• Kleinbuchstaben
• Großbuchstaben
• Ziffern
• Andere

Basierend auf dem Booleschen Wert geben wir entweder das höchste Vorkommen einer (oder mehrerer) dieser vier Gruppen aus oder das niedrigste, wobei wir alles andere durch Leerzeichen ersetzen.

Beispielsweise:

Eingabe: "Just_A_Test!"
Es enthält:
- 3 Großbuchstaben: JAT
- 6 Kleinbuchstaben: ustest
- 0 Ziffern
- 3 weitere:__!

Dies wären die Ausgaben für trueoder false:

true:   " ust    est "

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

(Hinweis: Sie dürfen nachgestellte Leerzeichen ignorieren, daher können die Ausgaben auch " ust est"und sein "".)

Herausforderungsregeln:

• Die Eingabe ist niemals leer oder enthält Leerzeichen und besteht nur aus druckbarem ASCII im Bereich 33-126oder '!'durch '~'.
• Sie können die Ein- und / oder Ausgänge als Zeichenfeld oder Liste verwenden, wenn Sie möchten.
• † Es sind zwei beliebige konsistente und unterschiedliche Werte für den Booleschen Wert zulässig: true/ false; 1/ 0; 'H'/ 'L'; "highest"/ "lowest"; usw. Beachten Sie, dass diese unterschiedlichen Werte (etwas) als Boolescher Wert verwendet werden sollten! Es ist also nicht erlaubt, zwei vollständige Programme einzugeben, eines, das das richtige Ergebnis für trueund das andere für liefert false, und dann nur Ihren tatsächlichen Code zu haben <run input with parameter>. Relevante neue Standardlücke, die ich hinzugefügt habe, obwohl sie hinsichtlich der Definitionen noch viel Feinabstimmung erfordern kann.
• Wenn das Vorkommen von zwei oder mehr Gruppen gleich ist, geben wir alle diese Vorkommen aus.
• Die erforderlichen nachgestellten Leerzeichen sind optional, und eine einzelne nachstehende neue Zeile ist ebenfalls optional. Erforderliche führende Leerzeichen sind obligatorisch. Andere führende Leerzeichen oder Zeilenumbrüche sind nicht zulässig.

Allgemeine Regeln:

• Das ist Code-Golf , also gewinnt die kürzeste Antwort in Bytes.
  Lassen Sie sich von Code-Golf-Sprachen nicht davon abhalten, Antworten mit Nicht-Codegolf-Sprachen zu veröffentlichen. Versuchen Sie, für jede Programmiersprache eine möglichst kurze Antwort zu finden.
• Für Ihre Antwort gelten Standardregeln. Daher dürfen Sie STDIN / STDOUT, Funktionen / Methode mit den richtigen Parametern und vollständige Programme verwenden. Ihr Anruf.
• Standardlücken sind verboten.
• Fügen Sie nach Möglichkeit einen Link mit einem Test für Ihren Code hinzu.
• Fügen Sie ggf. auch eine Erklärung hinzu.

Testfälle:

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

Schale , 27 26 24 22 Bytes

-2 Bytes dank Zgarb

-2 Bytes dank Leo

Takes ' 'as Falseand 'a'as True(In Husk sind Leerzeichen in Fasly und alle anderen Zeichen die Wahrheit)

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

Probieren Sie es online!

Wie funktioniert es?

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

† ḟ ist eine Funktion, die ein Prädikat pund eine Liste annimmt Lund das erste Element davon zurückgibt, das Lerfüllt p. Wenn kein Element erfüllt ist, wird pein Standardargument zurückgegeben. In diesem Fall ' '. Durch die Anwendung ḟauf eine eine Zeichenkette, sagen wir im Wesentlichen if p c then c else ' '.

ṪIst Funktion , die eine Funktion übernimmt fund zwei Listen L1, L2. Es wird eine Tabelle mit fangewendeten Werten für alle Paare von L1und zurückgegeben L2. In diesem Fall fist ḟ, L1unsere Liste mit 4 Funktionen und L2die Liste mit einer Zeichenfolge.

Nachdem Ṫḟwir eine Liste von Zeichenfolgen erstellt haben, in der jede Zeichenfolge das Ergebnis des Ersetzens von Zeichen ist, die einer der Regeln nicht entsprechen, durch a ' '.

Hinweis: In neueren Versionen von Husk ġ#¬Ö#≡⁰kann dies durch k#≡⁰eine 3-Byte-Einsparung ersetzt werden!

Gelee , 31 Bytes

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

Probieren Sie es online!

Die Booleschen Werte sind 2 und 1(oder jedes andere positive gerade / ungerade Paar), die Trueund darstellenFalse . Ich werde versuchen, nach weiteren Golfspielen eine Erklärung hinzuzufügen.

Dank Caird Coinheringaahing für die Einsparung von 2 Bytes und Lynn für das Speichern von 4 Bytes! Dank eines von Eriks Tricks , der mich dazu inspiriert hat, 4 Bytes zu sparen!

Wie es funktioniert

Beachten Sie, dass dies die Erklärung für die 35-Byte-Version ist. Das neue tut ungefähr das Gleiche (aber ein bisschen von Lynn optimiert), also werde ich es nicht ändern.

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

Probieren Sie es online!

R , 193 186 179 158 Bytes

-7 Bytes dank NofP und seinem Vorschlag von cbind

-6 Bytes mit outer, -1 Bytes [^a-zA-Z0-9]mit[[:punct:]]

-21 Bytes Dank an MickyT für den Hinweis auf eine Liste von Zeichen ist erlaubt

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

Überprüfen Sie alle Testfälle

Nimmt 1/Tals wahr ( max) und 0/Fals falsch ( min) und nimmtS als Liste der einzelnen Zeichen.

Probieren Sie es online!

In meiner ursprünglichen Version (mit den Vorschlägen von NofP) wird die Matrix erstellt, yindem sie grepl(regex, S)für jede ausgewertet regexund dann als Spalten einer Matrix zusammengefügt wird. Dies führt zu mehreren Anrufen an grepl, aber wie Sbehoben, schien es, dass etwas anderes getan werden musste. Wie ich bemerkte:

Es gibt möglicherweise kürzere Ansätze. mapply, zum Beispiel:

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

Dies wird sich als Matrix im 1-stelligen Beispiel von leider nicht vereinfachen "A".

Ich habe outerstattdessen verwendet mapply, was immer ein Array (in diesem Fall eine Matrix) zurückgibt und dazu gezwungen wurde Vectorize grepl, was eigentlich nur ein Array istmapply Wrapper .

Ich habe auch die vordefinierte Zeichengruppe entdeckt, [:punct:]die mit Interpunktionszeichen (keine Leerzeichen, keine alphanumerischen Zeichen) übereinstimmt.

Schale , 31 29 28 Bytes

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

Verwendet 0 für minimale und 1 für maximale Zeichenanzahl. Probieren Sie es online!

Erläuterung

Funktionslisten sind cool.

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)

Probieren Sie es online!

Jonathan Frech hat ein Byte gespeichert. Vielen Dank!

Am höchsten ist m=-1, am niedrigsten ist m=0.

Gelee , 35 Bytes

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

Probieren Sie es online!

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

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

Probieren Sie es online!

Ruby , 118 116 Bytes

Nimmt 0(niedrigste) oder -1(höchste) als zweites Argument.

-2 Bytes dank 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:" "}}

Probieren Sie es 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

Vielen Dank an Jonathan Frech für die Kürzung

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

Dies nimmt die Zeichenfolgen 'max(l)'und 'min(l)'als wahr und falsch. (Ich glaube nicht, dass dies gegen die Regeln verstößt ...?) Dies ist länger als die anderen beiden Python-Antworten, aber anders, also dachte ich, ich würde es posten. Ich bin kein großartiger Golfer, also denke ich, dass dies weiter verbessert werden könnte, aber all die Dinge, die ich versucht habe, haben nicht funktioniert.

Probieren Sie es 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}