Nonoblock: Difference between revisions

{{task}} [[Category:Puzzles]]

Nonoblock is a chip off the old [[Nonogram solver|Nonogram]] puzzle.

 

;Given:

* The size of each, (space separated), connected block of cells to fit in the row, in left-to right order.

 

 

;Enumerate the following configurations:

 

;Example:

 

|_|_|_|_|_| # 5 cells and [2, 1] blocks

 

This:

 

 

 

;An algorithm:

* The leftmost cell can legitimately be placed in all positions from the LHS up to a RH position that allows enough room for the rest of the blocks.

* for each position of the LH block recursively compute the position of the rest of the blocks in the ''remaining'' space to the right of the current placement of the LH block.

(This is the algorithm used in the [[Nonoblock#Python]] solution).

 

;Reference:

* The blog post [http://paddy3118.blogspot.co.uk/2014/03/nonogram-puzzle-solver-part-1.html Nonogram puzzle solver (part 1)] Inspired this task and donated its [[Nonoblock#Python]] solution.

 

=={{header|C++}}==

#include <iomanip>

#include <iostream>

return 0;

}

{{out}}

<pre>

=={{header|D}}==

{{trans|python}}

std.concurrency, std.range;

 

writeln;

}

{{out}}

<pre>Configuration (5 cells and [2, 1] blocks):

 

=={{header|EchoLisp}}==

;; size is the remaining # of cells

;; blocks is the list of remaining blocks size

(writeln "❌ no solution for" size blocks)

(nonoblock size blocks (stack 'cells)))))

{{out}}

size:5 blocks:(2 3)

❌ no solution for 5 (2 3)

 

=={{header|Elixir}}==

{{trans|Ruby}}

def solve(cell, blocks) do

width = Enum.sum(blocks) + length(blocks) - 1

e in RuntimeError -> IO.inspect e

end

 

{{out}}

Possibilities:

%RuntimeError{message: "Those blocks will not fit in those cells"}

</pre>

 

Implementation:

 

s=. 1+(1+x)-+/1+y

pad=.1+(#~ s >+/"1)((1+#y)#s) #: i.s^1+#y

)

 

 

Task example:

 

│A│A│ │B│ │

│A│A│ │ │B│

│ │ │A│A│ │B│B│B│ │C│C│ │D│D│D│

neat 5 nonoblock 2 3

 

=={{header|Java}}==

{{works with|Java|8}}

import static java.util.Arrays.stream;

import static java.util.stream.Collectors.toList;

return sb.toString();

}

<pre>blocks [2, 1], cells 5

11010

blocks [2, 3], cells 5

No solution</pre>

 

=={{header|Kotlin}}==

{{trans|Java}}

 

fun printBlock(data: String, len: Int) {

val a = data.toCharArray()

println("\nblocks ${a.asList()}, cells $len")

if (len - sumChars <= 0) {

printBlock("2323", 15)

printBlock("23", 5)

 

{{out}}

</pre>

 

 

 

{{out}}

<pre>

 

=={{header|Python}}==

if not blocks or blocks[0] == 0:

yield [(0, 0)]

for i, vector in enumerate(nonoblocks(blocks, cells)):

print(' ', pblock(vector, cells))

 

{{out}}

Also, the blocks are not identified. I suppose they could be easily enough, but in the nonogram task, these patterns are converted to bit-fields shortly after the nonoblock generation, and bits have no names (sad, but true).

 

(require racket/trace)

 

(tst 10 '[8])

(tst 15 '[2 3 2 3])

 

{{out}}

|..XX.XXX.XX.XXX|

5 cells, (2 3) blocks => impossible

</pre>

 

=={{header|Ruby}}==

'''Simple version:'''

raise 'Those blocks will not fit in those cells' if cell < blocks.inject(0,:+) + blocks.size - 1

nblock(cell, blocks, '', [])

p e

end

 

{{out}}

===Class version===

The output form consulted the one of the python.

def initialize(cell, blocks)

raise 'Those blocks will not fit in those cells' if cell < blocks.inject(0,:+) + blocks.size - 1

end

end

 

{{out}}

Possibilities:

#<RuntimeError: Those blocks will not fit in those cells>

</pre>

 

{{tcllib|generator}}

{{trans|Python}}

package require generator

 

}

 

{{out}}

<pre>

Possibilities:

--> ERROR: those blocks will not fit in those cells

</pre>

 

=={{header|zkl}}==

{{trans|Python}}

if(not blocks or blocks[0]==0) vm.yield( T(T(0,0)) );

else{

vec.apply2('wrap([(a,b)]){ a.walker(b).pump(Void,vector.set.fp1(ch.next())) });

String("|",vector.concat("|"),"|");

T(T(2,3),5) )){

println("\nConfiguration:\n %s # %d cells and %s blocks"

},0)

: println(" A total of %d possible configurations.".fmt(_));

{{out}}

<pre>