Напишите функцию, fкоторая принимает положительное целое число и возвращает функцию.

Возвращенная новая функция должна быть идентичной f. Однако, когда происходит «вызов завершения», fвместо этого следует возвращать сумму всех переданных целых чисел.

Например, g=f(4)(если fпервая функция) должна установить gдругую функцию. h=g(3)будет делать то же самое. Однако, когда вы вызываете hбез аргументов (см. Подробности ниже), он должен вывести 7, так как это сумма предыдущих аргументов функции. Другими словами f(3)(4)() == 7.

Обратите внимание, это не то же самое, что f(3,4)().

«Прекращение вызова» является одним из следующих вариантов (на ваш выбор):

• вызов без аргументов
• ноль в качестве аргумента
• любое неположительное значение

Произвольное количество вызовов функций должно поддерживаться, предопределенного ограничения нет.

Гарантируется, что общая сумма не будет больше 1000.

Мы можем предположить, что перед «завершением вызова» сделан хотя бы один вызов.

Ваш код не должен использовать статические переменные для каждой программы, поэтому должна быть возможность многократно запускать эксперимент в одно и то же время выполнения и наблюдать одно и то же поведение.

Примеры:

f(1)() == 1
f(4)(2)(7)() == 13
f(4)(2)(7)(5)(2)() == 20

JavaScript (ES6), 18 байт

f=n=>m=>m?f(m+n):n

Передайте ложное значение, чтобы получить сумму. Нули могут быть разрешены для стоимости 2 байта.

Попробуйте онлайн

Ungolfed:

f = function(n) {
    return function(m) {
        if (m) {
            return f(m+n);
        } else {
            return n;
        }
    }
}

Haskell (GHC), 118 байт

Это 98 байт для кода и 20 байт для флага компилятора GHC -XFlexibleInstances, который включает расширение системы типов.

class F a where f::Int->a
instance F(()->Int)where f n()=n
instance F a=>F(Int->a)where f=(f.).(+)

Это определяет «функцию» f, которая может быть вызвана с произвольным числом целых чисел, за которыми следует единица (), после чего она возвращает целое число. Тип аннотации обязательны. Попробуйте онлайн!

объяснение

Чтобы заставить систему жестких типов Haskell разрешить это, требуется некоторое волшебство, а именно включение расширения GHC для гибких экземпляров классов типов. Как это работает, так fэто параметрически полиморфная функция, ограниченная ограничением класса типа: ее тип есть F a => Int -> a. Это означает, что fпринимает целое число и возвращает значение типа aдля любого типа, aкоторый принадлежит классу типов F. Fэто просто имя класса типов, который предоставляет функцию f; это объявлено в первой строке.

Следующие две строки являются двумя экземплярами Fдля разных типов a. Во второй строке указывается, что тип функций от ()целых принадлежит F(где ()это тип модуля, единственным членом которого является значение ()), а реализация - f n () = n; функция возвращает свой первый аргумент. В последней строке указывается, что если aпринадлежит F, то и тип функций из целых чисел в a: из функции f :: Int -> aмы можем сгенерировать другую функцию f :: Int -> Int -> a. Реализация такова f m n = f (m+n)(код использует комбинаторы, чтобы сделать его короче), где fслева - новый, а fсправа - старый. Это по сути даетfновый целочисленный аргумент, который добавляется к следующему. Несколько аргументов суммируются вместе следующим образом:

  f  a1   a2   a3   a4   a5  ()
= f (a1 + a2)  a3   a4   a5  ()
= f (a1 + a2 + a3)  a4   a5  ()
= f (a1 + a2 + a3 + a4)  a5  ()
= f (a1 + a2 + a3 + a4 + a5) ()
=    a1 + a2 + a3 + a4 + a5

fНа каждой линии имеет другой тип.

Функции на Haskell каррируются автоматически, поэтому, если вы дадите fтолько целые числа, вы получите функцию.

Python 2, 42 41 36 байт

Это решение никогда не будет переполнено, так как Python поддерживает целые числа произвольной точности. Ноль - это «особая ценность».

f=lambda n:lambda m:m and f(m+n)or n

Попробуйте онлайн

Ungolfed:

def f(n):
    def g(m=''):
        return f(m+n)if m<''else n
    return g

C, 62 58 байт, пограничный конкурирующий

Сохранено 4 байта благодаря Кевину! (До сих пор не удаляем typedef, потому что это нужно для вызова.)

typedef(*(*B)(_))(_);q;f(x,o,_){x=x?(q+=x,f):(x=q,q=0,x);}

Функция для вызова есть f; Вы перестаете звонить и получаете результат, звоня с неположительным числом, таким как 0. Попробуйте использовать тестовые ремни онлайн!

Итак, насколько я могу судить, единственный способ «карри» функций с несколькими типами возвращаемых значений - это выполнить одно из следующих действий:

1. Приведите результат к функции, чтобы сообщить компилятору, что вы хотите снова вызвать результат;
2. или создайте тип union/, structкоторый имеет intподтипы и функцию / самоссылку.

Я попытался сделать (2), но это казалось немного противоречащим духу вопроса и, откровенно говоря, почти невозможно отменить. Таким образом, в соответствии с духом задачи, я выбрал вариант (1). Это требует приведения каждой возвращаемой функции в функцию, чтобы ее можно было использовать.

Этот «карри» синтаксис выглядит немного странно, но довольно похоже. Чтобы подражать f(21)(1), нужно было бы написать ((B)((B)f(21))(1))(0). Я определил Bтип как функцию, которая принимает целое число и возвращает указатель на функцию, которая принимает целое число. В развернутом виде это выглядит так:

   ( (B)( (B) f(21) )(1) )(0)
//            f(21)            - call f with 21
//        (B)                  - cast to B, a function pointer
//      (           )(1)       - call with 1
//   (B)                       - cast to a function pointer
// (                     )(0)  - call with 0

Mathematica, 25 байтов

f[x_]@y_=f[x+y]
f[x_][]=x

Попробуйте онлайн! (Используя математику.)

Можно портировать ответ на JavaScript на три байта меньше, но я хотел представить более идиоматическое решение Mathematica. Это @всего лишь синтаксический сахар, который делает решение эквивалентным:

f[x_][y_]=f[x+y]
f[x_][]=x

Так что да, идея в том, что в Mathematica вы не можете просто определить функцию, f[x_]но вы можете напрямую прикрепить значение к более сложному выражению, содержащему f, например f[x_], передав другой аргумент. Установив два определения для этого, мы можем получить желаемое поведение:

• Первое определение объединяет один f[x][y]вызов f[x+y], тем самым потребляя один «вызов» и суммируя аргументы внутри. Это правило действует до тех пор, пока нас не оставят f[sum][].
• Второе определение распаковывает этот последний случай, определяя всю вещь для оценки sum.

C ++, 72 байта

#define O(P)operator()(P){return{P+a};}int
struct F{F O(int(m))O()a;}f;

Это определяет тип, Fкоторый действует как запрошенная функция, и переменная fэтого типа для вызова. Он действителен для C ++ 11 и работает с онлайн-версиями GCC, clang, icc и VC ++.

Использование:

int main() {
  return f(1)(2)(3)(); // returns 6
}

Объяснение:

После предварительной обработки и переформатирования это выглядит так:

struct F {
  F operator()(int(m)) { return{int(m)+a}; }
  int operator()() { return {+a}; }
  int a;
} f;

Это обычно будет написано:

struct F {
  F operator()(int m) { return {m+a}; }
  int operator()() { return a; }
  int a;
} f;

return a;и return {+a};делать то же самое, поскольку унарное +не меняет значение, и допускаются избыточные скобки вокруг возвращаемого значения. int mи int(m)сделать то же самое, поскольку допускаются избыточные скобки вокруг имени переменной, включая параметры функции. return {m+a};и return {int(m)+a};делать то же самое, так как приведение mиз intв intне меняет своего значения. Эти изменения operator()сближают две перегрузки по синтаксису, позволяя дважды вызывать одно определение макроса. Выбор правильного порядка для трех членов позволяет также intвключить в определение макроса первое слово следующей строки ( ).

Рубин, 23 байта

f=->n{->m{m ?f[n+m]:n}}

Использование:

f[1][2][3][nil]
=> 6

C 104 96 байт

#define a(i)s(i)|b
#define b(i)u(i)|c
#define c(i)u(i)|b
b,c,d;s(i){b=c=i;i=d;}u(i){c=b+=i;i=d;}

Использует метод по ссылке, которой поделилась @JulianWolf. Последний аргумент должен быть 0.

Попробуйте онлайн!

Math.JS, 38 байт

f(x)=i(x,0)
i(x,y)=x<0?y:j(z)=i(z,y+x)

Позвони с f(number_a)(number_b)(...)(negative_number)

Если нам разрешено указать начальный вызов, 12 bytes ( f(x)=i(x,0)\n) может быть отброшено, и его можно вызвать сi(number_one,0)(number_two)(...)(negative_number)

Попробуй!

Explination

Как показано в приведенном выше примере LaTex, f(x)просто вызывает i(x,0), затем i(x,y)возвращает значение yif xменьше 0 или функцию j(z)=i(z,x+y), которая принимает один аргумент, который зацикливается. Добавление к стоимости y.

C 232 206 байт

#include<string.h>
#include<stdlib.h>
#define f(X)s(""#X)?0:g
#define g(X)u(""#X)?0:h
#define h(X)u(""#X)?0:g
g=0,h=0;s(char*s){g=h=atoi(s);return 0;}u(char*s){char*a=strlen(s)?s:"0";g=h+=atoi(a);return 0;}

Это, вероятно, может быть значительно улучшено, но должно служить подтверждением концепции, что C можно использовать без каких-либо языковых расширений *, чтобы решить эту проблему, вызывая без аргументов, а не с магическим значением.

* @hvd отметил, что, хотя это работает «из коробки» с использованием gcc, некоторая часть поведения не определена в стандарте C, что означает, что это не может быть переносимым. Используйте на свой риск!

Ungolfed:

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#define f(X) start("" #X) ? 0 : f0
#define f0(X) update("" #X) ? 0 : f1
#define f1(X) update("" #X) ? 0 : f0

long f0 = 0;
long f1 = 0;

int start(const char *s) {
    f0 = f1 = strtol(s, NULL, 10);

    return 0;
}

int update(const char *s) {
    const char *a = strlen(s) ? s : "0";
    f0 = f1 += strtol(a, NULL, 10);

    return 0;
}

int main() {
    printf("f(1)()          -> %ld\n", f(1)());
    printf("f(1)(2)(0)(3)() -> %ld\n", f(1)(2)(0)(3)());
    printf("f(1)(-2)(3)()   -> %ld\n", f(1)(-2)(3)());
    printf("f()             -> %ld\n", f());

    return 0;
}

Компиляция и запуск с gcc arbitrary-length-currying.c -o arbitrary-length-currying && ./arbitrary-length-curryingвыходами (после некоторых предупреждений)

f(1)()          -> 1
f(1)(2)(3)(0)() -> 6
f(1)(-2)(3)()   -> 2
f()             -> 0

8086 машинный код, 27 байт

00000000  bb 00 00 85 c0 74 13 01  d8 be 00 01 89 e7 47 47  |.....t........GG|
00000010  57 b9 1b 00 f3 a4 5b 89  47 01 c3                 |W.....[.G..|
0000001b

Этот машинный код должен быть по адресу 0x100 и предполагает модель крошечного кода (cs = ds = es = ss). Расположение функции может быть изменено без затрат дополнительных байтов. Установка его со смещением 0сэкономит байт ( xor si,siвместо mov si, 0x100)

Обязательное соглашение о вызовах

Это предполагает, что вызывающий предварительно выделил как минимум 27 байтов в стеке. Он принимает число axи возвращает указатель на функцию bx. Вызов этого указателя с ax=0завершает цепочку и возвращает сумму в bx.
Итак, для первого звонка:

mov bp, sp
sub sp, 28
mov ax, number_to_add
call function
; new function pointer in bx

Затем для каждого последующего вызова:

sub sp, 28
mov ax, number_to_add
call bx
; new function pointer in bx

Чтобы прекратить:

mov ax, 0
call bx
; result in bx
mov sp, bp

Ungolfed (прокомментировал разборку машинного кода):

00000000  BB0000            mov bx,0x0      ; 0 is replaced after copying
00000003  85C0              test ax,ax
00000005  7413              jz 0x1a         ; if(ax==0) ret (with value in bx)
00000007  01D8              add ax,bx       ; arg += total
00000009  BE0001            mov si,0x100    ; address of the original: ds:0x100
0000000C  89E7              mov di,sp
0000000E  47                inc di
0000000F  47                inc di          ; dst = sp+2 = above return address
00000010  57                push di
00000011  B91B00            mov cx,0x1b
00000014  F3A4              rep movsb         ; copy the function code.
00000016  5B                pop bx            ; bx = start of copy destination
00000017  894701            mov [bx+0x1],ax   ; update total in the copied code
0000001A  C3                ret               ; with bx = function pointer

После вызова этого с ненулевым AX, bx = spи буфер заполняется измененной копией машинного кода из function. 16-битный непосредственно в первой инструкции содержит сумму. (Это написано последней инструкцией перед ret.)

push di/ pop bxможно заменить на mov bx, di(до rep movsb), что упрощает, но не экономит.

Требование к вызывающей стороне передать указатель на буфер dst diпозволит сэкономить 4 байта по сравнению с вычислением его относительно sp.

Если сделать начальный адрес функции таким же, как размер функции, можно было бы сохранить byte ( mov cx, si).

C #, 62 байта

dynamic f(int n)=>(System.Func<int,dynamic>)(m=>m<0?n:f(n+m));

Для завершения вызова введите отрицательный номер, например

f(1)(2)(3)(-1) == 6

Скала, 58 символов

case class f(n:Int){def apply(m:Int)=f(n+m)
def apply()=n}

Попробуйте онлайн

Ungolfed:

case class f(n:Int){
  def apply(m:Int)=f(n+m)
  def apply()=n
}

Объяснение:

Этот код определяет case classвызываемый f с конструктором, принимающим int. Определите класс case, который будет генерировать методы equals, hashcode, toString и copy, а также сопутствующий объект с тем же именем для создания объекта без newключевого слова.

Этот класс имеет перегруженный метод apply: для добавления требуется другое целое число и создается новый объект с обновленной суммой, а другой - без аргументов для получения суммы.

В Scala любой объект с методом apply может быть вызван как метод, то есть o.apply(x)записан как o(x). Это используется в стандартной библиотеке для массивов, списков, карт и Function1признаков, реализованных анонимными функциями

Pyth, 19 байт

DhdDebR?bh+dbdR$end

Попробуйте онлайн!

Я впечатлен тем, что Javascript побеждает Pyth, но опять же Pyth не совсем предназначен для передачи функций.

Perl 5, 36 байт

sub f{my$n=pop;sub{@_?f($n+pop):$n}}

say f(1)->(); # 1
say f(1)->(2)->(3)->(); # 6

Brain-Flak , 6 байтов

На самом деле я только что заметил, что, поскольку ToS является допустимым возвращаемым форматом, выталкивание 0 на самом деле не нужно, что экономит 2 байта:

({{}})

Попробуйте онлайн!

Оригинал (ы), 8 байт

Используется 0как специальное значение:

({{}}{})

Попробуйте онлайн!

объяснение

С учетом аргументов a ₁ , a ₂ ,…, a _n , 0 стек изначально выглядит так:

                                                       а _н

                                                       ⋮

                                                       ₂

                                                       ₁

                                                       0

Затем код продолжается, выдает каждые a _i , накапливает их, выдает 0, добавляет их и отправляет результат:

(      )  -- push the following value:
 {  }     --   while ToS ≠ 0 (sums the runs):
  {}      --     pop 1 element
     {}   --   pop the remaining 0 & add it

Альтернативные решения, 8 байт

Вместо того, чтобы ставить 0 и добавлять его к сумме, мы также можем поменять стеки, так как правый изначально пуст:

({{}}<>)

Попробуйте онлайн!

Используя -rфлаг, 0 находится на вершине стека, так что мы могли бы вытолкнуть его первым:

({}{{}})

Попробуйте онлайн!

{}({{}})

Попробуйте онлайн!

C (GCC), 83 байта

Мой первый C гольф! Есть несколько других C-решений, но это немного другое. Использование препроцессора чисто косметическое. Этот подход был впервые обсужден в ответе Конора О'Брайена здесь .

#define r union r
t=0;r{int v;r(*f)();};r e;r f(a){t+=a;e.v=a?f:t;t*=a>0;return e;}

Терминальное значение равно нулю. Возвращаемое значение представляет собой объединение, поэтому для вызова результата используйте поле f, а для доступа к конечному значению используйте поле v, например

f(1).f(2).f(3).f(0).v

Попробуйте онлайн

Ограничения

Глобальная переменная содержит промежуточную сумму. Хотя это явно запрещено, отправка поддерживает повторные вызовы (общее значение сбрасывается при вызове терминала), что, по-видимому, и является причиной запрета глобального состояния.

Указатель на fсохраняется в возвращаемом объединении через intчлен, так что это явно не переносимо. Я не уверен, работает ли это на GCC на всех платформах, или только на Linux, или только на x86, или только с ELF или ... Если кто-нибудь знает какие-либо подробности об этом, пожалуйста, прокомментируйте или отправьте сообщение!

APL (Dyalog Classic) , 48 47 46 ₄₄ 32 байта

∇r←(a f)x
r←⍎'(a+x)f'↓⍨-0=x
∇
0f

Попробуйте онлайн!

Завершается передачей в ноль. Синтаксис вызова:((0 f 1) 2) 0

-15 байт благодаря @ngn

требует ⎕IO←0

Любые советы по гольфу приветствуются!

Perl 6 , 31 байт

sub f(\n){->$m?{$m??f n+$m!!n}}

Dyvil , 34 байта

infix int apply(i:int,j:int=0)=i+j

Использование :

0() // = 0
0(1)() // = 1
0(1)(2)() // = 3

Трейлинг ()может быть опущен.

Пояснение :

Определяет оператор сопоставления, который берет два целых и добавляет их. Параметр jимеет значение 0по умолчанию для поддержки вызова без аргументов. В 0приведенных выше примерах это не имя, а литерал.

Юлия v0.5 +, 52 байта

type F n end
F()=0
(f::F)()=f.n
(f::F)(x)=(f.n+=x;f)

Звоните как F. Вероятно, это можно было бы сделать намного короче, приняв метод менее ОО, но мне всегда нравится получать возможность использовать эту идиому.

Если можно предположить, что «перед завершающим вызовом будет сделан хотя бы один вызов», вторая строка может быть удалена для сохранения 6 байтов.

Юлия 0,5 , 18 байт

!n=k->k>0?!(n+k):n

Попробуйте онлайн!

R, 40 байт

f=function(x)function(y)`if`(y,f(x+y),x)

0 действует как стоп-значение здесь. Еще два байта мы можем опустить.

Проблема в том, что R не хватает краткой встроенной лямбды. Но если мы добавим один , мы можем получить код до 26 байтов :

f=x->(y->`if`(y,f(x+y),x))

(Да, это действительно R. Это просто нужно импортировать.)

PHP, 44 байта

Идея от @ user63956

Завершение вызова 0

function f($i){return[$_GET[0]+=$i][$i]?:f;}

Онлайн версия

Прекращение вызова с NULLнеобходимостью гипса [$i]в[+$i]

PHP, 47 байт

function f($i){global$s;return$i?f.!$s+=$i:$s;}

Онлайн версия

PHP, 52 байта

Завершение вызова NULLили любое другое значение, которое является ложным в PHP

function f($i){global$s;$i?$s+=$i:print$s;return f;}

если программа должна завершиться после выхода, заменить print$sна die("$s")+ 2 байта

Онлайн версия

PowerShell, 86 байт

$f={$n=$args[0];$f=(gv f).value;{if($args){&$f($args[0]+$n)}else{$n}}.getnewclosure()}

Попробуйте онлайн!

Тестовый код:

&(&(&(&(&(&$f 4)2)7)5)2)

Выход: 20

Python 3 , 63 байта

f=lambda n,l=[]:n and(l.append(n)or f)or sum(l)*(l.clear()or 1)

Попробуйте онлайн!

Завершается 0

Python, 69 байт

def f(a=0,s=[]):
    if a:
        return lambda b=0:f(b,s+[a])
    return sum(s)

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

function r=f(n)r=@(m)merge(m,f(m+n),n);

* Аргументом завершения вызова является 0.

Попробуйте онлайн!

* endfunctionтребуется добавить некоторые другие коды.

R, 54 52 байта

f=function(x){g=function(y='')'if'(y>'',f(x+y),x);g}

Благодаря MickyT сэкономлено 2 байта!

Похоже на один из ответов питона. Ungolfed:

f=function(x){
  g=function(y=''){
    if(y>''){
      f(y+x)
      }
      else{x}
  }
  g
}

Работает как

> f(1)(2)(4)()
[1] 7

C ++ (gcc) , 95 91 байт

struct f{int s;f(int t):s(t){}int operator()(){return s;}f operator()(int t){return s+t;}};

Попробуйте онлайн!