Definimos el espacio en blanco como cualquiera de los tres caracteres, tabulación (0x09), nueva línea (0x0A) o espacio (0x20).

Para este desafío, debe escribir dos programas o funciones en el mismo lenguaje de programación, que realizan las siguientes tareas:

1. Cuente los caracteres de espacio en blanco en una cadena dada. Por ejemplo, la entrada

     123 -_-   abc
   def
   

   devolvería 7 (siempre que no haya una nueva línea final).

2. Dividir una cadena dada en ejecuciones consecutivas de espacios en blanco. Si la cadena comienza o termina con espacios en blanco, no se deben devolver cadenas vacías en los extremos. Por ejemplo, la misma entrada

     123 -_-   abc
   def
   

   Volvería ["123", "-_-", "abc", "def"].

En cualquier caso, puede ingresar datos a través de STDIN, argumento de línea de comando o argumento de función para devolver el resultado o imprimirlo STDOUT. Para el segundo programa, si elige imprimir en STDOUT, imprima cada cadena en su propia línea, sin comillas.

Para ambos programas, puede suponer que la entrada contiene solo ASCII imprimible (0x20 a 0x7E) y espacios en blanco.

Ahora aquí está la trampa:

• Si se elimina todo el espacio en blanco de ambos programas / funciones, las cadenas resultantes deben ser idénticas. Es decir, sus dos presentaciones solo pueden diferir en el número y la ubicación de los espacios en blanco.
• Ningún programa / función puede contener cadenas o expresiones literales regulares (los literales de caracteres están bien, siempre que su idioma tenga un tipo de carácter designado).
• Ningún programa / función puede contener comentarios.
• No debe leer el código fuente del programa, directa o indirectamente.

Este es el código de golf. Su puntaje es la suma de los tamaños de ambas soluciones (en bytes). La puntuación más baja gana.

Tablas de clasificación

El siguiente fragmento de pila genera una tabla de clasificación regular y una descripción general de los ganadores por idioma. Entonces, incluso si su idioma de elección no le permite ganar el desafío completo, ¿por qué no tratar de obtener un lugar en la segunda lista? ¡Me interesaría mucho ver cómo las personas abordan este desafío en una variedad de idiomas!

Para asegurarse de que su respuesta se muestre, comience con un título, utilizando la siguiente plantilla de Markdown:

# Language Name, N bytes

¿Dónde Nestá el tamaño total de su envío? Si mejora su puntaje, puede mantener los puntajes antiguos en el título, tachándolos. Por ejemplo:

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

También puede incluir los recuentos individuales antes del recuento total, p. Ej.

# Python 2, 35 + 41 = 76 bytes

El último número que no se tacha será utilizado por el fragmento.

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

Probarlo aquí .

Mostrador:

L@,cb)sm!cd)b1 0

Disidente:

L@,cb)sm!cd)b10

Cada uno de ellos define una función, yque toma una entrada de cadena para resolver la tarea deseada.

Gracias a @FryAmTheEggman por la idea de usar la función de indexación modular de Pyth en listas para afeitar un personaje.

Casos de prueba:

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

Explicación:

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

Mostrador:

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

Disidente:

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

Para el contador, usamos el hecho de que Python está de acuerdo con tener solo una expresión en una línea. Es necesario dividir +1y 0<9or x.split()evitar que NameErrorse lance, ya 0<9que Trueimpide que x.split()se evalúe debido a un cortocircuito.

Para el divisor, dado que el número de espacios en blanco siempre es no negativo, sum(y.isspace()for y in x)+10<9siempre lo es Falsey la función de división entra en juego.

Alternativa 1, 59 + 60 = 119 bytes

Mostrador:

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

Disidente:

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

Los resultados de contar y dividir se almacenan en una lista de dos elementos. La lista se indexa por cualquiera min([1]), devolviendo el mínimo de la lista de un elemento que contiene 1, o m in([1]), que devuelve False(equivalente a 0) como mno está contenido [1].

Alternativa 2, 67 + 69 = 136 bytes

Mostrador:

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

Disidente:

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

Al igual que arriba, los resultados de contar y dividir se almacenan en una lista de dos elementos. sortedes una función incorporada que es un valor verdadero, por lo que not sorteddevuelve False(equivalente a 0). Porque not s or ted, dado que ses una función y también es verdad, not ses Falsey ted = 1se devuelve.

Alternativa 3, 59 + 60 = 119 bytes

Mostrador:

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

Disidente:

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

Esta es una función donde el resultado del divisor se almacena en la variable a, y el resultado del contador se almacena en la variable a1. Como antes, Python está bien con solo tener una expresión en una línea, en este caso 1. La división a1determina qué volver de la función.

Java 8, 239 + 240 = 479

Cuenta el espacio en blanco (devuelve Integer)

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 en el espacio en blanco (devuelve Stream <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);}

Explicación:

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

Espacio en blanco, 75 + 153 = 228

Espacios, pestañas y nuevas líneas sustituidos por STL, respectivamente, y plegados para legibilidad. Convierte a un archivo de espacio en blanco adecuado con tr -d \\n | sed 'y/STL/ \t\n/'.

Mostrador

SSSLLSSLSSSTSSSSSLSLSSLSTLTSTTTSLSLTSSLTSSTLTTLSSSTLTSSSLSLLLSSSLS
LLSLLTLST

Disidente

SSSTLSSSLTTSLSSTLSSSLSLSTLTSTTTSLSSLSLTSLSSSTSSSSTLTSSTLTTTTLSSSTL
SLSTTSLSLSLLSSTTLSSSTSTSLSSSTLTTTLTSTSLTLSSSSSTLSSSLTTSLSSTSLLSLTL
LSSSLTLSSLSLTLLSSLLLL

Marbelous, 103 + 92 = 195

Mostrador:

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

Disidente:

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

Prueba estos programas aquí. Los tableros cilíndricos, las bibliotecas de inclusión y los espacios para celdas en blanco se deben verificar.

La entrada y la salida son a través de STDIN / STDOUT.

Explicación

Mostrador:

El camino azul recibe entrada. Si el carácter es un espacio en blanco (valor ASCII menor que 0x21), se toma la ruta negra, que se sincroniza con la ruta púrpura.

La ruta púrpura simplemente incrementa una canica almacenada en el &1sincronizador cada vez que se toma la ruta negra.

Una vez que no hay más entradas, se toma la ruta roja, imprime el número de caracteres de espacios en blanco y sale.

Disidente:

El programa comienza con la ruta azul, que se repite hasta encontrar un carácter que no sea un espacio en blanco.

Una vez que se recupera un carácter que no es un espacio en blanco, se toma el camino negro, que imprime este carácter y mueve la ejecución al camino verde, que se repite e imprime hasta que se recibe un carácter de espacio en blanco. Luego, la ejecución continúa hacia la ruta púrpura, que contiene 3W, o un divisor de tres vías.

La rama izquierda mueve la ejecución a la ruta azul (y el espacio en blanco se descarta hasta que se encuentre un carácter que no sea un espacio en blanco).

La rama central establece la copia de la entrada en 0 con ?0(genera un número aleatorio entre 0y 0) y agrega 10 ( 0x0A= nueva línea), que luego se genera.

El camino correcto se descarta.

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

Mostrador

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

Disidente

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

Cómo funciona

La idea es simple: calcule el número de espacios en blanco y divida la cadena en ejecuciones consecutivas de espacios en blanco. Luego elija uno de ellos basándose en el siguiente hecho que ' !significa not of space characterque es falso, mientras que '!es el !personaje, que es verdadero.

Código ampliado:

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

La entrada es de STDIN y la salida es de STDOUT

Pruébalo en línea aquí

Mathematica, 44 + 43 = 87 97 bytes

Pensé que agregaría otro idioma a la mezcla.

Mostrador:

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

Disidente:

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

Esto hace uso de la característica de Mathematica de que la separación espacial es lo mismo que la multiplicación. Y que multiplicar algo por 0 siempre es 0, y agregar 0 a algo siempre es idempotente.

Para el contador, primero contamos el espacio en blanco y luego lo agregamos 0*1*StringSpli*t@#. StringSpliy tno están definidos, pero Mathematica usa el cálculo simbólico, por lo que solo los trata como una variable y función desconocidas. El 1*es idempotente (igual que 0+), el lo 0*convierte en cero. Es necesario separar el StringSpliten dos variables, ya que 0una lista de veces se trata como una multiplicación de vector escalar que resulta en un vector (lista) de ceros.

Para el divisor, estoy usando el hecho de que Counttambién existe pero no busca cadenas. Intenta contar todas las subexpresiones que coinciden con el patrón, pero Whitespacees un patrón que solo se aplica al contenido de la cadena. Así Countsiempre volverá 0, lo que hace que Stringdesaparezca. La multiplicación de la matriz dividida por 01 = 1es nuevamente idempotente.

Ruby, 107 91 bytes

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

pes un método predefinido que, sin argumentos, solo devuelve nil. Usamos esto de varias maneras. En el divisor, la inicial pno hace nada. gets(p)lee todo desde la entrada estándar, ya que el delimitador es nulo. Llamamos al método de división incorporado en eso y le asignamos el resultado p, por lo que ahora, cuando no se le dan argumentos, se analizará como una variable. puts p||...cortocircuita e imprime cada elemento de la pvariable en su propia línea.

En el contador, eliminamos la primera línea nueva para que se asigne la matriz dividida pp. Como no lo hemos asignado p, sigue siendo el método de retorno nulo, por lo que la segunda parte del ||se evalúa y se pasa a puts. $_es una variable mágica que contiene el resultado de gets, por lo que la cantidad total de espacios en blanco es el tamaño de eso menos los caracteres que no son espacios en blanco, que son los que ppcontiene. Siento que debería haber una forma más corta de hacer el conteo, pero no puedo encontrar una, y en cualquier caso, usar la matriz dividida en el contador es divertido.

Python, 169

¡Es casi demasiado fácil hacer esto en Python!

Mostrador:

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

Disidente:

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

Difieren en un solo espacio, y no estoy haciendo ningún truco como dividir un número o un nombre de variable por la mitad :)

C, 138 + 136 = 274

En cada caso, el código es un programa que acepta exactamente un argumento de línea de comandos e imprime el resultado en stdout. \tdebe reemplazarse con un carácter de tabulación. Si desea pasar un argumento que contenga pestañas y nuevas líneas, es su trabajo averiguar cómo;).

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

Terrible

#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

Mostrador:

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

Disidente:

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

Sin golf:

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
    }

La RegExp(String.fromCharCode(92,115)línea crea la expresión regular de coincidencia de espacios en blanco /\s/sin expresiones regulares o literales de cadena.

En cada programa, usamos la variable vo vv. Almacenamos la matriz dividida en esa variable ( vo vv), y luego ramificamos nuestro comportamiento en el valor de v(mientras tanto, vvse ignora). En el mostrador, vtiene un valor de verdad; en el divisor tiene un valor falso (porque vvobtuvo el valor en su lugar).

Alternativa: JavaScript, 250 bytes

Tengo otra solución que no está ganando ningún premio por brevedad, pero pensé que era un desafío interesante abusar del comportamiento de inserción automática de punto y coma de JavaScript.

Mostrador:

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}

Disidente:

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 sin golf:

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

El divisor es exactamente el mismo, excepto por la línea:

break x;

es ahora

break
x;

La inserción automática de punto y coma de JavaScript normalmente no termina las declaraciones de varias líneas antes si pueden entenderse sin un salto de línea, pero no tolera los saltos de línea después return, continueo break. Por lo tanto, la línea se lee simplemente como break, que se escapa solo del bucle interno, en lugar de salir del bucle externo. El comportamiento de "segundo paso" o = a.filter(j=>j)se ejecuta (en lugar de omitirse en el contador), porque el bucle externo recibe un segundo paso.

Python, 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)

ior1es una variable falsey, pero i or 1es veraz. Ese es el truco principal.

Befunge 98, 61 + 59 = 120

Mostrador:

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

Disidente:

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

Bash, 75 + 79 = 154 bytes

Esto se basa en que bash pueda continuar la ejecución incluso si algunas líneas o partes de una línea del script están mal formadas (en algunas circunstancias). El espacio en blanco se usa para desactivar los escapes para algunos corchetes cercanos y para romper una tubería colocándola en una nueva línea.

Disidente:

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

Mostrador:

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

La entrada es a través del argumento de línea de comandos, la salida es a través de stdout.

Debido a que esto se basa en el comportamiento de error bash, se espera que el usuario ignore stderr.

Ejemplo de ejecución (que muestra la entrada con una nueva línea y múltiples espacios contiguos):

# 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

Rubí, 114 + 116107 + 109 = 216 bytes

Esto no puede competir con la solución rubí del histocrat, pero pensé que valdría la pena aguantar de todos modos.

Solía $zpor nily nil.to_sparaString.new

El carácter de espacio en blanco adicional que agrego al final de la entrada es forzar que la última palabra se agregue a la matriz ( r): una palabra solo se agrega al final de la matriz cuando un carácter de espacio en blanco sigue a un carácter que no es un espacio en blanco. La alternativa era agregar otro r<<w if wdespués del each_bytebloqueo.

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}

Terrible

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

Mostrador

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

Disidente

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

Esta solución hace uso del hecho de que en Haskell las funciones son una instancia de la clase de tipo Monad y, por lo tanto, se pueden usar como acciones monádicas en notación.

En el primer caso, la función resultante del bloque do es el primer argumento de pure(que es esencialmente constpara el tipo de función), lo que hace que el contador sea el resultado final y se descarte el divisor.

En el segundo caso, puresolo se aplica a un único argumento, por lo que es una función que devuelve otra función (el contador). Sin embargo, el resultado nunca se usa y, por lo tanto, se descarta. El resultado final es la segunda línea del do-block, el divisor.

Java 8, 187 + 188 = 375

En primer lugar, me gustaría decir que esta respuesta se basa en gran medida en @ Ypnypn. Básicamente reemplacé algunas partes por otras más cortas (incluida la parte dependiente del espacio en blanco, que IMO es la más importante en este desafío), pero el código funcional es casi el mismo.

Cuente el espacio en blanco , 187 (retornos 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);}

Dividir en el espacio en blanco , 188 (retornos 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

Dos funciones que toman y devuelven un solo argumento. Utilicé la forma más desagradable que se me ocurrió para vencer la regla del mismo pero espacio en blanco, por lo que probablemente haya personajes para salvar al encontrar una ruta más inteligente alrededor de eso.

(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 el verbo apara que tenga dos acciones diferentes, dependiendo de si se usa con un argumento o con dos. Con un argumento, es (e.u:)&9 10 32, que comprueba si cada carácter es espacio en blanco o no. Con dos argumentos, es decir a:-.~(<;._1~1,}.), que toma un vector booleano a la derecha y corta el argumento izquierdo en esas posiciones, arrojando cualquier corte vacío con a:-.~.

Luego, definimos el aanúmero de valores Verdaderos en el resultado de a, que solo tiene sentido con un argumento. Finalmente, usamos aao a adependiendo de si queremos contar o dividir el espacio en blanco de la cadena. aaFunciona como se esperaba.

La razón a afunciona porque cuando J ve (f g)y, considera (f g)un gancho y lo evalúa como y f (g y). En este caso, fes la diádica asuperior la que hace el corte, y ges a[aa, que calcula la suma de aa, la arroja y calcula (monádica) anuevamente.

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

Mostrador

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

Disidente

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

Mostrador

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

Pruébalo en línea!

?^1se analiza como el ?^ 1que aplica el operador de negación booleano a 1, lo que da como resultado False.

Disidente

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

Pruébalo en línea!

? ^1convierte el rango 0..0 a Bool, lo que resulta en True.

Pitón 2, 98

División (49)

Devuelve los tokens en una lista.

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

Contar (49)

Devuelve una lista de longitud uno que contiene el número de caracteres de espacio. Lo más probable es que cause un error de tiempo de ejecución, pero la función fse puede usar después de ejecutar el código.

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

C (gcc) , 88 + 89 = 177 bytes

Disidente

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

Disidente

Mostrador

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

Mostrador

Atropellar

Toma la entrada como un argumento de función. La función de conteo devuelve el número de espacios en blanco. La función de división usa STDOUT para su salida (pero incidentalmente devuelve el número de espacios en blanco menos uno también).

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

• Ningún programa / función puede contener cadenas o expresiones literales regex

No estoy seguro de si [^$IFS]califica, ya que se utiliza en la coincidencia de patrones. Aquí hay una solución 45 + 45 en caso de que esté prohibida.

División:

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

Contar:

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

El valor :incorporado es equivalente a true, lo usamos como algo entre un comentario y / dev / null (ya que los comentarios no están permitidos) al canalizar la expansión no deseada.

Zsh tiene una función integrada para dividirse en espacios en blanco, ese ser ${=var}. Esto hace que sea difícil hacer cualquier tipo de combinación lógica que no sea simplemente ejecutar ambas y descartar la que no queremos.

Pruébalo en línea!