Java (JDK 10), 11 bytes

a->a.length 

Try it online!

JavaScript, 15 bytes

[].push.bind(0) 

The Array.prototype.push function takes any number of arguments, adds them to its array, and returns the size of the array. Therefore, the push function used on an empty array returns the number of arguments supplied to push.

f = [].push.bind(0) f(10,2,65,7) > 4 f() > 0 

The .bind(0) simply gives the push function a fixed this value so that it can be stored in a variable. In fact, the 7-byte identifier [].push can be used literally (but not assigned) without bind:

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

JavaScript (ES6), 16 bytes

(...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 bytes

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 

Try it online!

This was surprisingly hard to get working, but I had fun trying to find out how to implement something that's trivial in imperative languages.

Python 3, 15 bytes

lambda*a:len(a) 

Try it online!

Zsh, 7 5 bytes

<<<$# 

Try it online!

Brain-Flak, 6 bytes

My first Brain-Flak solution worthy posting, I guess it's the right tool for this job:

([]<>) 

Try it online!

Explanation

When executing a Brain-Flak program, initially the left stack contains all arguments. From there it's simply a matter of:

( -- 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 

Wolfram Language (Mathematica), 11 bytes

Tr[1^{##}]& 

Try it online!

Suggested by JungHwan Min. Some restrictions (input must be rectangular) but we are not required to handle arbitrary input.

11 bytes

Length@!##& 

Try it online!

Another 11 byte solution suggested by Martin Ender. This seems to error when there isn't one input but it still returns the correct value in all cases.

12 bytes

Length@{##}& 

Try it online!

My original solution.

In Mathematica ## stands for a variadic number of arguments in a function. { and } wraps them in a list and Length@ takes the length of this list. & at the end turns this into an actual function.

R, 30 bytes

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

Try it online!

Bash, 12 bytes (thanks to paxdiablo for saving 4)

n()(echo $#) 

Copy and paste at a bash prompt. Then run the n function from the prompt:

$ 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 bytes

As generic variadic lambda function (C++14 required):

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

Try it online!

Previous (incorrect) answer: 32 bytes

It was missing the template<class...T> and (p)

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

Octave, 9 bytes

@()nargin 

Try it online!

Anonymous function taking any number of arguments (and silently discarding the lot), and outputs the number of arguments through the built-in nargin. This does not work in MATLAB, where you would need varargin to allow for arbitrary many arguments.

Ruby, 12 bytes

->*a{a.size} 

Try it online!

*a is a splat of the arguments, making a consume all arguments passed to the Proc. a.size obtains its size.

Perl 6, 5 bytes

Thanks @Joshua for -5 bytes

{+@_} 

Try it online!

C++, 72 bytes

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

Saves bytes by only working with ints.

Perl 5, 9 bytes

sub{~~@_} 

Try it online!

PHP, 34 bytes

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

C# .NET, 11 bytes

a=>a.Length 

Try it online.

Explanation:

In C# .NET object is used for multi-type arguments, allowing one to pass integers, strings, characters, etc. as possible inputs. For example:

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

C# .NET can also have a fixed size of optional arguments. For example:

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

And there are also varargs, which is an undefined amount of optional arguments (which is what I've used in this answer). For example:

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

Usually lambdas are created like this:

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) 

But unfortunately System.Func doesn't support params varargs, so I'll have to create a delegate instead:

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 

Which is my answer for this challenge, and can be found in the linked TIO test code.

The only limitation is that inputting an actual object[] like f(new object[]{1,2,3}) will result in 3 instead of 1. f(new int[]{1,2,3}) will still result in 1, because it interprets the int[] as a single object. To have the object[] parameter be interpret as a single object as well it can be casted to an object like this: f((object)new object[]{1,2,3}).

Dodos, 32 31 bytes

f 	dot i f dab i 	 	dip dot dab 

Try it online!

Uses Dennis' increment function.

Explanation

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|) 

Alternatively, 32 bytes without recursion in target function (thanks @Leo)

	dot i i 	dip dot dab dot 	i dab

Try it online!

Explanation

 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) 

Rust, 57 bytes

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

Explanation:

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. }; } 

Test:

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 } 

R, 20 bytes

function(...)nargs() 

Try it online!

R has a function just for that.

PHP, 35 bytes

function(){return func_num_args();} 

manual entry

Common Lisp, 28 bytes

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

Try it online!

Add++, 3 bytes

L,L 

Try it online!

PHP, 11 bytes

<?=$argc-1; 

Try it online: 1 input | 3 inputs

PowerShell 3, 25 bytes

function a(){$args.Count} 

Usage:

a 1 2 ... 

Console output for "a 1 2 3"

PS: C:\> a 1 2 3 3 

Pretty self explanatory. Powershell stores all unspecified args in the $args list, so we just grab a count of it. Since the language implicitly writes values to the console, the act of finding the count will print to the console without needing a Write-Host or Write-Output.

Edit: Mistyped; should have been 25 bytes (typed 35).

Batch, 50 49 bytes

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

No builtin in Batch, so we have to go old-school. Saved 1 byte thanks to @IsmaelMiguel. Outputs via exit code, or save 3 bytes if output via global variable is valid. Example of use in a full program:

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

x86 32-bit (i386) machine code function, 13 bytes

Calling convention: i386 System V (stack args), with a NULL pointer as a sentinel / terminator for the end-of-arg-list. (Clobbers EDI, otherwise complies with SysV).

C (and asm) don't pass type info to variadic functions, so the OP's description of passing integers or arrays with no explicit type info could only be implemented in a convention that passed some kind of struct / class object (or pointers to such), not bare integers on the stack. So I decided to assume that all the args were non-NULL pointers, and the caller passes a NULL terminator.

A NULL-terminated pointer list of args is actually used in C for functions like POSIX execl(3): int execl(const char *path, const char *arg, ... /* (char *) NULL */);

C doesn't allow int foo(...); prototypes with no fixed arg, but int foo(); means the same thing: args unspecified. (Unlike in C++ where it means int foo(void)). In any case, this is an asm answer. Coaxing a C compiler to call this function directly is interesting but not required.

nasm -felf32 -l/dev/stdout arg-count.asm with some comment lines removed.

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 

The question shows that the function must be able to return 0, and I decided to follow that requirement by not including the terminating NULL pointer in the arg count. This does cost 1 byte, though. (For the 12-byte version, remove the LEA and uncomment the scasd outside the loop and the xchg, but not the dec edx. I used LEA because it costs the same as those other three instructions put together, but is more efficient, so the function is fewer uops.)

C caller for testing:

Built with:

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 is required even at -O0 to tell gcc to assume that functions clobber edi without saving/restoring it, because I used so many calls in one C statement (the printf call) that even -O0 was using EDI. It appears to be safe for gcc's main to clobber EDI from its own caller (in CRT code), on Linux with glibc, but otherwise it's totally bogus to mix/match code compiled with different -fcall-used-reg. There's no __attribute__ version of it to let us declare the asm functions with custom calling conventions different from the usual.

#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); } 

Two other versions also came in at 13 bytes: this one based on loopne returns a value that's too high by 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 

This version uses rep scasd instead of a loop, but takes the arg count modulo 256. (Or capped at 256 if the upper bytes of ecx are 0 on entry!)

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 

Amusingly, yet another version based on inc eax / pop edx / test edx,edx / jnz came in at 13 bytes. It's a callee-pops convention, which is never used by C implementations for variadic functions. (I popped the ret addr into ecx, and jmp ecx instead of ret. (Or push/ret to not break the return-address predictor stack).

Go, 44 30 28 bytes

-2 bytes thanks to BMO

My first code golf attempt.

func(a...int){print(len(a))} 

Try it online (outputs to Debug-window instead of STDOUT).