Nonoblock: Difference between revisions

{{trans|Python}}

 

[[(Int, Int)]] r

I blocks.empty | blocks[0] == 0

L(vector) nb

print(‘ ’pblock(vector, cells))

 

{{out}}

|_|_|A|A|_|B|B|B|_|C|C|_|D|D|D|

A total of 15 Possible configurations.

</pre>

 

=={{header|AutoHotkey}}==

NonoBlock(cells, blocks){

result := [], line := ""

return output

}

Results .= NonoBlock(5, [2, 1]) "------------`n"

Results .= NonoBlock(5, []) "------------`n"

MsgBox, 262144, , % Results

return

{{out}}

<pre>---------------------------

 

=={{header|C}}==

#include <string.h>

 

 

return 0;

 

{{out}}

=={{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|Mathematica}}/{{header|Wolfram Language}}==

SpacesDistributeOverN[s_, p_] :=

Flatten[

Possibilities[{8}, 10]

Possibilities[{2, 3, 2, 3}, 15]

{{out}}

<pre>{".##.#", "##..#", "##.#."}

=={{header|Nim}}==

{{trans|Go}}

 

 

printBlock("8", 10)

printBlock("2323", 15)

 

{{out}}

blocks [2, 3] cells 5

No solution</pre>

 

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

 

=={{header|Swift}}==

 

func nonoblock(cells: Int, blocks: [Int]) {

print()

 

 

{{out}}

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