Tercih ettiğiniz dili kullanarak, değişken sayıda argüman alan ve çağrıldığı argüman sayısını döndüren bir işlev yazın.

Özellikleri:

• Dilinizin değişken değişkenli argüman işlevlerini desteklemesi gerekir: rastgele sayıda argüman alan ve bir değer döndüren çağrılabilir bir şey.
• Parametreler ayrı ayrı geçirilebilmelidir. Bu, bir diziyi geçmenin yalnızca bir parametre için sayılacağı anlamına gelir. Diliniz destekliyorsa "tüm iletilen argümanlar" dizisini kullanabilirsiniz; kısıtlama, fonksiyonun nasıl çağrıldığı ile ilgilidir.
• Bu işlevi çağıran kod , kaynağındaki argüman sayısını iletmek için gerekli olmamalıdır . Bir derleyici, görüşme kuralının bir parçası olarak argüman sayısını girerse, buna izin verilir.
• Argümanlar istediğiniz türde olabilir. Yalnızca tek bir türü (örneğin, yalnızca destek inthala geçerlidir), isteğe bağlı türlerini (herhangi bir tür argümana izin verilir) veya herhangi bir argüman türünün birleşimini (örneğin, ilk argüman int, geri kalan dizelerdir) destekleyebilirsiniz.
• İşleviniz maksimum sayıda argümana sahip olabilir (özellikle kaynaklar sınırlı olduğu için), ancak en az 2 argümanı desteklemesi gerekir .

Örnekler:

• f() döner 0
• f(1)veya f("a")iadeler1
• f([1, 2, 3])döner 1bunun gibi bir dizisi, 3 argümanlar geçirilir
• f(1, 10)veya f(1, "a")iadeler2

Bu kod golf olduğu için, kazanan çözüm en az bayt sayısını kullanan çözümdür.

BASIC'den Amstrad CPC Z80 ikili çağrısı, 1 bayt, hex kodlanmış

C9          : RET

(Ayrıca 2 ve 5 byte sürümleri, aşağıya bakınız)

Aramaya girişte, iletilen parametrelerin sayısı Akayıt defterinde olacaktır. Kod hemen geri döner. Z80'de geri dönüş değerleri kavramı yoktur, sadece giriş ve çıkış durumları vardır. Değer, sadece (orada PC) program kodu ve SP(yığın işaretçisi) haricinde, giriş koşullarını değiştirmediğinden kayıt defterinde erişilebilir "orada" dır . Bununla birlikte, içindeki değer ABASIC tarafından erişilebilir değildir ve hemen üzerine yazılır.

Örnekler:

CALL &8000, "Hello", "World"

A = 2

CALL &8000, 42

A = 1

CALL &8000

A = 0

Talep üzerine, BASIC'te değeri erişilebilir kılan bazı kodlar buradadır. Sadece 5 baytta yapılabildiğine çok şaşırdım !:

Makine kodu:

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

Girişte:

• AF - akümülatör ve bayrak kayıtları (iki adet 8 bitlik kayıt olarak kabul edilir)
  • A En fazla 32 parametreye kadar geçirilen parametre sayısını içerir.
  • Neyin içinde olduğundan emin değilim F. Her 0ikisi de tanımlanmamış iki bayrak hariç, RESET tüm bayraklara sahip görünüyor 1. Zİçin bayrak (sıfır) SET olduğu 1geçirilen hiçbir parametre olsaydı
• BC
  • B- 32 eksi parametre sayısı ( A+ B= 32)
  • C - &FF
• DE - Son parametrenin adresi veya eğer hiçbir parametre iletilmediyse arama adresi
• HL - Halen yürütülmekte olan tokenize BASIC komutundan sonraki ilk baytın adresi (bir program olarak veya anında komut modunda)
• IX - İmlecin son parametreye kadar yığın adresi
• IY - &0000

Kod

1. Lo da değeri ile Dgösterilen adresDEA
2. INCrements DE
3. XORs A(birlikte A) veren&00
4. Lo tarafından gösterilen adrese Dverilen değerADE
5. RETçömleği

Çıkışta:

• Ayok edildi (her zaman &00)
• DE yok edilir (her zaman girişten bir tane daha yüksektir)
• Diğer tüm kayıtlar korunur

Basit

Amstrad basic sadece üç veri tipine ve ayrıca basit dizilere sahiptir. Varsayılan olarak, tüm BASIC değişkenleri GERÇEK (işaretli, 32 bit mantis, 8 bit üstel) ve bunlar açıkça belirtilebilir !. Bir INTEGER (işaretli, 16 bit) kullanım için %ve bir STRING (1 byte string uzunluğu, 255 byte karakter verisine kadar, ikili güvenli) kullanın $:

• x - GERÇEK (üstü kapalı)
• x! - GERÇEK (açık)
• x% - INTEGER
• x$ - STRING

Ayrıca kullanabilirsiniz DEFINT, DEFREALve DEFSTRtek harfle veya iki tek harf bir dizi FORTRAN benzer o mektubu ile başlayan tüm değişkenler için varsayılan türünü belirtmek için.

• DEFSTR a
• DEFINT x-z

Şimdi:

• a - STRING (örtülü)
• i - GERÇEK (üstü kapalı)
• x - INTEGER (örtülü)
• x$ - STRING (açık)

Çalışılması en kolay tür tamsayıdır. Makine kodu, son parametrenin değere değil adrese göre iletilmesini beklemektedir, bu yüzden @değişkene ön ek verilmiştir. Dönüş değişkeni CALLs parametrelerinden biri olarak sayılır .

Makine kodu, BASIC'den aşağıdaki şekilde çağrılır (adrese belleğe yüklendiği varsayılarak &8000):

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

n% = 4

Bu başlangıç ​​değerinden bağımsız olarak daima doğru sonucu verecektir n%.

Tüm giriş kayıtlarını koruyan 2 baytlık bir sürüm için:

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

n% = 4

Bu ilk üç bayt atlar ve başlangıç değeri ise sadece doğru sonucu verir n%ise 0- 255. Bu işe yarar, çünkü Z80 çok azdır.

Return parametresi geçilmeden önce başlatılmalıdır, aksi takdirde BASIC bir Improper argumenthata atar . Aşağıdaki resimde, ?değişimin değerini göstermek için çağrıdan hemen önce ve sonra dönüş değerlerini (gösteriyi de golf oynadığımdan bu yana kısayolla) basıyorum. Değeri kullanıyorum, &FFFFçünkü bu -1imzalı bir tamsayı için ikili gösterimdir . Bu, 5 baytlık programın her iki baytı da doğru şekilde yazdığını gösterir, oysa 2 baytlık program sadece düşük baytları yazar ve yüksek baytın zaten var olduğunu varsayar &00.

Java (JDK 10) , 11 bayt

a->a.length

Çevrimiçi deneyin!

JavaScript, 15 bayt

[].push.bind(0)

Array.prototype.pushİşlevi diziye ekler, bağımsız değişkenler herhangi bir sayıyı alır, ve dizinin boyutunu verir. Bu nedenle, pushboş bir dizide kullanılan işlev , verilen argüman sayısını döndürür push.

f = [].push.bind(0)

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

f()
> 0

.bind(0)Sadece veren pushfonksiyonu sabit thisbir değişkene saklanabilir, böylece değer. Aslında, 7 baytlık tanımlayıcı [].pushtam anlamıyla kullanılabilir (ancak atanmamış) bind:

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

[].push()
> 0

JavaScript (ES6), 16 bayt

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

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

Çevrimiçi deneyin!

Çalışmak şaşırtıcı derecede zordu, ancak zorunlu dillerde önemsiz olan bir şeyi nasıl uygulayacağımı öğrenmeye eğlendim.

Python 3 , 15 bayt

lambda*a:len(a)

Çevrimiçi deneyin!

Zsh , 7 5 bayt

<<<$#

Çevrimiçi deneyin!

Beyin Flak , 6 bayt

İlk Brain-Flak çözümüm, göndermeye değer, sanırım bu iş için doğru araç:

([]<>)

Çevrimiçi deneyin!

açıklama

Bir Brain-Flak programı yürütülürken, başlangıçta soldaki yığın tüm değişkenleri içerir. Oradan sadece meselesi:

(      -- 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 Dili (Mathematica) , 11 bayt

Tr[1^{##}]&

Çevrimiçi deneyin!

JungHwan Min tarafından önerildi. Bazı kısıtlamalar (giriş dikdörtgen olmalıdır) ancak isteğe bağlı girişi ele almamız gerekli değildir.

11 bayt

Length@!##&

Çevrimiçi deneyin!

Martin Ender tarafından önerilen 11 baytlık bir çözüm daha. Bu, bir giriş olmadığında hata gibi görünüyor ancak yine de her durumda doğru değeri döndürüyor.

12 bayt

Length@{##}&

Çevrimiçi deneyin!

Orijinal çözümüm.

Mathematica'da ##, bir fonksiyonda değişken sayıdaki argümanlar bulunur. {ve }onları bir listeye sarar ve Length@bu listenin uzunluğunu alır. &sonunda bunu gerçek bir işleve dönüştürür.

R , 30 bayt

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

Çevrimiçi deneyin!

Bash, 12 bayt (4 tasarruf için paxdiablo'ya teşekkürler)

n()(echo $#)

Bir bash komut isteminde kopyalayıp yapıştırın. Sonra istemden n işlevini çalıştırın:

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

Genel varyadik lambda işlevi olarak (C ++ 14 gerekli):

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

Çevrimiçi deneyin!

Önceki (yanlış) cevap: 32 bayt

Bu eksikti template<class...T>ve(p)

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

Yakut , 12 bayt

->*a{a.size}

Çevrimiçi deneyin!

*aProc'a ailetilen tüm argümanları tüketen argümanların bir uyarısıdır. a.sizeboyutunu alır.

Oktav , 9 bayt

@()nargin

Çevrimiçi deneyin!

Herhangi bir sayıda argüman alarak (ve lotu sessizce atma) anonim işlev, ve yerleşik argüman sayısını yerleşik olarak verir nargin. Bu, vararginbirçok argümana keyfi olarak izin vermeniz gereken MATLAB'da çalışmaz .

Perl 6 , 5 bayt

Teşekkürler -Joshua -5 bayt için

{+@_}

Çevrimiçi deneyin!

Perl 5 , 9 bayt

sub{~~@_}

Çevrimiçi deneyin!

PHP, 34 bayt

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

C # .NET, 11 bayt

a=>a.Length

Çevrimiçi deneyin.

Açıklama:

C #. NET'te objectçoklu tür argümanları için kullanılır, biri tamsayıları, dizeleri, karakterleri vb. Mümkün olan girişleri geçmesine izin verir. Örneğin:

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

C # .NET, isteğe bağlı değişkenlerin sabit bir boyutta olabilir. Örneğin:

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

Ayrıca tanımsız miktarda isteğe bağlı argüman olan (bu cevapta kullandığım) varargs da vardır. Örneğin:

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

Genellikle lambdas şöyle yaratılır:

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)

Fakat ne yazık ki varargs'i System.Funcdesteklemiyor params, o yüzden delegatebunun yerine bir tane oluşturmam gerekecek :

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

Bu zorluğa cevabım hangisi ve bağlantılı TIO test kodunda bulunabilir.

Tek sınırlama, gerçek bir object[]benzer girişin f(new object[]{1,2,3})1 yerine 3 ile f(new int[]{1,2,3})sonuçlanacağı, yine de 1 ile sonuçlanacağı, çünkü int[]tek olarak yorumladığıdır object. Sahip olmak object[]böyle bir nesneye dökülebilir sıra parametre tek bir nesne olarak yorumlamak edilebilir: 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!