Su objetivo es tomar ASCII multilínea como

|  v  |
* * * *
 * * *

y tener una matriz que incluye todo lo que no es una estrella cambiada a una estrella (excepto los espacios [de cualquier ancho]) y la cantidad de estrellas que incluyó y la cantidad de estrellas que ahora incluye. Entonces la salida de mi ejemplo sería:

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

o

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

dependiendo de lo que haga tu lenguaje de código.

Este es un desafío de código de golf , por lo que gana los bytes más cortos.

GolfScript, 30 caracteres

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

Toma la entrada de stdin. Ejemplo ( prueba en línea ):

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

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

Python - 58 66 caracteres

Así que ... mi primer intento de Code Golf ...

Código:

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

Salida:

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

Variables:

• i - cadena de entrada
• p - patrón
• o- salida - eliminado

Dependencias:

reMódulo de Python

Código completo:

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

Ediciones:

• Agregado import rea la solución
• Reemplazado o=con impresión
• r'[/\S/g]'fue cambiado a r'\S' (gracias @ 14mRh4X0r)

Ruby 2.0, 53 caracteres

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

No estoy seguro de los formatos exactos de entrada / salida requeridos. Esto toma la entrada en STDIN y formatea la salida de la siguiente manera:

Entrada:

|  v  |
* * * *
 * * *

Salida:

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

JavaScript (ECMASCript 6) - 51 caracteres

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

Asume que la variable Acontiene la entrada ASCII multilínea. Para tomarlo del usuario, reemplace el Acon prompt()(+7 caracteres) o como una función (nuevamente +7 caracteres):

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

La salida es a la consola.

Prueba:

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

Salidas:

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

PHP ≥ 5.5, 84 69 63 bytes

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

No hay mucho que decir sobre esto. Como no hay una especificación sobre cómo manejar la entrada / salida, supongo que el almacenamiento variable. Espera la entrada en variable $sy almacena la matriz en variable $a. Lástima que esos nombres de funciones sean tan largos.

Rebol, 84

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

Establezca tel texto así ...

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

y esto volvería ...

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

Versión sin golf con algunas 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"*"}]"

Utiliza Groovy 2.2.1

Lecturas de STDIN. En mi humilde opinión, no es especialmente inteligente, pero bastante fácil de leer (dada su brevedad)

En JavaScript / CoffeeScript - 66 caracteres

Al igual que el ejemplo de PHP, la longitud se debe a la longitud de los nombres de las funciones

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

Ejemplo de uso (CoffeeScript):

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

C # - 116

El camino más corto que puedo pensar es que devuelve una 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

Toma entrada de entrada estándar, imprime en salida estándar.

Suponiendo que el formato de salida como describió en su pregunta, se podría acortar un poco si se permitiera un formato de salida diferente.

Javascript - 50 caracteres

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

Prueba

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

Salida

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

AWK, (demasiado largo)

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

No soy un awkmaestro, así que estoy seguro de que se puede mejorar. La conclusión es que me divertí mucho escribiéndola. La lucha vino con la forma de preservar la newlinesinformación, pero no ponerla , 7,10]en una nueva línea. Ese poco de lógica ( NR>1{z=z "\n" $0} NR==1{z=z $0}) me costó muchos personajes. Me interesaría ver otros awkenfoques en ese frente.

No proporcioné el archivo al final del script, pero obviamente el uso sería awk '{<code>}' ascii.txt, donde ascii.txtcontiene la "entrada" de varias líneas.

Salida

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

Java, 199 bytes

Golfizado:

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

Sin golf:

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

Correr en línea .