Mục tiêu

Viết chương trình hoặc hàm (hoặc tương đương) sắp xếp và trả về chữ cái lẻ trong ma trận có kích thước ngẫu nhiên.

Chi tiết

Bạn sẽ được thông qua một ma trận (dưới dạng một chuỗi) dưới dạng đầu vào của các kích thước ngẫu nhiên như thế này.

bbbbbbbbbbb
bbbbbdbbbbb
bbbbbbbbbbb
bbbbbbbbbbb
bbbbbbbbbbb

Công việc của bạn là tìm chữ cái không khớp với phần còn lại (trong trường hợp này, nó được dtìm thấy ở dòng 2, col 6) và trả lại chữ cái đó làm đầu ra. Ma trận sẽ bao gồm các chữ cái A-Z, a-zdòng mới ( \n, chỉ ở cuối các hàng) và có kích thước nằm trong khoảng từ 5x5 đến 10x10 (25-100 chữ cái).

Tiêu chuẩn áp dụng. Đây là một thử thách golf mã; mục nhập với mã ít byte nhất sẽ thắng.

Đầu vào

Đầu vào sẽ được chuyển qua đầu vào tiêu chuẩn dưới dạng một chuỗi nếu đó là một chương trình hoặc là một đối số nếu một hàm (hoặc tương tự).

Đầu ra

Một nhân vật duy nhất là "kỳ quặc" trong ma trận hay None , nil, NUL, hoặc chuỗi "None"nếu không có "kỳ quặc" nhân vật.

Thêm ví dụ

AAAAAAA
AAAAAAA
AAAAAAA
AAAIAAA
AAAAAAA

Câu trả lời: I

vvqvvvvvvv
vvvvvvvvvv
vvvvvvvvvv
vvvvvvvvvv
vvvvvvvvvv

Câu trả lời: q

puuuuuuuu
uuuuuuuuu
uuuuuuuuu
uuuuuuuuu
uuuuuuuuu
uuuuuuuuu
uuuuuuuuu
uuuuuuuuu
uuuuuuuuu
uuuuuuuuu

Câu trả lời: p

Máy phát điện

Dưới đây là một trình tạo ma trận ngẫu nhiên được viết bằng Python mà bạn có thể sử dụng để kiểm tra chương trình của mình. Lưu ý: Có một cơ hội nhỏ rằng nó có thể phạm sai lầm và không đặt trong một lá thư kỳ lạ.

Instructions

1. Copy this code into a file called `matrix_gen.py`.
2. Run it with `python matrix_gen.py`.

---

from random import randint

rows = randint(5,10)
cols = randint(5,10)

charset = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
neg = charset[randint(0,51)]
pos = charset[randint(0,51)]
p_used = 0

comp = 0
matrix = ""

while comp < rows:
  row = ""
  while len(row) < cols:
    if not p_used and not randint(0,10):
      p_used = 1
      row = row + pos
    else:
      row = row + neg
  row = row + "\n"
  matrix = matrix + row
  comp += 1

print matrix[:-1]

Python 3 , 27 byte

lambda x:min(x,key=x.count)

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

J , 12 10 7 byte

-.}./.~

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

    /.~        Group identical items together
  }.           Remove one item from each group
-.             Remove the rest from the input

Phiên bản 10 byte

-._1 1{\:~

^{tiếng rít ...}

       \:~        Sort down
  _1 1{           Take the last character (which is a newline) and the second one.
-.                Remove those from the input

Brachylog , 8 4 byte

oḅ∋≠

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

Giải trình

Tôi chưa sử dụng Brachylog trước đây, vì vậy điều này có thể không tối ưu.

oḅ∋≠  Input is a string.
o     Sort the input.
 ḅ    Split it into blocks of equal elements.
  ∋   There is a block
   ≠  whose elements are all different.
      That block is the output.

K (oK) , 7 6 byte

Giải pháp

*<#:'=

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

Thí dụ:

*<#:'="vvqvvvvvvv\nvvvvvvvvvv\nvvvvvvvvvv\nvvvvvvvvvv\nvvvvvvvvvv"
"q"

Giải trình:

Tìm thấy một cách tiếp cận ngắn hơn một chút: Đánh giá từ phải sang trái:

*<#:'= / the solution
     = / group matching items together
  #:'  / count (#:) each (')
 <     / sort ascending
*      / take the first one

Ghi chú:

Trong khi tôi hy vọng khía cạnh phần thưởng của thử thách này sẽ bị loại bỏ, giải pháp này sẽ trả về ký tự dòng mới \nnếu không có ký tự lẻ:

*<#:'="vvvvvvvvvv\nvvvvvvvvvv\nvvvvvvvvvv\nvvvvvvvvvv\nvvvvvvvvvv"
"\n"

Prolog (SWI) , 46 byte

p(L):-select(X,L,Y),\+member(X,Y),writef([X]).

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

Hoặc nếu đầu ra đúng tiêu chuẩn từ các truy vấn prolog không ổn:

Prolog (SWI) , 48 byte

Z*L:-select(X,L,Y),\+member(X,Y),char_code(Z,X).

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

Giải trình

Find the first element X in the input  
that when removed, results in output  
that does not contain X

then depending on the version above either:  
print X as a character  
or  
return X as an atom

C (gcc) , 93 92 90 66 62 byte

Ngắn hơn nhiều như một chức năng

t;f(char*p){for(t=*p;*p;)t^*p++?putchar(*p^*--p?*p:t),*p=0:0;}

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

mã kiểm tra

main()
{
    char s[99];
    for(;gets(s);)f(s);
}

phiên bản cũ là một chương trình

C 86 byte

char*p;s[9];main(t){for(;p=gets(s);)for(t=*p;*p;)t^*p++?putchar(*p^*--p?*p:t),*p=0:0;}

Xuất ra ký tự lẻ, hoặc không có gì. chạy như thế này;

C:\eng\golf>python matrix_gen.py | a.exe
X
C:\eng\golf>python matrix_gen.py | a.exe
G
C:\eng\golf>python matrix_gen.py | a.exe
x
C:\eng\golf>python matrix_gen.py | a.exe

C:\eng\golf>python matrix_gen.py | a.exe
J

05AB1E ,  4  2 byte

Đã lưu 2 byte nhờ Adnan

.m

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

Giải trình

.m   # push a list of the least frequent character(s) in input

Võng mạc , 13 byte

s(O`.
(.)\1+

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

Giải trình

s(O`.

Sắp xếp tất cả các nhân vật.

(.)\1+

Xóa bất kỳ ký tự xuất hiện ít nhất hai lần.

Husk , 2 byte

◄=

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

Đây là một hàm lấy một chuỗi làm đầu vào và trả về một ký tự. Nó lấy tối thiểu của chuỗi đầu vào khi so sánh các ký tự cho đẳng thức (nghĩa là nó trả về ký tự bằng số lượng ký tự khác ít nhất).

C, 94 byte

Trả về bằng con trỏ. Nếu không, trở về \0.

Điều này sẽ gây rò rỉ bộ nhớ. Giả sử intlà 4 byte.

*t;f(c,p,i)char*c,*p;{t=calloc(64,8);for(*p=-1;*c;c++)t[*c]--;for(i=0;++i<128;)!~t[i]?*p=i:0;}

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

Toán học, 27 byte

Last@*Keys@*CharacterCounts

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

-1 byte từ Martin Ender

Bash , 15 20 byte

fold -1|sort|uniq -u

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

Giải thích: fold s đầu vào cho 1ký tự trên mỗi dòng, sorts nó thành các nhóm chữ cái phù hợp, sau đó chỉ in các dòng là unique.

Cảm ơn @Nahuel Fouilleul vì đã nắm bắt và giúp khắc phục vấn đề với phương pháp này.

Bình thường , 4 byte

ho/Q

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

Perl 5, 17 + 3 (-00p) -25% = 15 byte

/(.)\1/;s/
|$1//g

thử trực tuyến

Matlab, 25 byte

a=input('');a(a~=mode(a))

Đầu vào "a" trong đó "a" không phải là chế độ của "a". Đầu ra mảng trống không có lẻ.

Haskell, 33 * 0,75 = 24,75 byte

f s=[c|[c]<-(`filter`s).(==)<$>s]

Trả về một danh sách trống nếu không có ký tự lẻ.

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

Đối với mỗi char ctrong ma trận (được đưa ra dưới dạng một chuỗi s), tạo một chuỗi gồm tất cả các ký tự trong sđó bằng cvà giữ các chuỗi có độ dài 1.

JavaScript (ES6), 37 byte

Trả về nullnếu không có thư lẻ.

s=>s.match(`[^
${s.match(/(.)\1/)}]`)

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

let f =

s=>s.match(`[^
${s.match(/(.)\1/)}]`)

console.log(f(
  'bbbbbbbbbb\n' +
  'bbbbbdbbbb\n' +
  'bbbbbbbbbb\n' +
  'bbbbbbbbbb\n' +
  'bbbbbbbbbb'
))

console.log(f(
  'AAAAAAA\n' +
  'AAAAAAA\n' +
  'AAAAAAA\n' +
  'AAAIAAA\n' +
  'AAAAAAA'
))

console.log(f(
  'vvqvvvvvvv\n' +
  'vvvvvvvvvv\n' +
  'vvvvvvvvvv\n' +
  'vvvvvvvvvv\n' +
  'vvvvvvvvvv'
))

console.log(f(
  'puuuuuuuu\n' +
  'uuuuuuuuu\n' +
  'uuuuuuuuu\n' +
  'uuuuuuuuu\n' +
  'uuuuuuuuu\n' +
  'uuuuuuuuu\n' +
  'uuuuuuuuu\n' +
  'uuuuuuuuu\n' +
  'uuuuuuuuu\n' +
  'uuuuuuuuu'
))

console.log(f(
  'AAAAA\n' +
  'AAAAA\n' +
  'AAAAA\n' +
  'AAAAA\n' +
  'AAAAA'
))

Japt , 6 byte

Đưa đầu vào dưới dạng một chuỗi nhiều dòng và xuất ra một chuỗi ký tự đơn hoặc một chuỗi trống nếu không có giải pháp.

k@èX É

Thử nó

Giải trình

Xóa các ký tự trả về truey ( k) khi truyền qua hàm ( @) đếm ( è) các lần xuất hiện của phần tử hiện tại ( X) trong đầu vào và trừ 1 ( É).

Lisp thông thường, 47 byte

(lambda(s)(find-if(lambda(x)(=(count x s)1))s))

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

Trả về chữ cái lẻ hoặc NIL nếu nó không tồn tại.

Thạch , 4 byte

ċ@ÐṂ

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

Trả về \n(một dòng mới) trong trường hợp không có ký tự lẻ. Rõ ràng \nkhông phải là một nhân vật có thể in được.

Thật trùng hợp, đây chính xác là thuật toán tương tự như câu trả lời của Mr.Xcoder Python. (Tôi nghĩ ra nó một cách độc lập)

Giải trình:

  ÐṂ    Ṃinimum value by...
ċ@      ċount. (the `@` switch the left and right arguments of `ċ`)

Điều đó hoạt động vì trong một m×nma trận:

• Nếu tồn tại ký tự lẻ: Có m-1dòng mới, 1 ký tự lẻ và m×n-1ký tự bình thường, và 1 < m-1 < m×n-1bởi vì 5 ≤ m, n ≤ 10.
• Nếu không tồn tại ký tự lẻ: Có m-1dòng mới và m×nký tự bình thường, và m-1 < m×n.

C # (.NET Core) , 54 byte

i=>i.GroupBy(x=>x).FirstOrDefault(g=>g.Count()<2)?.Key

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

C (gcc) , 91 86 82 79 71 byte

f(char*s){for(;*++s==10?s+=2:0,*s;)if(*s^s[-1])return*s^s[1]?*s:s[-1];}

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

• Cảm ơn Gastropner cho xor và? thủ thuật (-3 byte)
• Làm lại phiên bản so sánh để sửa lỗi và sử dụng phép thuật Gastropner từ các bình luận.

Giải trình:

So sánh char hiện tại và trước đó trong khi bỏ qua các dòng mới. Nếu khác, so sánh với char tiếp theo. Điều này cho chúng tôi biết nếu chúng tôi trả lại char hiện tại hoặc trước đó. Hàm trả về giá trị char "lẻ" nếu nó tồn tại hoặc 0 nếu mảng không lẻ. Chúng tôi tránh xa với kiểm tra char "tiếp theo" bởi vì luôn có một dòng mới trước \0char. Nếu không có char lẻ, về bản chất chúng ta sẽ trả về \ 0 từ vòng lặp for.

Cũ hơn, mã xor quyến rũ hơn Giải thích:

Tạo mặt nạ xor đang chạy của 3 giá trị chuỗi tiếp theo. Nếu tất cả đều giống nhau, thì giá trị sẽ bằng với bất kỳ trong số ba. Nếu chúng khác nhau, thì 2 cái giống nhau sẽ triệt tiêu lẫn nhau để lại cái duy nhất.

Phải yếu tố / n trước xor hoặc nó trở nên lộn xộn. Ngoài ra phải kiểm tra 2 ký tự cho bất đẳng thức trong trường hợp s [0] là giá trị lẻ. Chi phí này thêm | | kiểm tra.

v;f(char*s){while(s[3]){s[2]==10?s+=3:0;v=*s^s[1]^s[2];if(v^‌​*s++||v^*s)break;}}

Octave , 26 25 byte

Lưu 1 byte nhờ @Giuseppe

@(x)x(sum(x(:)==x(:)')<2)

Hàm ẩn danh lấy một mảng char 2D làm đầu vào và xuất ra một chữ cái lẻ hoặc một chuỗi trống nếu nó không tồn tại.

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

Alice , 16 * 75% = 12 byte

/-.nDo&
\i..*N@/

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

Đầu ra Jabberwockynếu không có ký tự trùng lặp.

Giải trình

/...@
\.../

Đây là một khung cho các chương trình tuyến tính hoạt động hoàn toàn trong Ordinal (chế độ xử lý chuỗi). Mã thực tế được thực thi theo cách ngoằn ngoèo và mở ra:

i..DN&-o

i   Read all input.
..  Make two copies.
D   Deduplicate one copy, giving only the two letters and a linefeed.
N   Multiset difference. Removes one copy of each letter and one linefeed.
    Therefore it drops the unique letter.
&-  Fold substring removal over this new string. This essentially removes
    all copies of the repeated letter and all linefeeds from the input,
    leaving only the unique letter.
.   Duplicate.
n   Logical NOT. Turns empty strings into "Jabberwocky" and everything else
    into an empty string.
*   Concatenate to the previous result.
o   Print the unique letter or "Jabberwocky".

Thay vì &-, chúng ta cũng có thể sử dụng ey(chuyển ngữ thành một chuỗi trống). Ngoài ra, bằng cách chi tiêu thêm một ký tự cho thao tác ngăn xếp, chúng tôi cũng có thể sao chép đầu vào cho phép chúng tôi loại bỏ các ký tự không mong muốn N, nhưng nó vẫn có cùng số byte:

i.D.QXN.n*o@

Alice , 13 byte

/N.-D@
\i&.o/

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

Đây là giải pháp không có tiền thưởng, đơn giản là nó thiếu .n*.

Võng mạc , 22 byte

!`(.)(?!.*\1)(?<!\1.+)

Hãy thử trực tuyến! Chỉ yêu cầu chiều cao và chiều rộng ít nhất là 3, thay vì 5.

APL + THẮNG, 16 byte

(1=+/a∘.=a)/a←,⎕

Lời nhắc cho đầu vào màn hình và xuất ra chữ cái lẻ hoặc không có gì nếu không có chữ cái lẻ

PowerShell , 39 byte

([char[]]"$args"|group|sort c*)[0].Name

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

Đưa đầu vào dưới dạng một chuỗi với các dòng mới (như được chỉ định trong thử thách), chuyển đổi nó thành một char-array. Chúng tôi sau đó Group-Objectcác nhân vật, để các nhân vật được nhóm lại với nhau theo tên của họ, sau đó sortdựa trên count. Điều này đảm bảo rằng nhân vật cô đơn là đầu tiên, vì vậy chúng tôi lấy [0]chỉ mục và xuất ra nó .Name.

Nếu dòng mới được chấp nhận cho "không có gì" thì điều này đủ điều kiện nhận thưởng.

Perl 6 ,  27  24 -25% = 18 byte

*.comb.Bag.min(*.value).key

Kiểm tra nó

{%(.comb.Bag.invert){1}}

Kiểm tra nó

Điều này sẽ trả về một giá trị không xác định khi được cung cấp một đầu vào không có ký tự lẻ.

Mở rộng:

{  # bare block lambda with implicit parameter ｢$_｣

  %(        # coerce into a Hash

    .comb   # split the input into graphemes (implicit method call on ｢$_｣)
    .Bag    # turn into a weighted Set
    .invert # invert that (swap keys for values) returns a sequence

  ){ 1 }    # get the character that only occurs once
}

Brainfuck, 125 byte

,[----------[>],]<[->+<]<<[[->->+<<]>[>[->-<<<+>>]>[,<<,>>]<<<[->+<]>[->+<]<]>[-<<+>>]>[-<+>]<<<<]>>>>[<]<++++++++++.

Dùng thử trực tuyến

In chữ cái của ma trận nếu không có số lẻ

Java 8, 85 byte

Đây là một lambda từ Stringđến String(ví dụ Function<String, String>). Nó thực chất là một bản sao của giải pháp của Luca , nhưng tôi đã phân loại chuỗi sắp xếp một chút.

s->new String(s.chars().sorted().toArray(),0,s.length()).replaceAll("(.)\\1+|\\n","")

Dùng thử trực tuyến