Соревнование

Напечатайте красивую рождественскую елку со своей звездочкой вверху, используя самый короткий код. Звезда дерева - это звездочка ( *), а тело дерева сделано из 0дерева. Высота дерева должна быть 10 рядов. Каждая строка должна иметь правильные отступы так, чтобы предыдущая строка центрировалась над следующей. Любая строка должна иметь на 2 больше нулей, чем предыдущая, за исключением первой, которая является звездой, и второй, которая имеет только один 0. Результат примерно такой:

          *
          0
         000
        00000
       0000000
      000000000
     00000000000
    0000000000000
   000000000000000
  00000000000000000

Разрыв связи для деревьев с изменяемой высотой без изменений программного обеспечения (кроме изменения параметра высоты)

Пожалуйста, вставьте получившееся дерево вашего кода тоже!

Leaderboard

var QUESTION_ID=4114,OVERRIDE_USER=73772;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;

body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>

Гольфскрипт, 27 символов

" "9*"*"9,{n\.4$>\.+)"0"*}%

Результирующее дерево выглядит так:

         *
         0
        000
       00000
      0000000
     000000000
    00000000000
   0000000000000
  000000000000000
 00000000000000000

Версия, которая использует параметр высоты только один раз, на один символ длиннее:

9." "*"*"@,{n\.4$>\.+)"0"*}%

Чтение высоты из стандартного ввода (с вводом «10» для генерации дерева примеров) занимает столько же символов (28):

~,)" "*"*"@{n\.4$>\.+)"0"*}%

Я знаю, что это не соответствует спецификации, но я подумала, что попытаюсь добавить сюда разнообразия деревьев, подражая этой классической рождественской сцене ASCII, созданной Джоан Дж. Старк .

Я не пытался воспроизвести всю картинку - это было бы слишком много, - но только дерево, для которого я представляю эту 138-байтовую программу Perl:

$_=join$/,qw'11| 8\2_2/ 9(\o/) 5---2/1\2--- 10>*<',map(11-$_.A.AA x$_,2..11),'9\|H|/';s/\d+/$"x$&/eg,s/A/substr">>>@*O<<<",rand 9,1/eg,say

И, конечно, вот пример вывода:

           |
        \  _  /
         (\o/)
     ---  / \  ---
          >*<
         >O><@
        <><<>><
       @><><>@<<
      @<O><*@*>>O
     OO@@*O<<<*<OO
    ><<>@><<>@<><><
   >><O<>>><@*>>><<O
  *<>*<><<>@><O*>><*<
 O><><<@<*>><O*@>O><>*
O<><<><@O>>*O*OO<><<>O>
         \|H|/

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

Код использует sayфункцию Perl 5.10+ , поэтому его необходимо запускать с помощью -M5.010(или -E) переключателя командной строки. (На самом деле, просто замена sayв конце на это printпозволит избежать этого за счет еще двух байтов и потери перевода строки после последней строки вывода.)

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

Чтобы не допустить, чтобы этот популярный ответ был полностью удален в соответствии с политикой, установленной после его публикации , вот также решение, совместимое со спецификацией токена (45 байт, также Perl 5):

$_=$"x10 ."*";say,s/ 0/00/,s/\*?$/0/ while/ /

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

Как и в приведенной выше программе, эту программу также необходимо запустить на Perl 5.10+ с -M5.010переключателем, чтобы включить эту sayфункцию. Очевидно (это вызов сложности Колмогорова ), он выдает точно такой же скучный вывод, как и все другие совместимые записи, которые я не буду здесь повторять. (Это также тривиально изменить размер, изменив число 10на любое другое значение.)

GolfScript (33 символа)

Версия с фиксированной высотой:

;8:^' '*.'*'+\'0'+^{.(;'00'+}*]n*

Или точно такой же длины

;8:^' '*.'*'+n@'0'+^{.n\(;'00'+}*

Дерево выглядит удивительно похоже на все остальные:

        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000

Версия, которая берет высоту от стандартного ввода:

~((:^' '*.'*'+\'0'+^{.(;'00'+}*]n*

Начало предыдущей строки - один из лучших смайликов, которые я сделал в «полезной» программе GolfScript.

Сценарий оболочки, 44 символа

printf %9c\\n \* 0|sed ':x
p;s/ 0/000/;tx
d'

Печатает это дерево:

        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000

Клен, 30/37 символов

Вдохновленный записью Mr.Wizard's Mathematica , я представляю команду Maple 12 из 30 символов:

<`*`,('cat(0$2*i+1)'$i=0..8)>;

Выход:

                              [        *        ]
                              [                 ]
                              [        0        ]
                              [                 ]
                              [       000       ]
                              [                 ]
                              [      00000      ]
                              [                 ]
                              [     0000000     ]
                              [                 ]
                              [    000000000    ]
                              [                 ]
                              [   00000000000   ]
                              [                 ]
                              [  0000000000000  ]
                              [                 ]
                              [ 000000000000000 ]
                              [                 ]
                              [00000000000000000]

Я также могу избавиться от скобок за счет еще семи символов:

`*`;for i in$0..8 do;cat(0$2*i+1);od;

Вывод опущен - выглядит так же, как и выше, только без скобок. К сожалению, я не знаю способа удержать Maple от вставки пустых строк между строками вывода в текстовом режиме. Это выглядит лучше в классическом режиме листа. Я думаю, я мог бы включить скриншот ...

(На снимке экрана показана более ранняя версия команды из 44 символов, но мне лень ее пересдавать. Вывод остается прежним.)

Да, да, размер полностью настраивается: просто замените 8 на n -2 для n- рядного дерева. В первом решении, если вы идете выше 25 строк (или 10 в графическом интерфейсе), требуется также установить интерфейс (rtablesize = n ).

(PS. Я думал, что смог победить GolfScript с последней версией, но увы ... )

Perl, 42 символа

say$"x9,"*";say$"x(9-$_),"00"x$_,0for 0..8

Выход:

         *
         0
        000
       00000
      0000000
     000000000
    00000000000
   0000000000000
  000000000000000
 00000000000000000

Высоту дерева можно изменить между 1 и 11 строками, заменив 8в конце значения от -1до 9. Чтобы перейти выше 11 строк, необходимо также увеличить два 9кода ранее в коде, которые контролируют, как далеко от левой части экрана будет отступать дерево.

Groovy, 65

(p={c,r->println' '*(9-r)+(c*(r*2-1))})'*',1;(1..9).each{p'0',it}

Удивительно, но дерево выглядит так:

        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000

Рубин, 46 знаков

puts" "*8+?*;9.times{|i|puts"%8s0"%(v=?0*i)+v}

Для того, чтобы изменить высоту, вам нужно изменить и 8, и, конечно, также 9. Результат программы следующий:

        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000

Редактировать : непростительно я опустил вывод в первом представлении.

PowerShell, 41

" "*8+"*";0..8|%{" "*(8-$_)+"0"+"0"*$_*2}

Неудивительно, что выводит то же дерево, что и все остальные :-p

Если вы параметризуете эту 8, она будет соответствовать размеру вашей консоли, скажем, 48 символов :

" "*($w=8)+"*";0..$w|%{" "*($w-$_)+"0"+"0"*$_*2}

Или, как полноценный скрипт, который принимает аргумент, 53 символа :

param($w)" "*$w+"*";0..$w|%{" "*($w-$_)+"0"+"0"*$_*2}

Называется, это выглядит так:

PS>: Get-Tree.ps1 8
        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000

Python 3: 62 персонажа

print(' '*9+'*',*('\n'+' '*(9-i)+'0'*(i*2+1)for i in range(9)))

Выход:

        * 
        0 
       000 
      00000 
     0000000 
    000000000 
   00000000000 
  0000000000000 
 000000000000000
00000000000000000

Обратите внимание, что это существенно превосходит ответ @ Ante на 11 символов, потому что этот ответ при преобразовании в Python 3 использует 73 символа.

Измените каждое 9значение на другое для другой высоты.

Python, 59

print' '*9+'*'
for i in range(9):print' '*(9-i)+'0'*(i*2+1)

Пролог: 183 или 186

r(0,_,L,L).
r(N,C,L,[C|T]):-N>0,M is N-1,r(M,C,L,T).
y(S,T,C):-r(T,C,[10],X),r(S,32,X,Y),atom_codes(A,Y),write(A).
x(A,B):-A>0,y(A,B,48),C is A-1,D is B+2,x(C,D).
x(N):-y(N,1,42),x(N,1).

Печать:

         *
         0
        000
       00000
      0000000
     000000000
    00000000000
   0000000000000
  000000000000000
 00000000000000000
false.

Может быть сжато для некоторых переводчиков (например, с помощью tab / 1 на SWI)

Вызвать с помощью x (N). Где N - количество строк в реальном дереве (исключая звездочку). Придание ему фиксированной высоты снизило бы его до 183.

С

Это версия C Уэйда Тэнди, но немного измененная:

           ;
          int
         main(
        ){int i
       =-1,j=0,c
      =10;while(j
     ++<c){printf(
    " ");}{;printf(
   "*");}while(++i<c
  ){for(j=-2;++j<c-i;
 )printf(" ");for(j=0;
++j<2*i;){printf("0");}
          ;;;
        printf(
         "\n")
          ;}}

Математика, 50

MatrixForm@Prepend[Row/@Table[0,{n,9},{2n-1}],"*"]

Applesoft BASIC, 143 символа

Поскольку этот вопрос напоминает мне домашнее задание, которое я получил в старшей школе (когда они учили на Apple // e):

1INPUTH:X=(H*2)-2:C=(X/2):S$="*":O=0:GOSUB2:S$="0":FORO=0TOX-2STEP2:GOSUB2:NEXT:END
2FORS=0TOC-(O/2):?" ";:NEXT:FORI=0TOO:?S$;:NEXT:?"":RETURN

Я использовал JavaScript Applesoft BASIC, найденный здесь: http://www.calormen.com/applesoft/

ВЫХОД:

?10
          *
          0
         000
        00000
       0000000
      000000000
     00000000000
    0000000000000
   000000000000000
  00000000000000000

Пролог: 127 символов

p:-write('        *'),h(1).
h(L):-(L<10,nl,w(L,-8),h(L+1));!.
w(L,N):-(N<9,N<L,(L>abs(N)->write('0');write(' ')),w(L,N+1));!.

Выход:

        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000
true 

Используется Prologпотому, что я не смог побить Groovyрекорд, не посмотрев на его код :(.

PostScript (с параметризованной высотой), 114 символов

/h 9 def/b{{( )=print}repeat}def
h -1 0{dup h eq{dup b(*)=}if dup b h sub neg 2 mul 1 add{(0)=print}repeat()=}for

Выход:

         *
         0
        000
       00000
      0000000
     000000000
    00000000000
   0000000000000
  000000000000000
 00000000000000000
0000000000000000000

Что, ты хотел распечатать?

JavaScript (Rhino: 108, узел: 114, консоль разработчика Webkit: 119, плагин jQuery: 132)

Rhino является самым коротким (из 108 символов), потому что (a) его printфункция имеет короткое имя и (b) она позволит вам назначать встроенные функции в более короткое имя переменной. Так:

h=10,p=print,m='0',a=Array(h-1),s=a.join(' ');p(s+'*\n'+s+m);while(h-->2){m+='00';a.pop();p(a.join(' ')+m);}

Node.js прибывает console.logза короткую секунду (с 114 символами), потому что его функция печати имеет более длинное имя, но это также позволит нам присвоить это и короткой переменной:

h=10,p=console.log,m='0',a=Array(h-1),s=a.join(' ');p(s+'*\n'+s+m);while(h-->2){m+='00';a.pop();p(a.join(' ')+m);}

Однако консоль разработчика Webkit (и, вероятно, Firebug тоже) считает, что p=console.logона слишком подлая (когда вы пытаетесь позвонить p(), она будет жаловаться на вас). Итак, мы должны удлинить до 119 символов:

h=10,m='0',a=Array(h-1),s=a.join(' ');with(console){log(s+'*\n'+s+m);while(h-->2){m+='00';a.pop();log(a.join(' ')+m);}}

(Интересно, withтолько нас спасает персонаж).

Наконец ... плагин jQuery (все еще с возможностью твитнуть в 132 символа!):

$.fn.xms=function(h){var m='0',w=2,l=['*',m];while(w++<h)l.push(m+='00');$(this).css({textAlign:'center'}).html(l.join('\n<br/>'));}

И вы можете вызвать его в нижней части этой самой страницы: $('#footer').xms(3)

Конечно, это не обязательно должен быть плагин ... поскольку нам, вероятно, пришлось бы использовать консоль JavaScript, чтобы добавить ее на страницу и вызвать ее, мы могли бы просто сделать фрагмент jQuery :

h=10,m='0',w=2,l=['*',m];while(w++<h)l.push(m+='00');$('#footer').css({textAlign:'center'}).html(l.join('\n<br/>'));

который весит более конкурентоспособных 116 символов - на самом деле, он превосходит другие реализации консоли разработчика. Но, опять же, использование jQuery и / или механизма компоновки браузера может считаться обманом. :)

С, 67

Я знаю, что это давно закончилось, но это моя первая попытка написать код-гольф, и я думаю, что у меня есть довольно хорошее C-решение.

Интересно, что я придумал это независимо от очень похожего решения @ Patrick.

И да, я не выиграю никаких связей с моими жестко закодированными ценностями;) В любом случае, я вполне доволен.

i;main(){for(;i<10;++i)printf("%*s%0*c\n",i?9-i:8,"",i*2,i?32:42);}

        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000
Нажмите любую клавишу для продолжения . , ,

оракул

select lpad('*', 11) from dual
union all
select rpad(' ', 10 - level) || rpad(' ', level * 2, '0') from dual
connect by level <= 9;


          *
          0
         000
        00000
       0000000
      000000000
     00000000000
    0000000000000
   000000000000000
  00000000000000000

10 rows selected.

PHP, 106 символов

На 7 меньше, чем предыдущий:

<?php echo str_pad(' ',9)."*\n";for($i=0;$i<9;$i++){echo str_pad("",9-$i).str_pad("",($i*2)+1,"0")."\n";}

LOLCODE, 527 байтов

CAN HAS STDIO?
HAI 1.2
IM IN YR LOOP UPPIN YR VAR TIL BOTH SAEM VAR AN 8
    VISIBLE " "!
IM OUTTA YR LOOP
VISIBLE "*"
I HAS A SPACES
SPACES R 8
I HAS A ZEROS
ZEROS R 1
IM IN YR LOOP UPPIN YR VAR TIL BOTH SAEM VAR AN 9
    IM IN YR LOOP UPPIN YR VAR2 TIL BOTH SAEM VAR2 AN SPACES
        VISIBLE " "!
    IM OUTTA YR LOOP
    IM IN YR LOOP UPPIN YR VAR2 TIL BOTH SAEM VAR2 AN ZEROS 
        VISIBLE "0"!
    IM OUTTA YR LOOP
    VISIBLE ""
    SPACES R DIFF OF SPACES AN 1
    ZEROS R SUM OF ZEROS AN 2
IM OUTTA YR LOOP
KTHXBYE

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

Выход:

        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000

Python, 70 символов

Не очень короткое, но рекурсивное решение :-)

def a(s):
 print s
 if s<"0":a(s[1:]+"00")
print" "*8+"*"
a(" "*8+"0")

Измените 8 для установки высоты.

Javascript, 119 знаков

Выходы в консоль firebug

i=h=9;a=new Array(h);a[0]=a.join(' ');b=a.join('000');a[0]+='*';while(i)a[i--]=b.substr(i,h+i);console.log(a.join('\n'))


        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000

PHP 113

Подумал, я бы включил с PHP-версии:

113 символов (настроить, $hчтобы изменить высоту, количество строк включает звезду):

$h=10;for($n=0;$n<$h;$n++){$i=$n>0?$n:1;$c=$n<1?"*":"0";echo str_repeat(" ",$h-$i).str_repeat($c,($i*2)-1)."\n";}

Я попытался сделать его коротким, не читаемым, и мы уже знали, что php не может соревноваться в краткости, так что это ничего не выиграет, все еще забавная маленькая головоломка.

выход как спецификация:

        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000

С, 77

i;main(c){printf("%*c\n",c,42);while(i<c)printf("%*s%0*d\n",c-i,"",i++*2+1,0);}

Прежде чем читать спецификацию printf более тщательно, у меня было это милое маленькое число до 138 символов:

#define x sprintf(b,
#define y printf(b,
i;main(c){char b[9]="%%%dc\n",*t="%%%ds%%0%dd\n";x b,c);y 42);while(i<c)x t,c-i,i++*2+1),y "",0);}

Ява, 192 (198 с параметром)

class V{public static void main(String[]a){int c=10,i=-1,j=0;String s="";while(j++<c)s+=" ";s+="*";while(++i<c){for(j=-2;++j<c-i;)s+=" ";for(j=0;++j<2*i;)s+="0";System.out.println(s);s="";}}}

Печатает запрошенное дерево:

        *           
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000

Для переменной высоты, немного длиннее:

class W{public static void main(String[]a){int c=a.length,i=-1,j=0;String s="";while(j++<c)s+=" ";s+="*";while(++i<c){for(j=-2;++j<c-i;)s+=" ";for(j=0;++j<2*i;)s+="0";System.out.println(s);s="";}}}

Длина списка аргументов командной строки определяет высоту (например java W a a a a a, даст высоту 5).

(Это в основном Java-версия решения С Уэйда Тэнди.)

Vim, 18 байт

17i0<esc>qqYPxr q8@qa*

Попробуйте онлайн в обратно-совместимом V-интерпретаторе!

Несмотря на то, что это очень подобный подход , как мой V ответ, на этот раз не не конкурирующих , так как Vim сумасшедший старый. :)

Объяснение:

17i0<esc>               " Insert 17 '0's
         qq     q       " Start recording into register 'q'
           YP           " Duplicate this line upwards
             x          " Delete one character
              r         " Replace this character with a space
                 8@q    " Playback macro 'q' 8 times
                    a*  " Append an asterisk

Scala, 74 байта

val h=10;println(" "*h+"*");for(i<-0 to h-2)println(" "*(h-i)+"0"*(i*2+1))

h - высота дерева

Выход

        *          
        0          
       000         
      00000        
     0000000       
    000000000      
   00000000000     
  0000000000000    
 000000000000000   
00000000000000000  

С, 80

i=9,k=10,j;main(F){while(i)putchar(++j<i?32:j<k?48-F*6:(i-=!F,k+=!F,F=j=0,10));}

Инициализируйте k до высоты дерева, i до k-1. F - флаг первой строки. Если аргументов нет, то F должен быть 1 при входе.

Немного длиннее (81) версия, где f не флаг первой строки:

i=9,k=10,j,f;main(){while(i)putchar(++j<i?32:j<k?42+f*6:(i-=f,k+=f,f=1,j=0,10));}