Nonoblock: Difference between revisions
m
→{{header|Wren}}: Minor tidy
(Added solution for Pascal) |
m (→{{header|Wren}}: Minor tidy) |
||
(2 intermediate revisions by 2 users not shown) | |||
Line 66:
{{trans|Python}}
<
[[(Int, Int)]] r
I blocks.empty | blocks[0] == 0
Line 107:
L(vector) nb
print(‘ ’pblock(vector, cells))
print(‘ A total of #. Possible configurations.’.format(nb.len))</
{{out}}
Line 156:
=={{header|Action!}}==
<
DEFINE NOT_FOUND="255"
Line 270:
Test(15,t4,4)
Test(5,t5,2)
RETURN</
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Nonoblock.png Screenshot from Atari 8-bit computer]
Line 319:
=={{header|AutoHotkey}}==
<
NonoBlock(cells, blocks){
result := [], line := ""
Line 393:
return output
}
;-------------------------------------------</
Results .= NonoBlock(5, [2, 1]) "------------`n"
Results .= NonoBlock(5, []) "------------`n"
Line 401:
MsgBox, 262144, , % Results
return
</syntaxhighlight>
{{out}}
<pre>---------------------------
Line 439:
=={{header|C}}==
<
#include <string.h>
Line 501:
return 0;
}</
{{out}}
Line 541:
=={{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;
Line 591:
}
}</
{{out}}
<pre style="height:50ex;overflow:scroll">
Line 628:
=={{header|C++}}==
<
#include <iomanip>
#include <iostream>
Line 728:
return 0;
}
</syntaxhighlight>
{{out}}
<pre>
Line 779:
=={{header|D}}==
{{trans|python}}
<
std.concurrency, std.range;
Line 862:
writeln;
}
}</
{{out}}
<pre>Configuration (5 cells and [2, 1] blocks):
Line 960:
=={{header|EchoLisp}}==
<
;; size is the remaining # of cells
;; blocks is the list of remaining blocks size
Line 1,006:
(writeln "❌ no solution for" size blocks)
(nonoblock size blocks (stack 'cells)))))
</syntaxhighlight>
{{out}}
Line 1,049:
=={{header|Elixir}}==
{{trans|Ruby}}
<
def solve(cell, blocks) do
width = Enum.sum(blocks) + length(blocks) - 1
Line 1,111:
e in RuntimeError -> IO.inspect e
end
end)</
{{out}}
Line 1,165:
=={{header|Go}}==
{{trans|Kotlin}}
<
import (
Line 1,212:
printBlock("2323", 15)
printBlock("23", 5)
}</
{{out}}
Line 1,254:
Implementation:
<
s=. 1+(1+x)-+/1+y
pad=.1+(#~ s >+/"1)((1+#y)#s) #: i.s^1+#y
Line 1,260:
)
neat=: [: (#~ # $ 0 1"_)@": {&(' ',65}.a.)&.></
Task example:
<
│A│A│ │B│ │
│A│A│ │ │B│
Line 1,291:
│ │ │A│A│ │B│B│B│ │C│C│ │D│D│D│
neat 5 nonoblock 2 3
</syntaxhighlight>
=={{header|Java}}==
{{works with|Java|8}}
<
import static java.util.Arrays.stream;
import static java.util.stream.Collectors.toList;
Line 1,347:
return sb.toString();
}
}</
<pre>blocks [2, 1], cells 5
11010
Line 1,383:
=={{header|JavaScript}}==
<
const inv = b => !b;
const arrJoin = str => arr => arr.join(str);
Line 1,444:
test(10, 4, 3);
test(5, 2, 3);
</syntaxhighlight>
{{out}}
<pre>5 cells. Blocks: 2,1
Line 1,496:
=={{header|Julia}}==
<
minlen(arr) = sum(arr) + length(arr) - 1
Line 1,532:
nonoblocks([2, 3, 2, 3], 15)
nonoblocks([2, 3], 5)
</
With blocks [2, 1] and 5 cells:
##.#.
Line 1,565:
=={{header|Kotlin}}==
{{trans|Java}}
<
fun printBlock(data: String, len: Int) {
Line 1,597:
printBlock("2323", 15)
printBlock("23", 5)
}</
{{out}}
Line 1,636:
=={{header|Lua}}==
<
{5, {2, 1}},
{5, {}},
Line 1,682:
main (example[1], example[2])
print ('A total of ' .. total .. ' possible configurations.')
end</
{{out}}
Line 1,736:
=={{header|M2000 Interpreter}}==
===Recursive===
<syntaxhighlight lang="m2000 interpreter">
Module NonoBlock {
Form 80,40
Line 1,792:
}
NonoBlock
</syntaxhighlight>
{{out}}
Line 1,828:
</pre >
===Non Recursive===
<syntaxhighlight lang="m2000 interpreter">
Module Nonoblock (n, m) {
Print "Cells:",n," Blocks:",m
Line 1,919:
Nonoblock 15,4,2,3,2,3
Nonoblock 5,2,3,2
</syntaxhighlight>
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<
SpacesDistributeOverN[s_, p_] :=
Flatten[
Line 1,943:
Possibilities[{8}, 10]
Possibilities[{2, 3, 2, 3}, 15]
Possibilities[{2, 3}, 5]</
{{out}}
<pre>{".##.#", "##..#", "##.#."}
Line 1,953:
=={{header|Nim}}==
{{trans|Go}}
<
Line 1,986:
printBlock("8", 10)
printBlock("2323", 15)
printBlock("23", 5)</
{{out}}
Line 2,026:
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;
Line 2,060:
inc(z[j - 1]);
z[h] := z[j] - 1;
end;
end;
Line 2,130 ⟶ 2,128:
PrintSolutions( 5, [2,3]);
end.
</syntaxhighlight>
{{out}}
<pre>
Line 2,172 ⟶ 2,170:
=={{header|Perl}}==
<
use warnings;
Line 2,191 ⟶ 2,189:
10 8
15 2 3 2 3
5 2 3</
{{out}}
<pre>
Line 2,235 ⟶ 2,233:
=={{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>
Line 2,285 ⟶ 2,283:
<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>
Line 2,367 ⟶ 2,365:
=={{header|Python}}==
<
if not blocks or blocks[0] == 0:
yield [(0, 0)]
Line 2,418 ⟶ 2,416:
for i, vector in enumerate(nonoblocks(blocks, cells)):
print(' ', pblock(vector, cells))
print(' A total of %i Possible configurations.' % (i+1))</
{{out}}
Line 2,481 ⟶ 2,479:
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)
Line 2,545 ⟶ 2,543:
(tst 10 '[8])
(tst 15 '[2 3 2 3])
(tst 5 '[2 3]))</
{{out}}
Line 2,580 ⟶ 2,578:
(formerly Perl 6)
{{trans|Perl}}
<syntaxhighlight lang="raku"
say $cells, ' cells with blocks: ', @blocks ?? join ', ', @blocks !! '∅';
my $letter = 'A';
Line 2,588 ⟶ 2,586:
say $row while $row ~~ s/^^ (\.*) <|w> (.*?) <|w> (\w+) \.<!|w> /$1$0.$2/;
say '';
}</
{{out}}
<pre>5 cells with blocks: 2, 1
Line 2,624 ⟶ 2,622:
=={{header|REXX}}==
<
$.=; $.1= 5 2 1
$.2= 5
Line 2,676 ⟶ 2,674:
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
pad: return left( arg(1), N, .)</
{{out|output|text= when using the default inputs:}}
<pre>
Line 2,724 ⟶ 2,722:
=={{header|Ruby}}==
'''Simple version:'''
<
raise 'Those blocks will not fit in those cells' if cell < blocks.inject(0,:+) + blocks.size - 1
nblock(cell, blocks, '', [])
Line 2,756 ⟶ 2,754:
p e
end
end</
{{out}}
Line 2,800 ⟶ 2,798:
===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
Line 2,853 ⟶ 2,851:
end
end
end</
{{out}}
Line 2,907 ⟶ 2,905:
=={{header|Rust}}==
{{works with|Rust|1.29.2}}
<
width: usize,
config: Vec<usize>,
Line 2,985 ⟶ 2,983:
println!();
}
}</
{{out}}
<pre>
Line 3,028 ⟶ 3,026:
=={{header|Swift}}==
<
func nonoblock(cells: Int, blocks: [Int]) {
Line 3,079 ⟶ 3,077:
print()
nonoblock(cells: 5, blocks: [2, 3])</
{{out}}
Line 3,121 ⟶ 3,119:
{{tcllib|generator}}
{{trans|Python}}
<
package require generator
Line 3,188 ⟶ 3,186:
}
package provide nonoblock 1</
{{out}}
<pre>
Line 3,243 ⟶ 3,241:
{{trans|Kotlin}}
{{libheader|Wren-math}}
<
var genSequence // recursive
Line 3,276 ⟶ 3,274:
printBlock.call("8", 10)
printBlock.call("2323", 15)
printBlock.call("23", 5)</
{{out}}
Line 3,316 ⟶ 3,314:
=={{header|zkl}}==
{{trans|Python}}
<
if(not blocks or blocks[0]==0) vm.yield( T(T(0,0)) );
else{
Line 3,348 ⟶ 3,346:
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"
Line 3,359 ⟶ 3,357:
},0)
: println(" A total of %d possible configurations.".fmt(_));
}</
{{out}}
<pre>
|