Mục tiêu của bạn là lấy ASCII nhiều dòng như

|  v  |
* * * *
 * * *

và có một mảng bao gồm mọi thứ không phải là một ngôi sao được thay đổi thành một ngôi sao (ngoại trừ các khoảng trống [bất kỳ chiều rộng]) và số lượng sao mà nó bao gồm và số lượng sao hiện có. Vì vậy, đầu ra của ví dụ của tôi sẽ là:

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

hoặc là

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

tùy thuộc vào những gì ngôn ngữ mã của bạn làm.

Đây là một thử thách chơi gôn , vì vậy các byte ngắn nhất sẽ thắng!

GolfScript, 30 ký tự

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

Lấy đầu vào từ stdin. Ví dụ ( kiểm tra trực tuyến ):

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

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

Con trăn - 58 66 ký tự

Sooo ... lần thử Code Golf đầu tiên của tôi ...

Mã số:

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

Đầu ra:

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

Biến:

• i - chuỗi đầu vào
• p - mẫu
• o- đầu ra - loại bỏ

Phụ thuộc:

reMô-đun Python

Mã đầy đủ:

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

Chỉnh sửa:

• Đã thêm vào import regiải pháp
• Thay thế o=bằng in
• r'[/\S/g]'đã được đổi thành r'\S' (cảm ơn @ 14mRh4X0r)

Ruby 2.0, 53 ký tự

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

Không chắc chắn về các định dạng đầu vào / đầu ra chính xác cần thiết. Điều này nhận đầu vào trên STDIN và định dạng đầu ra như vậy:

Đầu vào:

|  v  |
* * * *
 * * *

Đầu ra:

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

JavaScript (ECMASCript 6) - 51 ký tự

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

Giả sử biến Achứa đầu vào ASCII đa dòng. Để lấy nó từ người dùng, sau đó thay thế Abằng prompt()(+7 ký tự) hoặc dưới dạng hàm (một lần nữa là GMT ký tự):

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

Đầu ra là vào bàn điều khiển.

Kiểm tra:

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

Đầu ra:

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

PHP ≥ 5,5, 84 69 63 byte

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

Không có nhiều điều để nói về điều này. Vì không có thông số kỹ thuật nào về cách xử lý đầu vào / đầu ra, tôi giả sử lưu trữ biến. Yêu cầu đầu vào trong biến $svà lưu trữ mảng trong biến $a. Quá xấu những tên chức năng quá dài.

Nổi loạn, 84

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

Đặt tthành văn bản như vậy ....

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

và điều này sẽ trở lại ...

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

Phiên bản Ungolfed với một số ghi chú:

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 ký tự

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

Sử dụng Groovy 2.2.1

Đọc từ STDIN. IMHO, không đặc biệt thông minh, nhưng khá dễ đọc (với sự ngắn gọn của nó)

Trong JavaScript / CoffeeScript - 66 ký tự

Giống như ví dụ PHP, độ dài là do độ dài của các tên hàm

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

Cách sử dụng ví dụ (CoffeeScript):

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

C # - 116

Cách ngắn nhất tôi có thể nghĩ về điều đó trả về một mảng ..

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

Perl, 52 byte

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

Đưa đầu vào từ đầu vào tiêu chuẩn, in ra đầu ra tiêu chuẩn.

Giả sử định dạng đầu ra như bạn mô tả trong câu hỏi của bạn, có thể được thực hiện ngắn hơn một chút nếu định dạng đầu ra khác được cho phép.

Javascript - 50 ký tự

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

Kiểm tra

Đầu vào

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

Đầu ra

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

AWK, (quá dài)

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

Tôi không có awkchủ nên tôi chắc chắn nó có thể được cải thiện. Việc mua là tôi đã vui vẻ viết nó! Cuộc đấu tranh đi kèm với cách bảo quản newlinesđầu vào nhưng không đặt , 7,10]trên một dòng mới. Đó là một chút logic ( NR>1{z=z "\n" $0} NR==1{z=z $0}) tiêu tốn của tôi rất nhiều nhân vật. Tôi muốn thấy bất kỳ awkcách tiếp cận nào khác trên mặt trận đó.

Tôi đã không cung cấp tệp ở cuối tập lệnh, nhưng rõ ràng cách sử dụng sẽ là awk '{<code>}' ascii.txtnơi ascii.txtchứa "đầu vào" nhiều dòng.

Đầu ra

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

Java, 199 byte

Chơi gôn

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

Chưa chơi gôn:

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

Chạy trực tuyến .