Ihr Ziel ist es, mehrzeilige ASCII-ähnliche zu verwenden

|  v  |
* * * *
 * * *

und ein Array haben, das alles enthält, was kein Stern ist, der in einen Stern geändert wurde (außer Leerzeichen mit beliebiger Breite), sowie die Anzahl der darin enthaltenen Sterne und die Anzahl der Sterne, die es jetzt enthält. Die Ausgabe meines Beispiels wäre also:

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

oder

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

abhängig davon, was Ihre Codesprache tut.

Dies ist eine Code-Golf- Herausforderung, also gewinnen die kürzesten Bytes!

GolfScript, 30 Zeichen

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

Nimmt die Eingabe von stdin. Beispiel ( online testen ):

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

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

Python - 58 66 Zeichen

Sooo ... mein erster Code Golf Versuch ...

Code:

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

Ausgabe:

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

Variablen:

• i - Eingabezeichenfolge
• p - Muster
• o- Ausgabe - entfernt

Abhängigkeiten:

Python - reModul

Vollständiger Code:

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

Bearbeitungen:

• import reZur Lösung hinzugefügt
• Durch o=Druck ersetzt
• r'[/\S/g]'wurde geändert in r'\S' (danke @ 14mRh4X0r)

Ruby 2.0, 53 Zeichen

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

Ich bin mir nicht sicher, welche genauen Eingabe- / Ausgabeformate erforderlich sind. Dies nimmt Eingaben in STDIN entgegen und formatiert die Ausgabe wie folgt:

Eingang:

|  v  |
* * * *
 * * *

Ausgabe:

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

JavaScript (ECMASCript 6) - 51 Zeichen

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

Angenommen, die Variable Aenthält den mehrzeiligen ASCII-Eingang. Um es dem Benutzer abzunehmen, ersetzen Sie es Adurch prompt()(+7 Zeichen) oder als Funktion (erneut +7 Zeichen):

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

Die Ausgabe erfolgt an die Konsole.

Prüfung:

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

Ausgänge:

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

PHP ≥ 5,5, 84 69 63 Bytes

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

Dazu gibt es nicht viel zu sagen. Da es keine Spezifikation für den Umgang mit Eingabe / Ausgabe gibt, gehe ich von variablem Speicher aus. Erwartet die Eingabe in Variable $sund speichert das Array in Variable $a. Schade, dass diese Funktionsnamen so lang sind.

Rebol, 84

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

Stellen Sie tden Text so ein ....

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

und das würde zurückkehren ...

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

Ungolfed Version mit einigen Anmerkungen:

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 Zeichen

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

Verwendet Groovy 2.2.1

Liest von STDIN. IMHO, nicht besonders klug, aber ziemlich leicht zu lesen (aufgrund seiner Kürze)

In JavaScript / CoffeeScript - 66 Zeichen

Wie im PHP-Beispiel ist die Länge auf die Länge der Funktionsnamen zurückzuführen

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

Beispiel für die Verwendung (CoffeeScript):

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

C # - 116

Der kürzeste Weg, den ich mir vorstellen kann, gibt ein Array zurück.

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

Übernimmt Eingaben von der Standardeingabe und druckt auf die Standardausgabe.

Angenommen, das Ausgabeformat, wie Sie es in Ihrer Frage beschrieben haben, könnte erheblich verkürzt werden, wenn ein anderes Ausgabeformat zulässig wäre.

Javascript - 50 Zeichen

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

Prüfung

Eingang

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

Ausgabe

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

AWK, (zu lang)

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

Ich bin kein awkMeister, also bin ich sicher, dass es verbessert werden kann. Zum Mitnehmen hatte ich Spaß beim Schreiben! Der Kampf kam mit der Frage, wie man newlinesdie Eingaben bewahrt, aber nicht , 7,10]auf eine neue Linie bringt. Dieses bisschen Logik ( NR>1{z=z "\n" $0} NR==1{z=z $0}) hat mich viele Charaktere gekostet. Es würde mich interessieren, andere awkAnsätze an dieser Front zu sehen.

Ich habe die Datei am Ende des Skripts nicht angegeben, aber offensichtlich wäre die Verwendung awk '{<code>}' ascii.txt, wo ascii.txtdie mehrzeilige "Eingabe" enthalten ist.

Ausgabe

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

Java, 199 Bytes

Golf:

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

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

Online ausführen .