Definiamo gli spazi bianchi come uno dei tre caratteri, tab (0x09), newline (0x0A) o spazio (0x20).

Per questa sfida, devi scrivere due programmi o funzioni nello stesso linguaggio di programmazione, che svolgono le seguenti attività:

1. Contare i caratteri degli spazi bianchi in una determinata stringa. Ad esempio, l'input

     123 -_-   abc
   def
   

   restituirebbe 7 (a condizione che non ci sia nuova riga finale).

2. Dividi una determinata stringa in serie consecutive di spazi bianchi. Se la stringa inizia o termina con spazi bianchi, non è necessario restituire stringhe vuote alle estremità. Ad esempio, lo stesso input

     123 -_-   abc
   def
   

   sarebbe tornato ["123", "-_-", "abc", "def"].

In entrambi i casi è possibile prendere input tramite STDIN, argomento della riga di comando o argomento della funzione per restituire il risultato o stamparlo STDOUT. Per il secondo programma, se si sceglie di stampare su STDOUT, stampare ciascuna stringa sulla propria riga, senza virgolette circostanti.

Per entrambi i programmi si può presumere che l'input contenga solo ASCII stampabili (da 0x20 a 0x7E) e spazi bianchi.

Ora ecco il trucco:

• Se tutto lo spazio bianco viene rimosso da entrambi i programmi / funzioni, le stringhe risultanti devono essere identiche. Cioè, i tuoi due invii possono differire solo nel numero e nella posizione dei caratteri degli spazi bianchi.
• Nessuno dei due programmi / funzioni può contenere valori letterali stringa o regex (i caratteri letterali vanno bene, a condizione che la lingua abbia un tipo di carattere designato).
• Nessun programma / funzione può contenere commenti.
• Non devi leggere il codice sorgente del programma, direttamente o indirettamente.

Questo è il codice golf. Il tuo punteggio è la somma delle dimensioni di entrambe le soluzioni (in byte). Il punteggio più basso vince.

Classifiche

Il seguente frammento di stack genera sia una classifica regolare che una panoramica dei vincitori per lingua. Quindi, anche se la tua lingua preferita non ti consente di vincere l'intera sfida, perché non provare a prendere un posto nella seconda lista? Sarei molto interessato a vedere come le persone affrontano questa sfida in una varietà di lingue!

Per assicurarti che la tua risposta venga visualizzata, ti preghiamo di iniziare la risposta con un titolo, usando il seguente modello Markdown:

# Language Name, N bytes

dove si Ntrova la dimensione totale del tuo invio. Se si migliora il punteggio, è possibile mantenere i vecchi punteggi nel titolo, colpendoli. Per esempio:

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

Puoi anche includere i conteggi individuali prima del conteggio totale, ad es

# Python 2, 35 + 41 = 76 bytes

L'ultimo numero non barrato verrà utilizzato dallo 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>

Pyth, 16 + 15 = 31 byte

Provalo qui .

Contatore:

L@,cb)sm!cd)b1 0

splitter:

L@,cb)sm!cd)b10

Ciascuno di essi definisce una funzione, yche accetta un input di stringa per risolvere l'attività desiderata.

Grazie a @FryAmTheEggman per l'idea di utilizzare la funzione di indicizzazione modulare di Pyth in liste per radere un personaggio.

Casi test:

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

Spiegazione:

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 byte

Contatore:

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

Per il contatore, usiamo il fatto che Python è d'accordo con avere solo un'espressione su una linea. È necessario dividere +1e 0<9or x.split()fermare un NameErrorsiano spinte, come 0<9essendo Trueimpedisce x.split()vengano valutati per corto circuito.

Per lo splitter, poiché il numero di spazi bianchi è sempre non negativo, lo sum(y.isspace()for y in x)+10<9è sempre Falsee la funzione di suddivisione entra in gioco.

Alternativa 1, 59 + 60 = 119 byte

Contatore:

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

I risultati del conteggio e della divisione sono memorizzati in un elenco di due elementi. L'elenco è indicizzato da min([1]), restituendo il minimo dell'elenco a un elemento contenente 1, oppure m in([1]), che restituisce False(equivalente a 0) come mnon contenuto in [1].

Alternativa 2, 67 + 69 = 136 byte

Contatore:

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]

Come sopra, i risultati del conteggio e della divisione sono memorizzati in un elenco di due elementi. sortedè una funzione incorporata che ha un valore di verità, quindi not sortedritorna False(equivalente a 0). Perché not s or ted, poiché sè una funzione e anche una verità, not sè Falseed ted = 1è restituita.

Alternativa 3, 59 + 60 = 119 byte

Contatore:

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

Questa è una funzione in cui il risultato del divisore è memorizzato nella variabile ae il risultato del contatore è memorizzato nella variabile a1. Come prima, in questo caso Python sta bene solo con un'espressione su una linea 1. La divisione a1determina cosa restituire dalla funzione.

Java 8, 239 + 240 = 479

Conta lo spazio bianco (restituisce 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);}

Dividi nello spazio bianco (restituisce 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);}

Spiegazione:

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

Spazio bianco, 75 + 153 = 228

Spazi, tabulazioni e newline sostituiti rispettivamente da STL e piegati per leggibilità. Converti in un file Whitespace corretto con tr -d \\n | sed 'y/STL/ \t\n/'.

contatore

SSSLLSSLSSSTSSSSSLSLSSLSTLTSTTTSLSLTSSLTSSTLTTLSSSTLTSSSLSLLLSSSLS
LLSLLTLST

splitter

SSSTLSSSLTTSLSSTLSSSLSLSTLTSTTTSLSSLSLTSLSSSTSSSSTLTSSTLTTTTLSSSTL
SLSTTSLSLSLLSSTTLSSSTSTSLSSSTLTTTLTSTSLTLSSSSSTLSSSLTTSLSSTSLLSLTL
LSSSLTLSSLSLTLLSSLLLL

Marbelous, 103 + 92 = 195

Contatore:

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

Prova questi programmi qui. Le schede cilindriche, le librerie di inclusione e gli spazi per le celle vuote devono essere tutti controllati.

Ingresso e uscita sono tramite STDIN / STDOUT.

Spiegazione

Contatore:

Il percorso blu riceve input. Se il carattere è uno spazio bianco (valore ASCII inferiore a 0x21), viene preso il tracciato nero, che si sincronizza con il tracciato viola.

Il percorso viola incrementa semplicemente un marmo memorizzato nel &1sincronizzatore ogni volta che viene eseguito il percorso nero.

Una volta che non c'è più input, viene preso il percorso rosso, stampando il numero di caratteri di spazi bianchi ed uscendo.

splitter:

Il programma inizia con il percorso blu, che scorre fino a quando non viene trovato un carattere non bianco.

Una volta recuperato un personaggio non di spazi bianchi, viene preso il tracciato nero, che stampa questo personaggio e sposta l'esecuzione sul tracciato verde, che scorre e stampa fino a quando non viene ricevuto un carattere di spazi bianchi. L'esecuzione continua quindi sul percorso viola, che contiene 3W, o uno splitter a tre vie.

Il ramo sinistro sposta l'esecuzione sul percorso blu (e lo spazio bianco viene scartato fino a quando non viene trovato un carattere non bianco).

Il ramo centrale imposta la copia dell'input su 0 con ?0(genera un numero casuale tra 0e 0) e aggiunge 10 ( 0x0A= newline), che viene quindi emesso.

La strada giusta viene scartata.

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

contatore

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

splitter

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

Come funziona

L'idea è semplice, calcola il numero di spazi bianchi e dividi la stringa su sequenze consecutive di spazi bianchi. Quindi sceglierne uno in base al fatto seguente che ' !significa not of space characterfalsità, mentre '!è il !personaggio, che è verità.

Codice espanso:

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

L'ingresso è da STDIN e l'uscita è da STDOUT

Provalo online qui

Mathematica, 44 + 43 = 87 97 byte

Ho pensato di aggiungere un'altra lingua al mix.

Contatore:

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

splitter:

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

Questo utilizza la caratteristica di Mathematica secondo cui la separazione spaziale è la stessa della moltiplicazione. E che moltiplicare qualcosa con 0 è sempre 0 e aggiungere 0 a qualcosa è sempre idempotente.

Per il contatore, contiamo prima gli spazi bianchi e aggiungiamo 0*1*StringSpli*t@#. StringSplie tnon sono definiti, ma Mathematica utilizza il calcolo simbolico, quindi li tratta solo come variabili e funzioni sconosciute. Il 1*è idempotente (altrettanto 0+), le 0*trasforma in uno zero. È necessario separare le StringSplitdue variabili, poiché a 0volte un elenco viene trattato come una moltiplicazione scalare-vettore che risulta in un vettore (elenco) di zero.

Per lo splitter, sto usando il fatto che Countesiste anche ma non esamina le stringhe. Cerca di contare tutte le espressioni secondarie corrispondenti al modello, ma Whitespaceè un modello che si applica solo al contenuto della stringa. Quindi Counttornerà sempre 0, il che fa Stringsvanire. La moltiplicazione dell'array diviso per 01 = 1è di nuovo idempotente.

Rubino, 107 91 byte

Splitter (46 byte)

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

Contatore (45 byte)

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

pè un metodo predefinito che, senza argomenti, restituisce semplicemente nil. Lo usiamo in diversi modi. Nello splitter, l'iniziale pnon fa nulla. gets(p)legge tutto dall'input standard, poiché il delimitatore è nullo. Su questo chiamiamo il metodo incorporato split e assegniamo il risultato a p, quindi ora quando non viene dato argomenti verrà analizzato come variabile. puts p||...cortocircuita e stampa ogni elemento della pvariabile sulla propria riga.

Nel contatore, eliminiamo la prima riga nuova in modo che venga assegnata ppinvece la matrice divisa . Dal momento che non abbiamo assegnato a p, è ancora il metodo di ritorno zero quindi la seconda parte del ||viene valutata e passata a puts. $_è una variabile magica contenente il risultato di gets, quindi la quantità totale di spazio bianco è la dimensione di quella meno i caratteri non bianchi, che sono ciò che ppcontiene. Sento che dovrebbe esserci un modo più breve di fare il conteggio, ma non riesco a trovarne uno, e in ogni caso usare l'array split nel contatore è divertente.

Python, 169

È quasi troppo facile farlo in Python!

Contatore:

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)

Differiscono in un solo spazio e non sto facendo alcun trucco come dividere un numero o un nome di variabile a metà :)

C, 138 + 136 = 274

In ogni caso, il codice è un programma che accetta esattamente un argomento della riga di comando e stampa il risultato su stdout. \tdovrebbe essere sostituito con un carattere di tabulazione. Se vuoi passare un argomento contenente schede e righe, è tuo compito capire come;).

Conteggio

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

scissione

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

Contatore:

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
    }

La RegExp(String.fromCharCode(92,115)linea crea il regex corrispondente agli spazi bianchi /\s/senza regex o valori letterali di stringa.

In ogni programma, usiamo la variabile vo vv. Memorizziamo l'array suddiviso in quella variabile ( vo vv), quindi ramifichiamo il nostro comportamento sul valore di v(nel frattempo, vvviene ignorato). Nel bancone, vha un valore veritiero; nello splitter ha un valore falso (perché invece ha vvottenuto il valore).

Alternativo: JavaScript, 250 byte

Ho un'altra soluzione che non sta vincendo alcun premio per brevità, ma ho pensato che fosse una sfida interessante abusare del comportamento di inserimento automatico del punto e virgola di JavaScript.

Contatore:

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}

Contatore non golfato:

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

Lo splitter è esattamente lo stesso, tranne per la linea:

break x;

è ora

break
x;

Inserimento automatico virgola JavaScript normalmente non termina dichiarazioni multilinea presto se possono essere comprese senza un'interruzione di linea, ma non tollera interruzioni di riga dopo return, continueo break. Pertanto, la riga viene letta semplicemente come break, che si interrompe solo dal loop interno, invece di uscire dal loop esterno. Il comportamento di "secondo passaggio" o = a.filter(j=>j)viene quindi eseguito (anziché essere ignorato nel contatore), poiché al loop esterno viene assegnato un secondo passaggio.

Python, 228 198 182 166 146 145 byte

Contatore ( 72 byte ):

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

Splitter ( 73 byte ):

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

ior1è una variabile falsa, ma i or 1è verità. Questo è il trucco principale.

Befunge 98, 61 + 59 = 120

Contatore:

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

splitter:

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

Bash, 75 + 79 = 154 byte

Ciò si basa sul fatto che bash è in grado di continuare l'esecuzione anche se alcune righe o parti di una riga dello script sono malformate (in alcune circostanze). Lo spazio bianco viene utilizzato per disattivare le fughe per alcune parentesi chiuse e per rompere un tubo inserendolo in una nuova linea.

splitter:

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

Contatore:

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

L'input avviene tramite argomento della riga di comando, l'output avviene tramite stdout.

Poiché ciò si basa sul comportamento dell'errore bash, l'utente dovrebbe ignorare stderr.

Esempio di esecuzione (che mostra l'input con una nuova riga e più spazi contigui):

# 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

Rubino, 114 + 116 107 + 109 = 216 byte

Questo non può competere con la soluzione ruby ​​dell'istocratico, ma ho pensato che valesse comunque la pena metterlo.

Ho usato $zper nile nil.to_sperString.new

Il carattere extra di spazio bianco che aggiungo alla fine dell'input è quello di forzare l'ultima parola da aggiungere all'array ( r) - una parola viene aggiunta alla fine dell'array solo quando un carattere di spazio bianco segue un carattere non di spazio. L'alternativa era aggiungerne un'altra r<<w if wdopo il each_byteblocco.

Conteggio

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

scissione

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

contatore

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

splitter

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

Questa soluzione sfrutta il fatto che in Haskell le funzioni sono un'istanza della classe di tipo Monad e quindi possono essere utilizzate come azioni monadiche nella notazione do.

Nel primo caso la funzione risultante del blocco di do è il primo argomento di pure(che è essenzialmente constper il tipo di funzione), rendendo il contatore il risultato finale e scartando lo splitter.

Nel secondo caso pureviene applicato solo a un singolo argomento, rendendolo una funzione che restituisce un'altra funzione (il contatore). Tuttavia, il risultato non viene mai utilizzato e quindi scartato. Il risultato finale è la seconda riga del do-block, lo splitter.

Java 8, 187 + 188 = 375

Prima di tutto, vorrei dire che questa risposta è fortemente basata su @ Ypnypn. Ho sostanzialmente sostituito alcune parti con parti più brevi (inclusa la parte dipendente dallo spazio, che IMO è la più importante in questa sfida), ma il codice funzionale è per lo più lo stesso.

Conta lo spazio bianco , 187 (ritorna 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);}

Dividi sullo spazio bianco , 188 (ritorna 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 caratteri

Due funzioni che accettano e restituiscono un singolo argomento. Ho usato il modo più crudele a cui potevo pensare per battere la stessa regola dello spazio bianco, quindi probabilmente ci sono personaggi da salvare trovando un percorso più intelligente attorno a quello.

(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

Definiamo il verbo aavere due diverse azioni, a seconda che sia usato con un argomento o con due. Con un argomento, lo è (e.u:)&9 10 32, che controlla se ogni personaggio è uno spazio o meno. Con due argomenti, è a:-.~(<;._1~1,}.), che prende un vettore booleano sulla destra e taglia l'argomento sinistro in quelle posizioni, eliminando qualsiasi taglio vuoto con a:-.~.

Quindi, definiamo il aanumero di valori True nel risultato di a, il che ha senso solo con un argomento. Infine, usiamo aao a adipende dal fatto che vogliamo contare o dividere lo spazio bianco della stringa. aafunziona come previsto.

Il motivo a afunziona perché quando J vede (f g)y, considera (f g)un hook e lo valuta come y f (g y). In questo caso, fè la diadica asopra la quale esegue il taglio ed gè a[aa, da cui calcola la somma aa, la butta fuori e calcola di nuovo (monadica) a.

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

contatore

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

Contatore :

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

Splitter :

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

Perl 6, 31 + 32 = 63 byte

contatore

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

Provalo online!

?^1viene analizzato come il ?^ 1quale applica l'operatore di negazione booleana a 1, risultando in False.

splitter

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

Provalo online!

? ^1converte l'intervallo 0..0 in Bool, risultando in True.

Python 2, 98

Splitting (49)

Restituisce i token in un elenco.

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

Conteggio (49)

Restituisce un elenco di lunghezza uno contenente il numero di spazi. Molto probabilmente causerà un errore di runtime, ma la funzione fpuò essere utilizzata dopo l'esecuzione del codice.

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

C (gcc) , 88 + 89 = 177 byte

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

contatore

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

contatore

Corri giù

Accetta input come argomento di funzione. La funzione di conteggio restituisce il numero di spazi bianchi. La funzione di divisione utilizza STDOUT per il suo output (ma restituisce per inciso anche il numero di spazi bianchi meno uno).

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 byte

• Nessun programma / funzione può contenere stringhe o valori letterali regex

Non sono sicuro se si [^$IFS]qualifica, poiché viene utilizzato nella corrispondenza dei modelli. Ecco una soluzione 45 + 45 nel caso in cui sia vietata.

Diviso:

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

Contare:

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

Il :builtin è equivalente a true, lo usiamo come qualcosa tra un commento e / dev / null (poiché i commenti non sono consentiti) eseguendo il piping dell'espansione indesiderata ad esso.

Zsh ha un built-in per la divisione in spazi bianchi, quell'essere ${=var}. Questo rende difficile fare qualsiasi tipo di combinazione logica oltre a eseguire entrambi e scartare quello che non vogliamo.

Provalo online!