Viết cầu thang


35

Viết chương trình hoặc hàm sẽ tạo ra một chuỗi nhất định theo kiểu cầu thang, viết từng phần của một từ bắt đầu bằng một nguyên âm một dòng bên dưới phần trước.

Ví dụ:

Input: Programming Puzzles and Code Golf


Output: Pr          P           C    G
          ogr        uzzl   and  od   olf
             amm         es        e
                ing

Đầu vào

Một chuỗi không chứa gì ngoài các chữ cái và dấu cách.

Chuỗi có thể được truyền qua STDINhoặc đối số chức năng hoặc bất cứ điều gì tương đương.

Chữ cái có thể là chữ thường hoặc chữ hoa.

Đầu vào luôn được giả định tuân theo các quy tắc đó, bạn không cần kiểm tra đầu vào không chính xác.

Đầu ra

Mỗi lần một nguyên âm (có nghĩa là, a, e, i, o, uhoặc y) bắt gặp trong một từ, bạn phải ra phần còn lại của từ trên dòng tiếp theo (nguyên âm gặp phải bao gồm), tại vị trí nằm ngang chính xác. Quy tắc này là đệ quy, có nghĩa là nếu có n nguyên âm trong từ, nó sẽ được viết trên n + 1 dòng.

  • Nguyên âm nên được viết ở đầu dòng tiếp theo, và không phải ở cuối dòng trước khi gặp phải.

  • Mỗi từ bắt đầu trên dòng đầu tiên và do đó nên được định dạng độc lập với các từ khác. Hai từ được phân cách bằng một khoảng trắng.

  • Nếu một từ bắt đầu bằng một nguyên âm, bạn phải viết nó bắt đầu trên dòng thứ hai.

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

  • Đầu vào: Programming Puzzles and Code Golf

Đầu ra:

Pr          P           C    G
  ogr        uzzl   and  od   olf
     amm         es        e
        ing
  • Đầu vào: The quick brown fox jumps over the lazy dog

Đầu ra:

Th  q     br    f   j          th  l    d
  e  u      own  ox  umps ov     e  az   og
      ick                   er        y
  • Đầu vào: aeiouy

Đầu ra:

 
a
 e
  i
   o
    u
     y
  • Đầu vào: YEAh UppErcAsE VOwEls

Đầu ra:

               V
Y    Upp        Ow
 E      Erc       Els
  Ah       As  
             E
  • Đầu vào: If you only knew the power of the Dark Side

Đầu ra:

            kn   th  p        th  D    S
If y   onl    ew   e  ow   of   e  ark  id
    o     y             er                e
     u

Chấm điểm

Đây là , vì vậy mã ngắn nhất sẽ thắng.


Ví dụ đầu ra thứ ba có vẻ không phù hợp với quy tắc "Nếu một từ bắt đầu bằng nguyên âm, bạn phải viết nó bắt đầu trên dòng thứ hai."
JohnE

1
Y là Y một nguyên âm?
Tối ưu hóa

1
@ John thực sự là nó, tôi đã sửa nó. Cảm ơn.
Gây tử vong vào

2
The vowel should be written at the beginning of the next line, and not at the end of the previous line when one is encountered.Sau một số suy nghĩ, tôi hiểu rằng điều này có nghĩa là việc chuyển sang dòng tiếp theo sẽ xảy ra trước khi nguyên âm được in, không phải sau đó, nhưng có thể đáng để diễn đạt điều này theo cách dễ hiểu ngay lập tức - tôi phải mất một thời gian.
trichoplax

3
Được theo dõi dòng mới / không gian được phép?
Loovjo

Câu trả lời:


18

Võng mạc , 50 44 34 (+10) 32 30 byte

Cảm ơn Dennis vì đã lưu 14 byte bằng cách sử dụng các ký tự điều khiển thực tế.

i`[aeiouy]
<VT>$0#
+`#(\S*)
$1<ESC>[A

Dựa trên câu trả lời này , tôi đang sử dụng mã thoát ANSI để di chuyển con trỏ đầu cuối theo chiều dọc. Các <ESC>nên được thay thế bằng ký tự điều khiển 0x1B, và <VT>với tab dọc 0x0B. Để thử nghiệm đơn giản hơn, bạn cũng có thể thay thế <ESC>bằng \e, <VT>với \vvà cung cấp đầu ra thông qua printf.

Đối với mục đích đếm, mỗi dòng đi trong một tệp riêng biệt. Tuy nhiên, để thuận tiện, chỉ cần dán mã vào một tệp duy nhất và gọi Retina với -stùy chọn.

Sự thay thế đầu tiên bao quanh mỗi nguyên âm \v...#, trong đó \vcon trỏ dịch chuyển xuống dưới và #là điểm đánh dấu cho bước thứ hai. Các i`là ký hiệu Retina cho phù hợp với case-insensitive.

Bước thứ hai sau đó lặp đi lặp lại ( +`) loại bỏ a #khỏi một từ và đặt một e\[Aở cuối từ làm dịch chuyển con trỏ lên trên. Điều này dừng lại khi chuỗi dừng thay đổi, tức là khi không có thêm #điểm đánh dấu trong chuỗi.


Bạn không cần printf. Chỉ cần thay thế \ebằng byte ESC (0x1b).
Dennis

@Dennis Oh, tốt hơn nhiều, cảm ơn bạn.
Martin Ender

1
Việc này thật là tuyệt!!!
kirbyfan64sos

Câu trả lời này là lý do tại sao không ai coi trọng Retina;)
Christopher Wirt

@ChristopherWirt Xin hãy giải thích :) (Mặc dù tôi sẽ thực sự được sợ nếu có ai mất Retina nghiêm túc.)
Martin Ender

8

CJam, 39 36 byte

0000000: 6c 7b 5f 65 6c 22 61 65 69 6f 75 79 22  l{_el"aeiouy"
000000d: 26 7b 22 1b 5b 41 22 27 0b 6f 5c 7d 26  &{".[A"'.o\}&
000001a: 5f 53 26 7b 5d 7d 26 6f 7d 2f           _S&{]}&o}/

Trên đây là kết xuất xxd có thể đảo ngược, vì mã nguồn chứa ký tự VT không thể in được (mã điểm 0x0b) và ESC (điểm mã 0x1b).

Giống như câu trả lời này , nó sử dụng các tab dọc và chuỗi thoát ANSI .

Điều này đòi hỏi một thiết bị đầu cuối văn bản video hỗ trợ, bao gồm hầu hết các trình giả lập thiết bị đầu cuối không phải của Windows.

Chạy thử nghiệm

Trước khi thực thi mã thực tế, chúng tôi sẽ vô hiệu hóa lời nhắc và xóa màn hình.

$ PS1save="$PS1"
$ unset PS1
$ clear

Điều này đảm bảo đầu ra được hiển thị đúng.

echo -n Programming Puzzles and Code Golf | cjam <(xxd -ps -r <<< 6c7b5f656c226165696f757922267b221b5b4122270b6f5c7d265f53267b5d7d266f7d2f)
Pr          P           C    G
  ogr        uzzl   and  od   olf
     amm         es        e
        ing

Để khôi phục lời nhắc, hãy thực hiện điều này:

PS1="$PS1save"

Làm thế nào nó hoạt động

Chúng tôi chèn một tab dọc trước mỗi nguyên âm để di chuyển con trỏ xuống và đủ các bản sao của chuỗi byte 1b 5b 41 ( "\e[A") sau mỗi khoảng trống để di chuyển con trỏ trở lại hàng đầu tiên.

l           e# Read a line from STDIN.
{           e# For each character C:
  _el       e#   Push lowercase(C).
  "aeiouy"& e#   Intersect with "aeiouy".
  {         e#   If the intersection is non-empty:
    ".[A"   e#     Push "\e[A" (will be printed later).
    '.o     e#     Print "\v".
    \       e#     Swap "\e[A" with C.
  }&        e#
  _S&       e#   Intersect C with " ".
  {         e#   If the intersection is non-empty:
    ]       e#     Wrap the entire stack in an array.
  }&
  o         e#   Print C or the entire stack.
}/          e#

Đừng quên unset PS1savesau đó.
bè và bạn bè

5

Java, 428 byte

void s(String s){int l=s.length(),m=0;char[][]c=new char[l][];for(int i=0;i<c.length;java.util.Arrays.fill(c[i++],' '))c[i]=new char[l];String v="aeiouyAEIOUY";String[]a=s.split(" ");for(int r=0,p=0;r<a.length;r++){String u=a[r]+" ";int o=v.indexOf(u.charAt(0))>=0?1:0,x=p;for(;x<u.length()-1+p;o+=v.indexOf(u.charAt(x++-~-p))>=0?1:0)c[o][x]=u.charAt(x-p);p+=u.length();m=m<o?o:m;}for(int i=0;i<=m;i++)System.out.println(c[i]);}

Tôi biết, nó thật kinh khủng. Có lẽ có một số ký tự có thể được cạo, nhưng tôi quá lười để làm điều đó.


Có thể bạn có thể khai báo nhiều bạn intbiến (cụ thể là i, r, p, o, và x), nơi bạn khởi tạo lmvì họ sẽ được đưa ra các giá trị sau này. Bạn cũng có thể làm String v="...",a[]=...;và làm tương tự như trên cho String u. Điều đó sẽ làm giảm điểm của bạn khá một chút.
TNT

Tôi thíchx++-~-p
Ypnypn

4

Perl, 31 byte

0000000: 24 5c 3d 22 1b 5b 41 22 78 20 73 2f 5b 61  $\=".[A"x s/[a
000000e: 65 69 6f 75 79 5d 2f 0b 24 26 2f 67 69     eiouy]/.$&/gi

Trên đây là kết xuất xxd có thể đảo ngược, vì mã nguồn chứa ký tự VT không thể in được (mã điểm 0x0b) và ESC (điểm mã 0x1b).

Mã này dài 27 byte và yêu cầu các bộ chuyển mạch 040p(4 byte).

Chương trình yêu cầu thiết bị đầu cuối văn bản video hỗ trợ các tab dọc và chuỗi thoát ANSI , bao gồm hầu hết các trình giả lập thiết bị đầu cuối không phải của Windows.

Chạy thử nghiệm

Trước khi thực thi mã thực tế, chúng tôi sẽ vô hiệu hóa lời nhắc và xóa màn hình.

$ PS1save="$PS1"
$ unset PS1
$ clear

Điều này đảm bảo đầu ra được hiển thị đúng.

echo -n Programming Puzzles and Code Golf | perl -040pe "$(xxd -ps -r <<< 245c3d221b5b41227820732f5b6165696f75795d2f0b24262f6769)"
Pr          P           C    G
  ogr        uzzl   and  od   olf
     amm         es        e 
        ing

Để khôi phục lời nhắc, hãy thực hiện điều này:

PS1="$PS1save"

Làm thế nào nó hoạt động

  • perl -040ptự động đọc đầu vào dưới dạng các mã thông báo được phân tách bằng dấu cách ( -040), lưu từng mã thông báo trong $_( -p) và thực thi chương trình.

  • s/[aeiouy]/.$&/githực hiện tìm kiếm toàn cầu, không phân biệt chữ hoa chữ thường $_và thay thế từng nguyên âm bằng ký tự điều khiển VT (di chuyển con trỏ xuống), theo sau là chính nguyên âm.

  • strả về số lần thay thế mà nó đã thực hiện, do đó $\=".[A"x s...lưu nhiều bản sao của chuỗi byte 1b 5b 41 (di chuyển con trỏ lên) $\, một cho mỗi nguyên âm.

  • Khi kết thúc chương trình, Perl sẽ tự động in "$_$\", vì -pchuyển đổi.


4

C, 200 190 byte

i,j,k,l,M;f(char*s){M=strlen(s)+1;char t[M*M];for(;i<M*M;++i)t[i]=(i+1)%M?32:10;for(i=0;i<M-1;++i)k=(strspn(s+i,"aeiouyAEIOUY")?++j:s[i]==32?j=0:j)*M+i,l<k?l=k:0,t[k]=s[i];t[l+1]=0;puts(t);}

Ung dung:

i,j,k,l,M;
f(char *s){
    M = strlen(s)+1;
    char t[M*M];
    for(; i<M*M; ++i) t[i] = (i+1)%M ? 32 : 10;
    for(i=0; i<M-1; ++i)
        k = (strspn(s+i,"aeiouyAEIOUY") ? ++j : s[i]==32 ? j=0 : j) * M + i,
        l<k ? l=k : 0,
        t[k] = s[i];
    t[l+1]=0;
    puts(t);
}

Nó phân bổ một bộ đệm hình chữ nhật (thực sự là hình vuông), lấp đầy nó bằng khoảng trắng và dòng mới, sau đó đi qua chuỗi đã cho. Cuối cùng, nó thêm một ký tự null để ngăn chặn các dòng mới.

Về mặt kỹ thuật, đây không phải là chức năng vì nó chứa toàn cầu; trong thực tế, nó không thể được gọi nhiều hơn một lần ( jlphải là 0 khi bắt đầu). Để tuân thủ, i,j,k,l,M;có thể được chuyển đến int i,j=0,k,l=0,M;khi bắt đầu chức năng.


char*t=malloc(M*M);-> char t[M*M];for(i=0;i<M*M;++i)->for(;i<M*M;++i)
Spikatrix

Bắt tốt, chỉnh sửa.
jcai

Đây không phải là C99 chỉ do char t[M*M]?
Zacharý

4

CJam, 47

Vâng, nó hơi dài, nhưng nó không "gian lận" với mã ANSI :)

q_{_S&!\el"aeiouy"-!U+*:U}%_0|$])\zff{~@-S@?}N*

Dùng thử trực tuyến

Ý tưởng là tính toán số dòng cho mỗi ký tự (bắt đầu từ 0, tăng dần theo nguyên âm và nhảy về 0 tại không gian), sau đó cho mỗi dòng, lặp lại chuỗi nhưng thay thế các ký tự có số dòng khác nhau bằng khoảng trắng .


3

K, 81 72 70 66 byte

Vâng, đó là một khởi đầu:

`0:{+{(-z)!y,x#" "}[|/s].'x,'s:,/{+\{12>"aeiouyAEIOUY"?x}'x}'(0,&~{"  "?x}'x)_ x}

Ví dụ sử dụng:

  `0:{+{(-z)!y,x#" "}[|/s].'x,'s:,/{+\{12>"aeiouyAEIOUY"?x}'x}'(0,&~{"  "?x}'x)_ x} "Programming Puzzles and Code Golf"
Pr          P           C    G   
  ogr        uzzl   and  od   olf
     amm         es        e     
        ing                      
  `0:{+{(-z)!y,x#" "}[|/s].'x,'s:,/{+\{12>"aeiouyAEIOUY"?x}'x}'(0,&~{"  "?x}'x)_ x} "YEAh UppErcAsE VOwEls"
               V     
Y    Upp        Ow   
 E      Erc       Els
  Ah       As        
             E       

Chỉnh sửa 1:

Tốt hơn. Thực hiện một số cải tiến cấp độ bề mặt:

`0:{+{(-z)!y,x#" "}[|/s].'x,'s:,/{+\{12>"aeiouyAEIOUY"?x}'x}'(0,&~{"  "?x}'x)_ x}
`0:{+{(-z)!y,x#" "}[|/s].'x,'s:,/(+\12>?["aeiouyAEIOUY"]')'_[0,&" "=x]x}

Đáng chú ý, tôi đã đảo ngược các đối số ?khi tôi thực hiện tìm kiếm nguyên âm và do đó loại bỏ sự cần thiết của lambda, đã làm điều tương tự với việc _tôi chia các từ trên khoảng trắng và tôi nhận ra rằng đó ~{" "?x}'xlà một cách nói quá ngớ ngẩn, quá phức tạp " "=x.

Chỉnh sửa 2:

Một điều chỉnh mức độ bề mặt khác strước khi áp dụng nó vào lambda, lưu parens bên trong:

`0:{+{(-z)!y,x#" "}[|/s].'x,'s:,/(+\12>?["aeiouyAEIOUY"]')'_[0,&" "=x]x}
`0:{+{z!y,x#" "}[|/s].'x,'-s:,/(+\12>?["aeiouyAEIOUY"]')'_[0,&" "=x]x}

Chỉnh sửa 3:

OK, chúng ta hãy thực hiện một cách tiếp cận khác nhau để tính toán bù cho mỗi ký tự. Thay vì chia chuỗi tại các khoảng trắng và tính tổng chạy ( +\) của các vị trí nguyên âm, chúng ta có thể thao tác trên toàn bộ chuỗi đầu vào trong một lần, nhân tổng chạy với 0 bất cứ khi nào chúng ta gặp khoảng trắng . Tôi cần phủ định chuỗi này, vì vậy tôi có thể trừ thay vì thêm khi tôi quét và sử dụng số phân biệt ( #?) thay vì max ( |/) khi tôi tính toán số lượng đệm dọc.

`0:{+{z!y,x#" "}[|/s].'x,'-s:,/(+\12>?["aeiouyAEIOUY"]')'_[0,&" "=x]x}
`0:{+{z!y,x#" "}[#?s].'x,'s:1_0{(~" "=y)*x-12>"aeiouyAEIOUY"?y}\x}

Điều đó tiết kiệm thêm 4 ký tự. Phù!


2

Ruby: 135 131 124 115 112 ký tự

a=[]
y=l=0
gets.split(r=/(?=[aeiouy ])/i).map{|w|w=~r&&y+=1
w<?A&&y=0
a[y]='%*s%s'%[-l,a[y],w]
l+=w.size}
puts a

Chạy mẫu:

bash-4.3$ ruby staircase.rb <<< 'Programming Puzzles and Code Golf'
Pr          P           C    G
  ogr        uzzl   and  od   olf
     amm         es        e
        ing

Nếu tôi không nhầm, bạn có thể rút ngắn regex của mình xuống /(?=[aeiouy ])/i.
Alex A.

À, bạn nói đúng @AlexA. Không gian như từ riêng biệt chỉ quan trọng đối với một lý thuyết trước đó. Cảm ơn.
thao tác

2

C, 192 byte

f(char*s){int l=0,r=1,v,c;for(;r;l=1){v=l;r=0;char*p;for(p=s;*p;++p){c=*p;if(c==' ')v=l,putchar(c);else if((strchr("aoeuiyAOEUIY",c)?--v:v)<0)r=1,putchar(' ');else*p=' ',putchar(c);}puts(p);}}

Điều này lặp lại thông qua chuỗi, xóa các ký tự khi nó in chúng. Nó lặp đi lặp lại cho đến khi không còn ký tự ngoài không gian để in. Đó là C di động, không giả định về mã hóa ký tự.

Phiên bản dễ đọc

f(char *s) {
    int l=0,       /* true if we've done the first line (no vowels) */
        r=1,       /* true if characters remain in buffer */
        v,         /* how many vowels to print from current word */
        c;         /* current character value */
    for (l=0; r; l=1) {
        v = l;
        r = 0;
        char *p;
        for (p=s;*p;++p) {
            c=*p;
            if (c==' ') {       /* a space - reset vowel counter */
                v=l;
                putchar(c);
            } else if ((strchr("aoeuiyAOEUIY",c)?--v:v)<0) {
                /* vowel conter exceeded - print a space */
                putchar(' ');
                r=1;
            } else {
                /* print it, and obliterate it from next line of output */
                putchar(c);
                *p=' ';
            }
        }
        puts(p); /* p points at the NUL, so this just prints a newline */
    }
}

' '-> 32f(char*s){int l=0,r=1,v,c;->l,r=1,v,c;f(char*s){
Spikatrix

@Cool - ' ' thể 32, nhưng nó phụ thuộc vào mã hóa ký tự, và như tôi đã nói, tôi đã tạo ra thiết bị cầm tay này C. intMặc dù vậy, việc bỏ đi rõ ràng là tuyệt vời - mặc dù không chắc tại sao tôi quên điều đó!
Toby Speight

2

Python 3, 265 207 202 185 177 ký tự

i=input()
w,e=i.split(" "),lambda:[[" "]*len(i)]
o,x=e(),0
for p in w:
    y=0
    for c in p:
        if c in"AEIOUYaeiouy":o+=e();y+=1
        o[y][x],x=c,x+1
    x+=1
for l in o:print("".join(l))

Điều này thật tồi tệ và tôi không tự hào. Tôi biết điều này có thể được thực hiện ngắn hơn, nhưng tôi nghĩ dù sao tôi cũng sẽ đăng.

Lấy cảm hứng từ phiên bản C, nó tạo ra một danh sách sau đó được điền vào trong khi duyệt qua chuỗi đầu vào.


2

GNU Sed, 151 + 1

(+1 vì nó cần -rcờ)

s/^/ /;h;s/[aoeuiy]/_/ig;:a;s/_[^ _]/__/;ta;y/_/ /;g;:x;:b;s/ [^ aoeuiy]/  /i;tb;h;s/([^ ])[aoeuiy]/\1_/ig;:c;s/_[^ _]/__/;tc;y/_/ /;g;s/ [^ ]/  /ig;tx

Tôi nghĩ rằng sed sẽ là công cụ cho công việc này, nhưng thấy nó khó một cách đáng ngạc nhiên.

Phiên bản dễ đọc:

#!/bin/sed -rf

# make sure the string starts with a space
s/^/ /
h

# print leading consonants, if any
s/[aoeuiy]/_/ig
:a
s/_[^ _]/__/
ta
y/_/ /
p
g

:x
# strip the consonants just printed
:b
s/ [^ aoeuiy]/  /i
tb
h

s/([^ ])[aoeuiy]/\1_/ig
:c
s/_[^ _]/__/
tc
y/_/ /
p
g
# remove leading vowel of each word
s/ [^ ]/  /ig
tx

Tôi sợ, đó phải là 128 ký tự. Phiên bản một dòng bị thiếu a p, vì vậy nó không tạo ra kết quả gì. Một vấn đề nhỏ là đầu ra bắt đầu với một không gian thêm. Một vấn đề lớn là đoạn văn bản đầu tiên bắt đầu bằng nguyên âm biến mất.
manatwork

Tôi chắc chắn rằng nó đã hoạt động sớm hơn. Tôi sẽ có một cái nhìn và xem những gì tôi đã phá vỡ. Cảm ơn bạn đã ủng hộ, @manatwork!
Toby Speight

Tôi đã sai khi nhảy vào vòng lặp c, do dòng vừa rồi tx. Tôi đã khôi phục một phiên bản trước đó với vòng lặp tương tự và tôi sẽ có một nỗ lực khác sau đó.
Toby Speight

2

Python 2, 145 142 byte

Có lẽ không cạnh tranh như một số phương pháp khác, nhưng tôi nghĩ rằng đây là một cách hay để sử dụng regex.

import re;s=I=input()[::-1]+" ";i=0
while s.strip()or i<2:s=re.sub("(?!([^aeiouy ]*[aeiouy]){%s}[^aeiouy]* )."%i," ",I,0,2)[::-1];print s;i+=1

Regex (?!([^aeiouy ]*[aeiouy]){N}[^aeiouy]* ).khớp với bất kỳ ký tự đơn nào không nằm trong nhóm chữ cái thứ N từ cuối từ. Vì nó được tính từ ngày tận thế, tôi đảo ngược chuỗi trước và sau đó, và tôi cũng phải thêm một khoảng trắng ở cuối, nhưng sau đó, nó trở thành một vấn đề đơn giản là sử dụng re.subđể thay thế mọi trường hợp của các ký tự này bằng một khoảng trắng. Nó thực hiện điều này cho mọi giá trị của N cho đến khi chuỗi rỗng.


Để sử dụng tốt và dễ đọc re.I, bạn có thể lưu 3 byte bằng cách thay thế giá trị cờ thích hợp, nghĩa là 2.
Sp3000

1
@ Sp3000 Chỉ trong golf-code mới có các liên kết tiêu cực với "đẹp và dễ đọc"
KSab

1

Octave, 132 129 ký tự

p=1;x=[];y=input(0);for j=1:numel(y);if regexpi(y(j),'[aeiouy]');p+=1;elseif y(j)==" ";p=1;end;x(p,j)=y(j);end;x(x==0)=32;char(x)

Kiểm tra

Đầu vào: "YEAh UppErcAsE VOwEls"

Đầu ra:

               V     
Y Upp Ow   
 E Erc Els
  À        
             E       

1

Gema : 53 48 ký tự

/[aeiouyAEIOUY]/=@append{u;^[[A}^K$1
 = $u@set{u;}

Lưu ý rằng ^[(x1b) và ^K(x0b) là các ký tự đơn. (Trong lần chạy mẫu dưới đây, tôi sử dụng tính tương thích \e\vtương đương sao chép của chúng , trong trường hợp bạn muốn dùng thử.)

Chạy mẫu:

bash-4.3$ gema '/[aeiouyAEIOUY]/=@append{u;\e[A}\v$1; = $u@set{u;}' <<< 'Programming Puzzles and Code Golf'
Pr          P           C    G    
  ogr        uzzl   and  od   olf 
     amm         es        e 
        ing 

1

Jelly , 42 byte (không cạnh tranh?)

Ḳµe€Øyœṗ⁸⁶ṁ$;¥\z⁶Zµ€µḷ/⁶ṁW⁸;ḣ®µ€L€Ṁ©$¡ZK€Y

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

Tại sao Jelly, tại sao? :-(


Dài hơn CJam có vẻ kỳ lạ
Fatalize

@Firthize Đó là vì Jelly chỉ không đi với chuỗi ... thông thường. Ngoài ra, bạn không thể thực sự so sánh các mô hình lập trình khác nhau (cjam là dựa trên ngăn xếp, thạch là ngầm).
Erik the Outgolfer 31/07/17
Khi sử dụng trang web của chúng tôi, bạn xác nhận rằng bạn đã đọc và hiểu Chính sách cookieChính sách bảo mật của chúng tôi.
Licensed under cc by-sa 3.0 with attribution required.