Ми визначаємо пробіл будь-якого з трьох символів, вкладка (0x09), новий рядок (0x0A) або пробіл (0x20).

Для цього завдання потрібно написати дві програми або функції однією мовою програмування, які виконують такі завдання:

1. Порахуйте символи пробілів у заданому рядку. Наприклад, вхід

     123 -_-   abc
   def
   

   повернеться 7 (за умови, що немає нового рядка).

2. Розділити заданий рядок під час послідовних пробілів пробілів. Якщо рядок починається або закінчується пробілом, на кінцях не повертаються порожні рядки. Наприклад, той самий вхід

     123 -_-   abc
   def
   

   повернеться ["123", "-_-", "abc", "def"].

У будь-якому випадку ви можете взяти вхід через STDIN, аргумент командного рядка або аргумент функції, повернути результат або роздрукувати його STDOUT. Для другої програми, якщо ви вирішили надрукувати на STDOUT, будь-ласка, надрукуйте кожен рядок у своєму власному рядку без навколишніх цитат.

Для обох програм ви можете припустити, що вхід містить лише друкований ASCII (0x20 до 0x7E) та пробіл.

Тепер ось улов:

• Якщо весь пробіл видалено з обох програм / функцій, отримані рядки повинні бути однаковими. Тобто, ваші два подання можуть відрізнятися лише кількістю та розміщенням символів пробілу.
• Жодна програма / функція не може містити будь-яких лінійних рядків або регулярних виразів (символьні літерали є нормальними, за умови, що ваша мова має визначений тип символів).
• Жодна програма / функція не може містити коментарів.
• Ви не повинні читати вихідний код програми прямо чи опосередковано.

Це код гольфу. Ваш бал - це сума розмірів обох рішень (у байтах). Виграє найнижчий рахунок.

Табло лідерів

Наступний фрагмент стека створює як звичайний таблицю лідерів, так і огляд переможців за мовою. Тож навіть якщо ваша обрана мова не дозволяє вам перемогти у всьому виклику, чому б не спробувати вирвати місце у другому списку? Мені б дуже цікаво подивитися, як люди вирішують цю проблему на різних мовах!

Щоб переконатися, що ваша відповідь відображається, будь ласка, почніть свою відповідь із заголовка, використовуючи наступний шаблон Markdown:

# Language Name, N bytes

де Nє загальний розмір вашого уявлення. Якщо ви покращите свій рахунок, ви можете зберегти старі бали у заголовку, прокресливши їх. Наприклад:

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

Ви також можете включити індивідуальні підрахунки до загальної кількості, наприклад

# Python 2, 35 + 41 = 76 bytes

Останнє число, яке не прокреслене, буде використано фрагментом.

<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 байт

Спробуйте тут .

Лічильник:

L@,cb)sm!cd)b1 0

Спліттер:

L@,cb)sm!cd)b10

Кожен з них визначає функцію, yяка вимагає введення рядка для вирішення потрібної задачі.

Завдяки @FryAmTheEggman за ідею використання особливості модуля індексування Pyth у списках для гоління персонажа.

Тестові приклади:

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

Пояснення:

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.

Пітон, 54 + 56 = 110 байт

Лічильник:

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

Спліттер:

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

Для лічильника ми використовуємо той факт, що в Python все гаразд із наявністю лише виразу на рядку. Необхідно розділитись +1і 0<9or x.split()не NameErrorдопустити викидання, оскільки це 0<9не Trueдозволяє x.split()оцінюватися через коротке замикання.

Для спліттера, оскільки кількість пробілів завжди невід’ємне, sum(y.isspace()for y in x)+10<9завжди є, Falseі функція розщеплення вступає в дію.

Альтернатива 1, 59 + 60 = 119 байт

Лічильник:

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

Спліттер:

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

Результати підрахунку та розбиття зберігаються у двоелементному списку. Список індексується будь-яким min([1]), повертаючи мінімум списку одноелементів, що містить 1, або m in([1]), який повертає False(еквівалентно 0), mякий не міститься в [1].

Альтернатива 2, 67 + 69 = 136 байт

Лічильник:

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

Спліттер:

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

Як і вище, результати як підрахунку, так і розбиття зберігаються у двоелементному списку. sortedце вбудована функція, яка є правдоподібним значенням, тому not sortedповертається False(еквівалентно 0). Бо not s or ted, оскільки sце функція, а також правда, not sє Falseі ted = 1повертається.

Альтернатива 3, 59 + 60 = 119 байт

Лічильник:

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

Спліттер:

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

Це функція, коли результат розгалужувача зберігається у змінній a, а результат лічильника - у змінній a1. Як і раніше, Python чудово поєднує в цьому випадку лише вираз на рядку 1. Розщеплення a1визначає, що потрібно повернути з функції.

Java 8, 239 + 240 = 479

Порахувати пробіли (повертає цілий ряд)

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

Розділити на пробіл (повертає Потік <String>)

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

Пояснення:

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

Пробіл, 75 + 153 = 228

Пробіли, вкладки та нові рядки заміщені відповідно STL та складені для розбірливості. Перетворити у відповідний файл Whitespace за допомогою tr -d \\n | sed 'y/STL/ \t\n/'.

Лічильник

SSSLLSSLSSSTSSSSSLSLSSLSTLTSTTTSLSLTSSLTSSTLTTLSSSTLTSSSLSLLLSSSLS
LLSLLTLST

Спліттер

SSSTLSSSLTTSLSSTLSSSLSLSTLTSTTTSLSSLSLTSLSSSTSSSSTLTSSTLTTTTLSSSTL
SLSTTSLSLSLLSSTTLSSSTSTSLSSSTLTTTLTSTSLTLSSSSSTLSSSLTTSLSSTSLLSLTL
LSSSLTLSSLSLTLLSSLLLL

Марбелус, 103 + 92 = 195

Лічильник:

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

Спліттер:

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

Випробуйте ці програми тут. Циліндричні дошки, включаючи бібліотеки та пробіли для порожніх комірок, повинні бути перевірені.

Вхід і вихід здійснюються через STDIN / STDOUT.

Пояснення

Лічильник:

Синій шлях отримує вхід. Якщо символ є символом пробілу (значення ascii менше 0x21), приймається чорний шлях, який синхронізується з фіолетовим шляхом.

Фіолетовий шлях просто збільшує мармур, що зберігається в &1синхронізаторі щоразу, коли йде чорний шлях.

Після того, як більше немає вводу, приймається червоний шлях, друкуючи кількість символів пробілу та вихід.

Спліттер:

Програма починається з блакитного контуру, який циклізує, поки не знайдеться символ, який не є пробілом.

Після отримання символу, який не є пробілом, приймається чорний шлях, який роздруковує цього символу і переміщує виконання до зеленого контуру, який циклізує та друкує до отримання символу пробілу. Потім виконання продовжується до пурпурного контуру, який містить 3W, або тристороннього спліттера.

Ліва гілка переміщує виконання до синього шляху (і пробіл відкидається, поки не знайдеться символ, який не пробігає).

Середня гілка встановлює копію введення на 0 з ?0(генерує випадкове число між 0і 0) і додає 10 ( 0x0A= новий рядок), який потім виводиться.

Правильний шлях відкидається.

CJam, 26 + 27 = 53 59 61 73 77 байт

Лічильник

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

Спліттер

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

Як це працює

Ідея проста, обчисліть кількість пробілів і розділіть рядок на послідовні пробіли пробілів. Потім виберіть один з них , грунтуючись на наступному факті , що ' !означає , not of space characterщо falsy, в той час як '!це !символ, який truthy.

Розширений код:

'! / ' !                              "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";

Вхід - від STDIN, а вихід - до STDOUT

Спробуйте його онлайн тут

Математика, 44 + 43 = 87 97 байт

Я думав, що додаю ще одну мову до суміші.

Лічильник:

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

Спліттер:

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

Це використовує особливість Mathematica, що розділення простору - це те саме, що і множення. А множення чогось на 0 завжди є 0, а додавання 0 до чогось завжди ідентичне.

Для лічильника спочатку підраховуємо пробіл і додаємо 0*1*StringSpli*t@#. StringSpliі tне визначені, але Mathematica використовує символічні обчислення, тому він просто розглядає їх як невідому змінну та функцію. 1*Ідемпотентна (як 0+), то 0*перетворює його в нуль. Необхідно розділити StringSplitдві змінні, тому що 0раз перелік трактується як скалярно-векторне множення, що призводить до вектора (списку) нулів.

Для спліттера я використовую той факт, що Countтакож існує, але не розглядає рядки. Він намагається підрахувати всі під вирази, що відповідають шаблону, але Whitespaceце шаблон, який стосується лише вмісту рядків. Так Countзавжди повернеться 0, що змушує Stringзникати. Множення розділеного масиву на 01 = 1знову є ідентичним.

Рубі, 107 91 байт

Спліттер (46 байт)

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

Лічильник (45 байт)

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

pце заздалегідь визначений метод, який без аргументів просто повертається nil. Ми використовуємо це декількома способами. У спліттері початковий pнічого не робить. gets(p)читається у всьому зі стандартного вводу, оскільки роздільник є нульовим. Ми називаємо вбудований метод розділення на цьому і призначаємо результат p, тому тепер, коли йому не надано аргументів, він буде розбиратися як змінна. puts p||...коротке замикання та друкує кожен елемент pзмінної до власного рядка.

У лічильнику ми видаляємо перший новий рядок, щоб ppзамість нього було призначено розділений масив . Оскільки ми цього не призначили p, це все-таки метод нульового повернення, тому друга частина отриманого ||оцінюється і передається puts. $_- це магічна змінна, що містить результат gets, тому загальна кількість пробілів - це розмір, мінус символи, що не ppмістять пробілів, що є тим, що містить. Я відчуваю, що повинен бути коротший спосіб підрахунку, але я не можу його знайти, і в будь-якому випадку використовувати розділений масив у лічильнику - це цікаво.

Пітона, 169

Це зробити занадто просто в Python!

Лічильник:

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

Спліттер:

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

Вони відрізняються лише одним простором, і я не займаюся хитрістю, як розділити число або ім’я змінної навпіл :)

С, 138 + 136 = 274

У кожному випадку код - це програма, яка приймає рівно один аргумент командного рядка і друкує результат у stdout. \tслід замінити символом вкладки. Якщо ви хочете передати аргумент, що містить вкладки та нові рядки, ваша робота з’ясувати, як;).

Підрахунок

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

Розщеплення

#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 байт

Лічильник:

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

Спліттер:

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

Безголівки:

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)Рядок створює пробільні зіставлення регулярних виразів /\s/без регулярних виразів або строкових літералів.

У кожній програмі ми використовуємо змінну vабо vv. Ми зберігаємо розділений масив у цю змінну ( vабо vv), а потім розгалужуємо свою поведінку на значення v(тим часом vvігнорується). У лічильнику vмає трибунове значення; у сплітері воно має помилкове значення (тому що vvотримало значення замість цього).

Чергуйте: JavaScript, 250 байт

У мене є ще одне рішення, яке не виграє жодних призів за стислість, але я подумав, що це цікаве завдання - зловживати автоматичною поведінкою JavaScript з введенням крапки з комою.

Лічильник:

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}

Спліттер:

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}

Лічильник безготівки:

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

Розділювач точно такий же, за винятком рядка:

break x;

зараз

break
x;

Автоматичне вставлення крапки з комою в JavaScript зазвичай не припиняє багаторядкові оператори рано, якщо їх можна зрозуміти без розриву рядка, але воно не переносить розриви рядків після return, continueабо break. Тому рядок читається просто як break, яка виривається лише з внутрішньої петлі, а не виривається із зовнішньої петлі. Потім поведінка "другого проходу" o = a.filter(j=>j)виконується (проти пропускання в лічильник), оскільки зовнішній цикл надається другим проходом.

Пітон, 228 198 182 166 146 145 байт

Лічильник ( 72 байти ):

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

Спліттер ( 73 байти ):

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

ior1є змінною фальси, але i or 1є правдоподібною. Це головна хитрість.

Befunge 98, 61 + 59 = 120

Лічильник:

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

Спліттер:

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

Bash, 75 + 79 = 154 байти

Це покладається на те, що bash може продовжувати виконання, навіть якщо деякі рядки або частини рядка сценарію неправильно (за деяких обставин). Пробіл використовується для деактивації втечі для деяких близьких кронштейнів та для розриву труби, переводячи її на нову лінію.

Спліттер:

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

Лічильник:

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

Введення здійснюється через аргумент командного рядка, вихід - через stdout.

Оскільки це покладається на поведінку помилок bash, очікується, що користувач ігнорує stderr.

Приклад запуску (показ вводу з новою лінією та кількома суміжними пробілами):

# 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

Рубі, 114 + 116 107 + 109 = 216 байт

Це не може конкурувати з рубіновим рішенням гістократа, але я вважав, що варто все-таки поставитись.

Я використовував $zдля nilі nil.to_sдляString.new

Додатковий символ пробілу, який я додаю в кінці введення, - змусити останнє слово додати до масиву ( r) - слово додається лише в кінці масиву, коли символ пробілу слідує за символом, який не є пробілом. Альтернативою було додавання ще одного r<<w if wпісля each_byteблоку.

Підрахунок

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

Розщеплення

->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 байти

Лічильник

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

Спліттер

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

Це рішення використовує той факт, що в Haskell функції є екземпляром класу типу Monad і, таким чином, можуть використовуватися як монадійні дії в do-notation.

У першому випадку результуюча функція do-блоку є першим аргументом pure(що по суті є)const є типом функції), що робить лічильник кінцевим результатом і сплітер відкидається.

У другому випадку pureзастосовується лише до одного аргументу, що робить його функцією, яка повертає іншу функцію (лічильник). Однак результат ніколи не використовується і, таким чином, відкидається. Кінцевий результат - другий рядок do-блоку, спліттера.

Ява 8, 187 + 188 = 375

Перш за все, я хотів би сказати, що ця відповідь ґрунтується на @ Ypnypn's. Я в основному замінив деякі частини більш короткими (включаючи частину, що залежить від пробілу, IMO є найважливішим у цьому виклику), але функціональний код здебільшого той самий.

Порахуйте пробіли , 187 (повернення 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);}

Розділити на пробіл , 188 (повертається 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 char

Дві функції беруть і повертають один аргумент. Використовується найсміливіший спосіб, який я міг би придумати, щоб перемогти те саме правило, але пробіл, тому, ймовірно, є символи, які слід зберегти, знайшовши більш розумний маршрут навколо цього.

(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

Ми визначаємо, що дієслово aмає дві різні дії, залежно від того, використовується воно з одним аргументом чи з двома. З одним аргументом, він (e.u:)&9 10 32перевіряє, чи кожен символ є пробілом чи ні. З двома аргументами, це він a:-.~(<;._1~1,}.), який бере бульний вектор справа і вирізає лівий аргумент у цих позиціях, викидаючи будь-які порожні надрізи зa:-.~ .

Тоді ми визначаємо aaкількість результатів True в результаті a, що має сенс лише за одним аргументом. Нарешті, ми використовуємо aaабо a aзалежно від того, чи хочемо ми порахувати чи розділити пробіл рядка. aaпрацює як очікувалося.

Причина a aпрацює в тому, що коли J бачить (f g)y, він вважає (f g)гачок і оцінює його як y f (g y). У цьому випадку f- діадія, aнад якою відбувається розрізання, і gє a[aa, яка обчислює суму aa, викидає її і знову обчислює (монадію) a.

У відповіді:

   (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 байти

Лічильник

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

Спліттер

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

Перл, 37 + 38 = 75

Лічильник :

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

Спліттер :

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

Perl 6, 31 + 32 = 63 байти

Лічильник

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

Спробуйте в Інтернеті!

?^1аналізується так, як ?^ 1застосовується оператор булевого заперечення до 1, в результаті чого False.

Спліттер

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

Спробуйте в Інтернеті!

? ^1перетворює діапазон 0..0 в Bool, в результаті чого True.

Пітон 2, 98

Розщеплення (49)

Повертає маркери в списку.

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

Підрахунок (49)

Повертає список довжини один, що містить кількість пробілів. Це, швидше за все, спричинить помилку виконання, але функцію fможна використовувати після виконання коду.

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

C (gcc) , 88 + 89 = 177 байт

Спліттер

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

Спліттер

Лічильник

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

Лічильник

Спуститися

Вводить введення як аргумент функції. Функція підрахунку повертає кількість пробілів. Функція розщеплення використовує STDOUT для свого виводу (але, до речі, також повертає кількість пробілів мінус один).

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 байт

• Жодна програма / функція не може містити будь-яких рядкових чи зворотних формул

Я не впевнений, чи підлягає [^$IFS]кваліфікації, оскільки він використовується в узгодженні шаблонів. Ось рішення 45 + 45 у випадку, якщо це заборонено.

Розділити:

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

Рахувати:

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

:Вбудована команда equivilent вtrue , ми використовуємо його як щось середнє між коментарем і / Dev / нуль (так як коментарі заборонену) по конвеєру небажаного розширення до нього.

Zsh має вбудований модуль для розбиття на пробіли ${=var}. Це ускладнює виконання будь-якої логічної комбінації, окрім просто виконання обох та відмови від тієї, яку ми не хочемо.

Спробуйте в Інтернеті!