Sejujurnya aku tidak percaya tantangan ini belum ada.

Tantangan

Tulis fungsi.

Spesifikasinya

• Program Anda harus mendefinisikan semacam fungsi yang bisa dipanggil. Ini termasuk apa pun yang umumnya dikenal sebagai fungsi, fungsi lambda, atau subrutin. Semua jenis callable ini akan disebut sebagai "fungsi" dalam posting ini.

  1. Input ke fungsi adalah opsional dan tidak diperlukan.

  2. Nilai kembali dari fungsi juga opsional dan tidak diperlukan tetapi kontrol harus kembali ke program panggilan.

• Fungsi tersebut harus ditetapkan ke beberapa jenis variabel sehingga memungkinkan untuk diakses di lain waktu. Ini termasuk penugasan tidak langsung (dalam sebagian besar bahasa yang umum di mana mendeklarasikan fungsi bernama secara otomatis menambahkan nama ke dalam cakupan saat ini) dan penugasan langsung (menugaskan fungsi anonim ke variabel secara langsung).

• Fungsi tidak perlu disebutkan namanya.

• Fungsi harus dibuat oleh Anda - Anda tidak bisa hanya menetapkan fungsi default dari bahasa ke variabel.

• Tidak ada celah standar , silakan.

Ini adalah kode-golf , jadi skor terendah dalam byte menang.

kode mesin x86 / x64, 1 byte

c3

Majelis:

ret

Cobalah online! (nasm)

¯ \ _ (ツ) _ / ¯

Jelly , 0 byte

Cobalah online!

Tautan monadik yang mengembalikan argumennya. Karena ini adalah fungsi pertama yang muncul dalam skrip, ia dapat dipanggil menggunakan1Ŀ .

Terima kasih kepada @ lirtosiast untuk menunjukkan bahwa tautan / fungsi 0 byte akan berfungsi di Jelly.

Yaitu

3,4,5 1Ŀ

Cobalah online!

Javascript, 6 byte

f=_=>0

Termasuk tugas variabel. Tidak banyak yang bisa dilihat di sini.

Python 3, 9 bytes

def f():1

Try it online!

ZX Spectrum BASIC, 6 bytes

DEF FN f()=PI

Hex dump: CE 66 28 29 3D A7. CE is a 1-byte keyword for DEF FN (including the trailing space), while A7 is a 1-byte keyword for PI. Call using FN f(). Example program:

  10 PRINT FN f(): DEF FN f()=PI

Output:

3.1415927

Haskell, 3 bytes

o=9

This code defines a polymorphic function called o which takes one type parameter and one typeclass instance parameter. When this function is called, it takes the given typeclass instance, gets its fromInteger member, calls that member with the Integer value for 9, and returns the result.

Granted, what I just described is merely the behavior of the Haskell function 9, and my code merely defines a function called o which is equivalent to 9.

Now the only question is, is the 9 function "created by you," or is it "a default function from the language"?

I think that it is "created by you." My reason for saying this is that if you read the specification for Haskell, you will (I assume) find no mention of a 9 function anywhere. Instead, the specification states that you can create a number literal by stringing together one or more digits. Therefore, by writing a string of digits, I have written a function—even if I just so happen to have only used one digit.

R, 9 bytes

body(t)=0

Try it online!

I think this complies with the rules. The function t takes no input and outputs 0. This works because there already exists a function called t (the transposition function) and it redefines the body of the function; it would not work with say body(a)=0 (no object called a) or body(F)=0 (F is a logical, not a function). I think it complies because it is still created by me: I am not reusing what the pre-defined function does, simply its name.

I don't think I've ever seen this used by R golfers, but there may be situations where it allows us to save a few bytes on challenges where we need a helper function.

A more standard solution would have been:

R, 13 bytes

f=function()0

Try it online!

Function which takes no input and outputs 0. This is 1 byte shorter than the function which takes no input and outputs nothing, which would be

f=function(){}

If we try to define a function with no body (f=function()), R interprets this as an incomplete command (this might not be true in older versions of R).

As pointed out by OganM, we take this down to 11 bytes with

R, 11 bytes

function()0

Try it online!

which technically complies with the challenge requirement that the function be assigned to some sort of variable, since it is (ephemerally) assigned to .Last.value.

Perl 6, 5 bytes

$!=!*

Try it online!

Creates a Whatever lambda that returns the boolean not of its parameter, and assigns it to the variable $!.

C (gcc), 5 bytes

Defines a function f that takes no arguments and technically returns an undefined integer value.

f(){}

Try it online!

Whitespace, 7 bytes

Creates a subroutine that returns control to the caller.

Explained in context:

[N
S S N
_Create_Label][N
T   N
_Return]

Try it online!

[Wolfram Language (Mathematica)], 1 byte

This one is slightly questionable:

f

Defines f, which can be "called" e.g. by f[], which "returns" the expression f[]

Forth (gforth), 5 bytes

This is a function named f that does nothing.

: f ;

Try it Online

In the TIO code, I added a footer of see f, which prints the definition of the function.

Lua, 8 bytes

f=load''

Try it online!

Defines a (global) function f.

This uses Lua load function to compile given string which happens to be empty in our case (empty code is valid code) into function which does exactly what we wrote in its body: nothing.

For ones wondering, standard solution would be

function f()end

but this is longer (15 bytes).

POSIX sh, 6 bytes

s()(1)

Using curly braces requires one more character.

Java, 10 Bytes

this should match the rules of the challenge

void f(){}

Perl 5, 7 bytes

sub f{}

Try it online!

Kotlin, 8 bytes

val f={}

An empty function stored in a variable f.
Call it using f() or f.invoke().

shortC, 1 byte

A

Try it online!

Transpiles into this C:

 int main(int argc, char **argv){;}

C (gcc), 14 13 bytes

(*f)()=L"Ã";

Try it online!

This defines a function f returning int and accepting an unspecified number (and type) of parameters, the machine code of which is contained within the string literal. The unicode character Ã (stored in memory as 0xc3 0x00 0x00 0x00 on a little endian machine) corresponds to the x86 ret instruction that returns from the function. Non x86 architectures may require different opcode(s) to return.

gcc may require the -zexecstack flag to avoid a segfault.

Haskell, 5 bytes

f x=0

Try it online!

Tcl, 6 5 11 bytes

set f {_ ;}

Try it online!

Including the assignment to the variable f as part of the bytecount to comply with rules. With this change, the more conventional definition below ties the one above for bytecount:

proc f _ {}

XSLT, 134 bytes

<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"><xsl:template name="a"></xsl:template></xsl:stylesheet>

A template is the closest thing this language has to a function. It can definitely be called; it takes zero arguments and "returns" the empty string.

F# (.NET Core), 9 bytes

let f a=a

Try it online!

Ruby, 6 bytes

Proc called f which accepts no argument and returns nil.

f=->{}

Try it online!

Python 3, 10 bytes

f=lambda:0

Try it online!

Pascal 23bytes

procedure A;begin end;

AppleScript, 10

on a()
end

Explained, compiled, and including invocation:

on a()    -- declare event handler "a"
end a     -- end declaration

-- invoke it:
a()

Japt, 2 bytes

_

Called as $U ($.

_ can be replaced with @, Ï, or È.

Try it

SmileBASIC (>=3), 9 bytes

DEF A
END

Function is called by A.

Wolfram Language (Mathematica), 2 bytes

#&

Try it online!

Unfortunately, just & does not work (an anonymous function that does nothing).