Chương trình chữ ký


34

Câu này sử dụng hai a, hai c, hai d, hai mươi tám e, năm f, ba g, tám h, mười một i, ba l, hai m, mười ba n, chín o, hai p, năm r, năm s, hai mươi ba t, sáu v, mười w, hai x, năm y và một z.

Những câu như vậy được gọi là chữ ký . Nhiệm vụ của bạn là viết một chương trình hoặc hàm có thuộc tính tương tự: nó lấy đầu vào là một byte và xuất ra một số nguyên biểu thị số lần byte đó xuất hiện trong mã nguồn của chương trình. Nó sẽ xuất 0 nếu đầu vào của nó không xuất hiện trong nguồn của nó.

Chương trình của bạn không được đọc mã nguồn riêng , trực tiếp hoặc gián tiếp, mà thay vào đó, tất cả dữ liệu cần cung cấp cho đầu ra của nó phải được mã hóa cứng, kiểu quine. Chương trình của bạn phải có ít nhất một byte chiều dài.

Đây là , vì vậy bài dự thi ngắn nhất (tính bằng byte) sẽ thắng. Tôi sẽ không chấp nhận câu trả lời, vì vậy hãy thoải mái cạnh tranh cho giải pháp ngắn nhất bằng ngôn ngữ yêu thích của bạn.

Bạn được khuyến khích bao gồm một lời giải thích trong bài viết của bạn.

Bảng xếp hạng

Dưới đây là bảng thành tích cho cả điểm tổng thể và mỗi ngôn ngữ:


5
Hộp cát . (Nó đã ở đó từ năm 2014!)
Nathaniel

Là chức năng được phép, hoặc chỉ chương trình đầy đủ?
Uriel

1
Lưu ý: Câu trả lời tương tự như câu hỏi này không được tính là hợp lệ nữa.
dùng202729

1
FWIW, định nghĩa quine thích hợp mạnh hơn một chút so với tôi thực sự muốn cho thử thách này. Ví dụ, tôi sẽ rất vui khi thấy một chương trình sử dụng tất cả các ký tự trong một phạm vi liền kề và chỉ xuất 1 nếu đầu vào của nó nằm trong phạm vi đó, mặc dù điều này không có "một phần của chương trình mã hóa một phần khác nhau của chương trình ". Vì lý do đó, tôi đã sẵn sàng cho phép ví dụ về võng mạc, mặc dù nó sẽ gây thất vọng nếu nó khiến người khác không đăng bài, do chỉ là 1 byte. (@ user202729)
Nathaniel

1
Vì nhận xét trên của tôi, tôi đã xóa tuyên bố áp dụng quy tắc quine. (Tôi đã giữ phần về việc không đọc mã nguồn.)
Nathaniel

Câu trả lời:


15

Octave , 44 byte

@(x)sum([[39,'(())*,239==@[[]]msuxx']]==x)*2

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

Kết quả của hàm, khi sử dụng từng ký tự trong hàm làm đầu vào:

'  (  )  *  ,  2  3  9  =  @  [  ]  m  s  u  x  
2  4  4  2  2  2  2  2  4  2  4  4  2  2  2  4  

Tất cả các ký tự đầu vào khác trả về một số không.

Việc tôi phải trốn thoát 'đã khiến chuyện này kéo dài hơn rất nhiều. Để tính đến 4 dấu ngoặc đơn, tôi chỉ có một bản sao trong chuỗi. Tuy nhiên, sao chép các dấu nháy đơn sẽ lấy dấu nháy đơn, vì vậy điều này chỉ đưa chúng ta đi xa hơn từ kết quả chính xác. Do đó, tôi đã phải đếm số dấu nháy đơn với giá trị ASCII của nó , 39. Điều này tất nhiên có nghĩa là tôi phải kiểm tra các nhân vật 39làm cho nó dài hơn rất nhiều.


2
Đây là loại điều tôi hy vọng sẽ thấy nhiều hơn. (Tối ưu hóa cho vấn đề, thay vì chỉ lấy một tiêu chuẩn và thêm mã để đếm các ký tự.)
Nathaniel

7

Excel, 84 byte

=IFERROR(MID("65496331125442343343233",FIND(A1,"""123456789,()=MINORFADEOMEN"),1),0)

Find()sẽ tìm giá trị trong ô A1trong chuỗi "123456789,()=MINORFADEOMEN( """lúc đầu là để thoát ký tự và sẽ đánh giá chỉ" ).

Dựa trên kết quả của Find(),Mid() hàm sẽ trả về ký tự tương ứng từ chuỗi số. Chuỗi này được tạo thông qua việc lặp lại cho đến khi nó ngừng thay đổi.

Nếu A1không tìm thấy ký tự , Find()trả về lỗi để IfError()hàm thoát ra để trả về0 .

Phần OMENcuối của chuỗi được tìm kiếm trong Find()hàm là các chữ cái trùng lặp để vị trí của chúng sẽ không bao giờ được trả về nhưng chúng cần thiết để điều chỉnh số lượng ký tự. Không có họ, có một vòng lặp vô tận thay đổi số lượng. Việc sắp xếp thư là sự lựa chọn phong cách.


5

JavaScript (ES6), 70 byte

Không đọc nguồn của hàm, nhưng cái này khá dài. Đưa đầu vào dưới dạng chuỗi 1 ký tự.

i=>~(n='\\34=\'in(|)0257?:.>[]Odefx~'.indexOf(i))?'3733544333'[n]||2:0

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


Bạn có thể rút ngắn bó này bằng cách làm lại một chút để giảm số lượng ký tự riêng biệt: i=>'36335633'[i='\\36=\'i|&()25.>[]Odefx~n'.indexOf(i)]||~i&&2(đã lưu 8 byte)
Yair Rand

5

Võng mạc , 1 byte

Điều này sẽ không hợp lệ nếu tuân thủ nghiêm ngặt các quy tắc quine, nhưng OP rõ ràng cho phép nó trong một bình luận .

x

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

Trong võng mạc, một chương trình một dòng đếm các lần xuất hiện của biểu thức chính đó trong đầu vào. Thách thức này được giải quyết bằng bất kỳ ký tự ASCII đơn trừ `, ., +, *, ?, [, (, ), ^, $, \và xuống dòng.


5

C # (Trình biên dịch Visual C #) , 88 57 byte

x=>"\\\"(())==>>??..::3300CCaaiinoossttx".Contains(x)?3:0

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

Trả về 3 nếu chuỗi chứa char đã qua, nếu không trả về 0. Chuỗi chứa mỗi ký tự của mã ít nhất một lần và chính xác số lượng cần thiết để có char 3 lần trong mã.

-31 byte nhờ Kevin Cruijssen


Cách tiếp cận tốt đẹp! +1 từ tôi. Bạn có thể lưu một số byte bằng cách xóa dấu ngoặc đơn xung quanh (a)=>và lấy đầu vào dưới dạng chuỗi thay vì char để .ToString()không còn cần thiết nữa (và a+""cũng có thể được sử dụng cho các thử thách chơi gôn mã mà bạn không bao giờ cần .ToString()). Ngoài ra, vì .Containsđã chứa một a, bạn có thể biến biến đầu vào thành một ký tự không sử dụng khác nhau (như xhoặc q) để có 3 cho mỗi ký tự thay vì 4. EDIT: Đừng bận tâm đến phần cuối cùng, tôi thấy "bây giờ cũng được sử dụng 4 lần.
Kevin Cruijssen

@KevinCruijssen Cảm ơn lời khuyên. Nhưng chuỗi có hợp lệ làm đầu vào không? Xem xét OP yêu cầu một byte là đầu vào?
Hyarus

Miễn là đó là một chuỗi ký tự đơn, tôi khá chắc chắn. Hầu hết các ngôn ngữ chỉ có thể nhập giá trị chuỗi và một số ngôn ngữ vẫn chọn ký tự là chuỗi (ví dụ như Java, JavaScript và Japt. Các định dạng đầu vào và đầu ra thường khá linh hoạt. Nhưng bạn luôn có thể hỏi OP trong một bình luận nếu bạn vẫn còn nghi ngờ. :)
Kevin Cruijssen

1
@KevinCruijssen nghe có vẻ hợp lý. Và nếu chúng ta thoát khỏi một trong những "chúng ta thậm chí có thể xuống tới mức 3 mong muốn
Hyarus

2
Chuỗi ký tự đơn làm đầu vào là tốt đối với tôi.
Nathaniel

4

Haskell , 66 byte

Hai phiên bản đầu tiên về cơ bản là một quine lọc các ký tự được yêu cầu và sau đó lấy độ dài:

q c=length.filter(==c)$id<>show$"q c=length.filter(==c)$id<>show$"

Hãy thử trực tuyến hoặc thử nghiệm với tất cả các nhân vật! *


Thay thế mà không có (<>), 72 byte

q c=length.filter(==c)$(++)<*>show$"q c=length.filter(==c)$(++)<*>show$"

Hãy thử trực tuyến hoặc thử nghiệm với tất cả các nhân vật!


Không thay thế quine, 87 86 byte

Vẫn có thể được cải thiện, nhưng tôi rất vui vì tôi chỉ nhận được ba nhóm khác nhau.

Tôi thích cái này nhất, mặc dù nó đếm nhiều byte nhất. Nó tính toán số ký tự / byte bằng tổng 2,37 (lưu ý cách một số ký tự trong nhiều nhóm):

u t=sum[fst e|e<-[(2," ()-237<=dflnst|"),(3," ()[\\]`mstu"),(7,"\",ee")],t`elem`snd e]

Hãy thử trực tuyến hoặc thử nghiệm với tất cả các nhân vật!


* nhập (<>)vì phiên bản GHC của TIO là 8.0.2


3

Python 2 , 54 52 32 byte

-20 byte nhờ vào ovs

("''+.23cnotu()"*2+'"*'*3).count

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


1
Tại sao bạn không có lambda hoặc đầu vào?
Stewie Griffin

2
@StewieGriffin Python tự động liên kết một tham chiếu phương thức, do đó "xxx".counttương đương với lambda c:"xxx".count(c).
Neil

@StewieGriffin và bạn sử dụng cả hai theo cùng một cách -> f="xxx".countf=lambda c:"xxx".count(c)sẽ được gọi làf('a')
Rod

3

Chồng , 11 10 8 byte

Cảm ơn Leo vì -2 byte!

#sD"#sD"

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

Giải trình

Điều này đảm bảo rằng nó chỉ sử dụng ASCII (vì showsẽ làm rối tung nó) và mỗi ký tự được chứa hai lần:

#sD"#sD"  -- character as input, eg. '"'
   "#sD"  -- string literal (note the redundant '"'): "#sD"
  D       -- double: "#sD#sD"
 s        -- show: "\"#sD#sD\""
#         -- number of occurences: 2

Phần mở rộng quine chuẩn, 11 byte

#hS+s"#hS+s

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

Giải trình

#hS+s"#hS+s  -- character as input, eg. '"'
     "#hS+s  -- string literal: "#hS+s"
  S+         -- join with itself: ("#hS+s"++)
    s        -- | and itself shown: "\"#hS+s\""
             -- : "#hS+s\"#hS+s\""
 h           -- init: "#hS+s\"#hS+s"
#            -- number of occurences in string: 1

1
Bạn có thể quản lý các trích dẫn dễ dàng hơn bằng cách nhân đôi chuỗi trước khi hiển thị: Hãy thử trực tuyến!
Leo

3

Java 10, 164 81 57 byte

q->"q-->>\\\"..ccoonttaaiiss(())??33::00".contains(q)?3:0

Câu trả lời C # của @Hyarus , vì vậy hãy đảm bảo nâng cao anh ấy!

Giải trình:

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

q->      // Method with String parameter and integer return-type
  "q->\\\"..ccoonttaaiiss(())??33::00".contains(q)?
         //  If the string above contains the input character
   3     //   Return 3
  :      //  Else:
   0     //   Return 0

164-byte câu trả lời:

c->{var s="c->{var s=%c%s%1$c;return s.format(s,34,s).replaceAll(%1$c[^%1$c+c+']',%1$c%1$c).length();}";return s.format(s,34,s).replaceAll("[^"+c+']',"").length();}

Giải trình:

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

c->{                                  // Method with char parameter and integer return-type
  var s="c->{var s=%c%s%1$c;return s.format(s,34,s).replaceAll(%1$c[^%1$c+c+']',%1$c%1$c).length();}";
                                      //  Unformatted source code
  return s.format(s,34,s)             //  Create the formatted source code (the quine),
          .replaceAll("[^"+c+']',"")  //  remove all characters not equal to the input,
          .length();}                 //  and return the length

-part:

  • Chuỗi schứa mã nguồn chưa được định dạng.
  • %sđược sử dụng để nhập Chuỗi này vào chính nó với s.format(...).
  • %c, %1$c34được sử dụng để định dạng dấu nháy kép.
  • s.format(s,34,s) đặt tất cả lại với nhau

Phần thử thách:

  • .replaceAll("[^"+c+']',"") loại bỏ tất cả các ký tự ngoại trừ những ký tự bằng với đầu vào.
  • .length() sau đó lấy độ dài của Chuỗi này.

LƯU Ý: .split(c).length(với Stringđầu vào thay vì char) có vẻ ngắn hơn, nhưng có hai vấn đề:

  1. Ký tự đầu tiên cho kết quả không chính xác, vì vậy nếu c(với c->phần đầu) là đầu vào, nó sẽ trả về không đúng một ký tự quá ít. Điều này có thể được khắc phục bằng cách thêm +(c==99?1:0)vào cả mã nguồn và chuỗi mã nguồn chưa được định dạng (và thay đổi .split(c)thành.split(c+"") , nhưng sau đó chúng ta vẫn gặp vấn đề sau:
  2. Nếu một ký tự regex (nghĩa là $) là đầu vào, thì .splitsẽ hiểu nó là một biểu thức chính quy, đưa ra một kết quả không chính xác.

3

Haskell , 58 byte

f c=sum[2|x<-succ '!':"f c=sum[2|x<-succ '!':,x==c]",x==c]

Hãy thử trực tuyến! hoặc xác minh giải pháp .

Các lựa chọn thay thế đếm byte giống nhau:

f c=sum[2|x<-tail$show"f c=sum[2|x<-tail$show,x==c]",x==c]
f c=sum[1|x<-id<>show$"f c=sum[1|x<-id<>show$,x==c]",x==c]

Haskell , 90 byte

sum.($zip"1234\"$,.[\\]opu+()iklmsz652"$[4,4,11,3,3,3,16,5,3,3,3,3,3,3,3]++[2,2..]).lookup

Hãy thử trực tuyến! hoặc xác minh giải pháp . Sử dụng thực tế rằng sum Nothing = 0và ví dụ sum (Just 4) = 4.


3

Smalltalk , 112 132 byte

Smalltalk không được biết đến chính xác về sự phù hợp chơi gôn của nó :-)

Phương thức được xác định trong lớp Nhân vật (được thử nghiệm trong VA Smalltalk và Squeak, nên hoạt động trong các phương ngữ khác như VisualWorks và Pharo):

a^(0to:6),#(10 18)at:(#('' ',[]^|+68cForu' '#0adefln' '1it' '()' ':s' ' ' '''')findFirst:[:s|s includes:self])+1

Các ký tự xuất hiện trong nguồn được nhóm theo số lần xuất hiện. Các nhóm được kiểm tra cho nhóm đầu tiên chứa máy thu và số lần xuất hiện phù hợp được trả về.

Phương pháp cũ:

a^('''''((((())))):::[[[[]]]]^^^^^0000066666aaaacccccdddddeefffFFFFFiiilllnnnnnrrrrrsssTTTTTuuuu'includes:self)ifTrue:[6]ifFalse:[0]

Mỗi ký tự xuất hiện trong phương thức xuất hiện chính xác 6 lần (bằng cách lặp lại trong hằng chuỗi), vì vậy phương thức chỉ kiểm tra xem máy thu có được chứa trong chuỗi hay không và trả về 6 nếu có, 0 nếu không.

Sau khi xác định phương thức như trên, bạn có thể xác nhận nó bằng cách sử dụng

| code |
code := Character sourceCodeAt: #a.
((0 to: 255) collect: [:b | b asCharacter]) reject: [:c | c a = (code occurrencesOf: c)]

Kết quả nên trống.


1
Chào mừng đến với PPCG!
Martin Ender

2

JavaScript, 31 byte

f=c=>~-`f=${f}`.split(c).length

Dùng thử trực tuyến


1
Tôi nghĩ rằng điều này đọc mã nguồn riêng của nó, phải không? Điều đó rõ ràng bị cấm, in đậm, trong câu hỏi.
Nathaniel

1
@Nathaniel, xem tại đây .
Shaggy

2
Hừm. Thành thật mà nói tôi nghĩ điều đó thật ngu ngốc, nhưng tôi thực sự không thể không đồng ý với sự đồng thuận meta mà tôi cho là.
Nathaniel

1
@Nathaniel Đối với tất cả các chương trình làm cho eval dễ dàng, họ cũng làm cho quine dễ dàng.
dùng202729

1
@ user202729 Tôi không nghĩ như vậy phải không? Bạn không thể thực hiện cùng một mẹo trong Python chẳng hạn. Đây là một eval ngược, không phải là eval
Nathaniel



2

Haskell , 96 byte

n"n"=15;n"="=14;n" "=2;n";"=13;n"\\"=3;n"\""=25;n"0"=2;n"1"=4;n"2"=4;n"3"=4;n"4"=5;n"5"=5;n n3=0

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

Haskell , 109 byte

n 'n'=15;n '='=14;n ' '=14;n ';'=13;n '\\'=3;n '\''=25;n '0'=2;n '1'=5;n '2'=4;n '3'=4;n '4'=5;n '5'=5;n n3=0

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

Haskell , 122 byte

n 'n'=21
n '='=14
n ' '=14
n '\n'=12
n '\\'=4
n '\''=32
n '0'=2
n '1'=5
n '2'=5
n '3'=3
n '4'=5
n '5'=5
n nnnnnn4'''''''=0

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

Giải thích

Những câu trả lời này không quá phức tạp. Đó là một loạt các tuyên bố, một cho mỗi nhân vật có mặt trong chương trình. Cuối cùng, chúng ta có một cái bắt tất cả trả về 0 cho các ký tự không có trong chương trình.

Tôi sử dụng một vài thủ thuật để giảm thiểu số lượng ký tự cần thiết trong chương trình và từ đó tôi loay hoay với mọi thứ cho đến khi các con số trở nên vừa phải. Bạn có thể thấy rằng tôi đã đệm tên biến trong khai báo cuối cùng, trong cả 3 tên này. Sự khác biệt giữa 3 chương trình là liệu tôi đã chọn sử dụng một dòng mới hay ;cho ngắt dòng và liệu tôi đã chọn lấy Chars làm đầu vào hay Chuỗi. Cách ;tiếp cận dường như không vượt trội so với các phương pháp khác, nó chỉ gặp may mắn và kết thúc ngắn hơn, tuy nhiên có vẻ như sử dụng Chuỗi là một ý tưởng tốt hơn Chars vì Chars yêu cầu khoảng trắng sau tên hàm mà String không có.


: | điều gì đã xảy ra với chính tả của bạn trong phần giải thích
ASCII-only

2

Khoảng trắng , 140 byte

[S S S N
_Push_0][S N
S _Duplicate][S N
S _Duplicate][T N
T   S _Read_STDIN_as_character][T   T   T   _Retrieve][S S S T  S S T   N
_Push_9][T  S S T   _Subtract][S N
S _Duplicate][N
T   S S T   N
_If_0_Jump_to_Label_TAB][S S S T    N
_Push_1][T  S S T   _Subtract][S N
S _Duplicate][N
T   S S N
_If_0_Jump_to_Label_NEWLINE][S S S T    S T T   S N
_Push_22][T S S T   _Subtract][N
T   S T N
_If_0_Jump_to_Label_SPACE][N
S T N
_Jump_to_Label_PRINT][N
S S S T N
_Create_Label_TAB][S S S T  S S T   S T N
_Push_37][N
S T N
_Jump_to_Label_PRINT][N
S S S N
_Create_Label_NEWLINE][S S S T  S S S S T   N
_Push_33][N
S T N
_Jump_to_Label_PRINT][N
S S T   N
_Create_Label_SPACE][S S S T    S S S T T   S N
_Push_70][N
S S N
_Create_Label_PRINT][T  N
S T _Print_as_integer]

Chữ cái S(dấu cách), T(tab) và N(dòng mới) được thêm vào dưới dạng chỉ tô sáng.
[..._some_action]chỉ thêm vào giải thích.

70 dấu cách, 37 tab và 33 dòng mới được sử dụng.

Thông thường tôi sử dụng Tạo Labels theo thứ tự NSSN, NSSSN, NSSTN, NSSSSN, NSSSTN, NSSTSN,NSSTTN , vv Nhưng vì in một số nơi nhị phân S=0/ T=1được sử dụng ảnh hưởng đến số tôi cần phải đầu ra, tôi đã sử dụng nhãn NSSN, NSSSN, NSSTN, và NSSSTNthay vào đó, đã mang đến cho số lượng không gian / tab hoàn hảo sẽ được in bằng các số nhị phân SSSTSSSSTN(33; số lượng dòng mới), SSSTSSTSTN(37; số lượng tab) và SSSTSSSTTSN(70; số lượng khoảng trắng).

Giải thích bằng mã giả:

Character c = STDIN-input as character
If c is a tab:
  Print 37
Else if c is a new-line:
  Print 33
Else if c is a space:
  Print 70
Else
  Print 0

Ví dụ chạy:

Đầu vào: không gian

Command       Explanation                   Stack       Heap     STDIN   STDOUT   STDERR

SSSN          Push 0                        [0]
SNS           Duplicate top (0)             [0,0]
SNS           Duplicate top (0)             [0,0,0]
TNTS          Read STDIN as character       [0,0]       {0:32}   \n
TTT           Retrieve                      [0,32]      {0:32}
SSSTSSTN      Push 9                        [0,32,9]    {0:32}
TSST          Subtract top two (32-9)       [0,23]      {0:32}
SNS           Duplicate top (23)            [0,23,23]   {0:32}
NTSSTN        If 0: Jump to Label_TAB       [0,23]      {0:32}
SSSTN         Push 1                        [0,23,1]    {0:32}
TSST          Subtract top two (23-1)       [0,22]      {0:32}
SNS           Duplicate top (22)            [0,22,22]   {0:32}
NTSSN         If 0: Jump to Label_NEWLINE   [0,22]      {0:32}
SSSTSTTSN     Push 22                       [0,22,22]   {0:32}
TSST          Subtract top two (22-22)      [0,0]       {0:32}
NTSTN         If 0: Jump to Label_SPACE     [0]         {0:32}
NSSTN         Create Label_SPACE            [0]         {0:32}
SSSTSSSTTSN   Push 70                       [0,70]      {0:32}
NSTN          Jump to Label_PRINT           [0,70]      {0:32}
NSSN          Create Label_PRINT            [0,70]      {0:32}
TNST          Print as integer              [0]         {0:32}            70
                                                                                  error

Chương trình dừng với một lỗi: Không có lối ra được xác định.
Dùng thử trực tuyến (chỉ có khoảng trắng, tab và dòng mới).

Đầu vào: tab

STDIN sẽ là \t( 9) thay vào đó, trong trường hợp đó nó sẽ 0ở đầu tiênIf 0 kiểm tra , đi đến LABEL_TAB/ NSSSTN, và sẽ đẩy và in37 thay thế.

Dùng thử trực tuyến (chỉ có khoảng trắng, tab và dòng mới).

Đầu vào: dòng mới

STDIN sẽ là \n( 10) thay vào đó, trong trường hợp đó, nó sẽ 0ở lần If 0kiểm tra thứ hai , đi đến Label_NEWLINE/ NSSSN, và sẽ đẩy và in33 thay thế.

Dùng thử trực tuyến (chỉ có khoảng trắng, tab và dòng mới).

Đầu vào: bất cứ điều gì khác

Bất kỳ ký tự đầu vào nào khác cũng sẽ làm NSTN(Chuyển đến Label_PRINT) sau lần If 0kiểm tra thứ ba , in0 vẫn còn trên ngăn xếp (mà chúng tôi đã nhân đôi ngay từ đầu).

Dùng thử trực tuyến (chỉ có khoảng trắng, tab và dòng mới).


1
Đây là một ngôn ngữ tuyệt vời cho thử thách này.
qwr

2

Japt , 27 byte

\Ua"" a a a " ÄU\\\"a "aU Ä
            " ÄU\\\"a "     // Given this string literal,
                       aU   // find the last index of the input
                          Ä // and add +1.
\Ua"" a a a                 // Do nothing useful, but make the results match.

Dài hơn câu trả lời Japt hiện có, nhưng sử dụng một cách tiếp cận khác.
Có giới hạn vốn có mà tất cả các ký tự cần phải xảy ra một số lần duy nhất.

Đưa đầu vào dưới dạng một chuỗi.

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


2

Perl, 130 byte

+print+0+((0)x40,6,6,0,3,43,0,0,0,22,12,6,3,5,2,4,0,1,0,0,0,1,0,1,(0)x28,1,0,1,(0)x6,1,(0)x4,1,(0)x4,1,1,1,0,2,0,1,0,0,0,5)[ord<>]

Không có dòng mới hoặc khoảng trắng khác. Đọc một dòng từ đầu ra tiêu chuẩn, nhưng chỉ quan tâm đến các byte đầu tiên của nó, sau đó in số lần byte đó xảy ra trong mã nguồn của chính nó ở dạng thập phân, không có dòng mới.

Chương trình này rất đơn giản. Hầu hết các mã nguồn được chiếm bởi một bảng bằng chữ đưa ra câu trả lời cho từng byte có thể. Các số 0 được lưu trữ được bỏ qua và các số 0 liền kề được nén theo thời gian chạy, nhưng không có mẹo đặc biệt nào khác. Phần còn lại của chương trình chỉ cần đọc đầu vào và tìm kiếm câu trả lời trong bảng.

Ví dụ, phần 22, 12, 6, 3, 5, 2, 4, 0, 1, 0trong mã nguồn cho tần số của các chữ số, do đó, có 22 số 0, 12 số, 6 twos, v.v. trong mã nguồn. Kết quả là, nếu bạn nhập 0vào đầu vào tiêu chuẩn của chương trình, chương trình sẽ in 22.


2

C (gcc) , 1033 byte

#include <stdio.h>
int main(int argc,char *argv[]){int r=0*14811;switch((int)argv[1][0]){case' ':r=6;break;case'"':r=3;break;case'#':r=2;break;case'%':r=2;break;case'\'':r=101;break;case'(':r=5;break;case')':r=5;break;case'*':r=5*1*1;break;case'.':r=2;break;case':':r=51;break;case';':r=103;break;case'<':r=2;break;case'=':r=52;break;case'>':r=2;break;case'[':r=4;break;case'\\':r=3;break;case']':r=4;break;case'0':r=11;break;case'1':r=20;break;case'2':r=20;break;case'3':r=9;break;case'4':r=7;break;case'5':r=12;break;case'6':r=3;break;case'7':r=2;break;case'8':r=5;break;case'9':r=2;break;case'a':r=106;break;case'b':r=51;break;case'c':r=55;break;case'd':r=4;break;case'e':r=102;break;case'f':r=2;break;case'g':r=4;break;case'h':r=4;break;case'i':r=10;break;case'k':r=51;break;case'l':r=2;break;case'm':r=2;break;case'n':r=8;break;case'o':r=2;break;case'p':r=2;break;case'r':r=108;break;case's':r=53;break;case't':r=8;break;case'u':r=2;break;case'v':r=3;break;case'w':r=2;break;case'{':r=3;break;case'}':r=3;break;}printf("%d",r);}

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

Đây là bởi NO có nghĩa là một câu trả lời được đánh gôn, nhưng thật vui khi cố gắng hoàn thành thử thách này bằng ngôn ngữ mà tôi không quen thuộc. Đó không phải là một thử thách đặc biệt khó khăn cho đến khi tìm thấy sự xuất hiện của các chữ số, bây giờ THAT là một thử thách. Phải làm một chút cân bằng sáng tạo :)


2

C (gcc) , 192 byte

F(J){J=J-70?J-40?J-41?J-74?J-'{'?J-'}'?J-39?J-48?J-49?J-50?J-51?J-52?J-53?J-54?J-55?J-56?J-57?J-47?J-61?J-63?J-45?J-58?J-59?0:1:23:23:23:1:2:3:3:4:4:14:14:10:10:15:6:4:2:2:25:1:1:1;}//84332211

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

Có lẽ có thể để golf xuống hơn nữa. Sử dụng một nhận xét ở cuối là 'khoảng trống' để thêm chữ số. Khi tôi phải thay đổi một chữ số từ X thành Y, tôi thay đổi một trong các chữ Y trong đầu thành chữ X để bù lại. Ngoài ra, đây chỉ là một hàm lấy một số nguyên, sử dụng thủ thuật gán để trả về một giá trị dựa trên một điều kiện ternary lớn.


Tôi có thể lưu 1 byte bằng cách di chuyển hằng số sang số 0 0*84332211như trong câu trả lời C khác, nhưng tôi cũng có thể lưu byte bằng cách tái cấu trúc nó nhỏ hơn, vì vậy tôi sẽ không bận tâm nữa.
LambdaBeta

Bạn có thể lưu byte bằng cách sử dụng kiểm tra phạm vi cho các số ít phổ biến hơn không? đó là nếu chúng ta giả sử 4-9 là các ký tự hiếm, chúng ta có thể xử lý tất cả chúng cùng một lúc bằng một kiểm tra có điều kiện.
qwr

Gần như chắc chắn. Có lẽ chúng ta có thể loại bỏ nhiều hơn bằng cách chọn tên thông minh cho các thứ để các biểu tượng nhất định không bao giờ xuất hiện hoặc để có thể sử dụng các mẫu bit (ví dụ: J&1?để khớp với tất cả các ký tự lẻ). Tôi có thể chơi gôn thêm nếu tôi có thời gian để làm như vậy.
LambdaBeta

2

x86 .COM, 17 byte, gây tranh cãi

0120 BF2001        MOV     DI,0120 (120 be the current address)
0123 B91100        MOV     CX,0011
0126 AE            SCASB
0127 7502          JNZ     012B
0129 FEC4          INC     AH
012B E2F9          LOOP    0126
012D C1E808        SHR     AX,8
0130 C3            RET

36 byte

0100 BF????        MOV     DI,(an copy of this code)
0103 B91200        MOV     CX,0012
0106 AE            SCASB
0107 7503          JNZ     010C
0109 80C402        ADD     AH,02
010C E2F8          LOOP    0106
010E C1E808        SHR     AX,8
0111 C3            RET

2
Đây không phải là đọc mã của riêng nó sao?
Razvan Socol

@RazvanSatio Tôi nghĩ nó giống như giải pháp JavaScript
l4m2

@RazvanSatio tốt, nó không yêu cầu lưu trong một tập tin nên không sao. rất nhiều nấm và JS cũng làm điều này
ASCII

Tôi cho rằng bạn đang đọc mã được thực thi, được tính là "đọc mã nguồn riêng". Bây giờ bạn có thể lập luận rằng có một bản sao chuỗi của chương trình, như hầu hết các giải pháp ở đây làm, cũng là "đọc mã nguồn", nhưng chuỗi không được thực thi.
qwr

1

Japt , 14 byte

Qi"QiUè² " ²èU

Thử nó


Giải trình

                   :Implicit input of character string U
  "QiUè² "         :String literal
Qi                 :Append a quotation mark
           ²       :Repeat twice
            èU     :Count the occurrences of U


1

Thạch , 16 byte

“;⁾w⁸a2”;⁾“”w⁸a2

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

Mỗi nhân vật xuất hiện chính xác hai lần.

“;⁾w⁸a2”;⁾“”w⁸a2
“;⁾w⁸a2”;⁾“”     the string ;⁾w⁸a2“”
            w⁸a2 return 2 if input in string

1

x86, 42 40 byte

Ở đây tôi sử dụng chiến lược giống như các chiến lược khác: Tạo một bản sao chuỗi của chương trình với các byte duy nhất, sau đó trả về 2 alnếu đầu vào alnằm trong chuỗi. Nếu chúng ta cho phép mình đọc mã thực sự đang chạy, chúng ta sẽ có giải pháp của l4m2 .

Tôi đã sử dụng một hướng dẫn chuỗi mát mẻ scasb. Theo hiểu biết tốt nhất của tôi, không có byte trùng lặp, nhưng đây là thứ tôi dễ dàng làm hỏng. Đang tải địa chỉ chuỗi mất 5 byte nhưng tôi không nhận thức được bất kỳ giải pháp ngắn hơn (64-bit leacủa ripvới bù đắp mất 6 byte).

-2 bằng cách nhảy lùi để tránh sử dụng 02hai lần.

.section .text
.globl main
main:
        mov     $0xff, %eax

start:
        push    $20             # program length
        pop     %ecx            # counter
        mov     $str, %edi      # load string

loop:
        scasb                   # if (al == *(edi++))  
        jne     loop1           
        mov     $2, %al         # ret 2
end:    ret             
loop1:
        loop    loop            # do while (--counter)
        xor     %eax, %eax      # ret 0
        jmp     end

str:    .byte 0x6a,0x14,0x59,0xbf,0xf4,0x83,0x04,0x08 
        .byte 0xae,0x75,0x03,0xb0,0x02,0xc3,0xe2,0xf8
        .byte 0x31,0xc0,0xeb,0xf9 

Hexdump (có định dạng tệp nhị phân elf32-i386, vì tệp obj không may có 00byte cho strđịa chỉ):

000003e0  6a 14 59 bf f4 83 04 08  ae 75 03 b0 02 c3 e2 f8  |j.Y......u......|
000003f0  31 c0 eb f9 6a 14 59 bf  f4 83 04 08 ae 75 03 b0  |1...j.Y......u..|
00000400  02 c3 e2 f8 31 c0 eb f9                           |....1...|

x86, 256 byte

Câu trả lời nhàm chán tương đương với một bình luận khổng lồ. Nhập vào cl, ngay lập tức trả về 1 in al. Tôi sẽ trả lời thực tế khi có thời gian rảnh.

00000039  b0 01 c3 00 02 03 04 05  06 07 08 09 0a 0b 0c 0d  |................|
00000049  0e 0f 10 11 12 13 14 15  16 17 18 19 1a 1b 1c 1d  |................|
00000059  1e 1f 20 21 22 23 24 25  26 27 28 29 2a 2b 2c 2d  |.. !"#$%&'()*+,-|
00000069  2e 2f 30 31 32 33 34 35  36 37 38 39 3a 3b 3c 3d  |./0123456789:;<=|
00000079  3e 3f 40 41 42 43 44 45  46 47 48 49 4a 4b 4c 4d  |>?@ABCDEFGHIJKLM|
00000089  4e 4f 50 51 52 53 54 55  56 57 58 59 5a 5b 5c 5d  |NOPQRSTUVWXYZ[\]|
00000099  5e 5f 60 61 62 63 64 65  66 67 68 69 6a 6b 6c 6d  |^_`abcdefghijklm|
000000a9  6e 6f 70 71 72 73 74 75  76 77 78 79 7a 7b 7c 7d  |nopqrstuvwxyz{|}|
000000b9  7e 7f 80 81 82 83 84 85  86 87 88 89 8a 8b 8c 8d  |~...............|
000000c9  8e 8f 90 91 92 93 94 95  96 97 98 99 9a 9b 9c 9d  |................|
000000d9  9e 9f a0 a1 a2 a3 a4 a5  a6 a7 a8 a9 aa ab ac ad  |................|
000000e9  ae af b1 b2 b3 b4 b5 b6  b7 b8 b9 ba bb bc bd be  |................|
000000f9  bf c0 c1 c2 c4 c5 c6 c7  c8 c9 ca cb cc cd ce cf  |................|
00000109  d0 d1 d2 d3 d4 d5 d6 d7  d8 d9 da db dc dd de df  |................|
00000119  e0 e1 e2 e3 e4 e5 e6 e7  e8 e9 ea eb ec ed ee ef  |................|
00000129  f0 f1 f2 f3 f4 f5 f6 f7  f8 f9 fa fb fc fd fe ff  |................|

1

APL (Dyalog Classic) , 30 byte

⊢⊢⊢11-11-11-'''''''1''⊢-⍳⍳0'⍳⊢

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

Giải trình

Trong APL, các trích dẫn đơn trong chuỗi được thoát bằng cách nhân đôi, '''''''1''⊢-⍳⍳0'chuỗi cũng vậy'''1'⊢-⍳⍳0 cũng chứa mọi ký tự được sử dụng trong chương trình.

Các mảng APL theo mặc định là 1 chỉ mục và hàm chỉ mục của hàm, thật thú vị, trả về 1 + max index nếu không tìm thấy phần tử.

Vì vậy, bằng cách sử dụng index-of trên chuỗi và trả về đầu vào

Input    Index    Count
'        1        10
1        4        7
⊢        6        5
-        7        4
⍳        8        3
0        10       1
<other>  11       0

Như người ta có thể thấy, 11 - indexđưa ra số lượng nhân vật trong chương trình. Vì vậy, thuật toán cơ bản là

11-'''''''1''⊢-⍳⍳0'⍳⊢

Phần còn lại là làm đầy số lượng nhân vật để cho phép chúng vừa khít với các khe.


1

R , 135 byte

Lấy cảm hứng từ câu trả lời Python này .

Các phiên bản trước đã bị hỏng. Nhờ @Giuseppe đã chỉ ra rằng pastekhông cần nó lưu lại 18 byte hoặc lâu hơn. lengths(regmatches(z,gregexpr(x,z)))là từ câu trả lời này .

function(x,z=rep(c("afilo2679=:","hmpu15'","nstxz","cgr","e","()",'"',","),c(2:5,7,9,15,16)))sum(lengths(regmatches(z,gregexpr(x,z))))

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



0

Ruby, 48 byte

->x{%q[->x{%q[].count(x.chr)*2}].count(x.chr)*2}

%q[str]là một cách thuận tiện hơn để viết một chuỗi theo nghĩa đen hơn "str"bởi vì nó có thể được lồng bên trong chính nó mà không có bất kỳ thoát. Vì vậy, tôi chỉ cần đặt toàn bộ mã ngoại trừ bản sao bên trong nó, sau đó tăng gấp đôi số lượng.


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.