Sử dụng ngôn ngữ bạn chọn, viết một hàm có số lượng đối số thay đổi và trả về số lượng đối số mà nó được gọi.

Cụ thể:

• Ngôn ngữ của bạn cần hỗ trợ các hàm đối số dao động: một cái gì đó có thể gọi được có số lượng đối số tùy ý và trả về một giá trị.
• Các thông số phải có thể được thông qua cá nhân. Điều này có nghĩa là việc truyền một mảng sẽ chỉ được tính cho một tham số. Bạn có thể sử dụng một mảng "tất cả các đối số được thông qua" nếu ngôn ngữ của bạn hỗ trợ nó; hạn chế là cách gọi hàm.
• Mã gọi hàm này không được yêu cầu để vượt qua số lượng đối số trong nguồn của nó . Nếu một trình biên dịch chèn số lượng đối số như là một phần của quy ước gọi, điều đó được cho phép.
• Các đối số có thể là bất kỳ loại bạn muốn. Bạn chỉ có thể hỗ trợ một loại duy nhất (ví dụ: chỉ hỗ trợ intvẫn hợp lệ), các loại tùy ý (bất kỳ loại đối số nào được cho phép) hoặc bất kỳ kết hợp nào của các loại đối số (ví dụ: đối số đầu tiên là int, phần còn lại là chuỗi).
• Hàm của bạn có thể có số lượng đối số tối đa (đặc biệt là vì tài nguyên là hữu hạn), nhưng phải hỗ trợ ít nhất 2 đối số.

Mẫu:

• f() trả lại 0
• f(1)hoặc f("a")trả lại1
• f([1, 2, 3])trả về 1vì nó được truyền vào một mảng, không phải 3 đối số
• f(1, 10)hoặc f(1, "a")trả lại2

Vì đây là môn đánh gôn, giải pháp chiến thắng là giải pháp sử dụng số byte ít nhất.

Cuộc gọi nhị phân Amstrad CPC Z80 từ BASIC, 1 byte, hex được mã hóa

C9          : RET

(Ngoài ra phiên bản 2 và 5 byte, xem bên dưới)

Khi vào cuộc gọi, số lượng tham số được truyền sẽ nằm trong thanh Aghi. Mã chỉ đơn giản là trả về ngay lập tức. Không có khái niệm về giá trị trả về trong Z80, chỉ có trạng thái nhập và thoát. Giá trị chỉ là "có" có thể truy cập được trong thanh ghi vì mã thay đổi không có điều kiện đầu vào, ngoại trừ PC(bộ đếm chương trình) và SP(con trỏ ngăn xếp). Tuy nhiên, giá trị trong ABASIC không thể truy cập được và bị ghi đè gần như ngay lập tức.

Ví dụ:

CALL &8000, "Hello", "World"

A = 2

CALL &8000, 42

A = 1

CALL &8000

A = 0

Theo yêu cầu, đây là một số mã làm cho giá trị có thể truy cập được trong BASIC. Tôi đã rất ngạc nhiên khi thấy nó có thể được thực hiện chỉ trong 5 byte!:

Mã máy:

12          : LD   (DE), A
13          : INC  DE
AF          : XOR  A
12          : LD   (DE), A
C9          : RET

Khi nhập cảnh:

• AF - các thanh ghi tích lũy và cờ (được coi là hai thanh ghi 8 bit)
  • A chứa số lượng tham số được truyền, tối đa 32 tham số
  • Tôi không chắc những gì trong F. Dường như có tất cả các cờ RESET 0, ngoại trừ hai cờ không xác định là cả hai 1. Các Zlá cờ (zero) là SET để 1nếu không có các thông số thông qua năm
• BC
  • B- 32 trừ đi số lượng tham số ( A+ B= 32)
  • C - &FF
• DE - Địa chỉ của tham số cuối hoặc địa chỉ gọi nếu không có tham số nào được truyền vào
• HL - Địa chỉ của byte đầu tiên sau lệnh BASIC được mã hóa hiện đang được thực thi (dưới dạng chương trình hoặc ở chế độ lệnh ngay lập tức)
• IX - Địa chỉ ngăn xếp của con trỏ đến tham số cuối cùng
• IY - &0000

Mật mã

1. Loa Ds địa chỉ được chỉ đến bởi DEgiá trị trongA
2. INCkhẩu vị DE
3. XORs A(với A), cho&00
4. Loa Ds giá trị trong Ađịa chỉ được chỉ bởiDE
5. RETbình

Khi thoát:

• Abị phá hủy (nó luôn luôn &00)
• DE bị phá hủy (nó luôn luôn cao hơn so với khi nhập cảnh)
• Tất cả các thanh ghi khác được bảo quản

Cơ bản

Amstrad cơ bản chỉ có ba loại dữ liệu, cộng với các mảng đơn giản. Theo mặc định, tất cả các biến BASIC là REAL (đã ký, mantissa 32 bit, số mũ 8 bit), có thể được làm rõ ràng với !. Đối với việc sử dụng INTEGER (đã ký, 16 bit) %và cho STRING (độ dài chuỗi 1 byte, tối đa 255 byte dữ liệu ký tự, an toàn nhị phân) sử dụng $:

• x - THỰC SỰ (ngầm)
• x! - THẬT (rõ ràng)
• x% - TỔNG HỢP
• x$ - CHUỖI

Bạn cũng có thể sử dụng DEFINT, DEFREALvà DEFSTRvới một lá thư duy nhất, hoặc một loạt các hai chữ duy nhất để xác định loại mặc định cho tất cả các biến bắt đầu bằng chữ đó, tương tự như FORTRAN.

• DEFSTR a
• DEFINT x-z

Hiện nay:

• a - CHUINGI (ngầm)
• i - THỰC SỰ (ngầm)
• x - INTEGER (ẩn)
• x$ - CHUINGI (rõ ràng)

Loại dễ nhất để làm việc là số nguyên. Mã máy hy vọng tham số cuối cùng được truyền theo địa chỉ, không phải giá trị, đó là lý do tại sao @tiền tố của biến. Biến trả về được tính là một trong các CALLtham số s.

Mã máy được gọi như sau từ BASIC (giả sử nó được tải vào bộ nhớ tại địa chỉ &8000):

CALL &8000, "Hello", "World", 42, @n%

n% = 4

Điều này sẽ luôn cho kết quả chính xác, bất kể giá trị ban đầu là n%.

Đối với phiên bản 2 byte bảo tồn tất cả các thanh ghi đầu vào:

CALL &8003, "Hello", "World", 42, @n%

n% = 4

Điều này bỏ qua ba byte đầu tiên và chỉ cho kết quả chính xác nếu giá trị ban đầu n%là 0- 255. Điều này hoạt động vì Z80 là ít endian.

Tham số trả về phải được khởi tạo trước khi được thông qua, nếu không BASIC sẽ đưa ra Improper argumentlỗi. Trong hình ảnh bên dưới, tôi đang in (với phím tắt ?vì tôi cũng đã trình diễn bản trình diễn!) Các giá trị trả về ngay trước và sau lệnh gọi để hiển thị giá trị thay đổi. Tôi đang sử dụng giá trị &FFFFvì đó là biểu diễn nhị phân của -1một số nguyên đã ký. Điều này chứng tỏ rằng chương trình 5 byte ghi chính xác cả hai byte, trong khi chương trình 2 byte chỉ ghi byte thấp và giả sử rằng byte cao đã có sẵn &00.

Java (JDK 10) , 11 byte

a->a.length

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

JavaScript, 15 byte

[].push.bind(0)

Các Array.prototype.pushchức năng phải mất bất kỳ số lượng đối số, thêm chúng vào mảng của nó, và trả về kích thước của mảng. Do đó, pushhàm được sử dụng trên một mảng trống trả về số lượng đối số được cung cấp cho push.

f = [].push.bind(0)

f(10,2,65,7)
> 4

f()
> 0

Đơn .bind(0)giản chỉ cần cung cấp cho pushhàm một thisgiá trị cố định để nó có thể được lưu trữ trong một biến. Trong thực tế, định danh 7 byte [].pushcó thể được sử dụng theo nghĩa đen (nhưng không được chỉ định) mà không có bind:

[].push(10,2,65,7)
> 4

[].push()
> 0

JavaScript (ES6), 16 byte

(...a)=>a.length

f=
(...a)=>a.length

console.log(f())
console.log(f(1))
console.log(f(1,2))
console.log(f(1,2,3))
console.log(f(1,2,3,4))

Haskell , 108 107 95 94 byte

class T r where z::Int->r
instance T Int where z=id
instance T r=>T(a->r)where z n _=z$n+1
z 0

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

Điều này thật khó để làm việc một cách đáng ngạc nhiên, nhưng tôi đã rất vui khi cố gắng tìm ra cách thực hiện một cái gì đó tầm thường trong các ngôn ngữ mệnh lệnh.

Python 3 , 15 byte

lambda*a:len(a)

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

Zsh , 7 5 byte

<<<$#

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

Brain-Flak , 6 byte

Giải pháp Brain-Flak đầu tiên của tôi đáng đăng, tôi đoán đó là công cụ phù hợp cho công việc này:

([]<>)

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

Giải trình

Khi thực hiện chương trình Brain-Flak, ban đầu ngăn xếp bên trái chứa tất cả các đối số. Từ đó đơn giản chỉ là vấn đề:

(      -- push the following..
 []    --   height of the stack (ie. # of arguments)
   <>  -- ..to the other stack  (toggles to the other stack)
)      --
       -- the right stack now contains the # of arguments which
       -- gets printed implicitly

Ngôn ngữ Wolfram (Mathicala) , 11 byte

Tr[1^{##}]&

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

Được đề xuất bởi JungHwan Min. Một số hạn chế (đầu vào phải là hình chữ nhật) nhưng chúng tôi không bắt buộc phải xử lý đầu vào tùy ý.

11 byte

Length@!##&

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

Một giải pháp 11 byte khác được đề xuất bởi Martin Ender. Điều này có vẻ như lỗi khi không có một đầu vào nhưng nó vẫn trả về giá trị chính xác trong mọi trường hợp.

12 byte

Length@{##}&

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

Giải pháp ban đầu của tôi.

Trong Mathicala ##là viết tắt của một số lượng đối số dao động trong một hàm. {và }kết thúc chúng trong một danh sách và Length@lấy độ dài của danh sách này. &ở cuối biến điều này thành một chức năng thực tế.

R , 30 byte

function(...)length(list(...))

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

Bash, 12 byte (nhờ paxdiablo để lưu 4)

n()(echo $#)

Sao chép và dán tại một dấu nhắc bash. Sau đó chạy hàm n từ dấu nhắc:

$ n
0
$ n 46 gr 3443 dad
4
$ n 4fwj23 wrw jdwj 00998 34 eyt q3 vg wq j qw
11

C ++ 14 (gcc) , 34 byte

Là hàm lambda chung (yêu cầu C ++ 14):

[](auto...p){return sizeof...(p);}

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

Câu trả lời trước (không chính xác): 32 byte

Nó đã thiếu template<class...T>và(p)

int f(T...p){return sizeof...p;}

Ruby , 12 byte

->*a{a.size}

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

*alà một biểu tượng của các đối số, làm cho atiêu thụ tất cả các đối số được truyền cho Proc. a.sizecó được kích thước của nó.

Octave , 9 byte

@()nargin

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

Hàm ẩn danh nhận bất kỳ số lượng đối số nào (và âm thầm loại bỏ lô) và xuất ra số lượng đối số thông qua tích hợp nargin. Điều này không hoạt động trong MATLAB, nơi bạn sẽ cần varargincho phép nhiều đối số tùy ý.

Perl 6 , 5 byte

Cảm ơn @Joshua cho -5 byte

{+@_}

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

Perl 5 , 9 byte

sub{~~@_}

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

PHP, 34 byte

function(...$a){return count($a);}

C # .NET, 11 byte

a=>a.Length

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

Giải trình:

Trong C # .NET objectđược sử dụng cho các đối số nhiều loại, cho phép một người vượt qua các số nguyên, chuỗi, ký tự, v.v. như các đầu vào có thể. Ví dụ:

// Can be called like: `F(2)`, `F("test")`, `F('a')`, etc.
void F(object arg){ ... }

C # .NET cũng có thể có kích thước cố định của các đối số tùy chọn. Ví dụ:

// Can be called like: `F()`, `F(2)`, `F("test")`, `F('a')`, etc.
void F(object arg = null){ ... }

Và cũng có các biến thể, đó là số lượng đối số tùy chọn không xác định (đó là những gì tôi đã sử dụng trong câu trả lời này). Ví dụ:

// Can be called like: `F()`, `F(2)`, `F(2, "test", 'a')`, etc.
void F(params object[] args){ ... }

Thông thường lambdas được tạo ra như thế này:

System.Func<object[], int> F f = a=>a.Length;
// A call like `f(new object[]{2, "test", 'a'))` will return 3 (size of the input array)

Nhưng thật không may System.Func, không hỗ trợ paramsvarargs, vì vậy tôi sẽ phải tạo một delegatethay thế:

delegate int F(params object[] args);
F f = a=>a.Length;
// A call like `f()` will return 0, and `f(2, "test", 'a')` will return 3

Đó là câu trả lời của tôi cho thử thách này và có thể được tìm thấy trong mã kiểm tra TIO được liên kết.

Hạn chế duy nhất là việc nhập một lượt object[]thích thực tế f(new object[]{1,2,3})sẽ dẫn đến 3 thay vì 1. f(new int[]{1,2,3})vẫn sẽ dẫn đến 1, vì nó diễn giải thành int[]một object. Để có object[]tham số được diễn giải thành một đối tượng duy nhất, nó có thể được truyền tới một đối tượng như thế này : f((object)new object[]{1,2,3}).

Dodos , 32 31 byte

f
	dot i f dab
i
	
	dip dot dab

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

Sử dụng chức năng tăng của Dennis.

Giải trình

f                     # definition of f - target function
        dot i f dab   # sum of j(f(all args but first)). recurses until it has 0 args
i                     # definition of i - returns (arg, 1) given 1 arg
                      # arg
        dip dot dab   # 1 (dot dab on list of length 1 returns 0, dip returns |0 - 1|)

Ngoài ra, 32 byte không có đệ quy trong hàm mục tiêu (cảm ơn @Leo )

	dot i
i
	dip dot dab dot
	i dab

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

Giải trình

        dot i             # anonymous function: sum of i(args)
                          # here this becomes implicit main
i                         # definition of i - returns a list with all arguments replaced with 1
        dip dot dab dot   # 1 (dab dot returns empty list, dot returns 0, dip returns |0 - 1|
        i dab             # list concatenated with i(all args but first)

C ++, 72 byte

int f(){return 0;}template<class...P>int f(int,P...p){return f(p...)+1;}

Lưu byte bằng cách chỉ làm việc với ints.

Rust, 57 byte

macro_rules!f{()=>{0};($($x:expr),+)=>{[$($x),+].len()};}

Giải trình:

macro_rules! f {         // define a macro called f
    () => {0};           // when called without arguments, expand to 0
    ($($x:expr),+) => {  // when called with 1 or more comma seperated arguments
        [                // rust uses [a, b, c] to make an array
            $($x),+      // expand to the arguments seperated with a comma
        ]                
        .len()           // take the length of that.
    };
}

Kiểm tra:

fn main() {
    println!("{:?}", f!());                // prints 0
    println!("{:?}", f!(4));               // prints 1
    println!("{:?}", f!(5, 2));            // prints 2
    // works with anything, as long as you dont mix things
    println!("{}", f!("", "a", "hello"));  // prints 3
}

PHP, 35 byte

function(){return func_num_args();}

bài hướng dẫn

Lisp thông thường , 28 byte

(defun f(&rest a)(length a))

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

Thêm ++ , 3 byte

L,L

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

PHP, 11 byte

<?=$argc-1;

Dùng thử trực tuyến: 1 đầu vào | 3 đầu vào

Hàng loạt, 50 49 byte

set n=0
for %%a in (%*)do set/an+=1
exit/b%n%

Không có nội dung trong Batch, vì vậy chúng tôi phải đi học cũ. Đã lưu 1 byte nhờ @IsmaelMiguel. Đầu ra thông qua mã thoát hoặc lưu 3 byte nếu đầu ra qua biến toàn cục là hợp lệ. Ví dụ về việc sử dụng trong một chương trình đầy đủ:

@echo off
call:c %*
echo %ERRORLEVEL%
exit/b
:c
set n=0
for %%a in (%*)do set/an+=1
exit/b%n%

Chức năng mã máy x86 32 bit (i386), 13 byte

Quy ước gọi: i386 System V (stack args), với con trỏ NULL là sentinel / terminator cho danh sách end-of-arg-list . (Clobbers EDI, nếu không thì tuân thủ SysV).

C (và asm) không chuyển thông tin loại cho các hàm matrixdic, do đó, mô tả của OP về việc truyền các số nguyên hoặc mảng không có thông tin loại rõ ràng chỉ có thể được thực hiện trong một quy ước truyền một số loại đối tượng struct / class (hoặc con trỏ tới ), không phải số nguyên trần trên ngăn xếp. Vì vậy, tôi quyết định giả định rằng tất cả các đối số đều là con trỏ không phải NULL và người gọi vượt qua một đầu cuối NULL.

Một danh sách con trỏ kết thúc bằng NULL thực sự được sử dụng trong C cho các hàm như POSIXexecl(3) : int execl(const char *path, const char *arg, ... /* (char *) NULL */);

C không cho phép các int foo(...);nguyên mẫu không có đối số cố định, nhưng int foo();có nghĩa tương tự: args không xác định. (Không giống như trong C ++ có nghĩa là gì int foo(void)). Trong mọi trường hợp, đây là một câu trả lời asm. Việc dỗ một trình biên dịch C để gọi hàm này trực tiếp là thú vị nhưng không bắt buộc.

nasm -felf32 -l/dev/stdout arg-count.asm với một số dòng bình luận loại bỏ.

24                       global argcount_pointer_loop
25                       argcount_pointer_loop:
26                               .entry:
28 00000000 31C0             xor   eax, eax  ; search pattern = NULL
29 00000002 99               cdq             ; counter = 0
30 00000003 89E7             mov   edi, esp
31                       ;    scasd           ; edi+=4; skip retaddr
32                       .scan_args:
33 00000005 42               inc   edx
34 00000006 AF               scasd            ; cmp eax,[edi] / edi+=4
35 00000007 75FC             jne  .scan_args
36                       ;    dec   edx       ; correct for overshoot: don't count terminator
37                       ;    xchg  eax,edx
38 00000009 8D42FE           lea   eax, [edx-2]    ; terminator + ret addr
40 0000000C C3               ret

size = 0D               db $ - .entry

Câu hỏi cho thấy hàm phải có thể trả về 0 và tôi quyết định làm theo yêu cầu đó bằng cách không bao gồm con trỏ NULL kết thúc trong số đếm arg. Điều này không tốn 1 byte, mặc dù. (Đối với phiên bản 12 byte, hãy loại bỏ LEA và bỏ ghi chú scasdbên ngoài vòng lặp và xchg, nhưng không phảidec edx . Tôi đã sử dụng LEA vì chi phí giống như ba hướng dẫn khác được đặt cùng nhau, nhưng hiệu quả hơn, do đó chức năng sẽ ít hơn ôi.)

Người gọi C để thử nghiệm :

Được xây dựng với:

nasm -felf32 -l /dev/stdout arg-count.asm | cut -b -28,$((28+12))- &&
 gcc -Wall -O3 -g -std=gnu11 -m32 -fcall-used-edi arg-count.c arg-count.o -o ac &&
 ./ac

-fcall-used-ediđược yêu cầu ngay cả ở -O0 để nói với gcc giả sử rằng các hàm edibị khóa mà không lưu / khôi phục nó, bởi vì tôi đã sử dụng rất nhiều cuộc gọi trong một câu lệnh C ( printfcuộc gọi) thậm chí -O0đang sử dụng EDI. Dường như an toàn cho gcc mainđể chặn EDI từ người gọi của chính nó (bằng mã CRT), trên Linux với glibc, nhưng nếu không thì nó hoàn toàn không có thật để trộn / kết hợp mã được biên dịch với khác nhau -fcall-used-reg. Không có __attribute__phiên bản nào của nó để cho phép chúng ta khai báo các hàm asm với các quy ước gọi tùy chỉnh khác với thông thường.

#include <stdio.h>

int argcount_rep_scas();       // not (...): ISO C requires at least one fixed arg
int argcount_pointer_loop();   // if you declare args at all
int argcount_loopne();

#define TEST(...) printf("count=%d = %d = %d   (scasd/jne) | (rep scas) | (scas/loopne)\n", \
        argcount_pointer_loop(__VA_ARGS__), argcount_rep_scas(__VA_ARGS__), \
        argcount_loopne(__VA_ARGS__))

int main(void) {
    TEST("abc", 0);
    TEST(1, 1, 1, 1, 1, 1, 1, 0);
    TEST(0);
}

Hai phiên bản khác cũng có 13 byte: phiên bản này dựa trên loopnetrả về giá trị quá cao bằng 1.

45                       global argcount_loopne
46                       argcount_loopne:
47                           .entry:
49 00000010 31C0             xor   eax, eax  ; search pattern = NULL
50 00000012 31C9             xor   ecx, ecx  ; counter = 0
51 00000014 89E7             mov   edi, esp
52 00000016 AF               scasd           ; edi+=4; skip retaddr
53                       .scan_args:
54 00000017 AF               scasd
55 00000018 E0FD             loopne  .scan_args
56 0000001A 29C8             sub   eax, ecx
58 0000001C C3               ret

size = 0D = 13 bytes               db $ - .entry

Phiên bản này sử dụng rep scasd thay vì vòng lặp, nhưng lấy số đếm modulo 256. (Hoặc giới hạn ở mức 256 nếu các byte trên ecxlà 0 khi nhập!)

63                       ; return int8_t maybe?
64                       global argcount_rep_scas
65                       argcount_rep_scas:
66                               .entry:
67 00000020 31C0             xor   eax, eax
68                           ;    lea   ecx, [eax-1]
69 00000022 B1FF             mov   cl, -1
70 00000024 89E7             mov   edi, esp
71                       ;    scasd              ; skip retaddr
72 00000026 F2AF             repne scasd        ; ecx = -len - 2 (including retaddr)
73 00000028 B0FD             mov   al, -3
74 0000002A 28C8             sub   al, cl       ; eax = -3 +len + 2
75                       ;    dec   eax
76                       ;    dec   eax
77 0000002C C3               ret

size =  0D = 13 bytes         db $ - .entry

Thật thú vị, nhưng một phiên bản khác dựa trên inc eax/ pop edx/ test edx,edx/ jnzxuất hiện ở mức 13 byte. Đó là một quy ước callee-pop, không bao giờ được sử dụng bởi các triển khai C cho các hàm biến đổi. (Tôi đã đưa addr retr vào ecx và jmp ecx thay vì ret. (Hoặc đẩy / ret để không phá vỡ ngăn xếp dự báo địa chỉ trả về).

R , 20 byte

function(...)nargs()

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

R có một chức năng chỉ cho điều đó .

JavaScript, 35 byte

f=
function(){return arguments.length}

console.log(f(2,5,4))

Súp lơ , 16 byte

(\((@a))(len@a))

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