Usando il linguaggio che preferisci, scrivi una funzione che accetta un numero variabile di argomenti e restituisce il numero di argomenti con cui è stata chiamata.

specifiche:

• La tua lingua deve supportare le funzioni degli argomenti variabili: qualcosa che può essere chiamato che accetta un numero arbitrario di argomenti e restituisce un valore.
• I parametri devono poter essere passati singolarmente. Ciò significa che il passaggio di un array conta solo per un parametro. È possibile utilizzare un array "tutti gli argomenti passati" se la lingua lo supporta; la restrizione è su come viene chiamata la funzione.
• Il codice che chiama questa funzione non deve essere richiesto per passare il numero di argomenti nella sua fonte . Se un compilatore inserisce il numero di argomenti come parte di una convenzione di chiamata, ciò è consentito.
• Gli argomenti possono essere di qualsiasi tipo tu voglia. È possibile supportare solo un singolo tipo (ad es. Solo il supporto intè ancora valido), tipi arbitrari (è consentito qualsiasi tipo di argomento) o qualsiasi combinazione di tipi di argomenti (ad esempio il primo argomento è int, il resto sono stringhe).
• La tua funzione può avere un numero massimo di argomenti (soprattutto perché le risorse sono limitate), ma deve supportare almeno 2 argomenti.

Campioni:

• f() ritorna 0
• f(1)o f("a")ritorna1
• f([1, 2, 3])restituisce 1quando viene passato un array, non 3 argomenti
• f(1, 10)o f(1, "a")ritorna2

Trattandosi di code-golf, la soluzione vincente è quella che utilizza il minor numero di byte.

Amstrad CPC Z80 chiamata binaria da BASIC, 1 byte, codifica esadecimale

C9          : RET

(Anche versioni da 2 e 5 byte, vedi sotto)

Al momento dell'iscrizione alla chiamata, il numero di parametri passati sarà nel Aregistro. Il codice ritorna semplicemente immediatamente. Non esiste un concetto di valori di ritorno nella Z80, ma solo gli stati di entrata e di uscita. Il valore è "lì" accessibile nel registro poiché il codice non modifica alcuna condizione di input, ad eccezione diPC (il contatore del programma) e SP(il puntatore dello stack). Tuttavia, il valore in Anon è accessibile a BASIC e viene sovrascritto quasi immediatamente.

Esempi:

CALL &8000, "Hello", "World"

A = 2

CALL &8000, 42

A = 1

CALL &8000

A = 0

Su richiesta, ecco un codice che rende il valore accessibile in BASIC. Sono stato molto sorpreso di scoprire che poteva essere fatto in soli 5 byte !:

Il codice macchina:

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

All'entrata:

• AF - i registri accumulatore e flag (trattati come due registri a 8 bit)
  • A contiene il numero di parametri passati, fino ad un massimo di 32 parametri
  • Non sono sicuro di cosa ci sia dentro F. Sembra avere tutti i flag RESET su 0, tranne i due flag indefiniti che sono entrambi 1. Il Zflag (zero) è impostato su 1se non sono stati passati parametri
• BC
  • B- 32 meno il numero di parametri ( A+ B= 32)
  • C - &FF
• DE - L'indirizzo dell'ultimo parametro o l'indirizzo chiamante se non sono stati passati parametri
• HL - L'indirizzo del primo byte dopo il comando BASIC tokenizzato attualmente in esecuzione (come programma o in modalità comando immediato)
• IX - L'indirizzo dello stack del puntatore all'ultimo parametro
• IY - &0000

Il codice

1. Lo Ds l'indirizzo indicato da DEcon il valore inA
2. INCrements DE
3. XORs A(con A), dando&00
4. Lo Ds il valore Anell'indirizzo indicato daDE
5. RETurne

All'uscita:

• Aè distrutto (è sempre &00)
• DE è distrutto (è sempre uno più alto rispetto all'ingresso)
• Tutti gli altri registri vengono conservati

La base

Amstrad basic ha solo tre tipi di dati, oltre a semplici array. Per impostazione predefinita, tutte le variabili BASIC sono REAL (con segno, mantissa a 32 bit, esponente a 8 bit), che possono essere esplicitate con !. Per un uso INTEGER (con segno, 16 bit) %e per un STRING (lunghezza stringa di 1 byte, fino a 255 byte di dati carattere, sicurezza binaria) utilizzare $:

• x - REAL (implicito)
• x! - REAL (esplicito)
• x% - NUMERO INTERO
• x$ - STRING

È inoltre possibile utilizzare DEFINT, DEFREALe DEFSTRcon una sola lettera, o un intervallo di due lettere singole per specificare il tipo di default per tutte le variabili che iniziano con quella lettera, simile a FORTRAN.

• DEFSTR a
• DEFINT x-z

Adesso:

• a - STRING (implicito)
• i - REAL (implicito)
• x - INTEGER (implicito)
• x$ - STRING (esplicito)

Il tipo più semplice con cui lavorare è l'intero. Il codice macchina prevede che l'ultimo parametro sia passato per indirizzo, non per valore, motivo per cui @è prefissato la variabile. La variabile di ritorno viene conteggiata come uno dei CALLparametri s.

Il codice macchina si chiama come segue da BASIC (supponendo che sia caricato in memoria all'indirizzo &8000):

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

n% = 4

Questo darà sempre il risultato corretto, indipendentemente dal valore iniziale di n%.

Per una versione a 2 byte che conserva tutti i registri di input:

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

n% = 4

Ciò salta i primi tre byte e fornisce il risultato corretto solo se il valore iniziale di n%è 0- 255. Questo funziona perché lo Z80 è little-endian.

Il parametro return deve essere inizializzato prima di essere passato, altrimenti BASIC genererà un Improper argumenterrore. Nell'immagine seguente, sto stampando (con la scorciatoia ?da quando ho giocato anche a golf la dimostrazione!) I valori di ritorno immediatamente prima e dopo la chiamata per mostrare la modifica del valore. Sto usando il valore &FFFFperché questa è la rappresentazione binaria di -1per un numero intero con segno. Ciò dimostra che il programma a 5 byte scrive correttamente entrambi i byte, mentre il programma a 2 byte scrive solo il byte basso e presuppone che il byte alto sia già &00.

Java (JDK 10) , 11 byte

a->a.length

Provalo online!

JavaScript, 15 byte

[].push.bind(0)

La Array.prototype.pushfunzione accetta qualsiasi numero di argomenti, li aggiunge alla sua matrice e restituisce la dimensione della matrice. Pertanto, la pushfunzione utilizzata su un array vuoto restituisce il numero di argomenti forniti a push.

f = [].push.bind(0)

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

f()
> 0

Il .bind(0)dà semplicemente la pushfunzione di un determinato thisvalore in modo che può essere memorizzato in una variabile. In effetti, l'identificatore a 7 byte [].pushpuò essere usato letteralmente (ma non assegnato) senza 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

Provalo online!

È stato sorprendentemente difficile farlo funzionare, ma mi sono divertito cercando di scoprire come implementare qualcosa che è banale in linguaggi imperativi.

Python 3 , 15 byte

lambda*a:len(a)

Provalo online!

Zsh , 7 5 byte

<<<$#

Provalo online!

Brain-Flak , 6 byte

La mia prima soluzione Brain-Flak degna di pubblicazione, credo sia lo strumento giusto per questo lavoro:

([]<>)

Provalo online!

Spiegazione

Quando si esegue un programma Brain-Flak, inizialmente lo stack di sinistra contiene tutti gli argomenti. Da lì si tratta semplicemente di:

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

Tr[1^{##}]&

Provalo online!

Suggerito da JungHwan Min. Alcune restrizioni (l'input deve essere rettangolare) ma non siamo tenuti a gestire input arbitrari.

11 byte

Length@!##&

Provalo online!

Un'altra soluzione a 11 byte suggerita da Martin Ender. Questo sembra errore quando non c'è un input ma restituisce comunque il valore corretto in tutti i casi.

12 byte

Length@{##}&

Provalo online!

La mia soluzione originale.

In Mathematica ##sta per un numero variabile di argomenti in una funzione. {e }li avvolge in un elenco e Length@occupa la lunghezza di questo elenco. &alla fine trasforma questo in una funzione reale.

R , 30 byte

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

Provalo online!

Bash, 12 byte (grazie a paxdiablo per il salvataggio di 4)

n()(echo $#)

Copia e incolla a un prompt di bash. Quindi eseguire la funzione n dal 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 byte

Come funzione lambda variadica generica (richiesto C ++ 14):

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

Provalo online!

Risposta precedente (errata): 32 byte

Mancava il template<class...T>e(p)

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

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.

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.

Perl 6, 5 bytes

Thanks @Joshua for -5 bytes

{+@_}

Try it online!

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)

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.

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
}

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

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

R, 20 bytes

function(...)nargs()

Try it online!

R has a function just for that.

JavaScript, 35 bytes

f=
function(){return arguments.length}

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

Cauliflower, 16 bytes

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

Try it online!