Wyzwanie:

Wejścia:

• Ciąg zawierający ASCII do wydruku (z wyłączeniem spacji, tabulatorów i nowych wierszy)
• Wartość logiczna †

Wynik:

Części ciągu są podzielone na cztery grupy:

• Małe litery
• Wielkie litery
• Cyfry
• Inny

W oparciu o wartość logiczną albo wypisujemy najwyższe wystąpienie jednej (lub wielu) z tych czterech grup, albo najniższą, zastępując wszystko inne spacjami.

Na przykład:

Wprowadzanie: "Just_A_Test!"
Zawiera:
- 3 duże litery: JAT
- 6 małych liter: ustest
- 0 cyfr
- 3 inne:__!

Byłyby wyjścia dla truelub false:

true:   " ust    est "

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

(Uwaga: możesz ignorować końcowe spacje, więc wyniki mogą być odpowiednio " ust est"i "").

Zasady konkursu:

• Dane wejściowe nigdy nie będą puste ani nie będą zawierać spacji i będą się składały wyłącznie z drukowalnego ASCII w zakresie 33-126lub '!'przez '~'.
• Możesz wziąć dane wejściowe i / lub wyjściowe jako tablicę znaków lub listę, jeśli chcesz.
• † Dozwolone są dwie spójne i różne wartości logiczne: true/ false; 1/ 0; 'H'/ 'L'; "highest"/ "lowest"; itd. Zauważ, że te odrębne wartości powinny być użyte (nieco) jako wartość logiczna! Dlatego nie wolno wprowadzać dwóch kompletnych programów, jednego, który daje poprawny wynik dla truedrugiego false, a drugiego dla , a następnie posiadanie tylko faktycznego kodu <run input with parameter>. Dodałem istotną nową domyślną lukę, chociaż nadal może ona zawierać wiele drobnych korekt dotyczących definicji.
• Jeśli wystąpienie dwóch lub więcej grup jest takie samo, wyprowadzamy wszystkie te wystąpienia.
• Niezbędne końcowe spacje są opcjonalne, a pojedyncza nowa linia jest również opcjonalna. Niezbędne pola wiodące są obowiązkowe. I żadne inne wiodące spacje lub nowe linie nie są dozwolone.

Główne zasady:

• To jest golf golfowy , więc wygrywa najkrótsza odpowiedź w bajtach.
  Nie pozwól, aby języki kod-golfowe zniechęcały Cię do publikowania odpowiedzi w językach niekodujących golfa. Spróbuj znaleźć możliwie najkrótszą odpowiedź na „dowolny” język programowania.
• Do odpowiedzi odnoszą się standardowe reguły , więc możesz używać STDIN / STDOUT, funkcji / metody z odpowiednimi parametrami, pełnych programów. Twoja decyzja.
• Domyślne luki są zabronione.
• Jeśli to możliwe, dodaj link z testem swojego kodu.
• W razie potrzeby dodaj również wyjaśnienie.

Przypadki testowe:

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

Łuska , 27 26 24 22 bajtów

-2 bajty dzięki Zgarbowi

-2 bajty dzięki Leo

Trwa ' 'jak Falsei 'a'jako True(W Łusce, białe znaki w Fasly i wszystkie inne postacie są prawdziwe)

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

Wypróbuj online!

Jak to działa?

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

† ḟ jest funkcją, która pobiera predykat pi listę Li zwraca pierwszy element, Lktóry spełnia p. Jeśli żaden element nie spełnia, pzwracany jest domyślny argument. W tym przypadku ' '. Stosując ḟdo ciągu jednego znaku, zasadniczo mówimy if p c then c else ' '.

ṪJest funkcją, która wykonuje funkcję fi dwie listy L1, L2. Zwraca tabelę fzastosowanych dla wszystkich par L1i L2. W tym przypadku fjest ḟ, L1znajduje się lista z 4 funkcjami, a L2lista jednego ciągów znaków.

Po Ṫḟmamy listę ciągów, w których każdy ciąg jest wynikiem zamiany znaków niespełniających jednej z reguł na a ' '.

Uwaga: W nowszych wersjach Husk ġ#¬Ö#≡⁰można zastąpić k#≡⁰3-bajtową oszczędnością!

Galaretka , 31 bajtów

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

Wypróbuj online!

Wartości logiczne o to 2i 1(lub dowolny inny pozytywny parzyste / nieparzyste parę), które stanowią Truei Falseodpowiednio. Spróbuję dodać wyjaśnienie po dalszej grze w golfa.

Dzięki caird coinheringaahing za zapisanie 2 bajtów i Lynn za zapisanie 4 bajtów! Dzięki jednej z sztuczek Erika , która zainspirowała mnie do zaoszczędzenia 4 bajtów!

Jak to działa

Zauważ, że to jest wyjaśnienie wersji 35-bajtowej. Nowy działa mniej więcej tak samo (ale trochę poprawił Lynn), więc go nie zmienię.

Ø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 bajtów

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)

Wypróbuj online!

R , 193 186 179 158 bajtów

-7 bajtów dzięki NofP i jego sugestii cbind

-6 bajtów za pomocą outer, -1 bajtowe przełączanie za [^a-zA-Z0-9]pomocą[[:punct:]]

-21 bajtów dzięki MickyT za wskazanie listy znaków jest dozwolone

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

Sprawdź wszystkie przypadki testowe

Pobiera 1/Tjako truey ( max) i 0/Fjako falsey ( min) i przyjmuje Sjako listę pojedynczych znaków.

Wypróbuj online!

W mojej oryginalnej wersji (z sugestiami NofP) macierz yjest konstruowana poprzez ocenę grepl(regex, S)każdego z nich regex, a następnie połączenie ich razem jako kolumn macierzy. Powoduje to wiele wywołań grepl, ale jak Szostało ustalone, wydawało się, że trzeba zrobić coś innego. Jak zauważyłem:

Istnieją potencjalnie krótsze podejścia; mapply, na przykład:

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

nie będzie to niestety uproszczone jako macierz w przykładzie 1-znakowym "A".

Użyłem outerraczej niż mapply, który zawsze zwraca tablicę (w tym przypadku macierz), i byłem do tego zmuszony Vectorize grepl, co jest tak naprawdę tylko mapplyotoczką.

Odkryłem również predefiniowaną grupę znaków, [:punct:]która pasuje do znaków interpunkcyjnych (spacji, nie alfanumerycznych).

Łuska , 31 29 28 bajtów

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

Używa 0 dla minimalnej i 1 dla maksymalnej liczby znaków. Wypróbuj online!

Wyjaśnienie

Listy funkcji są fajne.

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 bajtów

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)

Wypróbuj online!

Jonathan Frech uratował bajt. Dzięki!

Najwyższy jest m=-1, najniższy jest m=0.

Galaretka , 35 bajtów

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

Wypróbuj online!

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

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

Wypróbuj online!

Rubin , 118 116 bajtów

Pobiera 0(najniższy) lub -1(najwyższy) za drugi argument.

-2 bajty dzięki 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:" "}}

Wypróbuj online!

Nie golfił

->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 bajtów

Podziękowania dla Jonathana Frecha za jego skrócenie

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

To trwa za sznurki 'max(l)'i 'min(l)'jako prawdziwe i fałszywe. (Nie sądzę, że to łamie zasady ...?) To jest dłuższe niż pozostałe dwie odpowiedzi w Pythonie, ale inne, więc pomyślałem, że to opublikuję. Nie jestem świetnym golfistą, więc myślę, że można to jeszcze poprawić, ale wszystkie rzeczy, których próbowałem, nie zadziałały.

Wypróbuj online!

JavaScript (ES6), 151 149 bajtów

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>

Niestety reguły prawdopodobnie nie pozwalają mi podać Math.maxani Math.minflagi. Edycja: Zapisano 2 bajty dzięki @JustinMariner.

Galaretka , 37 bajtów

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

Wypróbuj online!

-6 bajtów „pożyczanie” od postu Erika: D

Java (OpenJDK 8) , 307 + 34 306 + 27 295 bajtów

Moje „interesujące” wyzwanie.

Dziękujemy Kevinowi Cruijssenowi za zmniejszenie bajtów importu i całkowite usunięcie importu!

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

Wypróbuj online!

Wyjaśnienie:

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

Najpierw zastępuje każdą grupę liczbą całkowitą od 0 do 3 za pomocą prostego wyrażenia regularnego i zapisuje to w nowym ciągu.

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

Inicjuje tablicę liczb całkowitych, a także kilka innych liczb całkowitych do użycia później. Ustawia yzmienną na maksymalny rozmiar int przy użyciu przesuniętego prawego bitu bez znaku.

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

Dla każdego znaku w zmodyfikowanym ciągu wykorzystuje wartość modulo 4 ASCII do obliczenia indeksu wspomnianej tablicy w celu zwiększenia.

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

Następnie przechodzi przez liczniki każdej grupy przechowywanej w tablicy i oblicza minimum ( y) i maksimum ( z).

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

Zapętla ponownie każdy znak w ciągu, sprawdzając, czy grupa tej grupy znaków jest równa wartości min / max (przy użyciu sztuczki modulo wspomnianej wcześniej). Jeśli nie jest równy, wówczas do nowego ciągu znaków dodaje się spację w miejscu znaków, w przeciwnym razie dodawany jest oryginalny znak.

return v;

Wreszcie zwróć nowy ciąg!

Bash, 229 227 212 bajtów

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

Wypróbuj online

PHP, 161 158 bajtów

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;

Uruchom -nrlub wypróbuj online .

• pierwsza pętla: dla każdej pozycji zapamiętaj grupę postaci
  i policz wystąpienia grup, w których nie ma obecnego znaku .
  (negacja zapisała 3 bajty)
• w zależności od drugiego parametru wybierz min. niezliczenie dla prawdy, maks. niezliczenie dla fałszu.
• druga pętla: jeśli (grupa bieżącego znaku) liczba niezliczona różni się
  od wartości min./maks. liczba, to wypisz przestrzeń, w przeciwnym razie wypisz znak

JavaScript (ES6), 139 bajtów

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)

Dane wejściowe i wyjściowe to tablica znaków. Pobiera na wejściu rzeczywiste wartości logiczne.

Inne podejście niż odpowiedź @ Neila ; prawie unikając wyrażeń regularnych. Zamiast tego użyłem serii testów, aby określić kategorię każdego znaku:

• Cyfry powrót truedo c>-1ponieważ nie-cyfry nie porównań matematycznych
• Wielkie litery pasują do wyrażenia regularnego /[a-z]/ii mają mniejszy kod niż"a"
• Małe litery pasują do tego wyrażenia regularnego, ale mają znaki kodowe nie mniej niż "a"
• Symbole nie przejdą żadnego z tych testów

Przypadki testowe

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}