编写一个脚本，将其写到标准输出或您的语言的等效输出中，以以下内容开头的100行Java代码：

class Tuple1 {public Object _0;}
class Tuple2 {public Object _0,_1;}
class Tuple3 {public Object _0,_1,_2;}
class Tuple4 {public Object _0,_1,_2,_3;}
class Tuple5 {public Object _0,_1,_2,_3,_4;}
class Tuple6 {public Object _0,_1,_2,_3,_4,_5;}
class Tuple7 {public Object _0,_1,_2,_3,_4,_5,_6;}
class Tuple8 {public Object _0,_1,_2,_3,_4,_5,_6,_7;}
class Tuple9 {public Object _0,_1,_2,_3,_4,_5,_6,_7,_8;}
class Tuple10 {public Object _0,_1,_2,_3,_4,_5,_6,_7,_8,_9;}
class Tuple11 {public Object _0,_1,_2,_3,_4,_5,_6,_7,_8,_9,_10;}
class Tuple12 {public Object _0,_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11;}

最后一行应以开头class Tuple100。

这是代码高尔夫球，因此以字节为单位的最短代码胜出！

Jolf，42个字节

我有史以来最好的分数击败果冻吗？包含无法打印的内容，因此您可能想在此处在线尝试。为了便于阅读，我将不可打印的内容替换为其各自的alt索引。

‼Μz~1d"Ξ/êί Tuple% {Ξ0î⌂ Ξ2Qμ_ %;}"HRzH",_

说明

‼Μz~1d"Ξ/êί Tuple% {Ξ0î⌂ Ξ2Qμ _%;}"HRzH",_
 Μz~1d                                     map the range 1..100 with the following function
      "                                    begin a string
       Ξ/êί                                short for "class"
            Tuple% {               H       string interpolate H (current number)
                    Ξ0î⌂ Ξ2Qμ              short for "public Object"
                              _%;}" RzH    string interpolate with a range from 1..H joined
                                       ",_  by the string ",_" (auto-closed quotes)

vim 56 54击键

iclass Tuple1 {public Object _0;}<esc>qyYp<C-a>$y2bPr,<C-a>q98@y

由于V向后兼容，因此您可以在线尝试！

这是vim的完美任务！我可能以后再打高尔夫球。另请注意，这<c-a>表示Control-A，它算作一次按键。

说明：

iclass Tuple1 {public Object _0;}<esc>         'Enter the starting text


qy                          'Start recording in register y
  Yp                        'Yank the current line, the print on the line below
     <C-a>                  'Increment the next digit to occur by one
          $                 'Move to the end of this line
           y2b              '(yank) 2 words (b)ack. This will grab '_0;'
              P             'Print the previously yanked word before the cursor.
               r,           '(r)eplace the char under the cursor with a comma.
                 <c-a>q     'Increment the current digit, then stop recording
                       99@y 'Playback macro 'y' 99 times.

果冻，44个字节

R’j“,_”
“¤>%,oỊȤʠ“ØụĊ5D³ṃṠɼQ»j;Ç;“;}¶”
ȷ2RÇ€

我的第一个果冻答案。在线尝试！

Pyth，53 50 48字节

VS100%." }SüÆðQ´Ó3Ô«%&a´4UçõÛ"[Nj",_"UN

在线尝试！

在range（1,100）上直接进行迭代，并通过格式化将字符串打包成相应的字符串。

说明

VS100％。“} SüÆðQ´Ó3Ô«％＆a´4UçõÛ” [Nj“，_” UN

VS100＃迭代范围（1,100）
     ％。“”} SüÆðQ´Ó3Ô«％＆a´4UçõÛ“＃解压缩字符串并将其格式化
                              [＃用于格式化参数的列表
                               N＃元组数
                                j UN＃连接对象编号...
                                 “，_”＃...在分隔符上，“ _”

解压后的字符串是 class Tuple%i {public Object _%s;}

CoffeeScript，86 84字节

console.log "class Tuple#{i} {public Object _#{[0...i].join ',_'};}"for i in[1..100]

在线查看解决方案

Java中，160，125个字节

感谢@ DenkerAffe，@ Denham Coote和@Mathias Ettinger所做的改进。

Java编写Java（因为有人必须这样做！）

void z(){String s="_0";for(int i=1;i<101;){System.out.println("class Tuple"+(i++)+" {public Object "+s+";}");s+=",_"+i;}}

和非高尔夫版本

void z(){
    String s = "_0";
    for(int i = 1 ;i < 101;){
        System.out.println("class Tuple" + (i++) + " {public Object "+ s + ";}");
        s += ",_" + i;
        }
    }

Oracle SQL 9.2， 138 137字节

SELECT REPLACE('class Tuple'||LEVEL||' {public Object'||SYS_CONNECT_BY_PATH(LEVEL-1,',_')||';}','t,','t ')FROM DUAL CONNECT BY LEVEL<101;

@Peter感谢指出0/1错误。

该查询使用层次查询的CONNECT BY CLAUSE生成100行。

LEVEL伪列包含每行的行号。

SYS_CONNECT_BY_PATH连接第一个参数，即每行的行号，并使用第二个参数作为分隔符。

批处理，128字节

@set m=_0
@for /l %%t in (1,1,100)do @call:b %%t
@exit/b
:b
@echo class Tuple%1 {public Object %m%;}&set m=%m%,_%1

编辑：由于@Bob，节省了10个字节。感谢@EʀɪᴋᴛʜᴇGᴏʟғᴇʀ，节省了1个字节。

视网膜，80 79字节

字节数假定为ISO 8859-1编码。

100$*1
1
class Tuple11$` {public Object 1$`}¶
1(?<= (1+))
_$1,
1(1)*
$#1
,}
;}

在线尝试！

Powershell-65字节

（根据评论进行修订）

全部归功于TimmyD

1..100|%{"class Tuple$_ {public Object _$(0..($_-1)-Join",_");}"}

Perl 6、65字节

say "class Tuple$_ \{public Object _{join ',_',^$_};}" for 1..100

的R - 199个 132 123 118字节

版本4

p=paste0;for(i in 1:10)cat(p("class Tuple",i," {public Object ",toString(sapply(0:(i-1),function(x)p("_",x))),";}\n"))

版本3

p=paste0;for(i in 1:8)cat(p("class Tuple",i," {public Object ",p(sapply(0:(i-1),function(x)p("_",x)),collapse=","),";}\n"))

版本2

p=paste0;for(i in 1:100)cat(p("class Tuple",i," {public Object ",p(sapply(0:(i-1),function(x)p("_",x)),collapse=","),";}"),sep="\n")

版本1

for (i in 1:100){
  foo <- paste0("class Tuple", i, " {public Object ")
  for (j in 0:(i - 1)){
    foo <- if (j < (i - 1)) paste0(foo, "_", j, ",") else paste0(foo, "_", j, ";}")
  }
  print(foo)
}

Ruby，71个字节

100.times{|i|puts"class Tuple#{i+1} {public Object _#{[*0..i]*',_'};}"}

Java，103个字节

s->{s="_0";for(int i=0;i++<100;s+=",_"+i)System.out.printf("class Tuple%s {public Object %s;}\n",i,s);}

我第一次来 嗨，您好！我去了一个Java8 lambda表达式（又名匿名函数）。

非高尔夫版本

s -> {
    s = "_0";
    for (int i = 0; i++ < 100; s += ",_" + i)
        System.out.printf("class Tuple%s {public Object %s;}\n", i, s);
}

要像在Java8中一样，实际使用它，必须将其分配给适当的功能接口的变量（或将其强制转换为），然后调用其方法。但是从技术上讲，该函数只是lambda表达式本身，因此我仅在此数数。

它还需要一个输入参数，这可以节省几个字节，因为我可以将其用作局部变量而不必指定其类型。我不确定这是否被认为是作弊，但对我来说似乎在规则之内：我只看到人们声明允许发布函数，而不是如何调用该函数。:)而且它实际上并没有读取参数，因此该函数仍然是独立的；您可以将任何String传递给它，甚至可以传递null，它将仍然产生正确的输出。

这是如何使用它：

import java.util.function.Consumer;

public class Main {
    public static void main(String[] args) {
        Consumer<?> r =
            s->{s="_0";for(int i=0;i++<100;s+=",_"+i)System.out.printf("class Tuple%s {public Object %s;}\n",i,s);}
        ;
        r.accept(null); 
    }
}

python 2，96

def f(n=99):s=n and f(n-1)+',_'+`n`or"class Tuple%d {public Object _0";print s%-~n+';}';return s

Python 3、98

def f(n=99):s=n and f(n-1)+',_%d'%n or"class Tuple%d {public Object _0";print(s%-~n+';}');return s

用法：

f()

取消高尔夫：

def javatuple(n=99):
    if n == 0:
        s = "class Tuple%d {public Object _0"
    else:
        s = javatuple(n-1) + ',_' + str(n)
    print(s%(n+1) + ';}')
    return s

前者：

103

r=range
for i in r(100):
 print"class Tuple%d {public Object _%s;}"%(i+1,',_'.join(`j`for j in r(i+1)))

108

def f(n=99):
 if n:f(n-1)
 print"class Tuple%d {public Object _%s;}"%(n+1,',_'.join(`i`for i in range(n+1)))

CJam，53个字节

100{)"class Tuple"\" {public Object _"1$,",_"*";}
"}/

在这里尝试。

Groovy，74个字符

“ join（）”无与伦比...感谢@yariash，这是新的解决方案

100.times{println"class Tuple$it {public Object _${(0..it-1).join',_'};}"}

旧解决方案，共78个字符：

(1..100).each{println"class Tuple$it {public Object _${(0..it-1).join',_'};}"}

朱莉娅77字节

for i=1:100;println("class Tuple$i {public Object _$(join(0:i-1,",_"));}")end

Lua，128106字节

我仍在尝试找到一种直接在打印值而不是字符串上工作的方法。

编辑：部分找到它！我仍然需要一个字符串作为“ _0，_1 ...”部分，但这已经更好了:)。

s=""for i=0,99 do s=(s..",_"..i):gsub("^,",s)print(("class Tuple"..(i+1).." {public Object ")..s..";}")end

旧的128字节解决方案

s="class Tuple1 {public Object _0;}"print(s)for i=1,99 do s=s:sub(1,s:find";"-1):gsub("e%d+","e"..i+1)..",_"..i..";}"print(s)end

不打高尔夫球

s=""
for i=0,99
do
  s=(s..",_"..i)              -- concatenate s with ",_i"
      :gsub("^,",s)           -- remove the leading "," for ",_0"
  -- then print the concatenated string
  print(("class Tuple"..(i+1).." {public Object ")..s..";}")
end

Python 3 111 109 105字节

[print('class Tuple%s {public Object %s;}'%(i,','.join('_%i'%j for j in range(i))))for i in range(1,101)]

这不是世界上最短的事情，我只是参加。

edit1：0,先删除2个字节range

edit2：我不必要地转换int为，str而不是仅仅使用%i...降至105。

Mathematica，130字节

{"class Tuple",ToString[#]," {public Object ",StringReplace[ToString[#-1&/@Range@#],{" "|"{" ->"_","}"->";}\n"}]}&/@Range[100]<>""

Scala，85字节

for(u<-1 to 100)println(s"class Tuple$u {public Object _${0 to u-1 mkString ",_"};}")

爪哇，116

^{（仅用于打印功能-根据一些评论，这符合规则）}

import static java.lang.System.*;
public class T
{
    public static void main(String[] args)
    {
        T t = new T();
        t.p();
    }

    void p(){String s="_0";for(int i=0;i<100;){out.println("class Tuple"+ ++i+" {public Object "+ s + ";}");s+=",_"+i;}}
}

PHP，112字节

<?php for($i=0;$i<100;$i++){$m.=$i==0?'_'.$i:',_'.$i;echo 'class Tuple'.($i+1).' {public Object '.$m.';}<br/>';}

严重的是55个字节

2╤R`;r"$'_+"£M',j@k"c╙ò T╒α%d {pu▐V Object %s;}"⌡%`M'
j

十六进制转储（与可逆xxd -r）：

00000000: 32e2 95a4 5260 3b72 2224 275f 2b22 c2a3  2...R`;r"$'_+"..
00000010: 4d27 2c6a 406b 2263 e295 99c3 b220 54e2  M',j@k"c..... T.
00000020: 9592 ceb1 2564 207b 7075 e296 9056 204f  ....%d {pu...V O
00000030: 626a 6563 7420 2573 3b7d 22e2 8ca1 2560  bject %s;}"...%`
00000040: 4d27 0a6a                                M'.j

在线尝试！

是的，该换行符应该在那里。

说明（用换行符替换\n）：

2╤R`;r"$'_+"£M',j@k"c╙ò T╒α%d {pu▐V Object %s;}"⌡%`M'\nj
2╤R                                                       push range [1,100]
   `                                              `M      map:
    ;r                                                      push a, range(a)
      "$'_+"£M                                              map:
       $'_+                                                   stringify, prepend "_"
              ',j                                           join with commas
                 @k                                         swap and push stack as list
                   "c╙ò T╒α%d {pu▐V Object %s;}"⌡           decompress, result is
                                                              "class Tuple%d {public Object %s;}"
                                                 %          string format
                                                    '\nj  join with newlines

Japt，52个字节

Lo £`cÓ? TÕà{X} \{puÞV Object {Xò ®'_+Z}&}` r&59d} ·

的?应为原义字节0x95。在线测试！

Japt具有：

• 简洁的语法有助于缩短代码。
• 字符串压缩以帮助进一步缩短它。
• 许多错误，使您想要将计算机扔到窗外。

我什至不能在字符串中使用分号，因为它包装的函数希望在分号后返回所有内容。这只能是46个字节：

Lo £`cÓ? TÕà{X} \{puÞV Object {Xò ®'_+Z};}`} ·

但是，事实并非如此。我将看看能否在接下来的几个小时内修复这些错误。

这个怎么运作

Lo £       }  // Generate the range [0..100), and map each item X in this range to:
`cÓ? TÕà{X}   //  "class Tuple" + X +
\{puÞV Object //  "{public Object" +
{Xò ®'_+Z}    //   Create the range [0..X] and map each item Z to "_" + Z.
              //   Upon stringification, this automatically inserts the commas.
&}`           //  + "&}"
r&59d         //  Replace the "&" with String.fromCharCode(59), or ";".
·             // Join the result with newlines.

Javascript，112110字节

感谢@CᴏɴᴏʀO'Bʀɪᴇɴ2字节。

_=>[...Array(100)].map((x,i)=>`class Tuple${++i} {public Object ${[...Array(i)].map((y,j)=>'_'+j)};}`).join`
`

取消高尔夫：

_=>                                         // anonymous function
    [...Array(100)].map((x,i)=>             // 100 times [0..99]
        `class Tuple${++i} {public Object   // Tuple index + 1
            ${[...Array(i)].map(            // (index + 1) times
                (y,j)=>'_'+j                // _+j with j in [0..index]
            )}                              // Array without join prints comma in between
        ;}`                                 // as literal string
    ).join`\n`                              // display array line by line

Groovy，97个字节

(1..100).each{println "class Tuple${it} {public Object ${(0..it-1).collect{"_$it"}.join(',')};}"}

在线尝试！

Python 2，96字节

r=range
for i in r(1,101):print"class Tuple%d {public Object _%s;}"%(i,',_'.join(map(str,r(i))))

感谢@DenkerAffe有关使用的建议lambda。

感谢@MathiasEttinger的join想法。

C ++， 164 159 157个字节（仅155个功能）

#include <iostream>
#define o std::cout<<
int main(){int j,i=0;for(;i<100;++i){o"class Tuple"<<i+1<<" {public Object _0";for(j=0;++j<=i;)o",_"<<j;o";}\n";}}

这是一个完整程序。如果替换为int main()，则可以仅函数形式保存2个字节void f()。

在Ideone中运行代码

空洞的，包括宏扩展

#include <iostream>
int main()
{
    int j,i=0;
    for(;i<100;++i)
    {
        std::cout << "class Tuple"<< i+1 <<" {public Object _0";
        for(j=0;++j<=i;)
            std::cout << ",_" << j;
        std::cout << ";}\n";
    }
}