Thử thách này bao gồm hai phần. Người chiến thắng sẽ là giải pháp có tổng số byte thấp nhất. Cùng một ngôn ngữ phải được sử dụng cho cả hai thách thức.

Phần 1:

Viết hàm hoặc chương trình lấy một câu chỉ có các từ hợp lệ làm đầu vào và xuất ra danh sách các ký tự được sử dụng, số lần mỗi chữ cái được sử dụng và số lượng chữ cái trong mỗi từ trong câu gốc. Đầu ra từ chương trình này phải là đầu vào hợp lệ cho chương trình tiếp theo (chính xác như được xuất ra)

Tôi sẽ thêm các ví dụ và quy tắc chi tiết hơn nữa.

Phần 2:

Viết hàm hoặc chương trình lấy đầu ra từ chương trình đầu tiên làm đầu vào và sử dụng danh sách các từ tiếng Anh này và tạo lại một câu với thông tin từ đầu ra. Câu không nhất thiết phải giống với câu gốc.

Thêm thông tin. quy tắc và hạn chế:

Phần 1:

• Đầu vào đầu tiên có thể ở bất kỳ định dạng phù hợp nào, có hoặc không có dấu ngoặc kép, như đối số chức năng hoặc từ STDIN, có hoặc không có dấu ngoặc, v.v.
• Câu đầu vào sẽ không chứa bất kỳ dấu câu hoặc ký tự đặc biệt nào, ngoại trừ dấu chấm / dấu chấm ở cuối. Ngoại trừ ký hiệu dấu chấm, tất cả các ký tự trong đầu vào sẽ nằm trong danh sách từ.
• Chữ cái đầu tiên của câu sẽ là chữ hoa, phần còn lại sẽ là chữ thường.
• Đầu ra của phần 2 phải bắt đầu bằng chữ in hoa giống như câu gốc (vì vậy không nên chuyển đổi đầu vào thành chữ thường (nhưng OK).
• Đầu ra có thể ở bất kỳ định dạng phù hợp:
  • Có thể sao chép-dán đầu ra trực tiếp vào chương trình / chức năng tiếp theo
  • Không thể thay đổi khi dán sao chép, toàn bộ đầu ra phải được sao chép và dán toàn bộ, không phải trong các phần.
  • Ví dụ, bạn có thể xuất một biểu đồ của tất cả các chữ cái trong bảng chữ cái hoặc chỉ những chữ cái được sử dụng (nói chung, bất cứ điều gì cần thiết để hoàn thành phần 2)
  • Bạn không thể xuất danh sách các ký tự trong đó nhiều lần xuất hiện được lặp lại. Chẳng hạn, The queuekhông thể mang lại một đầu ra : Teeehquu (3,5), nó phải giống như : Tehqu, (1 3 1 1 2),(3 5).

Phần 2:

• Chương trình / chức năng phải chấp nhận đầu vào chính xác như từ phần 1 (một ngoại lệ, xem bình luận bên dưới về việc lấy tên tệp làm đầu vào.).
  • Nếu dấu ngoặc xung quanh, dấu ngoặc kép hoặc tương tự là cần thiết để phân tích đầu vào thì chúng phải là một phần của đầu ra từ phần 1.
• Danh sách từ có thể được tìm thấy ở đây.
  • Danh sách từ có thể được lưu cục bộ dưới dạng w.txthoặc có thể được tìm nạp từ url. Url sẽ chỉ được tính là 5 byte, vì vậy bạn không cần một trình rút ngắn url.
  • Nếu chương trình không thể mở tệp mà không đọc tên làm đầu vào từ STDIN (tôi tin rằng ít nhất đây là trường hợp của Pyth), thì tên tệp có thể được lấy làm đối số đầu vào riêng biệt.
• Đầu ra phải chỉ là một câu (danh sách các từ hợp lệ), kết thúc bằng một dấu chấm và một dòng mới tùy chọn.
  • Đầu ra phải có các từ có cùng số lượng chữ cái với câu gốc trong phần 1 (theo đúng thứ tự)
  • Tất cả các chữ cái đã được sử dụng trong câu gốc phải được sử dụng trong đầu ra mới.
  • Câu phải bắt đầu bằng chữ in hoa giống như câu đầu vào ban đầu và kết thúc bằng một dấu chấm.

Cả hai phần:

• Cả hai phần sẽ không mất hơn 2 phút để thực hiện (chọn ngẫu nhiên các từ cho đến khi đạt được giải pháp không được chấp nhận).

Với các quy tắc được liệt kê ở trên, sẽ có cơ hội công bằng rằng cùng một câu chính xác được sao chép, tuy nhiên đó không phải là một yêu cầu.

Ví dụ:

Trong các ví dụ dưới đây, một vài định dạng đầu vào và đầu ra khác nhau được hiển thị. Nhiều hơn nữa được chấp nhận.

Phần 1:

Đầu vào:

Zulus win.

Đầu ra loại 1:

Z i l n s u w
1 1 1 1 1 2 1
5 3

Loại đầu ra 2:

(('Z',1),('i',1),('l',1),('n',1),('s',1),('u',2),('w',1)), (5,2)

Loại đầu ra 3:

'Zilnsuuw',[1,1,1,1,1,2,1],[5,2]

Phần 2:

Đầu vào: Một bản sao chính xác của đầu ra từ phần 1. Đầu ra:

Zulus win.

Lưu ý rằng các kết hợp từ khác được chấp nhận miễn là chúng bắt đầu bằng a Zvà từ đầu tiên có 5 chữ cái và từ thứ hai có 3 chữ cái.

Mã ngắn nhất trong byte thắng.

LabVIEW, 166 LabVIEW Nguyên thủy

Trước hết tôi không tạo 2 chương trình riêng biệt vì Labview không dataflow nên thực sự không cần.

Lưu biểu đồ với phần tử đầu tiên = mã ascii của phần còn lại của chữ cái đầu tiên từ 1-26 đi theo số lượng. Lenght chỉ đơn giản là được lưu trong một mảng.

Từ đầu tiên có 3 kiểm tra, chữ cái đầu tiên, chiều dài và chữ cái có sẵn trong biểu đồ. Kiểm tra chữ cái đầu tiên dừng lại sau từ đầu tiên.

Tôi kiểm tra biểu đồ bằng cách giảm nó cho mỗi chữ cái và kiểm tra xem nó có giảm xuống dưới 0 không.

Nếu tôi tìm thấy từ thứ N của mình và không có từ nào có thể xây dựng được từ các chữ cái còn sót lại, tôi sẽ bắt đầu xóa các từ từ dictonary và làm lại từ Nth và cứ thế cho đến khi tôi tìm được giải pháp.

Điều này có thể hoặc có thể không hoạt động đối với các câu có, vì điều đó sẽ mất mãi mãi để tính toán (ví dụ của tôi đã mất vài giây rồi).

Những gì tôi đã cố gắng

In: Zulus win.
Out: Zulus win.

In: Dovecot flagships oleander.
Out: Dolphin advocates forelegs.

In: Abash abel mammal test.
Out: Amass abbe hamlet malt.

Python 2.7, 353 byte

Thật không may, tôi không thể kiểm tra nó với ATM tệp w.txt thực tế vì QPython cho Android dường như không thể xử lý tệp I / O. Nó làm việc với dữ liệu tôi đã sao chép và dán mặc dù.

Phần 1, 76 byte

h=lambda s:({c:s.count(c)for c in s if c.isalnum()},map(len,s[:-1].split()))

Trong: 'Hi there.'

Ngoài: {'H':1, 'i':1, 't':1, 'h':1, 'e':2, 'r':1}, (2, 5)

vì vậy, một danh sách chứa:

• một hashmap với biểu đồ

• một danh sách đếm thư

Phần 2, 277 byte

import itertools as i
m=lambda c:' '.join([s for s in i.product(*[[w for w in open('w.txt')if len(w)==length]for length in c[1]])if sorted(''.join(s))==sorted(sum([[k.lower()]*n for k,n in c[0].items()],[]))and s[0][0]==filter(str.isupper,c[0])[0].lower()][0]).capitalize()+'.'

Tôi thực sự vui mừng vì tôi đã quản lý để làm cho nó hoạt động hoàn toàn 100%. Không chắc điều đó có giúp ích gì cho việc chơi golf thực sự không, nhưng tôi chắc chắn đã có phần obfuscation đúng: D Đây là phiên bản pt thân thiện với con người hơn. 2 (chính xác cùng một luồng, nhưng có tên biến):

from itertools import product

def matching(counts):
  histo, word_lengths = counts
  first_letter = filter(str.isupper, histo)[0].lower()

  letters_nested = [ [char.lower()]*count for char, count in histo.items() ]
  letters = sum(letters_nested, [])

  word_options = [[word for word in open('w.txt') if len(word)==length] for length in word_lengths]

  sentences = product(*word_options)

  valid = [sentence for sentence in sentences if sorted(''.join(sentence))==sorted(letters) and sentence[0][0]==first_letter]
  return ' '.join(valid[0]).capitalize()+'.'

Perl, 516 504 byte

bao gồm 2x +1 cho -p

@l=map{length}/\w+/g;s/\w/$c{$&}++/eg;@h=map{"$_$c{$_}"}keys%c;$_="@h @l";chomp(@w=`cat w.txt`);s/([A-Z])1//;$o=$1;s/(\w)(\d)/$h{$1}=$2,''/eg;@L=/\d/g;$l=shift@L;@O=$_,s/^.//,g([@L],%h)&&last for grep{$l==length&&/^$o/i&&h(\%h,substr$_,1)}@w;$_="@O.";s/^./uc$&/e;sub g{my%g;($R,%g)=@_;my@R=@$R;if($j=shift@R){s/./$g{$&}--/eg;my@C=grep{$j==length&&h(\%g,$_)}@w;push(@O,$_),g([@R],%g)and return 1 or pop@O for@C;0}else{1}}sub h{($y,$z)=@_;my%T;$z=~s/\w/$T{$&}++/eg;$K=1;$K&=$T{$_}<=$y->{$_}for keys%T;$K}

Đòi hỏi phải có w.txttrong unix định dạng ( \ndòng cuối). Sử dụng catđể đọc các tập tin; thay đổi typecho các cửa sổ.
Lưu oneliner ở trên 534.plvà chạy như echo Test. | perl -p 534.pl.

Khá lớn, nhưng đó là một khởi đầu - rất nhiều cơ hội chơi gôn, nhưng tôi chỉ muốn đăng nó để làm cho câu trả lời LabVIEW bớt cô đơn ;-). Tôi đã bỏ qua các tối ưu hóa để thực hiện phụ thứ hai, tiết kiệm hơn 30 byte.

Đoạn đầu tiên (73 byte):

@l=map{length}/\w+/g;s/\w/$c{$&}++/eg;@h=map{"$_$c{$_}"}keys%c;$_="@h @l"

Nó tạo ra một biểu đồ và từ lenghts trong một định dạng nhỏ gọn. Đối với đầu vào, Zulus win.nó tạo ra đầu ra loại 2 mà không cần (,), điều này không cần thiết ở đây:

s1 l1 u2 Z1 w1 i1 n1 5 3

Nó đây rồi, vô dụng:

sub i{
    $_=shift;                       # get parameter
    @l = map{length} /\w+/g;        # cound word lengths
    s/\w/$c{$&}++/eg;               # count letters in hash %c
    @h=map{"$_$c{$_}"}keys%c;       # construct letter-frequency pairs
    "@h @l"                         # implicit interpolation with $" (space) separator
}

Đoạn mã thứ hai (441 byte)

Phần chính này liên quan đến I / O và cách xử lý đặc biệt của chữ cái đầu tiên, sử dụng chương trình con gvà hđược liệt kê dưới đây.

sub o {
    $_=shift;
    chomp(@w=`cat w.txt`);          # load the wordlist.

    s/([A-Z])1//; $o=$1;            # get and remove the uppercase character,
    s/(\w)(\d)/$h{$1}=$2,''/eg;     # reconstruct histogram in hash %h.
    @L=/\d/g;                       # get the word counts.

    $l = shift @L;                  # get the first word length.

    @O = $_,                        # initialize output with first word,
    s/^.//,                         # strip first char of word
    g([@L],%h) && last              # call the main algoritm and quit on success

    for grep {                      
            $l==length &&           # check length
            /^$o/i &&               # only match words starting with the uppercase char
            h(\%h,substr$_,1)       # check if the word satisfies the histogram
        } @w;                       # iterates all words (speedups removed).

    $_="@O.";                       # construct output sentence.
    s/^./uc$&/e;                    # make first char uppercase.
    $_
}

Hàm đệ quy này lấy một bản sao của biểu đồ, một bản sao của số từ còn lại và từ hiện tại. Nếu mảng độ dài từ trống, trả về true. Khác, nó làm giảm số lượng biểu đồ cho các chữ cái trong từ đã cho, lấy độ dài từ tiếp theo và tìm danh sách các từ phù hợp từ danh sách từ. Đối với mỗi từ phù hợp, nó đệ quy.

sub g {
    my%g;                           # local version of histogram
    ($R,%g)=@_;                     # get parameters.
    my@R=@$R;                       # dereference arrayref copy of word lengths.

    if($j=shift @R)                 # get the next word-length.
    {
        s/./$g{$&}--/eg;            # update histogram

        my @C =                     # get a list of suitable words.
        grep { $j==length && h(\%g,$_) }
        @w;

        push(@O,$_),                # append word to output
        g( [@R], %g )               # recurse.
            and return 1            # true: append word we're done.
            or pop @O               # remove word from output
        for @C                      # (for some reason the @C=grep doesn't work here)

        ;0
    } else { 1 }                    # no more words, done!
}

Và cuối cùng, chương trình con này được đưa ra một từ và biểu đồ câu. Nó tính toán một biểu đồ mới cho từ và kiểm tra xem tất cả các chữ cái không xảy ra thường xuyên hơn mức cho phép của biểu đồ câu.

# check if first histogram is within bounds of second
sub h{
    ($y,$z)=@_;
    my%T; $z =~ s/\w/$T{$&}++/eg;    # calc histogram

    $K=1;
    $K &= $T{$_} <= $y->{$_}
    for keys %T;#$_[0];
    $K
}

Bạn có thể dán đoạn mã không được mã hóa ( sub i/o/g/h) vào một tệp duy nhất và nối thêm mã kiểm tra bên dưới.

sub t {
    print $i=i(shift),$/,o($i),$/x2;
    %c=%h=@L=@X=@O=();
}

t "Test.";                              # Test.
t "Zulus win.";                         # Zulus win.
t "Happy solstice.";                    # Happy solstice.
t "Abash abel mammal test.";            # Abase alms embalm that.
t "Dovecot flagships oleander.";        # Dangled horoscope festival.
t 'This code requires further golfing.';# Tech deer fighting ferrous liquors.

• cập nhật 504 : lưu 12 byte loại bỏ a substrvà tham số cho sub g.