Rosetta Code

Strange plus numbers: Difference between revisions

Page Discussion

Strange plus numbers (view source)

Revision as of 17:03, 28 August 2022

1,638 bytes added ,  1 year ago
m
syntax highlighting fixup automation
m (syntax highlighting fixup automation)
Line 13:
{{trans|Python}}
 
<langsyntaxhighlight lang="11l">F is_strange_plus(n)
V xs = String(n).map(c -> Int(c))
R all(zip(xs, xs[1..]).map((a, b) -> a + b C (2, 3, 5, 7, 11, 13, 17)))
Line 23:
print(el, end' ‘ ’)
I L.index % 10 == 9
print()</langsyntaxhighlight>
 
{{out}}
Line 42:
 
=={{header|Action!}}==
<langsyntaxhighlight Actionlang="action!">BYTE Func IsStrangePlusNumber(INT i)
BYTE ARRAY primes=[0 0 1 1 0 1 0 1 0 0 0 1 0 1 0 0 0 1 0]
BYTE d,prev,first,sum
Line 77:
OD
PrintF("%E%EThere are %I strange plus numbers",count)
RETURN</langsyntaxhighlight>
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Strange_plus_numbers.png Screenshot from Atari 8-bit computer]
Line 90:
=={{header|ALGOL 68}}==
Does not attempt to generalise beyond 3 digit numbers.
<langsyntaxhighlight lang="algol68">BEGIN # find numbers where the sum of the first 2 digits is prime and also #
# the sum of the second 2 digits is prime #
# considers numbers n where 100 < n < 500 #
Line 105:
FI
OD
END</langsyntaxhighlight>
{{out}}
<pre>
Line 119:
=={{header|ALGOL W}}==
{{Trans|ALGOL 68}}
<langsyntaxhighlight lang="pascal">begin % find numbers where the sum of the first 2 digits is prime and also %
% the sum of the second 2 digits is prime %
% considers numbers n where 100 < n < 500 %
Line 139:
end for_n
end.
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 153:
=={{header|APL}}==
{{works with|Dyalog APL}}
<langsyntaxhighlight APLlang="apl">(∧⌿ 2 3 5 7 11 13 17 ∊⍨ 2 +⌿ 10 (⊥⍣¯1) X)/X←100+⍳399</langsyntaxhighlight>
 
{{out}}
Line 163:
 
=={{header|AppleScript}}==
<langsyntaxhighlight lang="applescript">------------------- STRANGE PLUS NUMBERS -----------------
 
-- isStrangePlus :: Int -> Bool
Line 362:
end tell
end if
end zipWith</langsyntaxhighlight>
{{Out}}
<pre>'Strange Plus' numbers found in range [100..500]
Line 378:
474 476 492 494 498</pre>
=={{header|AWK}}==
<syntaxhighlight lang="awk">
<lang AWK>
# syntax: GAWK -f STRANGE_PLUS_NUMBERS.AWK
BEGIN {
Line 405:
return(1)
}
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 419:
 
=={{header|BASIC}}==
<langsyntaxhighlight lang="gwbasic">10 DEFINT A-Z
20 FOR I=100 TO 500
30 N=I
Line 428:
80 R=N MOD 10
90 IF INSTR("CDFHLNR",CHR$(L+R+65)) THEN 50
100 NEXT I</langsyntaxhighlight>
{{out}}
<pre> 111 112 114 116 120
Line 445:
 
=={{header|BCPL}}==
<langsyntaxhighlight lang="bcpl">get "libhdr"
 
let smallprime(n) = n=2 | n=3 | n=5 | n=7 | n=11 | n=13 | n=17
Line 462:
$)
wrch('*N')
$) </langsyntaxhighlight>
{{out}}
<pre>111 112 114 116 120 121 123 125 129 141
Line 473:
 
=={{header|BQN}}==
<langsyntaxhighlight lang="bqn">∘‿13⥊(∧´2‿3‿5‿7‿11‿13‿17∊˜(+˝∘⍉2↕•Fmt-'0'˙))¨⊸/100+↕400</langsyntaxhighlight>
{{out}}
<pre>┌─
Line 486:
Generalized solution: a number is strange iff the sum of two consecutive digits is always prime. Numbers < 10 are considered non-strange.
 
<langsyntaxhighlight lang="c">#include <stdio.h>
 
static int p[19] = {0, 0, 1, 1, 0, 1, 0, 1, 0, 0,
Line 509:
}
return 0;
}</langsyntaxhighlight>
 
{{out}}
Line 523:
=={{header|C++}}==
{{trans|Java}}
<langsyntaxhighlight lang="cpp">#include <iostream>
#include <vector>
 
Line 563:
test(101, 499);
return 0;
}</langsyntaxhighlight>
{{out}}
<pre>111 112 114 116 120 121 123 125 129 141
Line 574:
 
=={{header|CLU}}==
<langsyntaxhighlight lang="clu">small_prime = proc (n: int) returns (bool)
small_primes = sequence[int]$[2,3,5,7,11,13,17]
for p: int in sequence[int]$elements(small_primes) do
Line 602:
end
end
end start_up</langsyntaxhighlight>
{{out}}
<pre> 111 112 114 116 120 121 123 125 129 141
Line 613:
 
=={{header|COBOL}}==
<langsyntaxhighlight lang="cobol"> IDENTIFICATION DIVISION.
PROGRAM-ID. STRANGE-PLUS-NUMBERS.
 
Line 651:
DISPLAY ROW,
MOVE SPACES TO ROW,
MOVE 1 TO PTR.</langsyntaxhighlight>
{{out}}
<pre>111 112 114 116 120 121 123 125 129 141
Line 662:
 
=={{header|Comal}}==
<langsyntaxhighlight lang="comal">0010 FUNC small'prime#(n#)
0020 RETURN n#=2 OR (n# MOD 2<>0 AND n#<>1 AND n#<>9 AND n#<>15)
0030 ENDFUNC small'prime#
Line 687:
0240 ENDFOR i#
0250 PRINT
0260 END</langsyntaxhighlight>
{{out}}
<pre>111 112 114 116 120 121 123 125 129 141
Line 698:
 
=={{header|Cowgol}}==
<langsyntaxhighlight lang="cowgol">include "cowgol.coh";
 
sub small_prime(n: uint8): (p: uint8) is
Line 731:
cand := cand + 1;
end loop;
print_nl();</langsyntaxhighlight>
{{out}}
<pre>111 112 114 116 120 121 123 125 129 141
Line 743:
=={{header|Delphi}}==
{{Trans|Go}}
<syntaxhighlight lang="delphi">
<lang Delphi>
program Strange_plus_numbers;
 
Line 786:
writeln(#10, count, ' strange plus numbers in all.');
readln;
end.</langsyntaxhighlight>
 
=== Alternate solution ===
 
<langsyntaxhighlight lang="delphi">program StrangePlusNumbers;
 
const
Line 823:
end
end
end.</langsyntaxhighlight>
 
{{out}}
Line 836:
 
=={{header|Draco}}==
<langsyntaxhighlight lang="draco">proc small_prime(word n) bool:
word primes = 0x8A2B;
n>=2 and primes >> (n-2) & 1 = 1
Line 866:
fi
od
corp</langsyntaxhighlight>
{{out}}
<pre> 111 112 114 116 120 121 123 125 129 141
Line 878:
=={{header|F_Sharp|F#}}==
This task uses [[Extensible_prime_generator#The_functions|Extensible Prime Generator (F#)]].<br>
<langsyntaxhighlight lang="fsharp">
// Strange numbers. Nigel Galloway: February 25th., 2021
let pD=[0..99]|>List.map(fun n->(n/10,n%10))|>List.filter(fun(n,g)->isPrime(n+g))
pD|>List.filter(fun(n,_)->n>0)|>List.map(fun(n,g)->(n,pD|>List.filter(fun(n,_)->n=g)))
|>List.collect(fun(n,g)->g|>List.map(fun(g,k)->n*100+g*10+k))|>List.filter((>)500)|>List.iter(printf "%d ");printfn ""
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 891:
=={{header|Factor}}==
{{works with|Factor|0.99 2021-02-05}}
<langsyntaxhighlight lang="factor">USING: grouping grouping.extras io kernel math math.primes
math.ranges math.text.utils prettyprint sequences ;
 
Line 901:
100 500 (a,b) [ strange+? ] filter dup
10 group [ [ pprint bl ] each nl ] each nl
length pprint " strange plus numbers found." print</langsyntaxhighlight>
{{out}}
<pre>
Line 919:
=={{header|Forth}}==
{{trans|C}}
<langsyntaxhighlight lang="forth">create isprime false , false , true , true , false ,
true , false , true , false , false , false , true ,
false , true , false , false , false , true , false ,
Line 951:
 
main
bye</langsyntaxhighlight>
 
{{out}}
Line 967:
=={{header|FreeBASIC}}==
{{trans|AWK}}
<langsyntaxhighlight lang="freebasic">
Function isPrime(valor As Integer) As Boolean
If valor <= 1 Then Return False
Line 992:
Print !"\n\n"; k; " n£meros m s extra¤os encontrados."
Sleep
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 1,018:
=={{header|Go}}==
{{trans|Wren}}
<langsyntaxhighlight lang="go">package main
 
import "fmt"
Line 1,049:
}
fmt.Printf("\n%d strange plus numbers in all.\n", count)
}</langsyntaxhighlight>
 
{{out}}
Line 1,067:
 
=={{header|Haskell}}==
<langsyntaxhighlight lang="haskell">import Data.List (intercalate)
import Data.List.Split (chunksOf)
 
Line 1,091:
unlines
(unwords <$> chunksOf 10 (show <$> xs))
]</langsyntaxhighlight>
{{Out}}
<pre>"Strange Plus" numbers found in range [100..500]
Line 1,110:
 
Definitions:
<langsyntaxhighlight Jlang="j">digits=: 10&#.inv"0
strangeplus=: 100&< * 500&> * (2&{. * ::0:&(1&p:)&(+/) _2&{.)@digits</langsyntaxhighlight>
 
Example:
<langsyntaxhighlight Jlang="j"> I.strangeplus i.500
111 112 114 116 120 121 123 125 129 141 143 147 149 161 165 167 202 203 205 207 211 212 214 216 230 232 234 238 250 252 256 258 292 294 298 302 303 305 307 320 321 323 325 329 341 343 347 349 383 385 389 411 412 414 416 430 432 434 438 470 474 476 492 494 498</langsyntaxhighlight>
 
 
=={{header|Java}}==
 
<langsyntaxhighlight lang="java">public class Strange {
private static final boolean[] p = {
false, false, true, true, false,
Line 1,147:
}
}
}</langsyntaxhighlight>
 
<syntaxhighlight lang="text">java Strange 101 499</langsyntaxhighlight>
 
{{out}}
Line 1,166:
 
See e.g. [[Erd%C5%91s-primes#jq]] for a suitable implementation of `is_prime`.
<langsyntaxhighlight lang="jq">def nwise($n):
def n: if length <= $n then . else .[0:$n] , (.[$n:] | n) end;
n;
Line 1,181:
| join(" ");
task</langsyntaxhighlight>
{{out}}
<pre>
Line 1,195:
 
=={{header|Julia}}==
<langsyntaxhighlight lang="julia">let
smallprimes = [2, 3, 5, 7, 11, 13, 17] # 0 <= all of these primes <= 18
paired_digit_sums(n) = (d = digits(n); [sum(p) for p in zip(d[1:end-1], d[2:end])])
Line 1,205:
end
end
</langsyntaxhighlight>{{out}}
<pre>
111 112 114 116 120 121 123 125 129 141 143 147 149
Line 1,216:
=={{header|Kotlin}}==
{{trans|Java}}
<langsyntaxhighlight lang="scala">val p = arrayOf(
false, false, true, true, false,
true, false, true, false, false,
Line 1,255:
fun main() {
test(101, 499)
}</langsyntaxhighlight>
{{out}}
<pre>111 112 114 116 120 121 123 125 129 141
Line 1,266:
 
=={{header|MAD}}==
<langsyntaxhighlight lang="mad"> NORMAL MODE IS INTEGER
 
INTERNAL FUNCTION(X)
Line 1,292:
TEST WHENEVER STGPLS.(I), PRINT RESULTS I
 
END OF PROGRAM</langsyntaxhighlight>
{{out}}
<pre style='height:50ex;'>I = 111
Line 1,360:
I = 498</pre>
=={{header|Maple}}==
<langsyntaxhighlight lang="maple">select(n->(u->isprime(add(u[1..2])) and isprime(add(u[2..3])))(convert(n,base,10)),[$101..499]);</langsyntaxhighlight>
 
{{out}}
Line 1,372:
 
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<langsyntaxhighlight Mathematicalang="mathematica">Select[Range[101, 499], PrimeQ[Total[IntegerDigits[#][[;; 2]]]] && PrimeQ[Total[IntegerDigits[#][[2 ;;]]]] &]
Length[%]</langsyntaxhighlight>
{{out}}
<pre>{111, 112, 114, 116, 120, 121, 123, 125, 129, 141, 143, 147, 149, 161, 165, 167, 202, 203, 205, 207, 211, 212, 214, 216, 230, 232, 234, 238, 250, 252, 256, 258, 292, 294, 298, 302, 303, 305, 307, 320, 321, 323, 325, 329, 341, 343, 347, 349, 383, 385, 389, 411, 412, 414, 416, 430, 432, 434, 438, 470, 474, 476, 492, 494, 498}
Line 1,379:
 
=={{header|Modula-2}}==
<langsyntaxhighlight lang="modula2">MODULE StrangePlusNumbers;
FROM InOut IMPORT WriteCard, WriteLn;
 
Line 1,412:
END;
WriteLn;
END StrangePlusNumbers.</langsyntaxhighlight>
{{out}}
<pre> 111 112 114 116 120 121 123 125 129 141
Line 1,423:
 
=={{header|Nim}}==
<langsyntaxhighlight Nimlang="nim">const Primes = {2, 3, 5, 7, 11, 13, 17}
 
proc digits(n: 100..999): array[3, int] =
Line 1,433:
if d[0] + d[1] in Primes and d[1] + d[2] in Primes:
inc count
stdout.write n, if count mod 13 == 0: '\n' else: ' '</langsyntaxhighlight>
 
{{out}}
Line 1,444:
=={{header|Perl}}==
{{libheader|ntheory}}
<langsyntaxhighlight lang="perl">use strict;
use warnings;
use feature 'say';
Line 1,452:
my $n = my @SP = grep { my @d = split ''; is_prime $d[0]+$d[1] and is_prime $d[1]+$d[2] } $low+1 .. $high-1;
say "Between $low and $high there are $n strange-plus numbers:\n" .
(sprintf "@{['%4d' x $n]}", @SP[0..$n-1]) =~ s/(.{80})/$1\n/gr;</langsyntaxhighlight>
{{out}}
<pre>Between 100 and 500 there are 65 strange-plus numbers:
Line 1,462:
=={{header|Phix}}==
Using the same approach as [[Strange_numbers#Phix]], so this should similarly scale/count easily to the 28-digit range.
<!--<langsyntaxhighlight Phixlang="phix">(phixonline)-->
<span style="color: #008080;">constant</span> <span style="color: #000000;">poss</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">apply</span><span style="color: #0000FF;">(</span><span style="color: #004600;">true</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">sq_sub</span><span style="color: #0000FF;">,{{</span><span style="color: #7060A8;">get_primes</span><span style="color: #0000FF;">(-</span><span style="color: #000000;">7</span><span style="color: #0000FF;">)},</span><span style="color: #7060A8;">tagset</span><span style="color: #0000FF;">(</span><span style="color: #000000;">9</span><span style="color: #0000FF;">,</span><span style="color: #000000;">0</span><span style="color: #0000FF;">)}),</span>
<span style="color: #000000;">nxts</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">apply</span><span style="color: #0000FF;">(</span><span style="color: #004600;">true</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">filter</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">poss</span><span style="color: #0000FF;">,{</span><span style="color: #008000;">"in"</span><span style="color: #0000FF;">},{{</span><span style="color: #000000;">0</span><span style="color: #0000FF;">,</span><span style="color: #000000;">9</span><span style="color: #0000FF;">}},{</span><span style="color: #008000;">"[]"</span><span style="color: #0000FF;">}})</span>
Line 1,481:
<span style="color: #004080;">sequence</span> <span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">strange_plus</span><span style="color: #0000FF;">(</span><span style="color: #000000;">3</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">tagset</span><span style="color: #0000FF;">(</span><span style="color: #000000;">4</span><span style="color: #0000FF;">))</span> <span style="color: #000080;font-style:italic;">-- (3 digit numbers beginning 1..4)</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;">"%d strange_plus numbers found: %s\n"</span><span style="color: #0000FF;">,{</span><span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">res</span><span style="color: #0000FF;">),</span><span style="color: #7060A8;">join</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">shorten</span><span style="color: #0000FF;">(</span><span style="color: #000000;">res</span><span style="color: #0000FF;">,</span><span style="color: #008000;">""</span><span style="color: #0000FF;">,</span><span style="color: #000000;">5</span><span style="color: #0000FF;">),</span><span style="color: #008000;">","</span><span style="color: #0000FF;">)})</span>
<!--</langsyntaxhighlight>-->
{{out}}
<pre>
Line 1,488:
 
=={{header|Picat}}==
<langsyntaxhighlight Picatlang="picat">main =>
L = [N : N in 100..500, S = N.to_string.map(to_int),
prime(S[1]+S[2]),
Line 1,497:
end,
nl,
println(len=Len)</langsyntaxhighlight>
 
{{out}}
Line 1,511:
 
=={{header|PL/I}}==
<langsyntaxhighlight lang="pli">StrangePlusNumbers: procedure options(main);
smallPrime: procedure(n) returns(bit);
declare n fixed;
Line 1,536:
end;
end;
end StrangePlusNumbers;</langsyntaxhighlight>
{{out}}
<pre> 111 112 114 116 120 121 123 125 129 141
Line 1,547:
 
=={{header|PL/M}}==
<langsyntaxhighlight lang="pli">100H:
BDOS: PROCEDURE(F,A); DECLARE F BYTE, A ADDRESS; GO TO 5; END BDOS;
EXIT: PROCEDURE; GO TO 0; END EXIT;
Line 1,598:
END;
CALL EXIT;
EOF</langsyntaxhighlight>
{{out}}
<pre>111 112 114 116 120 121 123 125 129 141
Line 1,611:
Using [https://docs.sympy.org/latest/modules/ntheory.html sympy.isprime]
 
<langsyntaxhighlight lang="python">Python 3.8.5 (default, Sep 3 2020, 21:29:08) [MSC v.1916 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license()" for more information.
>>> from sympy import isprime
Line 1,619:
isprime(sum(int(c) for c in str(x)[1:]))]
[111, 112, 114, 116, 120, 121, 123, 125, 129, 141, 143, 147, 149, 161, 165, 167, 202, 203, 205, 207, 211, 212, 214, 216, 230, 232, 234, 238, 250, 252, 256, 258, 292, 294, 298, 302, 303, 305, 307, 320, 321, 323, 325, 329, 341, 343, 347, 349, 383, 385, 389, 411, 412, 414, 416, 430, 432, 434, 438, 470, 474, 476, 492, 494, 498]
>>> </langsyntaxhighlight>
 
 
Or, as we may not need to wake up '''sympy''' just to check membership of {2, 3, 5, 7, 11, 13, 17}:
 
<langsyntaxhighlight lang="python">'''Strange Plus Numbers'''
 
 
Line 1,682:
# MAIN ---
if __name__ == '__main__':
main()</langsyntaxhighlight>
{{Out}}
<pre>"Strange Plus" numbers in range [100..500]
Line 1,698:
=={{header|R}}==
 
<langsyntaxhighlight lang="rsplus"># Primes up to 18
pr <- sapply(1:18, \(n) n > 1 && all(n %% seq(2, length.out = n - 2) > 0))
 
Line 1,707:
 
a <- 101:499
a[sapply(a, is.strange)]</langsyntaxhighlight>
 
{{out}}
Line 1,716:
 
=={{header|Raku}}==
<syntaxhighlight lang="raku" perl6line>unit sub MAIN ($start = 100, $end = 500);
put +$_, " matching numbers from $start to $end:\n", $_ given
($start .. $end).hyper(:256batch,:8degree).grep: { all .comb.rotor(2 => -1).map: { .sum.is-prime } };</langsyntaxhighlight>
{{out}}
<pre>65 matching numbers from 100 to 500:
Line 1,724:
 
=={{header|REXX}}==
<langsyntaxhighlight lang="rexx">/*REXX pgm lists strange+ integers (within a range); sum of adjacent dec. digs is prime.*/
parse arg LO HI . /*obtain optional arguments from the CL*/
if LO=='' | LO=="," then LO= 101 /*Not specified? Then use the default.*/
Line 1,746:
say # ' strange plus numbers found between ' LO " and " HI ' (inclusive)'
say
say strip($)</langsyntaxhighlight>
{{out|output|text=&nbsp; when using the default inputs:}}
<pre>
Line 1,758:
=={{header|Ring}}==
 
<langsyntaxhighlight lang="ring">
load "stdlib.ring"
 
Line 1,784:
ok
next
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 1,799:
=={{header|Ruby}}==
{{trans|Kotlin}}
<langsyntaxhighlight lang="ruby">$p = [
false, false, true, true, false,
true, false, true, false, false,
Line 1,836:
end
 
test(101, 499)</langsyntaxhighlight>
{{out}}
<pre>111 112 114 116 120 121 123 125 129 141
Line 1,847:
 
=={{header|Seed7}}==
<langsyntaxhighlight lang="seed7">$ include "seed7_05.s7i";
 
const func boolean: prime (in integer: number) is
Line 1,878:
end if;
end for;
end func;</langsyntaxhighlight>
{{out}}
<pre>
Line 1,889:
 
=={{header|Sidef}}==
<langsyntaxhighlight lang="ruby">100..500 -> map { .digits }.grep {|d|
is_prime(d[-1]+d[-2]) && is_prime(d[-2]+d[-3])
}.map{ .digits2num }.slices(10).each { .join(' ').say }</langsyntaxhighlight>
{{out}}
<pre>
Line 1,905:
=={{header|Vlang}}==
{{trans|Go}}
<langsyntaxhighlight lang="vlang">fn is_prime(n int) bool {
return n == 2 || n == 3 || n == 5 || n == 7 || n == 11 || n == 13 || n == 17
}
Line 1,932:
}
println("\n$count strange plus numbers in all.")
}</langsyntaxhighlight>
 
{{out}}
Line 1,950:
 
=={{header|VTL-2}}==
<langsyntaxhighlight VTL2lang="vtl2">10 C=0
20 N=101
30 K=N
Line 1,969:
180 #=C/10*0+0<%*!
190 ?=""
200 #=!</langsyntaxhighlight>
{{out}}
<pre>111 112 114 116 120 121 123 125 129 141
Line 1,981:
=={{header|Wren}}==
Simple brute force is adequate for this.
<langsyntaxhighlight lang="ecmascript">var primes = [2, 3, 5, 7, 11, 13, 17]
var count = 0
var d = []
Line 1,999:
}
if (count % 10 != 0) System.print()
System.print("\n%(count) strange plus numbers in all.")</langsyntaxhighlight>
 
{{out}}
Line 2,020:
A 16-bit solution for NASM under DOS. Assemble with <code>nasm -fbin strange.asm -o strange.com</code>. The prime sieve up to 18 is hard-coded.
 
<syntaxhighlight lang="text"> org 100h
 
mov cx, 10 ; cl is used for division, ch to count numbers printed on a line
Line 2,067:
 
p db 0, 0, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0
k equ $-p</langsyntaxhighlight>
 
{{out}}
Line 2,080:
 
=={{header|XPL0}}==
<langsyntaxhighlight XPL0lang="xpl0">func StrangePlus(N);
int N, A, B, S;
[N:= N/10;
Line 2,099:
IntOut(0, N);
if rem(Cnt/20) = 0 then CrLf(0) else ChOut(0, ^ )];
]</langsyntaxhighlight>
 
{{out}}
Thundergnat
10,333

edits

Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/328492"