Как решить красноречивый Javascript "шахматная доска"?

вот другой подход.

каждая строка имеет четыре экземпляра либо _# или #_ (где подчеркивание-это пробел).

четные строки начинаются с _# и нечетные строки начинаются с #_:

var chessBoard= '',
    size= 8,
    c;

for(var i = 0 ; i < size ; i++) {
  c= i%2 ? '# ' : ' #';
  for(var j = 0 ; j < size/2 ; j++) {
    chessBoard+= c;
  }
  chessBoard+= '\n';
}

console.log(chessBoard);

jsFiddle Demo

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

var board = "";
for(var i = 0; i < 8; i++){
 for(var a = 0; a < 8; a++){
  board += (a % 2) == (i % 2) ? " " : "#";
 }
 board += "\n";
}

просмотр платы, теперь он показывает сетку 8x8

console.log(board);

 # # # #
# # # # 
 # # # #
# # # # 
 # # # #
# # # # 
 # # # #
# # # # 

вместо i для номера строки или a для a номер столбца. Или указать оба размера :) он все равно будет работать. Например, a < 20 даст 20 столбцов

 # # # # # # # # # #
# # # # # # # # # # 
 # # # # # # # # # #
# # # # # # # # # # 
 # # # # # # # # # #
# # # # # # # # # # 
 # # # # # # # # # #
# # # # # # # # # # 

вот версия

console.log((new Array(65).join().split("")).map( function(v,i) {
    return ( (i/8 >> 0 ) % 2 ? ( i%2 ? " " : "#") : (i%2 ? "#" : " ") ) +
           ( (i+1) %8 ? "" : "\n" );
}).join(""));

var chessBoard = "";
var size = 8;

for (var lineCounter = 1; lineCounter < size; lineCounter++) { 

    if (lineCounter%2 === 0) { //if lineCounter is an even number
        for (var charCounter = 1; charCounter < size; charCounter++) {
            var evenOdd = (charCounter%2 === 0);
            switch (evenOdd) {
                case true:
                    chessBoard += "#";
                    break;
                case false:
                    chessBoard += " ";
                    break;
                }
            }                   
        }
    else { //if lineCounter is an odd number
        for (var charCounter = 1; charCounter < size; charCounter++) {
            var evenOdd = (charCounter%2 === 0);
            switch (evenOdd) {
                case true:
                    chessBoard += " ";
                    break;
                case false:
                    chessBoard += "#";
                    break;
            }
        }                       
    }   
    chessBoard += "\n";
}
console.log(chessBoard);

используя только знания, полученные до этого момента в книге Красноречивый JavaScript вот мое решение:

   var board = "";
   var size = 8;

   // Outer for loop creates a new line** after each cycle of the inner for loop
   for (var lineCount = 0; lineCount < size; lineCount++) {
       //The nested for loop adds a character to the board variable on a single line proportional to the size variable
       for (var spaceCount = 0; spaceCount < size; spaceCount++) {
           //This if statement creates the offset lines in the example image by alternating the first character depending on the lineCount
           if (lineCount % 2 == 0) {
               var black = "#",
                   white = " ";
           } else {
               black = " ";
               white = "#";
           }
           if (spaceCount % 2 == 0) {
               board += white;
           } else {
               board += black;
           }
       }
       board += "\n"; //** new line created
   }
   console.log(board);

в случае, если кто-то задается вопросом, есть способ сделать это только с одной петлей:

var chess="";
var size=8;
var k=0, l=1;

//k is to check even for now
//l is for odd for now

var tmp;
var isEven=false;

//we check if chess is Even (if not isEven stays false)

if(size%2==0)
  isEven=true;

//sqSize tells us how many chess squares are there

sqSize= size*size;

for(var i=1; i<sqSize+1;i++){
  /*
  At the beginning of loop we check if the i is even
  When we have even ches e.g. 8x8 we need to swap condition
  every line (is i even? ----> is i odd? ---->etc.)
  */
  if (i%2==k)
    chess+=" ";
  else
    chess+="#";
  if (i%size==0){
    chess+="\n";
    //Adding new line every "size" number.
    /* 
    Here the the swap happens
    Earlier, we checked if the size is odd or even.
    Now we use this knowledge.
    k is condition value. we swap 0 to 1, so we will
    be checking different condition in the next loop passing.
    */
    if(isEven==true){
      tmp=k;
      k=l;
      l=tmp;
    }
  }

}
console.log(chess);

вот моя версия. Не такой чистый и красноречивый, как книга one, но он работает! размер var = 8; var board ="";

for (var z = 0; z < size; z++) { 
 for (var y = 1; y < size; y++) { 
  if (board[y-1]===" ")
    board += "#";
  else 
    board += " ";
 } 
board += "\n";
console.log(board);
  if (board[0]===" ")
    board = "#";
  else 
    board = " ";      
 }

var size = 8;
var block = '#';
var space = ' ';

for (var i = 1; i <= size; i++) {
  var line = '';

  for (var y = 1; y <= size; y++){
    if (i%2) {
        if (y%2) {
            line = line + space;
        } else {
            line = line + block;
        }
    } else {
        if (y%2) {
            line = line + block;
        } else {
            line = line + space;
        }
    }
  }

  console.log(line);
}

Это мое решение:

var size=8, line="", c="";
for (i=0;i<size;i+=1){
    i%2==0?c=" ":c="#"; 
    for(n=0;n<size;n+=1){
        c==" "?c="#":c=" ";     
        line+=c;    
    }   
    console.log(line);
    line=""
}

просто хотел добавить от себя :)

var times = 8; //set the times you want to run the loop
var result = '';//result is the chessboard.
for(var i = 0; i < times; i++){ //run the loop starting at zero and going up.
  for(var x = 0; x <= 4; x++){ //run a second loop to run each line of the chessboard.
    if(i % 2 === 0){ //check if i(current index of the loop) is divisible by 0, and concatenate '# ' to result
      result += '# ';
    }else{ //if not divisible by 0 then concatenate ' #'
      result += ' #';
    }
  }
  result = result + '\n' //add a line brake to at the end of every index 
}
console.log(result); //result should now print the chessboard.

таким образом, я и некоторые кодирующие приятели ходили взад и вперед, оптимизируя эту функцию для удовольствия и образования.

Я не видел нашего выигрышного решения здесь, так почему бы не бросить его?

function board(size) {
        // determine if we're dealing with an odd board size
    var odd=size%2,  
        // get size-1 if odd, so we can simplify things
        s=odd?size-1:size, 
        // our first row base
        r1 = " #",
        // our first row
        row1 = r1,
        // our second row base
        r2 = "# ",
        // our second row
        row2 = r2,
        // total size of board, including newlines
        total = (size*size)+size,
        // our output 
        out = "",
        // our board base
        o;

    // if size was 1, then it would be odd and s = 0
    // in that case return first row, first character
    // just a single white space
    if(!s) {
        return r1[0];
    }

    // next we build our rows with 2 loops
    // this first loop doubles each row until we're within 2*n of total length
    // we'd want to skip this step for small values of size
    for(n=2;2*n<s;n*=2) {
        row1+=row1;
        row2+=row2;
    }

    // this second loop adds our bases until we have the size length
    while(row1.length<s) {
        row1+=r1;
        row2+=r2;
    }

    // if our size is odd, then a row ends with the same character it begins with
    if(odd) {
        row1+=r1[0];
        row2+=r2[0];
    }

    // add our newlines to complete our rows
    row1+="\n";
    row2+="\n";

    // we do the same thing to build the board, 2 loops
    // start with our base of the 2 rows we just built
    out = o = row1+row2;

    // double up the rows until we're within 2*n rows of a full board
    // again, we'd want to skip this step for small values of size
    for(n=2;2*n<s;n*=2) {
        out+=out;
    }

    // add the base until we're complete or 1 row off (if odd)
    while(out.length+size+1<total) {
        out+=o;
    }

    // if odd add the first row as final row
    if(odd) {
        out+=row1;
    }

    // return the completed chessboard string
    return out;
}

// function call with size, returns our chessboard string
console.log(board(8));

если убрать for(n=2;2*n<s;n*=2) петли, то он будет работать быстрее для генерации небольших плат, но держать их в делает его гораздо более эффективным для больших плат. В идеале вы можете вычислить и указать threshold и пропустить for циклы, когда size<threshold.

это может быть поздно, но есть ответы на самой странице см.:http://eloquentjavascript.net/code/

манипулировать для цикла / формул для понимания, как

var size = 8;

var board = "";

for (var y = 0; y < size; y++) {
  for (var x = 0; x < 1; x++) {

    if ((x + y) % 2 == 0)
      board += (x+y)+"%";
    else
      board += (x+y)+"#";

  }
  board += "\n";
}

console.log(board);

я попробовал мой с циклами while и базовым пониманием решения книг.

var board = ""
var size = 8
var x = 0
var y = 0

while (x < size) //restricts number of rows "size" times
  {
    while (y < size) //changes value of board to board+= # or " " a combined "size" times restricting columns to "size"
     {
         if ((x+y) % 2 == 0) //adding x+y ensures each row begins with altering #/_
            board += " "; //increases value of board by _
         else
            board += "#"; //increases value of board by _
         y++; // increases from 0-8 allowing loop to execute 8 times.
     }
    board += "\n";
    x++; // increases from 0-8 allowing loop to execute 8 times.
    y = 0; //resets vaule of y to 0 to allow inner loop to repeate
  }

console.log(board) // board prints as a repeating string of #_ using line breaks to create new rows

var sizeX = 8,
    sizeY = 8;
var emty = " #",
    grid = "# ";

for (x = 0; x < sizeX; x++) {
    if (x % 2) {
        console.log(emty.repeat(sizeY))
    } else {
        console.log(grid.repeat(sizeY))
    }
}

здесь идет альтернативный ответ с использованием тернарного оператора (Мой первый вклад: D):

var size = 8; //this is the variable setting

var board = "";//this is the empty string we're going to add either ' ' , '#' or newline

for (var i = 0; i  < size; i++) {   /*in the outer loop we add newline to separate rows*/
  for (var j = 0; j  < size; j++) {/*every inner loop represents a column, and alternatively it's adding either ' ' or '#' to the string that's being populated*/
        ((i+j%2==0 ? board+=" ": board+="#") /*Here you can see the ternary operator. The syntax = condition ? true: false */
  }
board+="\n";
}; 
 console.log(board);

Я сделал следующее... Это не очень красноречиво, но это сработало для scenerio.

var hash = ' # #';
var rehash = '# # ';
for( var i = 1; i<9; i++){
  if( i%2 ==0){
    console.log(rehash+ rehash);}
  else{
    console.log(hash + hash);}
}

я использовал два независимых циклов и все работало. Надеюсь, независимый для циклов делает его читаемым. Размер платы может быть изменен, и он отражает соответственно.

size = 8
oddline  = ""
evenline = ""

/*First for loop is for creating the first and second lines*/
for (i=0;i<size/2;i++)
{
    oddline = oddline + "#" + " "
    evenline = evenline + " " + "#"
}

/* This for loop is for printing the first and second lines repeatedly */
for (j=0;j<size/2;j++)
{
console.log(oddline)
console.log(evenline)
}

Не самое элегантное решение, я уверен, но это работает.

let chessBoard = "";
const boardSize = 8;

for (let yAxis = 0; yAxis < boardSize; yAxis++) {
  for (let xAxis = 0; xAxis < (boardSize / 2); xAxis++) {
    if (yAxis % 2 === 0) {
      chessBoard += " ";
      chessBoard += "#";
    }
    else {
      chessBoard += "#";
      chessBoard += " ";
    }
  }
  chessBoard += "\n";
}
console.log(chessBoard)

Я создал решение с помощью строку.повторяю!--3--> метод, который я думаю, намного чище, чем многие из решений здесь:

var size = 8;
var grid = "";

for (i = 1; i <= size; i++) {
  if (i%2 == 0)
    grid += "# ".repeat(size/2) + "\n";
  else
    grid += " #".repeat(size/2) + "\n";
}

console.log(grid);

function PrintChessBoard(x,y){
var newHashString = CreateHashString(8);
var charArray = newHashString.split('');
//var tempArry =[];
for(var i = 1 ; i<=y ;i++)
{
if(i % 2 ==0){
  for(var j=0 ; j<x; j=j+2){
    charArray[j+1] = ' ';

  }
}
else{
    for(var k=0 ; k<x ; k += 2){
    charArray[k] = ' ';

  }
 }
var HashString = ConcatArrayToString(charArray)
//reset array
charArray = newHashString.split('');
console.log(HashString);
}

}

function CreateHashString(x){
    var hashString = '';
    while(x>0){
      hashString +='X';
      x--;
    }
   return hashString;
}

function ConcatArrayToString(arr){
  var nS ='';
 for(var i = 0 ; i<arr.length ;i++){
   nS +=arr[i];
 }
 return nS;
}

PrintChessBoard(8,8);

официальное решение использует символ новой строки /n что я понимаю. Вкладывая два for петли внутри друг друга, вы можете создать всю шахматную доску в одну линию. Конечно.

но если я хочу построить oddRow (начиная с # и повторение по ширине) и evenRow (начиная с _ и повторение по ширине) отдельно, затем последовательно печатайте каждую строку с новым

вот еще одна упрощенная версия этого:

function chessBoard(symbol, gridSize) {
    gridSize = gridSize || 8;
    symbol=symbol || "#";
    let pattern = "";
    for (let i = 0; i < gridSize/2; i++)
        pattern += symbol + " ";//Forming the pattern

    for (let i = 0; i < gridSize; i++) {

        if (i % 2 === 0) {
            console.log(pattern);
        }
        else {
            console.log(" " + pattern) //For even rows adding the space in front
        }
    }
}
chessBoard('#',8);

let num = prompt("choose area of board"); // gets input to determine board size.
rowString = "";
for (let height = 0; height < num; height++){ // sets board height
  for(let width = 0; width < num; width++){ // sets board width
    if ((height+width) % 2 == 0){ // alternates chars by row & height position
      rowString += "# ";
    }
    else{
      rowString += "  ";
    }
  }
  rowString += "\n"; // after 'num' chars added to row, add new line to board
}
console.log(rowString);

(высота+строка) % 2 == 0 в строке 5 имеет важное значение, так как он определяет, добавляет ли он "" или # к строке строки на основе высоты и значения строки. Если бы это было просто основано на высоте, вы бы получили чередование колонки из #и"", или если бы это было просто на основе ширины, вы бы получили чередование строки " В " и #. Если вы рассматриваете первую точку; высота 0 ширина 0, она будет оценивать четную, высоту 1 ширина 1, нечетную и т. д.. следующей строке высота 1 ширина 0, нечетный etc... Это гарантирует масштабируемость платы.

альтернативно...

var holder = '';
var len = 4;

for (var count=0; count<len;count++)
    holder += '# '
    holder += '\n ' + holder;
    if (holder.length > len)
        for (var curr=0; curr<len; curr++)
            console.log(holder);

хе-хе, я думаю, что я сделал самое бесполезное, но рабочее решение для этого

var string1 = " # # # #";
var string2 = "# # # # ";
var i = 0;

for (i = 0; i < 8; i++){
  if (i % 2 === 0){
      console.log(string1);
  }
  else{
      console.log(string2);
  }
}