Nonoblock: Difference between revisions

* 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.

<br><br>

 

=={{header|C sharp}}==

This solution uses a StringBuilder. Spaces are moved from right to left and the problem is then solved recursively.

using System.Linq;

using System.Text;

}

 

{{out}}

<pre style="height:50ex;overflow:scroll">

 

=={{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}}

=={{header|Elixir}}==

{{trans|Ruby}}

def solve(cell, blocks) do

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

e in RuntimeError -> IO.inspect e

end

 

{{out}}

=={{header|Go}}==

{{trans|Kotlin}}

 

import (

printBlock("2323", 15)

printBlock("23", 5)

 

{{out}}

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

 

=={{header|JavaScript}}==

const inv = b => !b;

const arrJoin = str => arr => arr.join(str);

test(10, 4, 3);

test(5, 2, 3);

{{out}}

<pre>5 cells. Blocks: 2,1

 

=={{header|Julia}}==

minlen(arr) = sum(arr) + length(arr) - 1

nonoblocks([2, 3, 2, 3], 15)

nonoblocks([2, 3], 5)

With blocks [2, 1] and 5 cells:

##.#.

=={{header|Kotlin}}==

{{trans|Java}}

 

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

printBlock("2323", 15)

printBlock("23", 5)

 

{{out}}

blocks [2, 3], cells 5

No solution

</pre>

 

=={{header|M2000 Interpreter}}==

===Recursive===

Module NonoBlock {

Form 80,40

}

NonoBlock

 

{{out}}

</pre >

===Non Recursive===

Module Nonoblock (n, m) {

Print "Cells:",n," Blocks:",m

Nonoblock 15,4,2,3,2,3

Nonoblock 5,2,3,2

 

=={{header|Perl}}==

use warnings;

 

10 8

15 2 3 2 3

{{out}}

<pre>

 

=={{header|Phix}}==

{{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}}

(formerly Perl 6)

{{trans|Perl}}

say $cells, ' cells with blocks: ', @blocks ?? join ', ', @blocks !! '∅';

my $letter = 'A';

say $row while $row ~~ s/^^ (\.*) <|w> (.*?) <|w> (\w+) \.<!|w> /$1$0.$2/;

say '';

{{out}}

<pre>5 cells with blocks: 2, 1

 

=={{header|REXX}}==

$.=; $.1= 5 2 1

$.2= 5

loc: _=0; do arg(2); _=pos('#.',pad(arg(1)),_+1); if _==0 then return 0; end; return _+1

add: if !.new==1 then return; #= # + 1; @.#= new; !.new=1; return

{{out|output|text=&nbsp; when using the default inputs:}}

<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}}

=={{header|Rust}}==

{{works with|Rust|1.29.2}}

width: usize,

config: Vec<usize>,

println!();

}

{{out}}

<pre>

===========

No solutions.

</pre>

 

{{tcllib|generator}}

{{trans|Python}}

package require generator

 

}

 

{{out}}

<pre>

{{trans|Kotlin}}

{{libheader|Wren-math}}

 

var genSequence // recursive

printBlock.call("8", 10)

printBlock.call("2323", 15)

 

{{out}}

=={{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>