Nonoblock: Difference between revisions

{{trans|Python}}

[[(Int, Int)]] r

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

L(vector) nb

print(‘ ’pblock(vector, cells))

{{out}}

=={{header|Action!}}==

DEFINE NOT_FOUND="255"

Test(15,t4,4)

Test(5,t5,2)

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Nonoblock.png Screenshot from Atari 8-bit computer]

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

=={{header|Lua}}==

{5, {2, 1}},

{5, {}},

main (example[1], example[2])

print ('A total of ' .. total .. ' possible configurations.')

{{out}}

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

With 15 cells and [2,3,2,3] blocks, it's a question of how to distribute 5 gap characters among 5 gaps (including the 2 gaps at the ends). To allow for the requirement that the 3 inner gaps must be strictly positive, we can reduce the size of each inner gap by 1, provided we remember to restore the deleted gap character when printing the result. Then 2 gap characters need to be distributed among 5 non-negative gaps. In general, for integers n > 0 and s, the task amounts to finding all arrays of n non-negative integers that sum to s. An iterative method is shown below.

program Nonoblock;

uses SysUtils;

PrintSolutions( 5, [2,3]);

end.

{{out}}

<pre>

=={{header|Perl}}==

use warnings;

10 8

15 2 3 2 3

{{out}}

<pre>

=={{header|Phix}}==

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #008080;">function</span> <span style="color: #000000;">nobr</span><span style="color: #0000FF;">(</span><span style="color: #004080;">sequence</span> <span style="color: #000000;">res</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">string</span> <span style="color: #000000;">neat</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">integer</span> <span style="color: #000000;">ni</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">integer</span> <span style="color: #000000;">ch</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">sequence</span> <span style="color: #000000;">blocks</span><span style="color: #0000FF;">)</span>

<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"\n"</span><span style="color: #0000FF;">)</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>

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