Bài tập

Cho một mảng không trống0 và 1, giảm một nửa độ dài của các lần chạy 0.

Đầu vào

Một mảng 0và 1. Định dạng có thể chấp nhận:

• Mảng thực trong ngôn ngữ của bạn
• Chuỗi phân tách theo dòng cho 0và1
• Chuỗi tiếp giáp của 0và1
• Bất kỳ định dạng hợp lý khác

Ví dụ: ba đầu vào sau đây đều được chấp nhận:

• [1, 0, 0, 1]
• "1\n0\n0\n1"(trong đó \nmột nguồn cấp dữ liệu U + 000A)
• "1001"

Bạn có thể cho rằng các bước chạy 0sẽ có độ dài chẵn .

Đầu ra

Một mảng 0và 1, trong các định dạng chấp nhận được ở trên.

Tủ thử

input ↦ output
[1,0,0,1,0,0,1] ↦ [1,0,1,0,1]
[1,1,0,0,1,1,0,0,1] ↦ [1,1,0,1,1,0,1]
[1,1,0,0,1,1,1,0,0,1,1] ↦ [1,1,0,1,1,1,0,1,1]
[1,1,1] ↦ [1,1,1]
[0,0,1] ↦ [0,1]
[0,0] ↦ [0]
[1,1,1,0,0,0,0,1,1,1,1,0,0,1,0,0,1,1,0,0,1,1,1,1,0,0,1,0,0] ↦ [1,1,1,0,0,1,1,1,1,0,1,0,1,1,0,1,1,1,1,0,1,0]

Chấm điểm

Đây là mã golf . Câu trả lời ngắn nhất trong byte thắng.

Tiêu chuẩn áp dụng.

Võng mạc , 4 byte

00
0

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

05AB1E , 5 byte

00¤.:

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

Giải trình

00     # push 00
  ¤    # tail, pushes 0
   .:  # replace

Haskell , 33 byte

f(0:0:r)=0:f r
f(x:r)=x:f r
f e=e

Hãy thử trực tuyến! Cách sử dụng : f[1,1,0,0,1,1,0,0,1]. Lặp lại danh sách và thay thế hai số không liên tiếp bằng một số không.

C (gcc) , 35 byte

f(char*s){while(*s)putchar(*s),*s++-48?:s++;}

48 là mã ascii của '0'

phiên bản tốt hơn 43 byte theo đề xuất của Neil

f(char*s){while(*s)putchar(*s),s+=2-*s%2;}

một cái khác 40 byte lần này (một lần nữa theo đề xuất của Neil & VisualMelon) :)

f(char*s){for(;*s;s+=50-*s)putchar(*s);}

và sau đó 35 byte nhờ Khaled.K

f(char*s){*s&&f(s+50-putchar(*s));}

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

sed , 8 byte

s/00/0/g

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

Octave, 22 byte

@(s)strrep(s,'00','0')

Xác nhận tất cả các trường hợp thử nghiệm ở đây.

Đây là một hàm ẩn danh lấy một chuỗi trên định dạng '1001000011'làm đầu vào và thay thế hai số không liên tiếp bằng một số không.

Java, 50 byte

String f(String s){return s.replaceAll("00","0");}

Thử trực tuyến

Haskell , 28 byte

f(h:t)=h:f(drop(1-h)t)
f e=e

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

Đệ quy lấy phần tử thứ nhất, bỏ phần tử thứ hai nếu phần tử thứ nhất bằng 0, cho đến khi danh sách trống. Nếu mục đầu tiên là h, thì mục đầu tiên 1-hđược loại bỏ từ phần còn lại.

Japt , 7 6 5 byte

d'0²0

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

Chỉ cần thay thế mỗi lần chạy hai số 0 trong đầu vào bằng một số không. Sử dụng đầu vào chuỗi (tức là "1001001").

PHP, 26

<?=strtr($argn,["00"=>0]);

chỉ cần thay thế tất cả 00bằng 0.

Alice , 13 byte

/oe00/
@iS0e\

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

Giải trình

/.../
@...\

Đây là một mẫu đơn giản cho các chương trình tuyến tính hoạt động hoàn toàn trong chế độ Thông thường. Chữ cái đầu tiên /phản ánh IP để di chuyển về phía đông nam và sau đó nó nảy lên theo đường chéo lên xuống thông qua mã cho đến khi các gương ở cuối. Những cái đó chỉ đơn giản là bù vị trí một cái để trên đường quay lại IP đi qua các ô còn lại. Đọc mã theo kiểu ngoằn ngoèo này, nó trở thành:

ie00e0So@

Đây là một thay thế chuỗi đơn giản:

i   Read all input.
e   Push an empty string.
00  Append two zeros to create the string "00".
e   Push an empty string.
0   Append a zero to create the string "0".
S   Substitute all occurrences of "00" in the input with "0".
o   Output the result.   
@   Terminate the program.

Có một vài cách khác để đẩy hai chuỗi, ví dụ '00'0hoặc e000t, nhưng tôi không tìm thấy bất cứ thứ gì có 5 byte ở đó (và tôi phải cạo hai byte để có thể rút ngắn chương trình).

Prolog (SWI) , 42 byte

[0,0|T]*[0|R]:-T*R.
[H|T]*[H|R]:-T*R.
H*H.

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

Java , 131 123 byte

int[]f(int[]a){int c=0,i=0,l=a.length;for(int x:a)c+=1-x;int[]r=new int[l-c/2];for(c=0;c<l;c+=2-a[c])r[i++]=a[c];return r;}

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

JavaScript (ES6), 26 21 byte

Lấy đầu vào là một chuỗi và trả về một chuỗi.

s=>s.replace(/00/g,0)

Thử nó

f=
s=>s.replace(/00/g,0)
i.addEventListener("input",_=>o.innerText=f(i.value))
console.log(f("1001001")) // "10101"
console.log(f("110011001")) // "1101101"
console.log(f("11001110011")) // "110111011"
console.log(f("111")) // "111"
console.log(f("001")) // "01"
console.log(f("00")) // "0"
console.log(f("11100001111001001100111100100")) // "1110011110101101111010"

<input id=i><pre id=o>

Lua, 33 byte

print((io.read():gsub("00","0")))

Lấy một chuỗi thông qua đầu vào và ngưng tụ hai số không. Dễ dàng.

Thạch , 8 byte

ṣ1j1,1m2

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

Có thể các câu trả lời khác trong các ngôn ngữ không có .replace()hoặc tương tự có thể sử dụng thủ thuật này.

Giải trình

ṣ1j1,1m2 - (duplicates the 1s, then halves all lengths)
ṣ1       - split by the element 1
  j1,1   - join the elements with the two-element list 1,1
      m2 - get every second element

Alice , 12 10 byte

Lưu 2 byte nhờ Martin Ender

i.h%.7%$io

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

Giải trình

Đây là mã 1-D hoạt động ở chế độ hồng y, vì vậy thật dễ dàng để theo dòng chảy của nó:

i                   Read a byte from input (pushes -1 on EOF)
 .h                 Duplicate it and add 1 to the copy
   %                Compute n%(n+1). This will exit with an error on n==-1
                    and return n for any non-negative n.
    .7%             Duplicate the input again and compute its value modulo 7
                    This returns 6 for '0' (unicode value 48) and 0 for '1'
                    (unicode value 49)
       $i           If this last result was not 0, input another number.
                    This ignores every other '0' in the input
                    and moves to the following number (another '0')
         o          Output the last byte read

                    At the end, wrap back to the beginning of the line

Python (danh sách I / O), 36 byte

f=lambda l:l and l[:1]+f(l[2-l[0]:])

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

Đệ quy lấy phần tử đầu tiên, sau đó loại bỏ phần tử còn lại nếu phần tử đầu tiên bằng không.

38 byte:

lambda l:eval(`l`.replace('0, 0','0'))

Dùng thử trực tuyến Điều này lấy danh sách Python và xuất ra danh sách Python bằng cách thay thế trên biểu diễn chuỗi của nó. Chuỗi I / O sẽ cho phép một giải pháp trực tiếp và ngắn hơn, chẳng hạn như

lambda s:s.replace('00','0')

cho '1001' định dạng.

APL (Dyalog) , 9 byte

'00'⎕R'0'

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

Perl 5, 7 + 1 (cờ -p) = 8 byte

<>if/0/

Lấy đầu vào là số mới tách dòng. Bỏ qua dòng tiếp theo nếu nó thấy số không.

V , 4 byte

òf0x

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

ò    ' Recursively (until we error)
 f0  ' Go to the next zero (errors when there are no zeros left)
   x ' Delete it

MATL , 5 byte

FFOZt

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

Giải trình

Điều này tương tự như câu trả lời Octave của Stewie Griffin :

FF     % Push [0 0]
O      % Push 0
Zt     % Implicitly take input. Replace [0 0] by 0. Implicitly display

8 byte

vy~f2L)(

Điều này tránh tích hợp thay thế chuỗi / mảng.

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

Giải trình

Hãy xem xét đầu vào [1,0,0,1,0,0,1]như một ví dụ:

v      % Concatenate stack (which is empty): pushes []
       % STACK: []
y      % Implicit input. Duplicate from below
       % STACK: [1,0,0,1,0,0,1], [], [1,0,0,1,0,0,1]
~f     % Negate, find: gives indices of zeros
       % STACK: [1,0,0,1,0,0,1], [], [2,3,5,6]
2L     % Push [2,2,1i]. As an index, this is interpreted as 2:2:end
       % STACK: [1,0,0,1,0,0,1], [], [2,3,5,6], [2,2,1i]
)      % Reference indexing. This selects the even-indexed entries
       % STACK: [1,0,0,1,0,0,1], [], [3,6]
(      % Assignment indexing. This deletes the specified entries
       % (assigns them the empty array). Implicitly display
       % STACK: [1,0,1,0,1]

Brachylog , 10 byte

ḅ{cẹ|ḍh}ᵐc

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

Không chắc đây là tối ưu

Giải trình

Điều này khai thác lỗi mà ctrong danh sách các số nguyên có số 0 đứng đầu sẽ không thành công.

ḅ               Blocks; group consecutive equal elements together
 {     }ᵐ       Map on each block:
  c               It is possible to concatenate the block into an int (i.e. it contains 1s)
   ẹ              Split it again into a list of 1s
    |             Else
     ḍh           Dichotomize and take the head
         c      Concatenate the blocks into a single list

C #, 191 byte

string a(string s){var l=(s+'1').ToCharArray();s="";int b=0;for(int i=0;i<l.Length;i++){if(l[i]=='1'){if(b>0){s+=new string('0',b/2);b=0;}s+=l[i];}else b++;}return s.Substring(0,s.Length-1);}

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

Nó không sạch cũng không ngắn, nhưng nó hoạt động.

Đưa đầu vào thành một chuỗi ký tự liền kề, đầu ra ở cùng định dạng

Giải trình:

string a(string s){                  //Define method a that takes input string s and returns a string
  var l=(s+'1').ToCharArray();       //Add a 1 to the end of s and split into char array l
  s="";                              //Empty s
  int b=0;                           //Initialize int b with value 0
  for(int i=0;i<l.Length;i++){       //Loop through l
    if(l[i]=='1'){                   //If current char is 1
      if(b>0){                       //If b is not 0
        s+=new string('0',b/2);      //Add half the amount of 0s we've counted to s
        b=0;                         //Reset b
      }                              //End if b is not 0
      s+=l[i];                       //Add current char to s
    }                                //End if current char is 1
    else b++;                        //If current char is not 1, increment b
  }                                  //End loop
  return s.Substring(0,s.Length-1);  //Return string minus last char
}                                    //End method

chú thích

Có, tôi biết điều này đơn giản có thể được thực hiện bằng cách sử dụng s.Replace("00","0"), mục đích của tôi là tránh sử dụng giải pháp rõ ràng. Rốt cuộc, toàn bộ quan điểm của PPCG là vui chơi, phải không? ;)

Bình thường, 8 byte

:z"00"\0

Liên kết thử.

Giải trình:

:z"00"\0 Takes unquoted contiguous 1-line input.
 z       Initialized to unevaluated first input line (Q won't be any shorter)
  "00"   Matching regex pattern /00/g
      \0 Substitution string "0"
:        Regex find-and-replace

Awk - 18 byte

Trước tiên hãy thử làm bất cứ điều gì với Awk để có thể chơi golf nhiều hơn.

{gsub(00,0);print}

Sử dụng: echo "1001001" | awk '{gsub(00,0);print}'

Mẻ, 24 byte

@set/ps=
@echo %s:00=0%

Đưa đầu vào vào STDIN. Một chút cạnh tranh cho một lần.

Lisp thường gặp, SBCL, 48 32 byte

-16 byte nhờ Julian Wolf

(format t"~{~[0~*~;1~]~}"(read))

đầu vào:

(1 0 0 0 0 1 1 1 0 0)

đầu ra:

1001110

Giải trình

Chúng tôi đọc danh sách đầu vào. Danh sách được sử dụng trong formatchức năng. Chúng tôi lặp qua nó xuất ra 1nếu phần tử là 1và xuất ra 0và bỏ qua phần tử tiếp theo của danh sách cho 0.

Toán học, 24 byte

StringReplace["00"->"0"]

Một hàm mong đợi một chuỗi "0"s và "1"s và trả về một chuỗi tương tự. Cú pháp tự giải thích. Mathematica có rất nhiều nội dung chuyển đổi; điều quan trọng là sử dụng một biến đổi mọi biểu hiện phụ có liên quan (không giống nhau /.) nhưng chỉ chuyển qua biểu thức một lần (không giống như //.).

Thạch , 10 byte

Œg¹m2$S?€F

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

Giải trình

Œg¹m2$S?€F
Œg          - Group runs of equal elements
        €   - To each run...
      S?    - If sum is truthy,
  ¹         -   return the run as it is
   m2$      - Else return every second element of the run.