Definimos espaço em branco como qualquer um dos três caracteres, tab (0x09), nova linha (0x0A) ou espaço (0x20).

Para esse desafio, você deve escrever dois programas ou funções na mesma linguagem de programação, que executam as seguintes tarefas:

1. Conte os caracteres de espaço em branco em uma determinada sequência. Por exemplo, a entrada

     123 -_-   abc
   def
   

   retornaria 7 (desde que não haja uma nova linha à direita).

2. Divida uma determinada sequência em execuções consecutivas de espaço em branco. Se a sequência começar ou terminar com espaço em branco, nenhuma sequência vazia deverá ser retornada nas extremidades. Por exemplo, a mesma entrada

     123 -_-   abc
   def
   

   voltaria ["123", "-_-", "abc", "def"].

Em qualquer um dos casos, você pode receber informações via STDIN, argumento de linha de comando ou argumento de função para retornar o resultado ou imprimi-lo STDOUT. Para o segundo programa, se você optar por imprimir em STDOUT, imprima cada sequência em sua própria linha, sem aspas.

Nos dois programas, você pode assumir que a entrada contém apenas ASCII imprimível (0x20 a 0x7E) e espaço em branco.

Agora, aqui está o problema:

• Se todo o espaço em branco for removido dos dois programas / funções, as seqüências resultantes deverão ser idênticas. Ou seja, seus dois envios podem diferir apenas no número e no posicionamento dos caracteres de espaço em branco.
• Nenhum programa / função pode conter literais de sequência ou regex (literais de caracteres são bons, desde que seu idioma tenha um tipo de caractere designado).
• Nenhum programa / função pode conter comentários.
• Você não deve ler o código fonte do programa, direta ou indiretamente.

Isso é código de golfe. Sua pontuação é a soma dos tamanhos de ambas as soluções (em bytes). Menor pontuação ganha.

Classificação

O seguinte snippet de pilha gera uma tabela de classificação regular e uma visão geral dos vencedores por idioma. Portanto, mesmo que seu idioma de escolha não permita que você vença todo o desafio, por que não tentar conquistar um lugar na segunda lista? Eu ficaria muito interessado em ver como as pessoas enfrentam esse desafio em vários idiomas!

Para garantir que sua resposta seja exibida, inicie-a com um título, usando o seguinte modelo de remarcação:

# Language Name, N bytes

onde Né o tamanho total do seu envio. Se você melhorar sua pontuação, poderá manter as pontuações antigas no título, identificando-as. Por exemplo:

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

Você também pode incluir as contagens individuais antes da contagem total, por exemplo

# Python 2, 35 + 41 = 76 bytes

O último número que não for atingido será usado pelo snippet.

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

Pitão, 16 + 15 = 31 bytes

Experimente aqui .

Contador:

L@,cb)sm!cd)b1 0

Divisor:

L@,cb)sm!cd)b10

Cada um deles define uma função, yque recebe uma entrada de sequência para resolver a tarefa desejada.

Obrigado a @FryAmTheEggman pela idéia de usar o recurso de indexação modular de Pyth em listas para fazer a barba de um personagem.

Casos de teste:

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

Explicação:

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 bytes

Contador:

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

Divisor:

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

Para o contador, usamos o fato de que Python não tem problema em ter apenas uma expressão em uma linha. É necessário dividir-se +1e 0<9or x.split()parar um NameErrorde ser lançada, como 0<9sendo Trueimpede x.split()de ser avaliada devido a curtos-circuitos.

Para o divisor, como o número de espaços em branco é sempre não-negativo, sum(y.isspace()for y in x)+10<9é sempre Falsee a função de divisão entra em ação.

Alternativa 1, 59 + 60 = 119 bytes

Contador:

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

Divisor:

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

Os resultados da contagem e da divisão são armazenados em uma lista de dois elementos. A lista é indexada min([1]), retornando o mínimo da lista de um elemento que contém 1, ou m in([1]), que retorna False(equivalente a 0) como mnão está contido [1].

Alternativa 2, 67 + 69 = 136 bytes

Contador:

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

Divisor:

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

Como acima, os resultados da contagem e divisão são armazenados em uma lista de dois elementos. sortedé uma função interna que é um valor verdadeiro; portanto, not sortedretorna False(equivalente a 0). Pois not s or ted, uma vez que sé uma função e também verdade, not sé Falsee ted = 1é retornado.

Alternativa 3, 59 + 60 = 119 bytes

Contador:

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

Divisor:

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

Esta é uma função em que o resultado do divisor é armazenado na variável ae o resultado do contador é armazenado na variável a1. Como antes, Python está bem em ter apenas uma expressão em uma linha, neste caso 1. A divisão a1determina o que retornar da função.

Java 8, 239 + 240 = 479

Conte o espaço em branco (retorna Inteiro)

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

Dividir no espaço em branco (retorna Stream <>)

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

Explicação:

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

Espaço em branco, 75 + 153 = 228

Espaços, tabulações e novas linhas substituídas por STL, respectivamente, e dobradas por legibilidade. Converta em um arquivo Whitespace adequado com tr -d \\n | sed 'y/STL/ \t\n/'.

Contador

SSSLLSSLSSSTSSSSSLSLSSLSTLTSTTTSLSLTSSLTSSTLTTLSSSTLTSSSLSLLLSSSLS
LLSLLTLST

Splitter

SSSTLSSSLTTSLSSTLSSSLSLSTLTSTTTSLSSLSLTSLSSSTSSSSTLTSSTLTTTTLSSSTL
SLSTTSLSLSLLSSTTLSSSTSTSLSSSTLTTTLTSTSLTLSSSSSTLSSSLTTSLSSTSLLSLTL
LSSSLTLSSLSLTLLSSLLLL

Marbelous, 103 + 92 = 195

Contador:

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

Divisor:

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

Teste estes programas aqui. Placas cilíndricas, bibliotecas de inclusão e espaços para células em branco devem ser todos verificados.

Entrada e Saída são através de STDIN / STDOUT.

Explicação

Contador:

O caminho azul recebe entrada. Se o caractere for um espaço em branco (valor ASCII menor que 0x21), o caminho preto será usado, que será sincronizado com o caminho roxo.

O caminho roxo simplesmente incrementa um mármore armazenado no &1sincronizador cada vez que o caminho preto é percorrido.

Quando não houver mais entrada, o caminho vermelho será percorrido, imprimindo o número de caracteres de espaço em branco e saindo.

Divisor:

O programa começa com o caminho azul, que faz um loop até encontrar um caractere que não seja um espaço em branco.

Depois que um caractere que não é de espaço em branco é recuperado, o caminho preto é escolhido, que imprime esse caractere e move a execução para o caminho verde, que faz um loop e imprime até que um caractere de espaço em branco seja recebido. A execução continua para o caminho púrpura, que contém 3Wou um divisor de três vias.

O ramo esquerdo move a execução para o caminho azul (e o espaço em branco é descartado até que um caractere que não seja em espaço em branco seja encontrado).

O ramo do meio define a cópia da entrada como 0 com ?0(gera um número aleatório entre 0e 0) e adiciona 10 ( 0x0A= nova linha), que é então emitida.

O caminho certo é descartado.

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

Contador

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

Splitter

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

Como funciona

A idéia é simples, calcule o número de espaços em branco e divida a string em execuções consecutivas de espaços em branco. Em seguida, escolha um deles com base no fato a seguir que ' !significa not of space characterque é falso, enquanto '!é o !personagem que é verdadeiro.

Código expandido:

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

A entrada é de STDIN e a saída é para STDOUT

Experimente online aqui

Mathematica, 44 + 43 = 87 97 bytes

Eu pensei em adicionar outro idioma à mistura.

Contador:

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

Divisor:

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

Isso faz uso do recurso do Mathematica de que a separação do espaço é igual à multiplicação. E que multiplicar algo por 0 é sempre 0, e adicionar 0 a algo é sempre idempotente.

Para o contador, contamos primeiro o espaço em branco e adicionamos 0*1*StringSpli*t@#. StringSplie tnão estão definidos, mas o Mathematica usa computação simbólica, portanto, trata-os apenas como uma variável e função desconhecidas. O 1*idempotente (assim como 0+), o 0*transforma em zero. É necessário separar as StringSplitduas variáveis, porque o 0tempo em que uma lista é tratada como uma multiplicação escalar-vetor que resulta em um vetor (lista) de zeros.

Para o divisor, estou usando o fato de que Counttambém existe, mas não examina as strings. Ele tenta contar todas as subexpressões correspondentes ao padrão, mas Whitespaceé um padrão que se aplica apenas ao conteúdo da sequência. Então Countsempre retornará 0, o que faz o Stringdesaparecer. A multiplicação da matriz dividida por 01 = 1é novamente idempotente.

Ruby, 107 91 bytes

Divisor (46 bytes)

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

Contador (45 bytes)

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

pé um método predefinido que, sem argumentos, apenas retorna nil. Usamos isso de várias maneiras. No divisor, a inicial pnão faz nada. gets(p)lê tudo da entrada padrão, já que o delimitador é nulo. Nós chamamos o método de divisão embutido nisso e atribuímos o resultado a p, então agora, quando não houver argumentos, ele será analisado como uma variável. puts p||...curto-circuito e imprime cada elemento da pvariável em sua própria linha.

No contador, excluímos a primeira nova linha para que a matriz dividida seja atribuída pp. Como não atribuímos a pele, ainda é o método de retorno nulo; portanto, a segunda parte do ||é avaliada e passada para puts. $_é uma variável mágica que contém o resultado de gets, portanto, a quantidade total de espaço em branco é o tamanho desse menos os caracteres que não são em branco, que são o que ppcontém. Eu sinto que deveria haver uma maneira mais curta de fazer a contagem, mas não consigo encontrar uma, e de qualquer forma é divertido usar o array dividido no contador.

Python, 169

É quase fácil demais fazer isso em Python!

Contador:

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

Divisor:

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

Eles diferem em apenas um espaço, e eu não estou fazendo nenhum truque como dividir um número ou nome de variável ao meio :)

C, 138 + 136 = 274

Em cada caso, o código é um programa que aceita exatamente um argumento da linha de comando e imprime o resultado em stdout. \tdeve ser substituído por um caractere de tabulação. Se você deseja passar um argumento contendo guias e novas linhas, é seu trabalho descobrir como;).

Contando

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

Divisão

#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 bytes

Contador:

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

Divisor:

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
    }

A RegExp(String.fromCharCode(92,115)linha cria a regex de correspondência de espaço em branco /\s/sem literais de regex ou string.

Em cada programa, usamos a variável vor vv. Armazenamos a matriz dividida nessa variável ( vou vv) e, em seguida, ramificamos nosso comportamento no valor de v(enquanto isso, vvé ignorado). No balcão, vtem um valor verdadeiro; no divisor, ele tem um valor falso (porque vvobteve o valor).

Alternativo: JavaScript, 250 bytes

Tenho outra solução que não está ganhando nenhum prêmio por brevidade, mas achei que era um desafio interessante abusar do comportamento automático de inserção de ponto e vírgula do JavaScript.

Contador:

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}

Divisor:

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}

Contador ungolfed:

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

O divisor é exatamente o mesmo, exceto pela linha:

break x;

é agora

break
x;

Inserção vírgula automática de JavaScript normalmente não terminar declarações de várias linhas cedo se eles podem ser compreendidas sem uma quebra de linha, mas não tolera quebras de linha depois return, continueou break. Portanto, a linha é lida simplesmente como break, que interrompe apenas o loop interno, em vez de interromper o loop externo. O comportamento da "segunda passagem" o = a.filter(j=>j)é então executado (contra ser ignorado no contador), porque o loop externo recebe uma segunda passagem.

Pitão, 228 198 182 166 146 145 bytes

Contador ( 72 bytes ):

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

Divisor ( 73 bytes ):

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

ior1é uma variável falsey, mas i or 1é verdadeira. Esse é o truque principal.

Befunge 98, 61 + 59 = 120

Contador:

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

Divisor:

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

Bash, 75 + 79 = 154 bytes

Isso depende do bash poder continuar a execução, mesmo que algumas linhas ou partes de uma linha do script estejam malformadas (em algumas circunstâncias). O espaço em branco é usado para desativar escapes para alguns colchetes próximos e para quebrar um tubo, colocando-o em uma nova linha.

Divisor:

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

Contador:

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

A entrada é via argumento da linha de comando, a saída é via stdout.

Como isso depende do comportamento do erro do bash, espera-se que o usuário ignore o stderr.

Exemplo de execução (mostrando a entrada com uma nova linha e vários espaços contíguos):

# 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 bytes

Isso não pode competir com a solução ruby ​​pelo histocrat, mas achei que valeria a pena colocar de qualquer maneira.

Eu usei $zpara nile nil.to_sparaString.new

O caractere de espaço em branco extra que adiciono ao final da entrada é forçar a última palavra a ser adicionada à matriz ( r) - uma palavra é adicionada apenas ao final da matriz quando um caractere de espaço em branco segue um caractere que não é de espaço em branco. A alternativa foi adicionar outra r<<w if wapós o each_bytebloco.

Contando

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

Divisão

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

Contador

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

Splitter

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

Essa solução utiliza o fato de que nas funções Haskell são uma instância da classe do tipo Monad e, portanto, pode ser usada como ações monádicas na notação de doação.

No primeiro caso, a função resultante do do-block é o primeiro argumento de pure(que é essencialmente constpara o tipo de função), tornando o contador o resultado final e o divisor sendo descartado.

No segundo caso, pureé aplicado apenas a um único argumento, tornando-o uma função que retorna outra função (o contador). No entanto, o resultado nunca é usado e, portanto, descartado. O resultado final é a segunda linha do do-block, o divisor.

Java 8, 187 + 188 = 375

Antes de mais, gostaria de dizer que esta resposta é fortemente baseada no @ Ypnypn's. Substituí basicamente algumas partes por outras mais curtas (incluindo a parte dependente de espaço em branco, que a IMO é a mais importante nesse desafio), mas o código funcional é basicamente o mesmo.

Conte o espaço em branco , 187 (retorna 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);}

Dividido no espaço em branco , 188 (retorna 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 caracteres

Duas funções pegando e retornando um único argumento. Usei a maneira mais crapp que eu poderia pensar para vencer a regra do mesmo espaço em branco, então provavelmente há caracteres a serem salvos ao encontrar uma rota mais inteligente em torno disso.

(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

Definimos o verbo acomo tendo duas ações diferentes, dependendo se ele é usado com um argumento ou com dois. Com um argumento, é (e.u:)&9 10 32, que verifica se cada caractere está em espaço em branco ou não. Com dois argumentos, é a:-.~(<;._1~1,}.), que pega um vetor booleano à direita e corta o argumento esquerdo nessas posições, jogando fora quaisquer cortes vazios com a:-.~.

Em seguida, definimos o aanúmero de valores True no resultado de a, o que só faz sentido com um argumento. Por fim, usamos aaou a adependendo se queremos contar ou dividir o espaço em branco da string. aafunciona como esperado.

O motivo a afunciona é porque, quando J vê (f g)y, considera (f g)um gancho e avalia como y f (g y). Nesse caso, fé o diádico aacima do qual faz o corte, e gé a[aa, o qual calcula a soma de aa, joga fora e calcula (monádico) anovamente.

No REPL:

   (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 bytes

Contador

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

Contador :

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

Divisor :

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

Perl 6, 31 + 32 = 63 bytes

Contador

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

Experimente online!

?^1é analisado como o ?^ 1que aplica o operador de negação booleano a 1, resultando em False.

Splitter

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

Experimente online!

? ^1converte o intervalo 0..0 em Bool, resultando em True.

Python 2, 98

Divisão (49)

Retorna os tokens em uma lista.

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

Contando (49)

Retorna uma lista de comprimento um contendo o número de caracteres de espaço. Provavelmente causará um erro de tempo de execução, mas a função fpode ser usada após a execução do código.

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

C (gcc) , 88 + 89 = 177 bytes

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

Contador

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

Contador

Atropelar

Recebe entrada como argumento de função. A função de contagem retorna o número de espaços em branco. A função de divisão usa STDOUT para sua saída (mas, aliás, retorna o número de espaços em branco menos um).

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 bytes

• Nenhum programa / função pode conter nenhuma string ou literal de regex

Não tenho certeza se [^$IFS]qualifica, pois é usado na correspondência de padrões. Aqui está uma solução 45 + 45 no caso de ser banida.

Dividido:

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

Contagem:

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

O :builtin é equivalente a true, nós o usamos como algo entre um comentário e / dev / null (já que os comentários são proibidos) canalizando a expansão indesejada para ele.

O Zsh tem um builtin para dividir em espaço em branco, sendo esse ${=var}. Isso torna difícil fazer qualquer tipo de combinação lógica, além de apenas executar as duas e descartar a que não queremos.

Experimente online!