m | Y bR | ain là Chúng tôi | iRd. F (o) RT (h) E La | sT fi (v) e YE | ars O | R s | o, (I) ha | ve C (u) T wO | rds trong h (a) lf wh | En (I) s (e) e Th | em. Khi tôi bắt đầu Làm | nó, nó thành | oK a meN | TaL nỗ lực - B (u) TI gần như cou (l) không N (o) T d | o nó. N (o) w, tôi d | o nó ở phía sau đầu của tôi, a (n) d khó ev | en không | iCe nó. Tuy nhiên, tôi nghĩ rằng wo | uld này tạo ra một thách thức lớn.

Các định nghĩa

Đối với thử thách này, mỗi chữ cái được cho một điểm số, dựa trên đánh giá của tôi về độ rộng của nó trong phông chữ sans-serif. Bạn sẽ sử dụng chiều rộng này để cắt một từ thành hai nửa chiều rộng bằng nhau. Các ký tự mà thử thách này sẽ sử dụng là bảng chữ cái trong các chữ thường và chữ hoa, dấu nháy đơn và dấu gạch nối.

Width  Characters
1      i l I '
2      f j r t -
3      a b c d e g h k n o p q s u v x y z
4      m w A B C D E F G H J K L N O P Q R S T U V X Y Z
5      M W

Đối với các giải thích và trường hợp kiểm tra của tôi, |biểu thị vị trí trong đó một từ có thể được phân chia rõ ràng một nửa. (và )ở hai bên của một lá thư chỉ ra rằng bức thư đó sẽ được chia làm đôi để tạo ra một sự phân chia rõ ràng.

Đầu vào

Đầu vào sẽ bao gồm một "từ" duy nhất (không bắt buộc phải có trong từ điển). Bạn có thể lấy từ này trong bất kỳ kiểu nhập văn bản nào bạn muốn (Chuỗi, mảng char, v.v.). Từ này sẽ chỉ chứa các chữ cái ', và -(xem bảng trên). Vì những gì bạn sẽ làm với từ này (xem bên dưới), trường hợp đầu vào được để lại theo quyết định của nhà phát triển. Trailing newlines cho phép nếu cần thiết.

Nhiệm vụ

Hoán vị thông qua tất cả các hình thức của đầu vào (tất cả các chữ cái ở tất cả các vị trí chữ hoa hoặc chữ thường có thể). Ví dụ, đối với đầu vào it's, bên dưới là tất cả các hoán vị:

it's
it'S
iT's
iT'S
It's
It'S
IT's
IT'S

Để chia một hoán vị của một từ, các điểm ở một bên của từ phải giống với các điểm của phía bên kia của từ. Tuy nhiên, nếu một chữ cái bị kẹt ở giữa hai phần chẵn, bạn cũng có thể cắt một chữ sạch một nửa.

Xin lưu ý rằng "một nửa" không có nghĩa là bạn đã di chuyển được một nửa vào chuỗi. "Một nửa" có nghĩa là các điểm ở cả hai bên bằng nhau.

Ví dụ:

Wđược 5 điểm. ilà 1 điểm. Chia Wiiiiimột nửa hoán vị sẽ dẫn đến W | iiiii, với 5 điểm ở mỗi bên của |.

Tđược 3 điểm. Việc chia TTTTmột nửa hoán vị sẽ cho kết quả TT | TT, với 6 điểm ở mỗi bên của |.

wđược 4 điểm. a là 3 điểm. Chia wawmột nửa hoán vị sẽ cho kết quả w (a) w, với 5,5 điểm ở mỗi bên. Các điểm từ ađược phân phối cho cả hai bên, như ađược chia một nửa.

Đầu ra

Đầu ra của bạn là một số nguyên của số lượng hoán vị duy nhất của đầu vào có thể được chia làm đôi một cách sạch sẽ. Trailing newlines cho phép nếu cần thiết.

Các trường hợp thử nghiệm

Tôi sẽ xuất ra tất cả các hoán vị hợp lệ của đầu vào cho các trường hợp thử nghiệm. Hãy nhớ rằng đó không phải là một phần của thông số kỹ thuật cho bạn.

Trong đầu ra trung gian của tôi, các con số biểu thị giá trị điểm của chữ cái phía trên chúng, vì vậy đầu ra dễ hình dung hơn một chút.

Input: a
( a ) 
  3   
( A ) 
  4   
Output: 2

Input: in
Output: 0

Input: ab
A | B 
4   4 
a | b 
3   3 
Output: 2

Input: abc
A ( B ) C 
4   4   4 
A ( b ) C 
4   3   4 
a ( B ) c 
3   4   3 
a ( b ) c 
3   3   3 
Output: 4

Input: will
W ( I ) L l 
5   1   4 1 
W ( I ) l L 
5   1   1 4 
W ( i ) L l 
5   1   4 1 
W ( i ) l L 
5   1   1 4 
w I | L l 
4 1   4 1 
w I | l L 
4 1   1 4 
w i | L l 
4 1   4 1 
w i | l L 
4 1   1 4 
Output: 8

Input: stephen
S T E ( P ) H E N 
4 4 4   4   4 4 4 
S T E ( p ) H E N 
4 4 4   3   4 4 4 
S T E | p h e n 
4 4 4   3 3 3 3 
S T e ( P ) H E n 
4 4 3   4   4 4 3 
S T e ( P ) H e N 
4 4 3   4   4 3 4 
S T e ( P ) h E N 
4 4 3   4   3 4 4 
S T e ( p ) H E n 
4 4 3   3   4 4 3 
S T e ( p ) H e N 
4 4 3   3   4 3 4 
S T e ( p ) h E N 
4 4 3   3   3 4 4 
S t E ( P ) H e n 
4 2 4   4   4 3 3 
S t E ( P ) h E n 
4 2 4   4   3 4 3 
S t E ( P ) h e N 
4 2 4   4   3 3 4 
S t E ( p ) H e n 
4 2 4   3   4 3 3 
S t E ( p ) h E n 
4 2 4   3   3 4 3 
S t E ( p ) h e N 
4 2 4   3   3 3 4 
S t e ( P ) h e n 
4 2 3   4   3 3 3 
S t e p | H E N 
4 2 3 3   4 4 4 
S t e ( p ) h e n 
4 2 3   3   3 3 3 
s T E ( P ) H E n 
3 4 4   4   4 4 3 
s T E ( P ) H e N 
3 4 4   4   4 3 4 
s T E ( P ) h E N 
3 4 4   4   3 4 4 
s T E ( p ) H E n 
3 4 4   3   4 4 3 
s T E ( p ) H e N 
3 4 4   3   4 3 4 
s T E ( p ) h E N 
3 4 4   3   3 4 4 
s T e ( P ) H e n 
3 4 3   4   4 3 3 
s T e ( P ) h E n 
3 4 3   4   3 4 3 
s T e ( P ) h e N 
3 4 3   4   3 3 4 
s T e ( p ) H e n 
3 4 3   3   4 3 3 
s T e ( p ) h E n 
3 4 3   3   3 4 3 
s T e ( p ) h e N 
3 4 3   3   3 3 4 
s t E ( P ) h e n 
3 2 4   4   3 3 3 
s t E p | H E N 
3 2 4 3   4 4 4 
s t E ( p ) h e n 
3 2 4   3   3 3 3 
s t e P | H E N 
3 2 3 4   4 4 4 
s t e p | H E n 
3 2 3 3   4 4 3 
s t e p | H e N 
3 2 3 3   4 3 4 
s t e p | h E N 
3 2 3 3   3 4 4 
Output: 37

Input: splitwords
S P L I T | W O r d s 
4 4 4 1 4   5 4 2 3 3 
<snip>
s p l i t w | o R d S 
3 3 1 1 2 4   3 4 3 4 
Output: 228

Input: 'a-r
' a ( - ) R 
1 3   2   4 
' a | - r 
1 3   2 2 
Output: 2

Input: '''''-
' ' ' ( ' ) ' - 
1 1 1   1   1 2 
Output: 1

Chiến thắng

Đây là môn đánh gôn , vì vậy câu trả lời ngắn nhất bằng byte thắng. Bạn phải có khả năng xuất tất cả các trường hợp thử nghiệm (vì vậy, tất cả các đầu vào tối đa 10 ký tự) trong một khoảng thời gian hợp lý. Không giả tạo giới hạn đầu vào của bạn.

Tiền thưởng

Tôi không biết nếu điều này là trong khả năng. Tuy nhiên, bạn là người chơi gôn - bạn sẽ làm bất cứ điều gì cho đại diện. Tôi đang cung cấp tiền thưởng 200 rep (tôi sẽ bắt đầu ngay khi điều kiện tiền thưởng này được thực hiện, vì về cơ bản là không thể đối với tôi) cho một chương trình xuất ra đầu ra chính xác antidisestablishmentarianismtrong dưới 15 giây trên một máy tính trung bình (còn gọi là của tôi). Xin lưu ý rằng trường hợp thử nghiệm này không được mã hóa cứng theo bất kỳ cách nào.

@DigitalTrauma nghiền nát tiền thưởng của tôi, đến sau chưa đầy hai giây. Kiểm tra câu trả lời của anh ấy ở đây .

Pyth , 75 74 73 70 byte

lfsm} sT-Bysded._Tm.n] d * Fmm? k | qd \ i + 4} d "mw" |} d "il '" h |} d "fjrt -" + 2} d "mw" -2 } d "'-
 lfsm} sT-Bysded._Tm.n] d * Fmm? k | qd \ i + 4} d" mw "| x} Ld + c" mw il' fjrt - ") G1 4-2} d "'- 
lfsm} sT-Bysded._Tm.n] d * Fm <, | x} Ld + c" mw il' fjrt - ") G1 4 | qd \ i + 4} d" mw "-2} d "'-
lfsm} sT-Bysded._Tm.n] d * Fm <, | x} Ld + c "mw il 'fjrt -") G1 4 | qd \ i + 4} d "mw" h} dG

Hãy thử trực tuyến!

Vì tình yêu của Thiên Chúa, xin đừng thử antidisestablishmentarianismtrong phiên dịch. Bạn sẽ sụp đổ nó.

Giải trình

lfsm}sT-Bysded._Tm.n]d*Fm<,|x}Ld+c"mw il' fjrt-")G1 4|qd\i+4}d"mw"h}dG

Hãy để chúng tôi chia mã này thành các phần X.

Phần đầu tiên: tạo các phiên bản có vỏ và ánh xạ tới các giá trị

m<,|x}Ld+c"mw il' fjrt-")G1 4|qd\i+4}d"mw"h}dG

Hãy để chúng tôi được rõ ràng ở đây. Trong không một phần của quá trình này là chữ viết hoa. Chúng ta chỉ cần ánh xạ một chữ cái thành hai giá trị (và dấu chấm câu thành một giá trị), mà không cần viết hoa chúng. Chúng tôi sẽ quyết định những nhân vật nào chúng ta sẽ cần hai giá trị và chúng ta sẽ cần những nhân vật nào:

m<,|x}Ld+c"mw il' fjrt-")G1 4|qd\i+4}d"mw"h}dGQ  Q implicitly appended
m                                             Q  for d in Q:
                                           }dG       d in alphabet?
                                          h          +1 (T/F as 1/0)
 <   take the first ^ elements of the following array
     for d in alphabet, it will take 2 elements;
     for d being ' or -, it will take 1 element.
  ,          pair up the following two values
   |x}Ld+c"mw il' fjrt-")G1 4                  this is the first value
                             |qd\i+4}d"mw"    this is the second value

Như bạn thấy, ngay cả phần đầu tiên là quá dài.

Giá trị đầu tiên dành cho phiên bản chữ thường, bao gồm 'và -. Giá trị thứ hai dành cho phiên bản chữ hoa, có 'và -sẽ không lấy.

Giá trị đầu tiên:

|x}Ld+c"mw il' fjrt-")G1 4
       "mw il' fjrt-"        does what it says on the tin
      c              )       split on spaces, creating an
                             array with three elements
     +                G      append another element, which
                             is the alphabet, as a fail-safe;
                             now the array has 4 elements
  }Ld                        check if d is in each array
                             as with above, True becomes 1
                             and False becomes 0 (T/F as 1/0)
 x                     1     find the first occurrence of 1
|                        4   logical or with 4. If it was 0,
                             it would become 4 now.

Chuỗi đầu tiên chứa "mw"ở chỉ số 0. Nó có giá trị là 4, giải thích sự cần thiết của logic hoặc. Lưu ý rằng Pyth sử dụng lập chỉ mục 0. Ngoài ra, không gian trước 4là để tách nó ra 1.

Giá trị thứ hai (chữ hoa):

|qd\i+4}d"mw"
 qd\i          d=="i"
|              logical OR
       }d"mw"  is d in "mw"? That is, is d "m" or "w"?
     +4        +4

Nếu dlà "i", sau đó nó đưa ra 1bước đầu tiên. Nếu không, nó tiếp tục. Nếu dlà "m"hoặc "w", thì bước thứ ba cho 1, được thêm vào 4để cho 5. Nếu dkhông "m"hoặc "w", thì bước thứ ba cho 0, được thêm vào 4để cho 4.

Phần thứ hai: hoàn thành công việc

lfsm}sT-Bysded._Tm.n]d*F

Điều này được thêm vào phần đầu tiên, về mặt kỹ thuật không tách rời khỏi phần thứ hai (nó vẫn là một lệnh). Vì vậy, giá trị từ phần đầu tiên được chuyển sang bên phải.

Tóm tắt: trong phần đầu tiên, chúng tôi đã ánh xạ các chữ cái thành các giá trị có thể có của chúng (chữ thường và chữ hoa cho các chữ cái, chỉ một giá trị cho hai dấu chấm câu). Đối với đầu vào "ab", người ta sẽ nhận được [[3,4],[3,4]].

Để tạo các phiên bản vỏ khác nhau (đáng lẽ phải được thực hiện trong phần đầu tiên, nhưng điều đó sẽ tràn ra), chúng tôi sử dụng sản phẩm của Cartesian nhiều lần, sau đó làm phẳng kết quả. Các vấn đề phát sinh khi chỉ có một chữ cái (testcase đầu tiên), bởi vì sản phẩm của Cartesian sẽ không cung cấp cho chúng ta một mảng và lệnh flatten ( .n) bị tràn để đưa ra kết quả lạ cho các số. Chúng ta sẽ xem làm thế nào tôi tránh được vấn đề này.

lfsm}sT-Bysded._Tm.n]d*F
                      *F  reduce by Cartesian product
                 m   d    for d in each unflattened version:
                    ]         [d] (wrap in array)
                  .n          flatten
 f                filter for resulting arrays as T
              ._T all prefixes of T
   m              for d in each prefix:
          sd          find the sum of d
         y            double
       -B   ed        [above, above - last element of d]
    }sT               is the sum of T in the above array of 2 elements?
  s               sum the 1/0 generated in each prefix
                  any non-zero value is regarded as truthy
l                 length

Nếu nó được chia ở giữa |, thì tiền tố sẽ có tổng gấp đôi là tổng của tổng.

Nếu nó được chia cho (), thì tổng tiền tố nhân đôi trừ đi giá trị trong ngoặc sẽ là tổng của tổng.

c, 378 byte; khoảng 0,6 giây choantidisestablishmentarianism

Cập nhật câu trả lời . Tôi đã đọc nhận xét của @ JonathanAllan về is, và lúc đầu tôi không hiểu tối ưu hóa này, nhưng bây giờ tôi thấy rằng vì cả hai ivà Icó chiều rộng là 1, nên chúng ta có thể đếm các hoán vị liên quan hai lần mà chỉ phải xác nhận một lần. Trước đây, giải pháp của tôi đã sử dụng nhiều luồng để truyền tải trên nhiều CPU và với điều đó tôi chỉ có thể trải qua tất cả 2 ²⁸ khả năng trên máy của mình. Bây giờ với việc itối ưu hóa, không cần phải lộn xộn với các luồng - một luồng duy nhất thực hiện công việc dễ dàng trong giới hạn thời gian.

Nếu không có thêm chức năng ado - golfed c:

char m[128]={[39]=10,[45]=20};f(s,l,p)char *s;{m[65]?:bcopy("PPPPPPPPPPPdPPPPPPPPPdPPP      <<<<<(<<(<P<<<<(<(<<P<<<",m+65,58);int g,h,u=0,v=0,x=0,y=0,c=0;if(p<l){g=s[p];if(g>64&&g-'i'){s[p]-=32;c+=f(s,l,p+1);}s[p]=g;c+=((g=='i')+1)*f(s,l,p+1);}else{for(l--,p=0,g=m[s[p]],h=m[s[l]];p<=l;){y=v;x=u;if(u+g>v+h){v+=h;h=m[s[--l]];}else{u+=g;g=m[s[++p]];}}c=u==v||y==x;}return c;}

Hàm đệ quy fcó 3 tham số - một con trỏ tới chuỗi đầu vào, độ dài chuỗi và phần bù trong chuỗi để bắt đầu xử lý (nên là 0 cho lệnh gọi cấp cao nhất). Hàm trả về số lượng hoán vị.

Hãy thử trực tuyến . TIO dường như thường chạy qua tất cả các testcase (bao gồm antidisestablishmentarianismtrong dưới 2 giây.

Lưu ý rằng có một số dấu vết không thể in được trong chuỗi được bcopy()ed m[]. TIO dường như xử lý những điều này một cách chính xác.

Ung dung:

#include <stdio.h>
#include <ctype.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <assert.h>

int width_tbl[] = {
    ['\''] = 1,
    ['-'] = 2,
    ['A'] = 4,4,4,4,4,4,4,4,1,4,4,4,5,4,4,4,4,4,4,4,4,4,5,4,4,4,
    ['a'] = 3,3,3,3,3,2,3,3,1,2,3,1,4,3,3,3,3,2,3,2,3,3,4,3,3,3
};

int
f (char *str, int len, int pos) {
    int lidx, ridx;
    int tot_width = 0;
    int lwidth, rwidth;
    int tot_lwidth = 0, tot_rwidth = 0;
    int prev_tot_lwidth = 0, prev_tot_rwidth = 0;
    char tmp;
    int perm_cnt = 0;

    if (pos < len) {
        tmp = str[pos];
        if (isalpha(tmp) && (tmp != 'i')) {
            str[pos] = toupper(str[pos]);
            perm_cnt += f(str, len, pos+1);
        }
        str[pos] = tmp;
        perm_cnt += ((tmp == 'i') + 1) * f(str, len, pos+1);
    } else {
        //puts(str);
        lidx = 0;
        ridx = len - 1;
        lwidth = width_tbl[str[lidx]];
        rwidth = width_tbl[str[ridx]];
        while (lidx <= ridx) {
            prev_tot_rwidth = tot_rwidth;
            prev_tot_lwidth = tot_lwidth;
            if (tot_lwidth + lwidth > tot_rwidth + rwidth) {
                tot_rwidth += rwidth;
                rwidth = width_tbl[str[--ridx]];
            } else {
                tot_lwidth += lwidth;
                lwidth = width_tbl[str[++lidx]];
            }
        }
        if (tot_lwidth == tot_rwidth) {
            perm_cnt = 1;
        } else if (prev_tot_rwidth == prev_tot_lwidth) {
            perm_cnt = 1;
        }
    }
    return perm_cnt;
}


int main (int argc, char **argv) {
    int i;
    int perm_cnt;

    if (argc > 0) {
        char *str = strdup(argv[1]);
        assert(str);

        perm_cnt = f(str, strlen(str), 0);

        printf("n = %d\n", perm_cnt);
    }

    return 0;
}

Tôi có MacBook Pro giữa năm 2015 chạy MacOS 10.12.4. Trình biên dịch là tiếng kêu MacOS mặc định. Tôi đang biên dịch với:

cc splitwords.c -O2 -o splitwords

Chạy tất cả các testcase, bao gồm cả antidisestablishmentarianismcho:

$ time ./splitwords
Testcase "a": n = 2
Testcase "in": n = 0
Testcase "ab": n = 2
Testcase "abc": n = 4
Testcase "will": n = 8
Testcase "stephen": n = 37
Testcase "splitwords": n = 228
Testcase "'a-r": n = 2
Testcase "'''''-": n = 1
Testcase "antidisestablishmentarianism": n = 83307040

real    0m0.573s
user    0m0.564s
sys 0m0.003s
$

Điều này không có nghĩa là tối ưu. Thuật toán chỉ đơn giản là bắt buộc phải vượt qua tất cả các khả năng (modulo i- xem các bình luận ở trên) và đếm các từ có thể được phân chia theo các tiêu chí.

JavaScript (ES6), 199 169 167 byte

Mong đợi chuỗi đầu vào trong trường hợp thấp hơn. Quá chậm cho tiền thưởng.

f=(s,r=[],t=R=0,i=3,x=parseInt("k1048cccctt"["i'l-fjrtmw".search(c=s[0])+1],36)+8>>i&7)=>x&&(c?(i&&f(s,r,t,0),f(s.slice(1),[x,...r],t+x)):R+=r.some(x=>t==x|!(t-=2*x)))

Các trường hợp thử nghiệm

f=(s,r=[],t=R=0,i=3,x=parseInt("k1048cccctt"["i'l-fjrtmw".search(c=s[0])+1],36)+8>>i&7)=>x&&(c?(i&&f(s,r,t,0),f(s.slice(1),[x,...r],t+x)):R+=r.some(x=>t==x|!(t-=2*x)))

;[ "a", "in", "ab", "abc", "will", "stephen", "splitwords", "'a-r", "'''''-" ]
.map(
  s => console.log(s, '->', f(s))
)

C, 403 394 byte,

Cảm ơn Kevin!

r;char*g[]={"","ilI'","fjrt-","","mw","MW",0},**p,b[99];q(c){for(p=g;*p;p++)if(strchr(*p,c))return p-g;return c>='a'&&c<='z'?3:4;}f(char*w,int l){int i,n,c,t,x,y;if(*w){for(i=0;i<2;i++)x=tolower(*w),y=toupper(*w),!i||x!=y?b[l]=i%2?x:y,b[l+1]=0,f(w+1,l+1):0;}else{t=0;for(c=0;c<2;c++)for(i=0;i<l;i++){x=y=0;for(n=0;n<l;n++)c==0||n!=i?((n<i)?(x+=q(b[n])):(y+=q(b[n]))):0;t|=x==y;}r+=t;}return r;}

Dùng thử trực tuyến

Mã bị đánh cắp:

int getwidth(int c)
{
    char **p, *g[] = { "", "ilI'", "fjrt-", "", "mw", "MW", 0};
    for (p=g; *p; p++)
    {
        if (strchr(*p,c))
            return p-g;
    }
    return c >= 'a' && c <= 'z' ? 3 : 4;
}

int test(char* w, int l)
{
    int i, n, c, t, x, y;

    if (*w)
    {
        for (i=0;i<2; i++)
        {
            x = tolower(*w);
            y = toupper(*w);
            if (!i || x != y)
            {
                b[l] = i % 2 ? x : y;
                b[l + 1] = 0;
                test(w + 1, l+1);
            }
        }
    }
    else
    {
        t = 0;
        for (c=0; c<2; c++)
        {
            for (i=0; i<l; i++)
            {
                x = 0;
                y = 0;
                for (n=0; n<l; n++)
                {
                    if (c == 0 || n != i)
                    {
                        if (n < i)
                            x += getwidth(b[n]);
                        else
                            y += getwidth(b[n]);
                    }
                }
                t |= x == y;
            }
        }
        r += t;
    }
    return r;
}