Використовуючи обрану мову, напишіть функцію, яка приймає змінну кількість аргументів і повертає кількість аргументів, з якими вона була викликана.

Особливості:

• Ваша мова повинна підтримувати різні функції аргументів: щось, що можна викликати, що приймає довільну кількість аргументів і повертає значення.
• Параметри повинні бути спроможні проходити окремо. Це означає, що передача масиву зараховуватиме лише один параметр. Ви можете використовувати масив "всі передані аргументи", якщо ваша мова підтримує його; обмеження на те, як функція викликається.
• Код, який викликає цю функцію, не повинен вимагати передачі кількості аргументів у своєму джерелі . Якщо компілятор вставляє кількість аргументів як частину конвенції виклику, це дозволено.
• Аргументи можуть бути будь-якого типу. Ви можете підтримувати лише один тип (наприклад, лише підтримка intвсе ще діє), довільні типи (дозволений будь-який тип аргументів) або будь-яку комбінацію типів аргументів (наприклад, перший аргумент є int, решта - це рядки).
• Ваша функція може мати максимальну кількість аргументів (тим більше, що ресурси обмежені), але вона повинна підтримувати щонайменше 2 аргументи.

Зразки:

• f() повертає 0
• f(1)або f("a")повертається1
• f([1, 2, 3])повертає 1як переданий масив, а не 3 аргументи
• f(1, 10)або f(1, "a")повертається2

Оскільки це код-гольф, виграшним рішенням є те, що використовує найменшу кількість байтів.

Двійковий дзвінок Amstrad CPC Z80 від BASIC, 1 байт, шістнадцятковий

C9          : RET

(Також 2 та 5 байт версії див. Нижче)

Після вступу на виклик кількість пройдених параметрів буде в Aреєстрі. Код просто повертається негайно. У Z80 не існує концепції повернення значень, лише стан входу та виходу. Значення просто "там" доступне в реєстрі, оскільки код не змінює жодних умов введення, крім PC(лічильник програми) та SP(покажчик стека). Однак значення AIN недоступне для BASIC і перезаписується практично відразу.

Приклади:

CALL &8000, "Hello", "World"

A = 2

CALL &8000, 42

A = 1

CALL &8000

A = 0

За запитом, ось якийсь код, який робить значення доступним у BASIC. Я був дуже здивований, виявивши, що це можна зробити всього в 5 байтах!

Код машини:

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

При вступі:

• AF - регістри акумулятора та прапорів (трактуються як два 8-бітні регістри)
  • A містить кількість пройдених параметрів, максимум до 32 параметрів
  • Я не впевнений, що там F. Схоже, всі прапори RESET to 0, за винятком двох невизначених прапорів, які є обома 1. ZПрапор (нуль) встановлено в положення, 1якщо не було проходили в параметри
• BC
  • B- 32 мінус кількість параметрів ( A+ B= 32)
  • C - &FF
• DE - Адреса останнього параметра або адреса виклику, якщо не були передані параметри
• HL - Адреса першого байту після введеної токенізованої команди BASIC (або як програма, або в режимі безпосередньої команди)
• IX - адреса стека вказівника на останній параметр
• IY - &0000

Кодекс

1. Loa Ds адресу, на яку вказує DEзначення уA
2. INCременти DE
3. XORs A(з A), даючи&00
4. Loа Ds значення в Aадресу, на яку вказуєDE
5. RETурни

На виході:

• Aзнищується (це завжди &00)
• DE знищується (це завжди на один вищий, ніж під час вступу)
• Усі інші регістри збережені

ОСНОВА

Amstrad basic має лише три типи даних, а також прості масиви. За замовчуванням всі BASIC змінні є РЕАЛЬНІ (підписані, 32-бітна мантіса, 8-бітний експонент), що можна зробити явними за допомогою !. Для використання INTEGER (16-бітний підпис) %та для STRING (1 байт довжиною рядка, до 255 байт даних символів, двійковий безпечний) $:

• x - РЕАЛЬНА (неявна)
• x! - РЕАЛЬНА (явна)
• x% - ІНТЕГЕР
• x$ - STRING

Ви також можете використовувати DEFINT, DEFREALі DEFSTRз однією літерою або діапазоном двох окремих літер , щоб вказати тип за замовчуванням для всіх змінних , що починаються з цієї букви, схожою на FORTRAN.

• DEFSTR a
• DEFINT x-z

Зараз:

• a - STRING (неявно)
• i - РЕАЛЬНА (неявна)
• x - INTEGER (неявно)
• x$ - STRING (явно)

Найпростіший тип роботи з цілим числом. Машинний код очікує, що останній параметр буде переданий за адресою, а не значенням, через що @префікс до змінної. Змінна повернення вважається одним із CALLs параметрів.

Машинний код називається так, як випливає з BASIC (якщо припустити, що він завантажений в пам'ять за адресою &8000):

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

n% = 4

Це завжди дасть правильний результат, незалежно від початкового значення n%.

Для двобайтової версії, яка зберігає всі вхідні регістри:

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

n% = 4

Це пропускає перші три байта, а тільки дає правильний результат , якщо початкове значення n%є 0- 255. Це працює, тому що Z80 є малоінтенсивним.

Параметр повернення повинен бути ініціалізований перед передачею, інакше BASIC видасть Improper argumentпомилку. На зображенні нижче я друкую (за допомогою ярлика, ?оскільки я також переграв демонстрацію!) Повертаються значення безпосередньо перед і після виклику, щоб показати значення, що змінюється. Я використовую значення, &FFFFоскільки це двійкове представлення -1для підписаного цілого числа. Це демонструє, що 5-байтова програма правильно записує обидва байти, тоді як 2-байтна програма записує лише низький байт і припускає, що високий байт вже є &00.

Java (JDK 10) , 11 байт

a->a.length

Спробуйте в Інтернеті!

JavaScript, 15 байт

[].push.bind(0)

Array.prototype.pushФункція приймає будь-яку кількість аргументів, додає їх в масив і повертає розмір масиву. Тому pushфункція, що використовується в порожньому масиві, повертає кількість аргументів, що надсилаються push.

f = [].push.bind(0)

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

f()
> 0

.bind(0)Просто дає pushфункцію фіксоване thisзначення , так що вона може бути збережена в змінної. Насправді 7-байтний ідентифікатор [].pushможна використовувати буквально (але не призначати) без bind:

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

[].push()
> 0

JavaScript (ES6), 16 байт

(...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 байт

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

Спробуйте в Інтернеті!

Напрочуд важко було працювати, але мені було весело, намагаючись дізнатися, як реалізувати щось, що є тривіальним, в імперативних мовах.

Python 3 , 15 байт

lambda*a:len(a)

Спробуйте в Інтернеті!

Zsh , 7 5 байт

<<<$#

Спробуйте в Інтернеті!

Мозок-Флак , 6 байт

Моє перше рішення Brain-Flak, гідне публікації, я думаю, що це правильний інструмент для цієї роботи:

([]<>)

Спробуйте в Інтернеті!

Пояснення

Під час виконання програми Brain-Flak спочатку лівий стек містить усі аргументи. Звідти це просто питання:

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

Мова Вольфрама (Mathematica) , 11 байт

Tr[1^{##}]&

Спробуйте в Інтернеті!

Запропоновано JungHwan Min. Деякі обмеження (вхід має бути прямокутним), але ми не зобов'язані обробляти довільні введення.

11 байт

Length@!##&

Спробуйте в Інтернеті!

Ще одне байтне рішення, запропоноване Мартіном Ендером. Здається, це помилка, коли немає одного вводу, але він все одно повертає правильне значення у всіх випадках.

12 байт

Length@{##}&

Спробуйте в Інтернеті!

Моє оригінальне рішення.

У Mathematica ##розшифровується кількість аргументів функції. {і }загортає їх у список та Length@приймає довжину цього списку. &в кінці перетворює це на фактичну функцію.

R , 30 байт

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

Спробуйте в Інтернеті!

Bash, 12 байт (завдяки paxdiablo за збереження 4)

n()(echo $#)

Скопіюйте та вставте на підказці. Потім запустіть 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 байт

Як загальна варіативна функція лямбда (потрібна C ++ 14):

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

Спробуйте в Інтернеті!

Попередня (неправильна) відповідь: 32 байти

У ньому бракувало template<class...T>і(p)

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

Рубін , 12 байт

->*a{a.size}

Спробуйте в Інтернеті!

*a- це фрагмент аргументів, змушує aспоживати всі аргументи, передані Proc. a.sizeотримує свої розміри.

Октава , 9 байт

@()nargin

Спробуйте в Інтернеті!

Анонімна функція приймає будь-яку кількість аргументів (і мовчки відкидає лот) і виводить кількість аргументів через вбудований nargin. Це не працює в MATLAB, де вам потрібно vararginбуде дозволити безліч довільних аргументів.

Perl 6 , 5 байт

Дякую @Joshua за -5 байт

{+@_}

Спробуйте в Інтернеті!

Perl 5 , 9 байт

sub{~~@_}

Спробуйте в Інтернеті!

PHP, 34 байти

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

C # .NET, 11 байт

a=>a.Length

Спробуйте в Інтернеті.

Пояснення:

У C # .NET objectвикористовується для аргументів багатьох типів, що дозволяє передавати цілі числа, рядки, символи тощо як можливі входи. Наприклад:

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

C # .NET також може мати фіксований розмір необов'язкових аргументів. Наприклад:

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

І є також вараги, що є невизначеною кількістю необов'язкових аргументів (саме це я використав у цій відповіді). Наприклад:

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

Зазвичай лямбди створюються так:

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)

Але, на жаль System.Func, не підтримує paramsvarargs, тому мені доведеться створити delegateнатомість:

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

Що є моєю відповіддю на це завдання, і його можна знайти у пов'язаному тестовому коді TIO.

Єдине обмеження полягає в тому, що введення фактичного object[]вподобання f(new object[]{1,2,3})призведе до 3 замість 1. f(new int[]{1,2,3})все одно призведе до 1, оскільки він інтерпретує значення int[]як єдине object. Для того, щоб мати object[]параметр можна інтерпретувати як єдиний об'єкт , а також він може бути перетворений в об'єкт , як це: f((object)new object[]{1,2,3}).

Додо , 32 31 байт

f
	dot i f dab
i
	
	dip dot dab

Спробуйте в Інтернеті!

Використовує функцію приросту Денніса.

Пояснення

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

Крім того, 32 байти без рекурсії в цільовій функції (спасибі @Leo )

	dot i
i
	dip dot dab dot
	i dab

Спробуйте в Інтернеті!

Пояснення

        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 байти

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

Зберігає байти, працюючи лише з ints.

Іржа, 57 байт

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

Пояснення:

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

Тест:

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 байт

function(){return func_num_args();}

ручний запис

Лист звичайний , 28 байт

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

Спробуйте в Інтернеті!

Додати ++ , 3 байти

L,L

Спробуйте в Інтернеті!

PHP, 11 байт

<?=$argc-1;

Спробуйте в Інтернеті: 1 вхід | 3 входи

Пакетна, 50 49 байт

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

В Партії немає вбудованих, тому нам доводиться ходити по старому школі. Збережено 1 байт завдяки @IsmaelMiguel. Виводиться через код виходу, або збережіть 3 байти, якщо вихід через глобальну змінну є дійсним. Приклад використання в повній програмі:

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

32-бітна (i386) функція машинного коду x86, 13 байт

Конвенція виклику: Система i386 V (стеки арг), з покажчиком NULL як дозорний / термінатор для кінця аргументу списку . (Clobbers EDI, інакше відповідає SysV).

C (і ASM) не передають інформацію про тип різноманітним функціям, тому опис ОП передачі цілих чисел або масивів без явної інформації про тип може бути реалізований лише в конвенції, яка передає якийсь об'єкт структури / класу (або покажчики на такий ), а не оголені цілі числа на стеку. Тому я вирішив припустити, що всі аргументи були не-NULL-покажчиками, а абонент передає NULL-термінатор.

Список покажчиків аргументів, що закінчується NULL, фактично використовується в C для таких функцій, як POSIXexecl(3) : int execl(const char *path, const char *arg, ... /* (char *) NULL */);

C не дозволяє int foo(...);прототипам без фіксованого аргументу, але int foo();означає те саме: аргументи не вказані. (На відміну від C ++, де це означає int foo(void)). У будь-якому випадку, це відповідь asm. Спільний компілятор С для виклику цієї функції безпосередньо цікавий, але не обов'язковий.

nasm -felf32 -l/dev/stdout arg-count.asm видалено рядки з коментарями.

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

Питання показує, що функція повинна вміти повертати 0, і я вирішив виконати цю вимогу, не включаючи закінчуючий вказівник NULL у число аргументів. Однак це коштує 1 байт. (Для 12-байтової версії вийміть LEA і розметайте scasdзовнішній цикл та на xchg, але не на dec edx. Я використовував LEA, оскільки він коштує так само, як і ці три три інструкції, укомплектовані, але він більш ефективний, тому функцій менше упс.)

C абонент для тестування :

Побудовано з:

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потрібно навіть при -O0 сказати gcc припускати, що функція clobber ediне зберігає / не відновлює її, оскільки я використав стільки викликів в одному операторі C ( printfвиклик), що навіть -O0використовував EDI. Це, мабуть, є безпечним для того, mainщоб gcc's клобувати EDI від власного абонента (у CRT-коді), в Linux з glibc, але в іншому випадку змішувати / відповідати коду, компільованому з різними, абсолютно неправдиво -fcall-used-reg. Немає його __attribute__версії, яка б дозволила нам оголосити функції asm зі спеціальними умовами викликів, відмінними від звичайних.

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

Дві інші версії також увійшли в 13 байт: ця заснована на loopneповерненні значення, яке занадто високе на 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

Ця версія використовує rep scasd замість циклу, але приймає аргумент підрахунку аргументу 256. (Або обмежено на 256, якщо верхні байти ecxдорівнюють 0!)

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

Цікаво, ще одна версія , заснована на inc eax/ pop edx/ test edx,edx/ jnzувійшов в 13 байт. Це умовний виклик callee-pops, який ніколи не використовується реалізаціями C для варіативних функцій. (Я перескакував ret addr в ecx, а jmp ecx замість ret. (Або натисніть / ret, щоб не порушити стек передбачувача зворотної адреси).

R , 20 байт

function(...)nargs()

Спробуйте в Інтернеті!

R має функцію саме для цього .

JavaScript, 35 байт

f=
function(){return arguments.length}

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

Цвітна капуста , 16 байт

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

Спробуйте в Інтернеті!