Chạy tích cực ngược


22

Đầu vào

Đầu vào của bạn là một danh sách các số có một chữ số ở bất kỳ định dạng hợp lý nào, bao gồm một chuỗi các chữ số. Đầu vào sẽ không trống.

Đầu ra

Đầu ra của bạn sẽ là danh sách đầu vào, nhưng với mỗi lần chạy tối đa các chữ số khác không được đảo ngược.

Thí dụ

Xem xét đầu vào

95883007414830
<--->  <---->

nơi chạy nonzero đã được đánh dấu bằng mũi tên. Đảo ngược từng bước chạy này, chúng ta có được đầu ra

38859003841470

Quy tắc và tính điểm

Bạn có thể viết một chương trình đầy đủ hoặc một chức năng. Số byte thấp nhất sẽ thắng và các sơ hở tiêu chuẩn không được phép.

Thách thức này có liên quan, nhưng phức tạp hơn nhiều, vì nó bao gồm xử lý chuỗi bổ sung.

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

4 -> 4
00 -> 00
123 -> 321
0010 -> 0010
12000345 -> 21000543
18161604 -> 61618104
95883007414830 -> 38859003841470
010230456078912 -> 010320654021987
357509902003550 -> 575309902005530
2492882377675046 -> 5767732882942064
03026302053000357099 -> 03036202035000753099

Bảng xếp hạng

Đây là một Đoạn trích để tạo bảng xếp hạng và danh sách người chiến thắng theo ngôn ngữ. Để đảm bảo câu trả lời của bạn xuất hiện, hãy bắt đầu bằng tiêu đề của biểu mẫu

## Language, N bytes

Bạn có thể giữ điểm số cũ trong tiêu đề bằng cách sử dụng thẻ gạch ngang: <s>57</s>sẽ xuất hiện dưới dạng 57 .

Câu trả lời:



8

IPOS , 5 byte

'0!r%

%chia chuỗi đầu vào trên các số 0, áp dụng lệnh r(đảo ngược) cho mọi chuỗi con và nối lại kết quả trên các số 0.


7

Võng mạc , 15 byte

S`0
O%^$`.

¶
0

Hãy thử trực tuyến! (Sửa đổi một chút để chạy tất cả các trường hợp thử nghiệm cùng một lúc.)

Giải trình

S`0

Tách đầu vào xung quanh 0s, đặt từng dòng (có thể trống) các chữ số khác không trên dòng riêng của nó.

O%^$`.

Điều này đảo ngược từng dòng, bởi:

  • Áp dụng các giai đoạn cho từng dòng riêng lẻ với %.
  • Phù hợp với từng nhân vật với ..
  • Sắp xếp nó theo kết quả của sự thay thế ( $) bằng chuỗi rỗng (dòng thứ hai trống). Tức là nó không sắp xếp gì cả, vì tất cả các giá trị sắp xếp là giống hệt nhau.
  • Sau đó đảo ngược thứ tự của các ký tự được sắp xếp.

Cuối cùng:

¶
0

Biến các nguồn cấp dữ liệu trở lại thành 0s.



5

Julia, 30 byte

s->replace(s,r"[^0]+",reverse)

Đây là một hàm ẩn danh chấp nhận một chuỗi và trả về một chuỗi. Để gọi nó, gán nó cho một biến.

Các replacechức năng cung cấp khả năng để thay thế các trận đấu của một biểu thức chính quy với kết quả của một hàm áp dụng cho từng trận đấu. Trong trường hợp này, chúng ta có thể nhận được các giá trị khác bằng cách sử dụng [^0]+và thay thế các lần chạy đó bằng kết quả của reversechức năng được áp dụng cho văn bản phù hợp.

Xác nhận tất cả các trường hợp kiểm tra trực tuyến!


4

Võng mạc, 25 24

O^$#`[^0](?=(.*?0)*)
$#1

Dùng thử trực tuyến

Lưu được 1 byte nhờ Martin!

Sắp xếp các chữ số khác không theo số không theo sau chữ số, theo thứ tự ngược lại.

Xem giải pháp của Martin để sử dụng thông minh chế độ trên mỗi dòng để có được một chương trình ngắn hơn!


4

Jolf, 8 byte

RΜGi0λ_0

Hãy thử nó ở đây!

Giải trình

RΜGi0λ_0
  Gi0     split input on zeroes
 Μ   λ_   map over reversal as a lambda
R      0  join by zeroes

Giải thích mã trông giống như lambda nếu bạn nheo mắt.

Một câu trả lời 8 byte tương đương:

RΜGi0΅O0

Điều tương tự, nhưng nó sử dụng ΅O(chuỗi gương lambda) thay thế.


Tôi muốn nói nó trông giống một số văn bản trong một hình dạng hài hước khi tôi nheo mắt nhìn nó. Có lẽ tôi nên đặt kính thiên văn này đi.
con mèo

1
@cat Không, không, giữ nó, nhưng hãy nhìn lambda khi bạn làm.
Conor O'Brien


3

Python, 58 50 byte

lambda x:"0".join([n[::-1] for n in x.split("0")])

Lấy một chuỗi x và chia trên các số 0 và đảo ngược từng phần tử trong phần tách và thêm một số 0 và trả về số trừ này về số 0 cuối cùng.


1
Chào mừng bạn đến với PPCG :) Bạn sẽ có thể làm "0".joinvà sau đó bỏ phần bổ sung và phần.
FryAmTheEggman

@FryAmTheEggman cảm ơn vì tiền boa
1232

Không có vấn đề :) Bạn cũng có thể loại bỏ khoảng trắng giữa ]for. Bạn có thể kiểm tra trang mẹo của chúng tôi để biết thêm gợi ý, nếu bạn muốn.
FryAmTheEggman

7
lambda x:"0".join(n[::-1]for n in x.split("0"))
orlp

3

Toán học, 30 byte

Join@@Reverse/@#~SplitBy~Sign&

ví dụ Join@@Reverse/@#~SplitBy~Sign&[{1,2,3,0,0,5,9,0}]={3, 2, 1, 0, 0, 9, 5, 0}


2

PowerShell v2 +, 45 byte

($args-split0|%{-join$_[$_.length..0]})-join0

Lạm dụng việc đúc ngầm như không có ngày mai. Có thể không thể rút ngắn hơn nhiều, vì không có nội dung ngược nào ngắn hơn thủ thuật lập chỉ mục này.

Giải trình

Một ví dụ về cách thức này hoạt động - giả sử 123045là đầu vào $args. Sau khi -splitbật 0, đường ống sẽ chứa một mảng (123,45). Vòng lặp đầu tiên |%{...}có phần tử hiện tại $_bằng 123, sau đó được đặt ngầm định thành một chuỗi, sau đó đảo ngược với việc []lập chỉ mục. Điều đó làm cho nó ('3','2','1')như là một mảng char. Vòng lặp -joinđặt nó trở lại thành một chuỗi "321"và để nó trên đường ống. Lặp lại vòng lặp tiếp theo (cuối cùng) đảo ngược đầu vào thành "54". Vì vậy bây giờ đường ống của chúng tôi là "321", "54". Điều đó được gói gọn trong các parens ()để nó được cải tổ thành một mảng và được -joinghép lại với các số 0 để tạo ra chuỗi đầu ra kết quả"321054". Điều đó còn lại trên đường ống và đầu ra cho giao diện điều khiển là ẩn.

Nếu có các số 0 tiếp theo trong đầu vào ban đầu, mảng sẽ được điền với các phần tử null, do đó, có số lượng số không chính xác trên đầu ra. Ví dụ, 1230045-split0biến thành (123,,45)và mọi thứ tiếp tục như trên.



2

Yếu tố, 35 byte

Đánh bại Pyfon và Clojure, booyah!

[ "0"split [ reverse ] map "0"join ]

Hàm ẩn danh này là một bản dịch theo nghĩa đen của câu trả lời Python này .

Điều này khá đơn giản, chỉ cần phân tách chuỗi trên các số 0, đảo ngược mọi phần tử của mảng kết quả và nối tất cả các phần tử (bao gồm các chuỗi có độ dài bằng không) với "0".

Đây là một ví dụ về nó chạy trên tất cả các trường hợp thử nghiệm:

IN: scratchpad auto-use {
        "4"
        "00"
        "123"
        "0010"
        "12000345"
        "18161604"
        "95883007414830"
        "010230456078912"
        "357509902003550"
        "2492882377675046"
        "03026302053000357099"
        }
        [ 
          "0" split [ reverse ] map "0" join
        ]
        map .

{
    "4"
    "00"
    "321"
    "0010"
    "21000543"
    "61618104"
    "38859003841470"
    "010320654021987"
    "575309902005530"
    "5767732882942064"
    "03036202035000753099"
}

"00120"-> { "" "" "12" "" }-> { "" "" "21" "" }->"00210"


2

Haskell, 45 byte

r%(0:t)=r++0:[]%t
r%(h:t)=(h:r)%t
r%_=r
([]%)

Đệ quy tích lũy chunk đảo ngược cho đến nay r, chuẩn bị nó khi 0đạt đến một. Khi chuỗi còn lại trống, nó cũng xả r.

Hai cái đầu tiên lặp lại một số mã, nhưng tôi không tìm thấy cách nào ngắn hơn để kết hợp chúng (45 và 47 byte):

r%(h:t)|h<1=r++h:[]%t|1>0=(h:r)%t
r%_=r
([]%)

r%l|0:t<-l=r++0:[]%t|h:t<-l=(h:r)%t
r%_=r
([]%)

Tôi nghĩ bạn cần thêm một cặp dấu ngoặc đơn trong dòng # 2:r%(h:t)=(h:r)%t
nimi


1

JavaScript (ES6), 50 49 byte

Phiên bản chuỗi:

s=>s.replace(/[^0]+/g,r=>[...r].reverse().join``)

Đã lưu một byte nhờ @Kevin Lau!

Phiên bản mảng (60 byte):

a=>a.map((n,i)=>n?a[z-i+[...a,0].indexOf(0,i)]:(z=i,0),z=-1)

1

J, 20 18 byte

0}:@;@(<@|.;.1)@,]

Cảm ơn Zgarb đã giúp đỡ với điều này! Đưa ra một danh sách được phân tách bằng dấu cách như là một đối số đúng.

-2 byte nhờ Zgarb!


1

Clojure / ClojureScript, 44 ký tự

#(flatten(map reverse(partition-by pos? %)))

Giải pháp tương tự như những người khác, chỉ dài dòng hơn nhờ tên hàm dài. Sẽ không đăng nó vì điều đó, nhưng nó đánh bại một số câu trả lời khác vậy tại sao không?

Hoạt động trên bất kỳ loại trình tự. Trong ClojureScript, điều này cũng hoạt động trên các chuỗi vì các chuỗi có thể xử lý dưới dạng danh sách các ký tự, thực sự chỉ là các chuỗi có độ dài 1, ép buộc các số cho những thứ như pos?.


1

Haskell, 46 byte

import Data.Lists
(reverse=<<).split(oneOf"0")

Ví dụ sử dụng: (reverse=<<).split(oneOf"0") $ "0123004500678090"-> "0321005400876090".

Đáng buồn là splitchức năng yêu cầu nhập khẩu đắt tiền. Tách danh sách đầu vào ở mọi nơi 0, ví dụ split(oneOf"0") "0120030"-> ["","0","12","0","","0","3","0",""], đảo ngược từng đoạn và nối thành một chuỗi.


1

F #, 103 byte

let f x=x="";x.Split '0'|>Array.map(fun s->System.String(s|>Seq.toArray|>Array.rev))|>String.concat "0"

1

Java, 179 byte (có nhập)

import java.util.*;static void r(String s){StringJoiner x= new StringJoiner("0");for(String a:s.split("0",s.length())){x.add(new StringBuilder(a).reverse());}System.out.print(x);}

Lấy một đầu vào chuỗi và chia các ký tự bằng 0, sau đó thêm chúng trở lại bằng cách gọi phương thức add trên lớp StringJoiner.


1

Oracle SQL 11.2, 131 123 byte

Lạm dụng các hàm XML.

SELECT LISTAGG(REVERSE(COLUMN_VALUE||''))WITHIN GROUP(ORDER BY rownum)FROM XMLTABLE(('"'||REPLACE(:1,'0','","0","')||'"'));

1

Perl, 22 byte

Bao gồm +1 cho -ptùy chọn:

s/[^0]+/reverse$&/eg

Đây là một sự thay thế khá tầm thường - xin lỗi vì quá nhàm chán. Lưu ý rằng nếu đầu vào của bạn bị chấm dứt dòng mới (ví dụ: sử dụng perl -pe 's/[^0]+/reverse$&/eg' <<<21000543trong Bash), nó sẽ bắt dòng mới bằng các chữ số - sử dụng echo -nhoặc printfđể tránh điều đó. Ngoài ra, với chi phí thêm một byte, hãy thay đổi lớp ký tự thành [1-9]và bạn có thể cung cấp nhiều đầu vào, mỗi đầu vào cho mỗi dòng.


1

C, 105 byte

#define x(o)for(p=s;*s&&'0'o*s;++s);for(r=s;r-->p;putchar(*r));
f(s,p,r)char*s,*p,*r;{x(^)x(==)*s&&f(s);}

Gọi fvới danh sách các chữ số dưới dạng một chuỗi kết thúc không, và nó sẽ in ra đầu ra chính xác.

Ungolfed và giải thích:

f(s,p,r)
char*s,*p,*r; // K&R style to avoid repeating `char`
{

    // x(^)x(==) expands to...

    // Find the next zero digit
    for(p = s; *s && '0' ^ *s; ++s)
        ;

    // Print that run backwards
    for(r = s; r-- > p; putchar(*r))
        ;

    // Find the next non-zero digit
    for(p = s; *s && '0' == *s; ++s)
        ;

    // Print that run backwards (no difference, it's all zeros)
    for(r = s; r-- > p; putchar(*r))
        ;

    // If there's more string, recurse
    *s && f(s);
}

Xem nó trực tiếp trên Coliru


0

Perl 5, 52 byte

Một chương trình con:

{$_=pop;y/0/ /;map$i.=reverse,split/\b/;$i=~y/ /0/r}

-akhông hoạt động (ít nhất là trong Dâu tây) khi chuỗi đầu vào kết thúc 0, vì split/\b/bao gồm cả $/với 0.
msh210

0

Trên thực tế, 22 byte

k"a%sa"%'0@s♂R'0j#pXdX

Điều này thực sự khiến tôi nhận thấy rằng có một lỗi trong lệnh split - nó không bảo toàn các phần tách trống. Như một giải pháp thay thế, tôi bao quanh chuỗi đầu vào bằng as trước khi thực hiện phân tách, đảo ngược và nối, sau đó xóa as ở cuối. Đầu vào được lấy dưới dạng chuỗi, đầu ra là danh sách các chuỗi ký tự đơn.

Dùng thử trực tuyến

Giải trình:

k"a%sa"%'0@s♂R'0j#pXdX
k"a%sa"%                surround input with "a" characters
        '0@s            split on 0
            ♂R          reverse each piece
              '0j       join on 0
                 #pXdX  listify, remove first and last element (the "a"s)

0

C #, 131 byte ##

giải pháp thiếu sót!

string j(string i){foreach(var s in i.Split('0'))if(s!="")i=i.Replace(s,new string(s.ToCharArray().Reverse().ToArray()));return i;}

vô dụng:

string j(string input)
    {

        string[] a = input.Split('0');

        foreach (string s in a)
        {
            if (s!="")
            input=input.Replace(s, new string(s.ToCharArray().Reverse().ToArray()));
        }

        return input;
    }

1
Tôi tin rằng phương thức này có một lỗi khi một chuỗi được đảo ngược là một tập hợp con của một chuỗi khác. Nếu được đưa vào đầu vào 01201230, điều này sẽ trở lại 02102130. Điều này là do phương thức String.Replace thay thế tất cả các lần xuất hiện của chuỗi thứ nhất bằng chuỗi thứ hai. Lỗi này cũng sẽ được gây ra nếu một mẫu xuất hiện khi đảo ngược ( 0120210sẽ quay trở lại 0120120).
Xynariz

Tôi thậm chí không nghĩ về điều đó ..
downrep_nation

0

C #, 133 byte


Chơi gôn

String m(String s){for(int i=0,p=i;i<s.Length;i++){if(s[i]=='0'){p=i+1;}else{s=s.Insert(p,s[i].ToString()).Remove(i+1,1);}}return s;}

Bị đánh cắp

String m( String s ) {
    // i = Index on the String
    // p = Pointer of the last '0' found
    for (int i = 0, p = i; i < s.Length; i++) {
        if (s[ i ] == '0') {
            // Move the 'p' pointer to the index after this '0'
            p = i + 1;
        } else {
            // Insert the Char at the Index location to the Pointer location 
            //    and remove the one at the Index Location + 1,
            //    since the String was incremented by one char due to the 'Insert()'.
            s = s.Insert( p, s[ i ].ToString() )
                 .Remove( i + 1, 1 );
        }
    }

    return s;
}

Mã đầy đủ

using System;
using System.Collections.Generic;

namespace Namespace {
    class Program {
        static void Main( String[] args ) {
            List<String> ls = new List<String>() {
                "4",
                "00",
                "123",
                "0010",
                "12000345",
                "18161604",
                "95883007414830",
                "010230456078912",
                "357509902003550",
                "2492882377675046",
                "03026302053000357099"
            };

            foreach (String s in ls) {
                String f = m( s );

                Console.WriteLine( String.Format( "{0,30}", s.Replace( "0", "0 " ) ) );
                Console.WriteLine( String.Format( "{0,30}", f.Replace( "0", "0 " ) ) );
                Console.WriteLine( "" );
            }

            Console.ReadLine();
        }

        static String m( String s ) {
            for (Int32 i = 0, p = i; i < s.Length; i++) {
                if (s[ i ] == '0') {
                    p = i + 1;
                } else {
                    s = s.Insert( p, s[ i ].ToString() ).Remove( i + 1, 1 );
                }
            }

            return s;
        }
    }
}

Bây giờ mới nhận thấy rằng @downrep_nation đã đăng lên đây một giải pháp cho C #, nó đánh bại mã của tôi bằng 2 byte ... (Có thể nhiều hơn ....)
auhmaan

0

Java, 126

a->{String r="",t[]=a.split("0");for(String s:t){r+=new StringBuilder(s).reverse()+"0";}return r.substring(0, r.length()-1);}

Nếu bạn khai báo sbiến ở phía trước với rt[], bạn có thể bỏ qua khai báo kiểu strong vòng lặp for không?
Cyoce

Không, tôi đã kiểm tra nó, tăng cường cho các vòng lặp cần một biến mới được khai báo.
Hy vọng hữu ích

Huh. Lạ nhỉ. Oh well
Cyoce

0

Clojure, 37 byte

#(mapcat reverse(partition-by #{0}%))

Sử dụng #{0}thay vì pos?(lưu 1 byte bằng cách nối với %) và sử dụng mapcatthay vì (flatten(map. Vẫn dài hơn Yếu tố .

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.