Seu objetivo é usar ASCII multilinha como

|  v  |
* * * *
 * * *

e tenha uma matriz que inclua tudo o que não é uma estrela alterada para uma estrela (exceto espaços com qualquer largura) e o número de estrelas incluídas e o número de estrelas que agora inclui. Portanto, a saída do meu exemplo seria:

['*  *  *
* * * *
 * * *',7,10]

ou

["*  *  *\n* * * *\n * * *", 7, 10]

dependendo do que sua linguagem de código faz.

Este é um desafio de código-golfe , portanto os bytes mais curtos vencem!

GolfScript, 30 caracteres

.{.'
 '?)\42if}%.{@'*'/,(}2*]`

Retorna a entrada de stdin. Exemplo ( teste online ):

> |  v  |
> * * * *
>  * * *

["*  *  *\n* * * *\n * * *\n" 7 10]

Python - 58 66 caracteres

Sooo ... minha primeira tentativa de Code Golf ...

Código:

import re;p=re.sub(r'\S','*',i);print[p,i.count('*'),p.count('*')]

Resultado:

['*  *  *\n* * * *\n * * *', 7, 10]

Variáveis:

• i - string de entrada
• p - padronizar
• o- saída - removida

Dependências:

reMódulo Python

Código completo:

import re
i = '|  v  |\n* * * *\n * * *'    
p = re.sub(r'\S','*', i)
print [p, i.count('*'), p.count('*')]

Editar% s:

• Adicionado import reà solução
• Substituído o=por impressão
• r'[/\S/g]'foi alterado para r'\S' (obrigado @ 14mRh4X0r)

Ruby 2.0, 53 caracteres

p [r=gets($n).gsub(/\S/,?*),$_.count(?*),r.count(?*)]

Não tenho certeza dos formatos exatos de entrada / saída necessários. Isso recebe entrada no STDIN e formata a saída da seguinte maneira:

Entrada:

|  v  |
* * * *
 * * *

Resultado:

["*  *  *\n* * * *\n * * *", 7, 10]

JavaScript (ECMASCript 6) - 51 caracteres

i=j=0,[A.replace(/\S/g,x=>(j++,i+=x=='*','*')),i,j]

Assume que a variável Acontém a entrada ASCII com várias linhas. Para retirá-lo do usuário, substitua Apor prompt()(+7 caracteres) ou como uma função (novamente +7 caracteres):

f=A=>(i=j=0,[A.replace(/\S/g,y=>(j++,i+=y=='*','*')),i,j])

A saída é para o console.

Teste:

A='|  v  |\n* * * *\n * * *'
i=j=0,[A.replace(/\S/g,x=>(j++,i+=x=='*','*')),i,j]

Saídas:

["*  *  *
* * * *
 * * *", 7, 10]

PHP ≥ 5,5, 84 69 63 bytes

$a=[preg_replace('/\S/','*',$s,-1,$n),substr_count($s,'*'),$n];

Não há muito a dizer sobre isso. Como não há especificação de como lidar com entrada / saída, estou assumindo o armazenamento variável. Espera a entrada na variável $se armazena a matriz na variável $a. Pena que esses nomes de função sejam tão longos.

Rebol, 84

c: s: 0 parse t[any["*"(++ s)|" "|"^/"| m: skip(change m"*" ++ c)]]reduce[t s s + c]

Defina tcomo o texto assim ....

t: {|  v  |
* * * *
 * * *}

e isso retornaria ...

["*  *  *^/* * * *^/ * * *" 7 10]

Versão ungolfed com algumas notas:

c: s: 0    ;; "s" is star count before change, "c" is count of chars changed to stars

; so using single-char ANY rule to parse each character in "t"

parse t [
    any [                              ;; so "t" is made up of ANY...
        "*"     (++ s) |               ;; "*" (if so then increment s)
        " "            |               ;; or a space
        "^/"           |               ;; or a newline
        m: skip (change m "*"  ++ c)   ;; or anything else (skip) 
                                       ;;   (and so change to "*" & increment c)
    ]
]

reduce [t s s + c]      ;; return array with amended text (t) and counts

Groovy: 96 92 caracteres

s=System.in.text
t=s.replaceAll(/[^\*\s]/,/\*/)
println "['$t',${s.count"*"},${t.count"*"}]"

Usa o Groovy 2.2.1

Lê de STDIN. IMHO, não especialmente inteligente, mas bastante fácil de ler (dada a sua brevidade)

Em JavaScript / CoffeeScript - 66 caracteres

Como no exemplo do PHP, o comprimento é devido ao comprimento dos nomes das funções

[x.replace(/\S/g,"*"),x.split("*").length-1,x.match(/\S/g).length]

Exemplo de uso (CoffeeScript):

((x="|  v  |\n* * * *\n * * *")->[x.replace(/\S/g,'*'),x.split('*').length-1,x.match(/\S/g).length])()

C # - 116

A maneira mais curta que consigo pensar em retornar uma matriz ..

object[]R(string a){var o=Regex.Replace(a,"\\S", "*");return new object[]{o,a.Count(x=>x=='*'),o.Count(x=>x=='*')};}

Perl, 52 bytes

$_=join'',<>;printf'["%s",%s,%s]',$_,tr/*//,s/\S/*/g

Leva a entrada da entrada padrão, imprime na saída padrão.

Supondo que o formato de saída como você descreveu na sua pergunta, poderia ser um pouco menor se um formato de saída diferente fosse permitido.

Javascript - 50 caracteres

i.replace(/\S/g,'*').replace(/\n/g,':').split(':')

Teste

Entrada

var i = 'Lately I been, I been losing sleep\nDreaming about the things that we could be\nBut baby, I been, I been prayin\' hard';
i.replace(/\S/g,'*').replace(/\n/g,':').split(':')

Resultado

["****** * ***** * **** ****** *****", "******** ***** *** ****** **** ** ***** **", "*** ***** * ***** * **** ******* ****"]

AWK, (muito longo)

awk '{y+=gsub(/[^* ]/, "*"); x+=NF}NR>1{z=z "\n" $0} NR==1{z=z $0} END{print "[\x27"z (x-y) "," x "\x27]"}'

Como não sou awkmestre, tenho certeza de que isso pode ser melhorado. O ponto principal é que eu me diverti escrevendo! A luta surgiu com a forma de preservar os dados newlinesde entrada, mas não colocar , 7,10]em uma nova linha. Essa parte da lógica ( NR>1{z=z "\n" $0} NR==1{z=z $0}) me custou muitos caracteres. Eu estaria interessado em ver outras awkabordagens nessa frente.

Não forneci o arquivo no final do script, mas obviamente o uso seria awk '{<code>}' ascii.txt, onde ascii.txtcontém a "entrada" de várias linhas.

Resultado

 ['* * *
 * * * *
 * * *',7,10]

Java, 199 bytes

Golfe:

class C{public static void main(String[]a){String i=a[0],o=i.replaceAll("\\S","*");System.out.println("["+o+","+g(i)+","+g(o)+"]");}static int g(String x){return x.replaceAll("[^\\*]","").length();}}

Sem golfe:

public class CountingStars {

    public static void main(String[] args) {
        String input = args[0];
        //replace all non-white-space char with *
        String output = input.replaceAll("\\S", "*");
        System.out.println("[" + output + "," + getStars(input) + "," + getStars(output) +"]");
    }

    static int getStars(String x) {
        //replace all non-* characters with empty-string and return length
        return x.replaceAll("[^\\*]", "").length();
    }
}

Execute online .