Meydan okuma:

girişler:

• Yazdırılabilir ASCII içeren bir dize (boşluklar, sekmeler ve yeni satırlar hariç)
• Bir boolean †

Çıktı:

Dizenin parçaları dört gruba ayrılır:

• Küçük harfler
• Büyük harfler
• Rakamlar
• Diğer

Boole'ye dayanarak, bu dört gruptan birinin (veya birden fazlasının) en yüksek oluşumunu veya en düşük olanını, diğer her şeyi boşluklarla değiştirerek çıkarırız.

Örneğin:

Girdi: "Just_A_Test!"
Şunları içerir:
- 3 büyük harf: JAT
- 6 küçük harf: ustest
- 0 rakam
- 3 diğer:__!

Bunlar trueveya için çıktılar olacaktır false:

true:   " ust    est "

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

(Not: Sondaki boşlukları " ust est"ve ""sırasıyla izleyen boşlukları yok saymanıza izin verilir .)

Zorluk kuralları:

• Giriş asla boş olmayacak veya boşluk içermeyecek ve yalnızca aralıktaki 33-126veya '!'içinden yazdırılabilir ASCII'den oluşacaktır '~'.
• İsterseniz, giriş ve / veya çıkışları karakter dizisi veya liste olarak alabilirsiniz.
• † Boole için tutarlı ve farklı iki değere izin verilir: true/ false; 1/ 0; 'H'/ 'L'; "highest"/ "lowest"; Bu farklı değerlerin (bir şekilde) bir boole olarak kullanılması gerektiğini unutmayın! Bu nedenle, biri için doğru sonucu truediğeri için doğru sonucu veren ve falseyalnızca gerçek kodunuzun olması için iki tam program girilmesine izin verilmez <run input with parameter>. Eklediğim ilgili yeni varsayılan boşluk, tanımlarla ilgili hala çok fazla finetuning kullanabilir.
• İki veya daha fazla grubun oluşumu aynı ise, tüm bu oluşumları çıkarırız.
• Gerekli sondaki boşluklar isteğe bağlıdır ve tek bir sondaki yeni satır da isteğe bağlıdır. Gerekli önde gelen alanlar zorunludur. Ve diğer önde gelen alanlara veya yeni satırlara izin verilmez.

Genel kurallar:

• Bu kod golf , bayt en kısa cevap kazanır.
  Kod golf dillerinin, kod yazmayan dillerle yanıt göndermenizi engellemesine izin vermeyin. 'Herhangi bir' programlama dili için mümkün olduğunca kısa bir cevap bulmaya çalışın.
• Cevabınız için standart kurallar geçerlidir , bu nedenle STDIN / STDOUT, fonksiyon / yöntemi uygun parametrelerle, tam programları kullanmanıza izin verilir. Çağrınız.
• Varsayılan Loopholes yasaktır.
• Mümkünse, lütfen kodunuz için test içeren bir bağlantı ekleyin.
• Ayrıca, gerekirse bir açıklama ekleyin.

Test senaryoları:

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

Kabuk , 27 26 24 22 bayt

Zgarb sayesinde -2 bayt

Leo sayesinde -2 bayt

Alır ' 'olarak Falseve 'a'sıra True(Truthy olan In Zurufundan, boşluk Fasly ve tüm diğer karakterler)

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

Çevrimiçi deneyin!

O nasıl çalışır?

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

† ḟ , yüklemi pve listeyi alan Lve Ltatmin edici olan ilk öğesini döndüren bir işlevdir p. Hiçbir öğe karşılanmazsa p, varsayılan bir argüman döndürülür. Bu durumda ' '. ḟBir karakter dizesine başvurarak , aslında şunu söylüyoruz if p c then c else ' '.

ṪBir işlevi alır fonksiyon mı fve iki listeleri L1, L2. Bu bir tablo geri fher çifti üzerine uygulanabilir L1ve L2. Bu durumda fise ḟ, L14 fonksiyonların bizim listesidir ve L2bir karakter dizeleri listesidir.

ṪḟHer dizenin kurallardan birini yerine getirmeyen karakterleri değiştirmenin bir sonucu olduğu dizelerin bir listesinden sonra ' '.

Not: Husk'un daha yeni sürümlerinde, 3 baytlık bir tasarruf için ġ#¬Ö#≡⁰değiştirilebilir k#≡⁰!

Jöle , 31 bayt

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

Çevrimiçi deneyin!

Mantıksal değerdir 2ve 1(ya da herhangi bir başka pozitif / tek çifti) temsil eder, ki Trueve Falsesırasıyla. Daha fazla golf sonra bir açıklama eklemek çalışacağız.

2 bayt tasarrufu için caird coinheringaahing'e ve 4 bayt tasarrufu için Lynn'e teşekkürler ! 4 bayt kurtarmam için bana ilham veren Erik'in numaralarından biri sayesinde !

Nasıl çalışır

Bunun 35 baytlık sürüm için bir açıklama olduğunu unutmayın. Yeni olan kabaca aynı şeyi yapar (ama Lynn tarafından biraz tweaked), bu yüzden değiştirmeyeceğim.

Ø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 , 166158 bayt

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)

Çevrimiçi deneyin!

R , 193 186 179 158 bayt

NofP ve önerisi sayesinde -7 bayt cbind

-6 kullanılarak bayt outer, -1 bayt geçiş [^a-zA-Z0-9]ile[[:punct:]]

Karakterlerin bir listesini belirtmek için MickyT sayesinde -21 bayt

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

Tüm test senaryolarını doğrulayın

Alır 1/Ttruthy olarak ( max) ve 0/FFalsey olarak ( min) ve alır Stek karakterlerin listesi gibi.

Çevrimiçi deneyin!

Orijinal versiyonumda (NofP'nin önerileriyle), matris y, grepl(regex, S)her biri için değerlendirildikten regexsonra bir matrisin sütunları olarak bir araya getirilerek oluşturulur. Bu, birden fazla çağrıyla sonuçlanır grepl, ancak Sdüzeltildiği gibi, başka bir şeyin yapılması gerektiği görülüyordu. Belirttiğim gibi:

Potansiyel olarak daha kısa yaklaşımlar vardır; mapply, Örneğin:

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

ne yazık ki, bu 1 karakterlik bir örnekte bir matris olarak basitleşmeyecektir "A".

Bunun outeryerine mapply, her zaman bir dizi (bu durumda bir matris) döndüren ve Vectorize greplgerçekten mapplyetrafında bir sarmalayıcı olan zorlanan yerine kullandım.

[:punct:]Noktalama işaretleri (boşluk olmayan, alfasayısal olmayan) karakterlerle eşleşen önceden tanımlanmış karakter grubunu da keşfettim .

Kabuk , 31 29 28 bayt

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

Minimum için 0 ve maksimum karakter sayısı için 1 kullanır. Çevrimiçi deneyin!

açıklama

İşlev listeleri havalı.

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 bayt

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)

Çevrimiçi deneyin!

Jonathan Frech bir bayt kurtardı. Teşekkürler!

En yüksek m=-1, en düşük m=0.

Jöle , 35 bayt

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

Çevrimiçi deneyin!

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

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

Çevrimiçi deneyin!

Yakut , 118 116 bayt

Alır 0(en düşük) ya da -1(en yüksek) ikinci argüman için.

Lynn sayesinde -2 bayt.

->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:" "}}

Çevrimiçi deneyin!

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 : " "
  }
}

Piton 2, 190 183 174 173 bayt

Jonathan Frech'e kısalttığı için teşekkürler

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

Bu, dizeleri alır 'max(l)'ve 'min(l)'doğru ve yanlış olarak alır . (Bunun kuralları ihlal ettiğini düşünmüyorum ...?) Bu diğer iki python cevabından daha uzun ama farklı, bu yüzden göndereceğimi düşündüm. Ben büyük bir golfçü değilim, bu daha da geliştirilebileceğini tahmin ediyorum ama denediğim her şey işe yaramadı.

Çevrimiçi deneyin!

JavaScript (ES6), 151 149 bayt

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>

Ne yazık ki kurallar muhtemelen geçmeme Math.maxveya Math.minbayrak olarak izin vermiyor . Düzenleme: @JustinMariner sayesinde 2 bayt kaydedildi.

Jöle , 37 bayt

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

Çevrimiçi deneyin!

Erik'in gönderisinden -6 bayt "borçlanma": D

Java (OpenJDK 8) , 307 + 34306 + 27295 bayt

Benim "ilginç" meydan okuma üstlenmek.

İthalatını tamamen kaldıran ithalat baytlarını azalttığı için Kevin Cruijssen'e teşekkürler !

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

Çevrimiçi deneyin!

Açıklama:

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

İlk olarak, basit bir normal ifade kullanarak her grubu 0 ile 3 arasında bir tamsayı ile değiştirir ve bunu yeni bir String'de saklar.

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

Daha sonra kullanmak için bir tamsayı dizisinin yanı sıra birkaç tamsayı da başlatır. yİmzasız sağ bit kaydırmayı kullanarak değişkeni maksimum int boyutuna ayarlar .

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

Değiştirilmiş dizgideki her karakter için bu, yukarıda belirtilen dizinin dizinini artırmak için ASCII değer modülodu 4'ü kullanır.

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

Bu daha sonra dizide saklanan her grubun sayıları arasında dolaşır ve minimum ( y) ve maksimum ( z) hesaplar .

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

Bu karakter grubu grubunun min / max'a eşit olup olmadığını kontrol ederek Dize'deki her karakter arasında tekrar dolaşır (daha önce belirtilen modulo hile kullanılarak). Eşit değilse, karakterler yerine yeni Dizeye bir boşluk eklenir, aksi takdirde orijinal karakter eklenir.

return v;

Sonunda yeni String döndür!

Bash, 229 227 212 bayt

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

Çevrimiçi Deneyin

PHP, 161158 bayt

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;

Birlikte çalışın-nr veya çevrimiçi deneyin .

• ilk döngü: her konum için, karakter grubunu hatırlayın
  ve geçerli karakterin içinde olmadığı grupların oluşumlarını sayın .
  (bu olumsuzlama 3 bayt kurtardı)
• ikinci parametreye bağlı olarak, doğruluk için min saymayı seçin, falsi için maks saymayı seçin.
• ikinci döngü: (geçerli karakter grubu) sayım
  min / maks sayımdan farklıysa yazdırma alanından farklıysa , başka karakter yazdırır.

JavaScript (ES6), 139 bayt

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)

Girdi ve çıktı bir karakter dizisidir. Giriş için gerçek boole değerlerini alır.

@ Neil'in cevabından farklı bir yaklaşım ; neredeyse düzenli ifadelerden kaçınıyor. Bunun yerine, her karakterin kategorisini belirlemek için bir dizi kontrol kullandım:

• Basamak olmayanlar matematiksel karşılaştırmalarda başarısız olduğu trueiçin basamaklar geri dönerc>-1
• Büyük harfler normal /[a-z]/iifadeyle eşleşir ve kod noktaları daha küçüktür"a"
• Küçük harfler bu normal ifadeyle eşleşir ancak kod noktaları daha az değildir "a"
• Semboller bu testlerin hiçbirini geçmez

Test Durumları

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}