挑战

在尽可能少的字符中，找到给定n的i ^ n值（大于0的正整数）。应将其输出为String。

对于那些不知道的人，i被定义为i ^ 2 = -1。所以：

• i ^ 1 = i
• i ^ 2 = -1
• i ^ 3 = -i
• i ^ 4 = 1

然后重复此步骤。

规则

• 如果您的语言支持复数，请不要使用任何可以解决此问题的函数或算法。
• 浮点数不正确的答案可以返回小数，但整数输入应能给出准确的结果

奖励积分

-5如果可以计算出其中n也为负的值

如果您可以计算任何实数的值，则为-15（此奖金包括上述奖金中的-5）

祝好运！

红宝石，得分-2

（13字节，-15奖金）

->n{[1,90*n]}

功能包括：无舍入错误！（如果您将输入作为Rational传递）

由作者Kezz101发布

如果支持任何实数，则可以任何有效的复数形式输出。

负分数使我的肾上腺素冲了出去。因此，滥用规则就可以实现这一崇高目标。

创建一个匿名函数，并输出包含2个条目的数组，这些条目以极坐标形式（角度单位：度）表示一个复数。

CJam，12个字符-5 = 7

1'iW"-i"]li=

在这里测试。

支持负输入。

1              "Push 1.";
 'i            "Push the character i.";
   W           "Push -1.";
    "-i"       "Push the string -i.";
        ]      "Wrap all four in an array.";
         li    "Read STDIN and convert to integer.";
           =   "Access array. The index is automatically taken module the array length.";

结果将自动打印在程序末尾。

Mathematica，22 20 19个字符-15 = 4

Sin[t=π#/2]i+Cos@t&

这是一个匿名函数，您可以像

Sin[t=π#/2]i+Cos@t&[15]

（或指定它f说，然后执行f[15]。）

支持实数并给出整数输入的精确结果。

请注意，i是不是数学的复杂我（这是I）。这只是一个未定义的变量。

同样，尽管表达式具有顺序，Mathematica也会将输出重新排序为R+Ci形式。

Python 2-（24-5）= 19

lambda n:'1i--'[n%4::-2]

大多数功劳属于@ user2357112，我只是从这个答案的评论中获得了更多答案。

说明：从n%4字符串中的索引处开始'1i--'。然后在字符串中的每个字母上以两个为单位向后迭代。因此，例如，n=6将从索引2开始，第一个-，然后跳过i并采用1，以返回-1。

@xnor指出了相同长度的解决方案：

lambda n:'--i1'[~n%4::2] 

积 -（14-5）= 9

无论我如何尝试反向/切片/等，我似乎只能得到14。：'（

%_2<"1i--"h%Q4

这与上面的python答案基本相同，但是分2个步骤，因为pyth不支持python的完整索引选项。在线尝试。

我将与isaacg讨论Pyth索引；）

TI-BASIC（NSpire）-5（20个字符-15）

cos(nπ/2)+sin(nπ/2)i

如果要接收复杂的返回值，请i用（复杂i）末尾替换。

Marbelous，43个字节

并不是真正的赢家，但Marbelous很有趣。:)

}0
^0
=0&2
&1
}0
^1\/
=0&02D3169
\/\/&0&1&2

这是一个从第一个命令行参数中将输入作为单个整数读取输入的程序。请注意，输入取模256，但这不会影响输入大于255的结果的有效性，因为256可被4整除。

说明

Marbelous是一种2D编程语言，它模拟掉入大量设备的“大理石”（字节值）。木板由2个字符宽的单元（设备）组成，可以处理大理石。落在电路板底部的所有内容都将打印到STDOUT。

让我们浏览一下正在使用的设备：

• }0是第一个命令行参数所在的位置。我已经使用了该设备的两个实例，因此（同时）获得了输入值的两个副本。
• ^n检查n输入大理石的th位（其中n=0最低有效位），并产生1或0取决于该位。
• =0与检查是否相等0。如果输入的弹珠相等，则将直接掉落，如果不相等，则将其推向右侧。
• \/ 是一个垃圾桶，所以它只会吞下输入的大理石，而不会产生任何东西。
• 2D是的ASCII代码-，31是的ASCII代码1和69是的ASCII代码i。
• 该&n是同步器。同步器会停顿一块大理石，直到所有同n一个同步器都握住一块大理石，这时它们都会让存储的大理石全部掉落。

因此，实际上，我要做的是将三个相关字符保留在三个同步器中，然后根据输入中最低有效位的设置方式释放它们。

有关更多信息，请参见规范草案。

JavaScript（ES6）29-5 = 24

支持负电源。

f=n=>(n&2?'-':'')+(n&1?'i':1)

ES5：

function f(n){return (n&2?'-':'')+(n&1?'i':1)}

Python 28字节-5 = 23

支持-ve输入。

假设可以接受lambda函数（感谢FryAmTheEggman！）：

lambda n:n%4/2*'-'+'1i'[n%2]

否则31个字节-5 = 26

print[1,"i",-1,"-i"][input()%4]

（Emacs）Lisp – 34

只是为了好玩，在（Emacs）Lisp中：

(lambda(n)(elt[1 i -1 -i](% n 4)))

如果要使用它，请使用defun或使用funcall：

(funcall
 (lambda (n) (elt [1 i -1 -i] (% n 4)))
 4) => 1

(mapcar
 (lambda(n)(elt[1 i -1 -i](% n 4)))
 [0 1 2 3 4 5 6 7 8])
 => (1 i -1 -i 1 i -1 -i 1)

APL（Dyalog），8个字符-15个红利=得分-7

内置（因此被禁止）的功能是0J1*⊢，但这使用@blutorange的方法。

¯12○.5×○

挑战作者Kezz101 写道：

如果支持任何实数，则可以任何有效的复数形式输出。

这将以复数形式返回复数，aJb这是APL显示复数的正常方式。

在线尝试！

说明

¯12○ 求出具有弧度角的单位向量

.5× 一半的时间

○ 自变量乘以𝜋（圆常数）

纯bash，29个字节-5 = 24

支持-ve输入。

a=(1 i -1 -i)
echo ${a[$1%4]}

Befunge- 98，41-5 = 36 35-5 = 30 32-5 = 27

&4%:01-`!4*+:2%'8*'1+\2/d*' +,,@

支持负整数。这种解决方案不会赢得任何奖项，但是无论如何。

它只是接受一个数字作为输入，对模数做一些欺骗（令人沮丧的是，它不像我用来测试它的解释器中的负数通常的模数那样工作）以使负数起作用，然后对决定每个字符应该是什么。

我确信这可以进一步进行下去。现在，这是另一种不接受负数的解决方案，但可以通过缩短奖金来弥补奖金的损失：

Befunge-98，32 26 23

&4%:2%'8*'1+\2/d*' +,,@

编辑 -现在利用以下事实：“-”距离“”有13（0xd）个字符。

编辑2-现在，再次利用以下事实：“ i” '8距离“ 1” 有56个字符（0x38或）。

Java 8得分：72

在Java中，这是有史以来最糟糕的高尔夫语言！打高尔夫球：

java.util.function.Function s=n->{new String[]{"i","-1","-i","1"}[n%4]};

展开：

class Complex{

    java.util.function.Function s = n -> {new String[]{"i","-1","-i","1"}[n%4]};

}

注意：我还不习惯Java8。我也没有运行时。请告诉我是否有语法错误。这也是我的第一个高尔夫。

编辑：已删除import。

编辑：删除类声明。

得分为87-15 = 72的另一个答案

java.util.function.Function s=n->{Math.cos(n*Math.PI/2)+"+"+Math.sin(n*Math.PI/2)+"i"};

展开：

class Complex{

    java.util.function.Function s = n -> {Math.cos(n * Math.PI/2) + " + " + Math.sin(n * Math.PI/2) + "i"};

}

MATLAB，33字节-5 = 28

x={'i','-1','-i','1'};x(mod(n,4))

即使增加了几个字节（37-5 = 32），我实际上还是更喜欢这种方法：

x='1i -';x((mod([n/2,n],2)>=1)+[3,1])

C 77

main(){int n;scanf("%d",&n);char c[]={n%4>1?'-':' ',~n%2?'1':'i',0};puts(c);}

由于Ruslan而有所改善

C 74-5 = 69

哦，当然是最明显的方法

main(){unsigned n,*c[]={"1","i","-1","-i"};scanf("%d",&n);puts(c[n%4]);}

OCaml 47

let m n=List.nth["1";"i";"-1";"-i"](n mod 4);;

这不是一个屡获殊荣的解决方案，但这是我第一次进行代码编程，因此我不确定自己在做什么。我尝试使用模式匹配，但这使我超过了58岁。

Pari / GP，19字节-5 = 14

$\mathbb{C}$$\mathbb{R}[x]/(x^2+1)$

n->Str(i^n%(i^2+1))

在i这里仅仅是一个符号，而不是虚数单位（这是I在帕里/ GP）。

在线尝试！

红宝石32-5 = 27

puts(%w[1 i -1 -i][gets.to_i%4])

适用于负功率！

Perl，26-5 = 21

say qw(1 i -1 -i)[pop()%4]

可以作为独立程序（命令行参数）或函数主体使用。

Java：151 131-5 = 126

打高尔夫球：

class A{public static void main(String[]a){int n=Integer.parseInt(a[0]);System.out.print(n%4==0?"1":n%4==1?"i":n%4==2?"-1":"-i");}}

取消高尔夫：

class A {
    public static void main(String[] a) {
        int n = Integer.parseInt(a[0]);
        System.out.print(n % 4 == 0 ? "1" : n % 4 == 1 ? "i" : n % 4 == 2 ? "-1" : "-i");
    }
}

作为函数：72-5 = 67

打高尔夫球：

void f(int n){System.out.print(n%4==0?"1":n%4==1?"i":n%4==2?"-1":"-i");}

取消高尔夫：

public void f(int n) {
    System.out.print(n % 4 == 0 ? "1" : n % 4 == 1 ? "i" : n % 4 == 2 ? "-1" : "-i");
}

是的，还有另一个Java答复-打高尔夫球比以往任何时候都要糟糕。但是您会尽力...

编辑：添加了功能版本。

编辑2：因此，经过一番反复试验之后，这是一个尝试按书进行操作的版本，而没有探讨循环漏洞。所以…

具有值计算的Java：146-15 = 131

打高尔夫球：

class B{public static void main(String[]a){float n=Float.parseFloat(a[0]);System.out.print(Math.cos((n*Math.PI)/2)+Math.sin((n*Math.PI)/2)+"i");}}

取消高尔夫：

class B {
    public static void main(String[] a) {
        float n = Float.parseFloat(a[0]);
        System.out.print(Math.cos((n * Math.PI) / 2) + Math.sin((n * Math.PI) / 2) + "i");
    }
}

（至少，我认为我可以要求最高奖金，否则请更正我）

的Python-31

print[1,'i',-1,'-i'][input()%4]

我最近才开始学习python。即使我知道这不好，这也是我能做的最好的。

Haskell GHCi，29字节-15 = 14

i p=[cos(p*pi/2),sin(p*pi/2)]

用法：

*Main> i 0
[1.0,0.0]
*Main> i pi
[0.22058404074969779,-0.9753679720836315]
*Main> i (-6.4)
[-0.8090169943749477,0.5877852522924728]

R，29-5 = 24字节

c(1,"i",-1,"-i")[scan()%%4+1]

在线尝试！

与上面的大多数方法相同，取4的模，并将其取1，因为R的数组是1索引的。也适用于负整数。

我在这里担心混合输出，但是Giuseppe指出，当R将数字类型混合时，它们会将数字类型强制转换为字符串类型。

PowerShell，28字节-5 = 23

('i',-1,'-i',1)["$args"%4-1]

在线尝试！

所有循环索引的端口

Haskell，29个字节-5 = 24

f n=words"1 i -1 -i"!!mod n 4

适用于负功率。

我设计了一个无点版本，但事实证明它实际上更长。

f=(words"1 i -1 -i"!!).(`mod`4)

Clojure（64 54 31个字符）

(defn i2n[n](println(case(mod n 4) 1 "i" 2 "-1" 3 "-i" 0 "1")))

编辑

根据@SeanAllred的建议，以下是使用文字向量而不是case函数的版本：

(defn i2n[n](println (["1" "i" "-1" "-i"] (mod n 4))))

编辑2

通过依靠REPL打印出结果集合并使用#()快捷方式对函数进行编码，我们可以将其简化为

#(["1" "i" "-1" "-i"](mod % 4))

（实际上，这比Clojure / Lisp-ish要多得多，因为该函数现在实际上返回生成的结果，从而允许该函数与一起使用map，如

(map #(["1" "i" "-1" "-i"](mod % 4)) [0 1 2 3 4 5 6 7 8])

哪个打印

("1" "i" "-1" "-i" "1" "i" "-1" "-i" "1")

分享并享受。

Groovy：27-5 = 22

f={n->[1,'i',-1,'-i'][n%4]}

C 105是117

char c[2];
int main()
{
int n,i,j=0;scanf("%d",&n);i=n%4;
i>1?c[j++]='-':c[j+1]='\0';
c[j]=i&1?'i':'1';
puts(c);
}

PARI / GP，26-5 = 21

n->Str([1,I,-1,-I][n%4+1])

n->cos(t=Pi*n/2)+I*sin(t)短一个字符，但不能处理确切的答案。当然n->I^n是不允许的，大概也是PARI的powIs。

果冻，2-20 = -18字节

ı*

在线尝试！

它不使用i ^ x内置函数，而是使用内置函数1j，**因此不确定是否允许。

05AB1E，得分5（10 字节 -5奖励）

'i®„-i1)Iè

在线尝试或验证更多测试用例。

说明：

'i         '# Push character "i"
  ®         # Push -1
   „-i      # Push string "-i"
      1     # Push 1
       )    # Wrap everything on the stack into a list: ["i", -1, "-i", 1]
        Iè  # Use the input to index into it (0-based and with automatic wrap-around)
            # (and output the result implicitly)