Biz tanımlayan boşluk üç karakterlerden herhangi sekme (0x09), yeni satır (0x0A) veya boşluk (0x20) olmak.

Bu zorluk için, aynı programlama dilinde, aşağıdaki görevleri yerine getiren iki program veya işlev yazmanız gerekir:

1. Boşluk karakterlerini verilen bir dizgede sayın. Örneğin, giriş

     123 -_-   abc
   def
   

   7 döndürür (izleyen bir yeni satır yoksa).

2. Belirli bir dizgiyi ardışık boşluk boşluklarında böl. Dize beyaz boşlukla başlar veya biterse, uçlarında boş dizeler döndürülmemelidir. Örneğin, aynı giriş

     123 -_-   abc
   def
   

   dönecekti ["123", "-_-", "abc", "def"].

Her iki durumda da STDIN, komut satırı argümanı veya function argümanı üzerinden girdi alabilir veya sonucu döndürür veya STDOUT yazdırabilirsiniz. İkinci program için, STDOUT'a yazdırmayı seçerseniz, lütfen her bir dizgiyi çevreleyen tırnak işaretleri olmadan kendi satırlarına yazdırın.

Her iki program için, girişin yalnızca yazdırılabilir ASCII (0x20 - 0x7E) ve beyaz boşluk içerdiğini varsayabilirsiniz.

Şimdi burada yakalamak:

• Tüm boşluklar her iki programdan / işlevlerden kaldırılırsa, ortaya çıkan dizelerin aynı olması gerekir. Diğer bir deyişle, iki gönderiminiz yalnızca boşluk karakterlerinin sayısında ve yerleşiminde farklılık gösterebilir.
• Hiçbir program / işlev herhangi bir dize veya regex değişmezi içeremez (dilinizin belirlenmiş bir karakter türüne sahip olması koşuluyla karakter değişmezleri iyidir).
• Hiçbir program / işlev herhangi bir yorum içermeyebilir.
• Programın kaynak kodunu doğrudan veya dolaylı olarak okumamalısınız.

Bu kod golfü. Puanınız, her iki çözümün boyutlarının toplamıdır (bayt cinsinden). En düşük puan kazanır.

Liderler

Aşağıdaki Stack Snippet'i hem düzenli bir lider tablosu hem de kazananların dile göre genel bir bakışını oluşturur. Öyleyse, seçtiğiniz dil tüm mücadeleyi kazanmanıza izin vermese bile, neden ikinci listedeki bir noktayı yakalamaya çalışmıyorsunuz? İnsanların bu zorluğun çeşitli dillerde nasıl üstesinden geldiğini görmek çok isterim!

Cevabınızın göründüğünden emin olmak için, lütfen aşağıdaki Markdown şablonunu kullanarak cevabınızı bir başlık ile başlatın:

# Language Name, N bytes

nerede Nolduğu toplam gönderiminize boyutu. Puanınızı artırmak varsa, olabilir onları içinden vurarak, başlığa eski hesapları tutmak. Örneğin:

# Ruby, <s>104</s> <s>101</s> 96 bytes

Bireysel sayıları toplam sayımdan önce de ekleyebilirsiniz, örn.

# Python 2, 35 + 41 = 76 bytes

Vurulmayan son sayı, snippet tarafından kullanılacaktır.

<script src='https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js'></script><script>site = 'meta.codegolf',postID = 5314,isAnswer = true,QUESTION_ID = 42253;jQuery(function(){var u='https://api.stackexchange.com/2.2/';if(isAnswer)u+='answers/'+postID+'?order=asc&sort=creation&site='+site+'&filter=!GeEyUcJFJeRCD';else u+='questions/'+postID+'?order=asc&sort=creation&site='+site+'&filter=!GeEyUcJFJO6t)';jQuery.get(u,function(b){function d(s){return jQuery('<textarea>').html(s).text()};function r(l){return new RegExp('<pre class="snippet-code-'+l+'\\b[^>]*><code>([\\s\\S]*?)<\\/code><\/pre>')};b=b.items[0].body;var j=r('js').exec(b),c=r('css').exec(b),h=r('html').exec(b);if(c!==null)jQuery('head').append(jQuery('<style>').text(d(c[1])));if (h!==null)jQuery('body').append(d(h[1]));if(j!==null)jQuery('body').append(jQuery('<script>').text(d(j[1])))})})</script>

Pyth, 16 + 15 = 31 bayt

Burada dene .

Sayaç:

L@,cb)sm!cd)b1 0

Splitter:

L@,cb)sm!cd)b10

Bunların her biri y, istenen görevi çözmek için bir dize girdisi alan bir işlevi tanımlar .

Pyth'in modüler indeksleme özelliğini bir karakter tıraş için listelerde kullanma fikri için @FryAmTheEggman'a teşekkürler.

Test durumları:

L@,cb)sm!cd)b1 0y++"abc def"b"gh ij k"
L@,cb)sm!cd)b10y++"abc def"b"gh ij k"

Açıklama:

L                  define a function, y, which takes one input, b.
 @                 Index into
  ,                2-tuple of
   cb)             b.split()                          (solution to splitter)
   s               sum over                           (solution to counter)
    m              map, with input d, to
     !cd)          logical negation of d.split()      (empty list is falsy)
     b             over b.
                   Index is either:
   10
   1
                   Indexing is modulo the length of the list in Pyth.
 0                 In one case, a 0 with a leading space is outside the function.
                   Leading space suppresses print, so the 0 is invisible.

Python, 54 + 56 = 110 bayt

Sayaç:

m=lambda x:sum(y.isspace()for y in x)
+1
0<9or x.split()

Splitter:

m=lambda x:sum(y.isspace()for y in x)+10<9or x.split()

Sayaç için, Python'un bir satırda sadece bir ifadeye sahip olmasıyla tamam olduğu gerçeğini kullanıyoruz. O bölmek gerekli +1ve 0<9or x.split()bir durdurma NameErrorgibi fırlamaya karşı 0<9olmak Trueönler x.split()nedeniyle kısa devre olmasına değerlendirilmektedir dan.

Ayırıcı için, boşlukların sayısı her zaman olumsuz değildir, sum(y.isspace()for y in x)+10<9her zaman Falseve bölme işlevi devreye girer.

Alternatif 1, 59 + 60 = 119 bayt

Sayaç:

m=lambda x:[x.split(),sum(y.isspace()for y in x)][min([1])]

Splitter:

m=lambda x:[x.split(),sum(y.isspace()for y in x)][m in([1])]

Hem sayma hem de bölmenin sonuçları iki elemanlı bir listede saklanır. Liste, min([1])içerdiği bir eleman listesinin minimumunu döndürerek 1veya içinde bulunmadığı şekilde (eşdeğerini ) m in([1])döndüren endekslenir .False0m[1]

Alternatif 2, 67 + 69 = 136 bayt

Sayaç:

ted=1;s=lambda x:[x.split(),sum(y.isspace()for y in x)][not s or ted]

Splitter:

ted=1;s=lambda x:[x.split(),sum(y.isspace()for y in x)][not sorted]

Yukarıda olduğu gibi, hem sayma hem de bölmenin sonuçları iki elemanlı bir listede saklanır. sortedbir truthy değeri olan yerleşik bir işlevdir, bu nedenle not sorteddöndürür False(eşdeğer 0). İçin not s or ted, çünkü sbir işlev ve ayrıca truthy olduğu not solduğu Falseve ted = 1döndürülür.

Alternatif 3, 59 + 60 = 119 bayt

Sayaç:

def f(s):a=s.split();a1=len(s)-len((s*0).join(a));return a1

Splitter:

def f(s):a=s.split();a1=len(s)-len((s*0).join(a));return a
1

Bu, splitter'ın sonucunun değişkende saklandığı ave sayıcının sonucunun değişkende depolandığı bir fonksiyondur a1. Daha önce olduğu gibi, Python bu durumda, bir satırda sadece bir ifadeye sahip olmakla iyi 1. Ayrılması a1, fonksiyondan ne döndürüleceğini belirler.

Java 8, 239 + 240 = 479

Boşlukları say (Tam sayı döndürür)

Object f(String s){String r=new String(new char[]{92,'s'}),e=new String();int intx=0;intx=1;return intx>0?s.chars().filter(c->c==9|c==10|c==32).count():java.util.Arrays.stream(s.split(r)).map(t->t.replaceAll(r,e)).filter(t->t.length()>0);}

Boşlukta ayır (Akış <String> döndürür)

Object f(String s){String r=new String(new char[]{92,'s'}),e=new String();int intx=0;int x=1;return intx>0?s.chars().filter(c->c==9|c==10|c==32).count():java.util.Arrays.stream(s.split(r)).map(t->t.replaceAll(r,e)).filter(t->t.length()>0);}

Açıklama:

Object f(String s){
    String r=new String(new char[]{92,'s'}),e=new String();  // init regex'es

    int intx=0;     // critical variable

    intx=1;         // change intx to 1
              OR
    int x=1;        // new, unused variable

    return intx>0 ? // test variable to decide what to do
      s.chars().filter(c->c==9|c==10|c==32).count() :
      java.util.Arrays.stream(s.split(r)).map(t->t.replaceAll(r,e)).filter(t->t.length()>0);
}

Boşluk, 75 + 153 = 228

Sırasıyla STL ile ikame edilmiş ve okunaklılık için katlanmış boşluklar, sekmeler ve yeni çizgiler. İle uygun bir Whitespace dosyasına dönüştürün tr -d \\n | sed 'y/STL/ \t\n/'.

sayaç

SSSLLSSLSSSTSSSSSLSLSSLSTLTSTTTSLSLTSSLTSSTLTTLSSSTLTSSSLSLLLSSSLS
LLSLLTLST

Splitter

SSSTLSSSLTTSLSSTLSSSLSLSTLTSTTTSLSSLSLTSLSSSTSSSSTLTSSTLTTTTLSSSTL
SLSTTSLSLSLLSSTTLSSSTSTSLSSSTLTTTLTSTSLTLSSSSSTLSSSLTTSLSSTSLLSLTL
LSSSLTLSSLSLTLLSSLLLL

Mermer, 103 + 92 = 195

Sayaç:

@0      @200@1@3
]]&1]]3W
  \\!!?001
        &0  >W@1
>W    @2/\  /\@3+A
00&0      &1
          Dp
@0//

Splitter:

@0  @200@1    @3
]]&1]]  3W    \\
  !!    ?001&0
>W@1>W@2
/\  /\@3+A00&0
          &1Dp@0
//

Bu programları burada test edin. Silindirik Panolar, Kütüphaneleri Dahil Et ve boş hücreler için boşlukların tümü kontrol edilmelidir.

Giriş ve Çıkış, STDIN / STDOUT aracılığıyla yapılır.

açıklama

Sayaç:

Mavi yol girdi alır. Karakter bir boşluk karakteri ise (ascii değeri 0x21'den küçükse), mor yolla senkronize olan siyah yol alınır.

Mor yol &1, siyah yol her alındığında senkronizörde depolanan bir mermeri artırır .

Başka giriş olmadığında, beyaz boşluk karakterlerinin sayısını bastırarak ve çıkarak kırmızı yol çekilir.

Splitter:

Program, boşluk olmayan bir karakter bulunana kadar dönen mavi yolla başlar.

Beyaz boşluk olmayan bir karakter alındığında, bu karakteri basan ve yürütmeyi yeşil yola doğru hareket ettiren, beyaz boşluk karakteri alınana kadar dönen ve yazdıran siyah yol çekilir. Uygulama daha sonra içeren 3Wveya üç yollu ayırıcı olan mor yola devam eder .

Sol dal, yürütmeyi mavi yola kaydırır (ve boşluk olmayan bir karakter bulunana kadar boşluk bırakılır).

Orta dal, girişin kopyasını 0 ile ayarlar ?0( 0ve arasında rastgele bir sayı oluşturur 0) ve daha 0x0Asonra çıkarılan 10 ( = newline) ekler .

Doğru yol atıldı.

CJam, 26 + 27 = 53 59 61 73 77 bayt

sayaç

'!q_,\SN9c++SerS%:Qs,-QN*?

Splitter

' !q_,\SN9c++SerS%:Qs,-QN*?

Nasıl çalışır

Fikir basit, her iki boşluk alanını da hesapla ve diziyi arka arkaya gelen boşluklardan ayır. Daha sonra aşağıdaki gerçeğine dayanır bunlardan birini seçmek ' !anlamına not of space characterederken, falsy olan '!ise !truthy olan karakter.

Genişletilmiş kod:

'! / ' !                              "Get truthy or falsy value";
        q_                            "Read the input, make a copy";
          ,\                          "Take the length of the copy and swap";
            SN9c++                    "Get a string comprised of all Whitespaces";
                  Ser                 "Replace any occurrence of any character of"
                                      "the above string with space";
                     S%               "Split on one or more runs of space";
                       :Qs,           "Store this in Q, flatten to a string and take length";
                           -          "Subtract from total length to get count";
                            QN*       "Put the splitted array on stack and join newline";
                               ?      "Base on the truthy or falsy value, pick one to print";

Giriş STDIN'den ve çıkış STDOUT'dan

Burada çevrimiçi deneyin

Mathematica, 44 + 43 = 87 97 bayt

Karışıma başka bir dil ekleyeceğimi düşündüm.

Sayaç:

StringCount[#,Whitespace]+0 1StringSpli t@#&

Splitter:

String Count[#,Whitespace]+01StringSplit@#&

Bu, Mathematica'nın, boşluk ayırmanın çarpma ile aynı olduğu özelliğini kullanır. Ve bir şeyi 0 ile çarpmak her zaman 0'dır ve bir şeye 0 eklemek her zaman önemsizdir.

Tezgâh için önce boşlukları sayarız ve ekleriz 0*1*StringSpli*t@#. StringSplive ttanımlanmadı, ama Mathematica sembolik hesap kullanıyor, bu yüzden sadece bilinmeyen bir değişken ve işlev olarak görüyor. 1*İdempotent (sadece gibidir 0+), 0*bir sıfır haline döner. StringSplitİçindeki iki değişkeni ayırmak gerekir , çünkü 0bir liste, bir sıfır (vektör) listesiyle sonuçlanan bir skaler-vektör çarpımı olarak değerlendirilir.

Ayırıcı için, Countaynı zamanda var olan ancak dizgelere bakmayan gerçeğini kullanıyorum . Desene uyan tüm alt ifadeleri saymaya çalışır , ancak Whitespaceyalnızca dize içeriği için geçerli olan bir kalıptır. Böylece Counther zaman geri döner 0, bu Stringortadan kaybolur. Bölünmüş dizinin çarpma işlemi 01 = 1yine idempotent.

Ruby, 107 91 bayt

Ayırıcı (46 bayt)

p
p=gets(p).split
puts p||$_.size-pp.join.size

Sayaç (45 bayt)

pp=gets(p).split
puts p||$_.size-pp.join.size

pargüman olmadan sadece geri dönen, önceden tanımlanmış bir yöntemdir nil. Bunu birkaç şekilde kullanıyoruz. Ayırıcıda, ilk phiçbir şey yapmaz. gets(p)sınırlayıcı boş olduğundan, standart girdideki her şeyi okur. Bunun üzerine yerleşik split yöntemini çağırır ve sonucu atarız p, böylece şimdi argümanlar verilmediğinde değişken olarak ayrıştırılır. puts p||...kısa devreler ve pdeğişkenin her bir öğesini kendi çizgisine yazdırır .

Sayaçta, ilk yeni satırı siliyoruz, böylelikle bunun ppyerine split dizisi atanıyor . Atanmadığımız için phala sıfır döndürme yöntemidir, bu yüzden ikinci bölüm ||değerlendirilir ve geçer puts. $_sonucunu içeren sihirli bir değişkendir gets, bu nedenle toplam boşluk alanı, eksi boşluk içermeyen karakterleri ppiçerir. Saymayı yapmanın daha kısa bir yolu olması gerektiğini düşünüyorum, ancak bir tane bulamıyorum ve sayaçtaki bölünmüş diziyi kullanmak hiç de eğlenceli değil.

Python, 169

Bunu Python'da yapmak neredeyse çok kolay!

Sayaç:

def x(s):
 def y(s):
  return sum(map(str.isspace,s))
  return s.split()
 return y(s)

Splitter:

def x(s):
 def y(s):
  return sum(map(str.isspace,s))
 return s.split()
 return y(s)

Sadece bir alanda farklılık gösterirler ve bir sayı veya değişken ismi ikiye bölmek gibi bir hile yapıyorum :)

C, 138 + 136 = 274

Her durumda, kod tam olarak bir komut satırı argümanını kabul eden ve sonucu stdout'a basan bir programdır. \tbir sekme karakteri ile değiştirilmelidir. Tablar ve yeni satırlar içeren bir argüman iletmek istiyorsanız, bunun nasıl olduğunu anlamak sizin işinizdir;).

sayma

#define strtok strpbrk
h=' \t\n';main(c,v,n)char**v;{for(n=- -c-1;v[n]=strtok(1[v],&h);n[v]++)v[!n]=0,puts(*v),c++;n*='d%';printf(&n,c-2);}

bölme

#define strtokstrpbrk
h=' \t\n';main(c,v,n)char**v;{for(n=--c-1;v[n]=strtok(1[v],&h);n[v]++)v[!n]=0,puts(*v),c++;n*='d%';printf(&n,c-2);}

JavaScript, 95 + 96 = 191 bayt

Sayaç:

c=(a,v)=>{v
v=a=a.split(RegExp(String.fromCharCode(92,115)));return v?a.length-1:a.filter(j=>j)}

Splitter:

s=(a,v)=>{vv=a=a.split(RegExp(String.fromCharCode(92,115)));return v?a.length-1:a.filter(j=>!!j)}

Ungolfed:

s=(a,v)=>{

    v  // this `v` is ignored, or combined with the next line to make `vv`

    // split array and store it in `a` and `v` (or alternatively `vv`)
    v = a = a.split(RegExp(String.fromCharCode(92,115)));

    return v?
            a.length-1        // return number of whitespace chars
            :
            a.filter(j=>j)    // return array without empty strings
    }

RegExp(String.fromCharCode(92,115)Hat boşluk eşleştirme regex yaratır /\s/ifadenin veya dize hazır olmadan.

Her programda vveya değişkenini kullanırız vv. Split dizisini bu değişkene ( vveya vv) saklıyoruz ve sonra davranışımızı v(bu arada, vvyoksayılıyor) değerine göre dallıyoruz . Sayaçta vbir truthy değeri vardır; Ayırıcıda sahte bir değer vvvar (çünkü bunun yerine değer var).

Alternatif: JavaScript, 250 bayt

Kısalık için herhangi bir ödül kazanmayan başka bir çözümüm var, ancak JavaScript'in otomatik noktalı virgül ekleme davranışını kötüye kullanmanın ilginç bir zorluk olduğunu düşündüm.

Sayaç:

c=a=>{a=a.split(RegExp(String.fromCharCode(92,115)));x:for(i=2;i--;)for(o=i?a.length-1:a.filter(j=>j);1;){break x}return o}

Splitter:

s=a=>{a=a.split(RegExp(String.fromCharCode(92,115)));x:for(i=2;i--;)for(o=i?a.length-1:a.filter(j=>j);1;){break
x}return o}

Ungolfed sayacı:

s=a=>{
    a = a.split(
            RegExp(String.fromCharCode(92,115))   // split input on whitespace regex /\s/
        );  
    x:                             // x is a label for the outer loop
    for(i=2;i--;)                  // run this outer loop twice
        for(o=i?                   // if this is the first outer loop pass, 
               a.length-1          //    set `o` to number of whitespaces
               :                   // else, on second outer loop pass,
               a.filter(j=>j);     //    set `o` to split input (w/o empty strings)
            1;                     // 1 is truthy; run inner loop forever
            ) {
                break x;           // break out of outer loop
            }
    return o;                      // return `o`
}

Ayırıcı, çizgi hariç tamamen aynıdır:

break x;

şimdi

break
x;

Bir satır ara vermeden anlaşılabilir eğer JavaScript'in otomatik noktalı virgül ekleme normalde erken çok satırlı ifadeleri sonlandırmak değil, ama o çizgi sonra kırar tahammül etmez return, continueya da break. Bu nedenle, çizgi, breakdış döngüden kopmak yerine, yalnızca iç döngüden kopan basit bir şekilde okunur . "İkinci geçiş" davranışı o = a.filter(j=>j)daha sonra yürütülür (karşıda atlamaya karşı) çünkü dış döngüye ikinci bir geçiş verilir.

Python, 228 198 182 166 146 145 bayt

Sayaç ( 72 bayt ):

ior1=0
w=lambda i:i.split()if ior1 else sum(ord(c)in(9,10,32)for c in i)

Ayırıcı ( 73 bayt ):

ior1=0
w=lambda i:i.split()if i or 1else sum(ord(c)in(9,10,32)for c in i)

ior1bir i or 1falsey değişkenidir, ancak gerçek değildir. Ana numara bu.

Befunge 98, 61 + 59 = 120

Sayaç:

~:'!-0`#v_ >$1+#@ #. #
 @#,#$ #<_v#`0-!':~ # .#
  ,#$ #+55<v

Splitter:

~:'!-0`#v_ >$1+#@ #.#
 @#, #$#<_v#`0-!':~ #.#
  , #$#+55<v

Bash, 75 + 79 = 154 bayt

Bu, betiğin bir satırının bazı bölümleri veya bazı şekilleri hatalı biçimlendirilse bile (bazı durumlarda) bash işlemine devam edebilmeye dayanır. Boşluk, bazı yakın parantezler için çıkışları devre dışı bırakmak ve yeni bir hatta koyarak bir boruyu kırmak için kullanılır.

Splitter:

echo $((`echo $1|wc -w`+${#1}-$(\)\)\)
for a in $1;do echo $a;done|wc -c)))

Sayaç:

echo $((`echo $1|wc -w`+${#1}-$(\ )\ )\ )
for a in $1;do echo $a;done
|wc -c)))

Giriş, komut satırı argümanı, çıkış ise stdout üzerinden yapılır.

Bu bash hatası davranışına dayandığından, kullanıcının stderr dosyasını yoksayması beklenir.

Örnek çalışma (girişi yeni satırlı ve bitişik boşluklarla gösteren):

# bash counter.sh "abc def
gh   ij k" 2>/dev/null
6
# bash splitter.sh "abc def
gh   ij k" 2>/dev/null
abc
def
gh
ij
k

Ruby, 114 + 116 107 + 109 = 216 bayt

Bu, histokratın yakut çözümüyle rekabet edemez, ama yine de asılmaya değeceğini düşündüm.

Kullandığım $ziçin nilve nil.to_siçinString.new

Girişin sonuna eklediğim fazladan boşluk karakteri, diziye ( r) eklenecek son sözcüğü zorlamaktır - bir sözcük, yalnızca boşluk karakterinin boşluksuz bir karakteri takip etmesi durumunda dizinin sonuna eklenir. Alternatif, bloktan r<<w if wsonra bir tane daha ekliyordu each_byte.

sayma

->s{r=[]
n=-1
w=$z
(s+9.chr).each_byte{|b|if b<33
r<<w if w
w=$z
n+=1
else
w=w.to_s+b.chr
end}
$zorr ?r:n}

bölme

->s{r=[]
n=-1
w=$z
(s+9.chr).each_byte{|b|if b<33
r<<w if w
w=$z
n+=1
else
w=w.to_s+b.chr
end}
$z or r ?r:n}

Haskell , 53 + 55 = 108 36 + 38 = 74 bayt

sayaç

f=do
 pure(length.filter(<'!'))words

Splitter

f=do
 pure(length.filter(<'!'))
 words

Bu çözüm, Haskell işlevlerinde Monad tipi sınıfın bir örneği olması ve bu nedenle de gösterimde monadik eylemler olarak kullanılabileceği gerçeğini kullanır.

İlk durumda do bloğun sonuçta ortaya çıkan işlevi, (sonuçta işlev türü için pureolan) ilk argümandır const, sayıcı son sonucu ve atılan ayırıcıdır.

İkinci durumda pure, yalnızca başka bir işlevi döndüren bir işlev (sayaç) yapan tek bir argümana uygulanır. Ancak, sonuç asla kullanılmaz ve bu nedenle atılır. Nihai sonuç do-blockun ikinci satırı, bölücüdür.

Java 8, 187 + 188 = 375

Her şeyden önce, bu cevabın yoğun olarak @ Ypnypn’e dayandığını söylemek isterim. Temel olarak bazı parçaları daha kısa olanlarla değiştirdim (IMO'nun bu mücadelede en önemli olduğu boşluğa bağlı kısım dahil), ancak işlevsel kod çoğunlukla aynı.

Boşlukları say , 187 (döner int):

Object f(String s){String r=new String(new char[]{92,115});int a=0;return a--+a>0?s.chars().filter(c->c>8&c<11|c==32).count():java.util.Arrays.stream(s.split(r)).filter(t->t.length()>0);}

Boşlukta bölün , 188 (döner Stream<String>):

Object f(String s){String r=new String(new char[]{92,115});int a=0;return a- -+a>0?s.chars().filter(c->c>8&c<11|c==32).count():java.util.Arrays.stream(s.split(r)).filter(t->t.length()>0);}

J, 48 + 49 = 97 karakter

Tek bir argüman alarak ve geri döndüren iki fonksiyon. Aynı -beyaz-boşluk kuralını yenmeyi düşündüğüm en açık yolu kullandım, bu yüzden etraflarında daha zekice bir rota bularak muhtemelen kaydedilecek karakterler var.

(aa[aa=.+/@a=.a:-.~(e.u:)&9 10 32 :(<;._1~1,}.))      NB. count
(a a[aa=.+/@a=.a:-.~(e.u:)&9 10 32 :(<;._1~1,}.))     NB. split

aFiili, tek bir argümanla mı yoksa iki ile mi kullanıldığına bağlı olarak, iki farklı eylemin olmasını tanımlarız . Bir argümanla, (e.u:)&9 10 32her karakterin boşluk bırakıp bırakmadığını kontrol eden karakterdir. İki argümanla, a:-.~(<;._1~1,}.)sağda bir boolean vektörü alan ve sol argümanı bu konumlarda kesen, boş olan herhangi bir boşluğu atmaktır a:-.~.

Ardından, aasonuçta ayalnızca bir argümanla anlamlı olan Gerçek değerlerin sayısı olarak tanımlarız . Son olarak, kullandığımız aaveya a abiz saymak veya dize boşluk bölmek istemediğinize bağlı. aabeklendiği gibi çalışır.

Nedeni a aJ gördüğünde çünkü çalışır olduğunu (f g)y, bu gördüğü (f g)bir kanca ve hoşuna değerlendirir y f (g y). Bu durumda, fdiyadik olan a, kesim yapan ve yukarıda golduğu a[aagelen toplamını hesaplar olan aa, dışarı atar ve hesaplar (Monadik) atekrar.

REPL'de:

   (aa[aa=.+/@a=.a:-.~e.&(u:9 10 32) :(<;._1~1,}.))   '  123',TAB,'-_-   abc',LF,'def'
7
   (a a[aa=.+/@a=.a:-.~e.&(u:9 10 32) :(<;._1~1,}.))  '  123',TAB,'-_-   abc',LF,'def'
+---+---+---+---+
|123|-_-|abc|def|
+---+---+---+---+

Bash, 54 + 50 = 104 bayt

sayaç

a=$IFS
IFS=
cat()(tr -cd $a|wc -c)
printf %s \\n$1|cat

Splitter

a=$IFSIFS=ca
t()(tr-cd$a|wc-c)
printf %s\\n $1|cat

Perl, 37 + 38 = 75

Sayaç :

sub f{($_)=@_;(y/   - //,[split])[0.1]}

Ayırıcı :

sub f{($_)=@_;(y/   - //,[split])[0 .1]}

Perl 6, 31 + 32 = 63 bayt

sayaç

{?^1??.words!!+grep 33>*,.ords}

Çevrimiçi deneyin!

?^1?^ 1Boole olumsuzlama işlecini 1'e uygulayan şekilde ayrıştırılır , sonuç olarak False.

Splitter

{? ^1??.words!!+grep 33>*,.ords}

Çevrimiçi deneyin!

? ^10..0 aralığını Bool değerine dönüştürür, sonuçta True.

Python 2, 98

Yarma (49)

Listedeki belirteçleri döndürür.

f=lambda s:[sum(map(str.isspace,s))]and s.split()

Sayma (49)

Boşluk karakterlerinin sayısını içeren bir uzunluk listesi döndürür. Büyük olasılıkla bir çalışma zamanı hatasına neden olur, ancak işlev fkodu yürüttükten sonra kullanılabilir.

f=lambda s:[sum(map(str.isspace,s))]
ands.split()

C (gcc) , 88 + 89 = 177 bayt

Splitter

i,n,x,c;f(char*s){x=n=i=0;for(x+++n;c=*s++;c*x&&putchar(c))i=c<33?n++,c=i*10,0:1;x=n-1;}

Splitter

sayaç

i,n,x,c;f(char*s){x=n=i=0;for(x+ ++n;c=*s++;c*x&&putchar(c))i=c<33?n++,c=i*10,0:1;x=n-1;}

sayaç

Bitkin

Fonksiyon argümanı olarak girdi alır. Sayma işlevi boşluk sayısını döndürür. Bölme işlevi, çıktısı için STDOUT işlevini kullanır (ancak bu arada yanlışlıkla beyaz boşluk sayısını de ekler).

i,                      Flag signalling whether we are inside a word.
n,                      Number of whitespace encountered.
x,                      Flag signalling whether or not we should output the words.
c;                      Current character.
f(char*s){              Take input string as an argument.
x=n=i=0;for(            Initialise everything and start loop.
x+++n;                  SPLITTER ONLY: Interpreted as x++ +n, meaning x is set to 1 and n stays 0.
x+ ++n;                 COUNTER ONLY: Inverse of the above. Sets n to 1, and x stays 0.
c=*s++;                 Sets c to current char and increment string pointer, end loop if end of string.
c*x&&putchar(c))        Only output c if x is 1 and c is non-zero, which only happens if we left a word.
i=c<33?                 Since input contains only printable ASCII or whitespace, anything below 33 is whitespace.
       n++,             ...if that is the case, increment the whitespace counter (n)
           c=i*10,      ...and set c to newline (10), but only if we just left a word (if i is 1)
                  0:    ...and set i to 0.
                    1;  If not a whitespace, set i to 1, signalling we are inside a word.
x=n-1;}                 Implicitly returns n-1, which is the number of whitespaces if we are in the counter function.

Zsh , 35 + 35 = 70 bayt

• Hiçbir program / işlev herhangi bir dize veya regex değişmezi içeremez

[^$IFS]Desen eşleştirmede kullanıldığından hak kazanıp kazanmadığından emin değilim . İşte yasaklanması durumunda 45 + 45 çözüm.

Bölünmüş:

:<<<${#1//[^$IFS]} 
:
<<<${(F)${=1}}

Miktar:

:
<<<${#1//[^$IFS]}
:<<<${(F)${=1}}

:Builtin için equivilent edilir truebiz buna istenmeyen genişlemesini borularla bir açıklama ve / dev / boş (yorumlar edemediğinden) arasında bir şey olarak kullanabilirsiniz.

Zsh, boşlukta bölmek için bir yapıya sahip ${=var} . Bu, ikisini birden yürütmek ve istemediklerimizi atmaktan başka mantıklı bir kombinasyon yapmayı zorlaştırır.

Çevrimiçi deneyin!