Look-and-say sequence: Difference between revisions

{{trans|Python}}

V result = ‘’

V repeat = number[0]

L 10

print(num)

{{out}}

puts: equ 9

; Due to how CP/M loads programs, the memory after here

; is free until we hit the stack.

=={{header|8086 Assembly}}==

cpu 8086

puts: equ 9h ; MS/DOS system call to print a string

section .data

newline: db 13,10,'$' ; Newline to print in between members

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

CHAR c

BYTE len

FI

OD

{{out}}

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

=={{header|Ada}}==

use Ada.Text_IO, Ada.Strings, Ada.Strings.Fixed;

end loop;

return Trim (Integer'Image (S'Length), Both) & Item;

This function can be used as follows:

Put_Line (+(+"1"));

Put_Line (+(+(+"1")));

Put_Line (+(+(+(+(+(+(+(+"1"))))))));

Put_Line (+(+(+(+(+(+(+(+(+"1")))))))));

{{out}}

<pre>

{{works with|ALGOL 68G|Any - tested with release mk15-0.8b.fc9.i386}}

{{works with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release 1.8.8d.fc9.i386}}

BEGIN

CHAR item = s[LWB s];

print ((+(+(+(+(+(+(+(+"1"))))))), new line));

print ((+(+(+(+(+(+(+(+(+"1")))))))), new line));

{{out}}

<pre>

=={{header|ALGOL-M}}==

string(1) function digit(n);

integer n;

curlen := j - 1;

end;

{{out}}

<pre>1

=={{header|APL}}==

⎕IO←0

d←{(1↓⍵)-¯1↓⍵}

f←{m←(0≠d ⍵),1 ⋄ ,(d ¯1,m/⍳⍴⍵),[.5](m/⍵)}

{(f⍣⍵) ,1}¨⍳10

This is an ugly little APL2 function that accepts a numeric vector (or scalar) and returns the result.

Apologies for the labeled loop...

R←LNS V;T

R←0⍴0 ⍝ initiate empty reply

R←R,T,↑V ⍝ append t and the 1st digit

→(0≠↑⍴V←T↓V)/LOOP ⍝ drop t digits and iterate

=={{header|AppleScript}}==

if (howMany < 1) then return {}

-- Test code:

{{output}}

=={{header|Arturo}}==

if n=0 -> return "1"

previous: lookAndSay n-1

loop 0..10 'x [

print [x "->" lookAndSay x]

{{out}}

=={{header|AutoHotkey}}==

Gui, -MinimizeBox

Gui, Add, Edit, w500 r20 vInput, 1

}

Return, r c d

=={{header|AWK}}==

{

s = ""

print b

}

=={{header|BASIC}}==

20 FOR Z=1 TO 15

30 PRINT I$

100 NEXT I

110 I$=O$

{{out}}

<pre>1

=={{header|BASIC256}}==

# look and say

print a$[j]

next n

=={{header|BBC BASIC}}==

FOR i% = 1 TO 10

number$ = FNlooksay(number$)

i% = j%

UNTIL i% > LEN(n$)

{{out}}

<pre>

=={{header|BCPL}}==

manifest $(

move(buf1,buf2)

$)

{{out}}

<pre>1

=={{header|BQN}}==

{{out}}

<pre>┌─

=={{header|Bracmat}}==

In this example we use a non-linear pattern and a negation of a pattern: the end of e sequence of equal digits is (1) the end of the string or (2) the start of a sequence starting with a different digit.

& 0:?lines

& whl

)

)

{{out}}

<pre>11

=={{header|C}}==

This program will not stop until killed or running out of memory.

#include <stdlib.h>

return 0;

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

using System.Text;

using System.Linq;

}

}

{{out}}

Alternate version using Regex (C#2 syntax only):

using System;

using System.Text.RegularExpressions;

}

}

{{out}} (with args: 1 15):

<pre>1

=={{header|C++}}==

#include <sstream>

#include <string>

std::cout << laf << '\n';

}

=={{header|Ceylon}}==

function lookAndSay(Integer|String input) {

print(result);

}

=={{header|Clojure}}==

No ugly int-to-string-and-back conversions.

"Returns a seq of the digits of a number (L->R)."

[n]

(defn look-and-say [n]

(->> n digits-seq (partition-by identity)

{{out}}

=={{header|CLU}}==

out: array[char] := array[char]$[]

count: int := 0

cur := look_and_say(cur)

end

{{out}}

<pre>1

=={{header|COBOL}}==

PROGRAM-ID. LOOK-AND-SAY-SEQ.

SUBTRACT 1 FROM STEP-AMOUNT.

IF STEP-AMOUNT IS NOT EQUAL TO ZERO GO TO LOOK-AND-SAY.

{{out}}

<pre>1

=={{header|Common Lisp}}==

"Compresses array by returning a list of conses each of whose car is

a number of occurrences and whose cdr is the element occurring. For

(parse-integer (string (cdr pair)))))

(compress (princ-to-string number))

Example use:

Straight character counting:

(let ((out (list (char s 0) 0)))

(loop for x across s do

(loop for s = "1" then (look-and-say s)

repeat 10

=={{header|Cowgol}}==

include "strings.coh";

CopyString(&nextbuf as [uint8], &curbuf as [uint8]);

members := members - 1;

{{out}}

{{trans|Ruby}}

The simplest one:

def lookandsay

gsub(/(.)\1*/){ |s| s.size.to_s + s[0] }

ss = '1'

{{trans|Ruby from Perl}}

str.gsub(/(.)\1*/) { |s| s.size.to_s + $1 }

end

num = "1"

{{trans|Ruby}}

Using Enumerable#chunks

str.chars.chunks(&.itself).map{ |(c, x)| x.size.to_s + c }.join

end

num = "1"

{{out}}

=={{header|D}}==

===Short Functional Version===

enum say = (in string s) pure => s.group.map!q{ text(a[1],a[0]) }.join;

void main() {

"1".recurrence!((t, n) => t[n - 1].say).take(8).writeln;

{{out}}

<pre>["1", "11", "21", "1211", "111221", "312211", "13112221", "1113213211"]</pre>

===Beginner Imperative Version===

pure string lookAndSay(string s){

for(auto i=0; i<10; i++)

(s = s.lookAndSay).writeln;

{{out}}

<pre>11

===Fast Imperative Version===

void showLookAndSay(bool showArrays)(in uint n) nothrow {

immutable n = (args.length == 2) ? args[1].to!uint : 10;

n.showLookAndSay!true;

{{out}}

<pre>Allocated 116 bytes.

With:

{{out}}

<pre>Allocated 158045069 bytes.

===Intermediate Version===

This mostly imperative version is intermediate in both speed and code size:

import std.stdio, std.conv, std.algorithm, std.array, std.string;

writefln("%2d: n. digits: %d", i, seq.length);

}

The output is the same as the second version.

This recursive version is able to generate very large sequences in a short time without memory for the intermediate sequence (and with stack space proportional to the sequence order).

// On Windows this uses the printf from the Microsoft C runtime,

evolve(39, n - base);

'\n'.putchar;

=={{header|Delphi}}==

=={{header|Draco}}==

proc nonrec look_and_say(*char inp, outp) void:

CharsCopy(&buf1[0], &buf2[0])

od

{{out}}

<pre>1

=={{header|E}}==

var seen := null

var count := 0

println(number)

number := lookAndSayNext(number)

=={{header|EchoLisp}}==

(lib 'math) ;; for (number->list) = explode function

(lib 'list) ;; (group)

(next L)))

{{out}}

(task 10 1)

1

31131211131221

13211311123113112211

=={{header|Elixir}}==

def next(n) do

Enum.chunk_by(to_char_list(n), &(&1))

end

{{out}}

'''Regex version:'''

def look_and_say(n) do

Regex.replace(~r/(.)\1*/, to_string(n), fn x,y -> [to_string(String.length(x)),y] end)

end

{{out}}

=={{header|Erlang}}==

-export([look_and_say/1, look_and_say/2]).

look_and_say(T, H, N+1, Acc);

look_and_say([H|T], Current, N, Acc) ->

{{out}}

=={{header|ERRE}}==

PROGRAM LOOK

END FOR

END PROGRAM

<pre>

11

=={{header|F Sharp|F#}}==

Library functions somehow missing in F# out of the box (but present in haskell)

let rec brk p lst =

match lst with

let group lst : list<list<'a>> when 'a : equality = groupBy (=) lst

Implementation

let lookAndSay =

let describe (xs: char list) =

Seq.take 10 lookAndSay

=={{header|Factor}}==

unclip-slice swap [ 1 ] 2dip [

2dup = [ drop [ 1 + ] dip ] [

: look-and-say ( str -- str' ) [ (look-and-say) ] "" make ;

=={{header|Fennel}}==

(let [lst t

ret []]

(for [i 1 10]

(print (table.concat lst))

Alternative solution

(var ret [])

(var (num cnt) (values (s:sub 1 1) 1))

(for [i 1 10]

(print str)

=={{header|FOCAL}}==

01.20 S B(0)=1;S B(1)=0

01.30 F Z=1,M;D 4;D 2

04.40 D 3

04.50 S X=X+1

{{out}}

<pre>HOW MANY:12

=={{header|Forth}}==

create buf2 256 allot

buf1 value src

0 do next-look-and-say cr src count type loop ;

=={{header|Fortran}}==

implicit none

end subroutine look_and_say

use LookAndSay

implicit none

end do

=={{header|FreeBASIC}}==

{{trans|BASIC256}}

Dim As Integer n, j, k, k0, r

Dim As String X(2)

Next n

End

{{out}}

<pre>

=={{header|Frink}}==

LookAndSay = "12211123"

println["Starting Value: " + LookAndSay]

println["$i - $LookAndSay"]

}

{{out}}

<pre>

'''[https://gambas-playground.proko.eu/?gist=83d63e1706fa1dc3c7468b1e9d7bcf05 Click this link to run this code]'''

Dim i, j, cnt As Integer

Dim txt$, curr$, result$ As String

Dec i

Until i <= 0

Output:

<pre>

=={{header|GAP}}==

local c, r, cur, ncur, v;

v := "123";

LookAndSay(last); # "1321132132111213122112311311222113111221131221"

LookAndSay(last); # "11131221131211131231121113112221121321132132211331222113112211"

=={{header|Go}}==

import (

fmt.Println(s)

}

{{out}}

<pre>

=={{header|Groovy}}==

def encoded = new StringBuilder()

(sequence.toString() =~ /(([0-9])\2*)/).each { matcher ->

}

encoded.toString()

Test Code

(1..12).each {

println sequence

sequence = lookAndSay(sequence)

{{out}}

<pre>1

=={{header|Haskell}}==

import Data.List (group)

where describe run = show (length run) ++ take 1 run

=={{header|Haxe}}==

class Main

return results;

}

=={{header|Icon}} and {{header|Unicon}}==

every 1 to 10 do

write(n := nextlooknsayseq(\n | 1))

}

return n2

{{out}}

'''Solution''':

'''Example''':

Note the result is an actual numeric sequence (cf. the textual solutions given in other languages).

{{trans|C#}}

{{works with|Java|1.5+}}

StringBuilder result= new StringBuilder();

}

return result.toString();

Testing:

String num = "1";

num = lookandsay(num);

}

{{out}}

<pre>1

=== With RegExp ===

{{trans|Perl}}

return str.replace(/(.)\1*/g, function(seq, p1){return seq.length.toString() + p1})

}

alert(num);

num = lookandsay(num);

=== Imperative version ===

var tokens=[]

var i=0, j=1

var phrase="1"

for(var n=0; n<10; n++ )

{{Output}}

<pre>11

=={{header|jq}}==

{{Works with|jq|1.4}}

def head(c; n): if .[n:n+1] == c then head(c; n+1) else n end;

tostring

else look_and_say as $lns

| $lns, ($lns|look_and_say(n-1))

'''Example'''

1 | look_and_say(10)

=={{header|Julia}}==

{{Works with|Julia|1.1}}

rst = IOBuffer()

c = 1

end

{{out}}

=={{header|K}}==

las 8

=={{header|Kotlin}}==

fun lookAndSay(s: String): String {

las = lookAndSay(las)

}

{{out}}

=={{header|Lasso}}==

The Look-and-say sequence is a recursive RLE, so the solution can leverage the same method as used for RLE.

local(orig = #str->values->asCopy,newi=array, newc=array, compiled=string)

while(#orig->size) => {

return #str

}

{{out}}

<pre>11

=={{header|LiveCode}}==

This function takes a string and returns the next Look-And-Say iteration of it:

put 0 into C

put char 1 of S into lastChar

end repeat

put x after message

{{out}}

=={{header|Logo}}==

if empty? :in [output (word :out :run :c)]

if equal? first :in :c [output look.and.say.loop bf :in :run+1 :c :out]

end

=={{header|Lua}}==

function lookandsayseq(n)

local t = {1}

end

end

Alternative solution, using LPeg:

local P, C, Cf, Cc = lpeg.P, lpeg.C, lpeg.Cf, lpeg.Cc

lookandsay = Cf(Cc"" * C(P"1"^1 + P"2"^1 + P"3"^1)^1, function (a, b) return a .. #b .. string.sub(b,1,1) end)

print(t)

t = lookandsay:match(t)

Alternative solution, using Lua Pattern:

return t:gsub("(1*)(2*)(3*)", function (...)

local ret = {}

print(t)

t = lookandsay(t)

return t:gsub("(1*)(2*)(3*)", function (x, y, z)

return (x == "" and x or (#x .. x:sub(1, 1))) ..

print(t)

t = lookandsay2(t)

{{out}}

Using regular expressions:

{{trans|Perl}}

define(`for',

`ifelse($#,0,``$0'',

`v

define(`v',las(v))')dnl

=={{header|Maple}}==

local times, output, i;

times := 1;

#Test:

{{out}}

=={{header|Mathematica}}/{{header|Wolfram Language}}==

The function:

takes as input an <em>arbitrary</em> positive integer and generates the next member of the ‘Look and Say’ sequence.

The first example returns the next 12 numbers of the sequence starting with 1:

<pre style='height:15em;overflow:scroll'>1

The second example returns the next 12 numbers of the sequence starting with 7:

<pre style='height:15em;overflow:scroll'>7

=={{header|Maxima}}==

[n: length(a), b: [ ], x: a[1], m: 1],

for i from 2 thru n do

"1113213211"

"31131211131221"

=={{header|MAXScript}}==

(

local result = ""

print num

num = lookAndSay num

=={{header|Metafont}}==

string r; r := "";

if string s:

endfor

=={{header|MiniScript}}==

repeats = function(digit, string)

count = 0

print number

numbers = number

{{out}}

<pre>

=={{header|Modula-2}}==

FROM InOut IMPORT WriteString, WriteLn;

FROM Strings IMPORT Assign, Length;

Assign(buf2, buf1);

END;

{{out}}

<pre>1

=={{header|NewLisp}}==

;;; Compute the following number in the sequence

(define (next-number s)

;

(go 10)

{{out}}

<pre>

=={{header|Nim}}==

var current = "1"

yield current

for s in lookAndSay(12):

{{out}}

=={{header|Objective-C}}==

-(NSString*)lookAndSay:(NSString *)word{

}

}

=={{header|OCaml}}==

=== Functional ===

This function computes a see-and-say sequence from the previous one:

| [], nys -> List.rev nys

| x::xs, [] -> seeAndSay(xs, [x; 1])

| x::xs, y::n::nys when x=y -> seeAndSay(xs, y::1+n::nys)

It can be used like this:

let xs = Array.create n [1] in

for i=1 to n-1 do

[1; 3; 1; 1; 2; 2; 2; 1]; [1; 1; 1; 3; 2; 1; 3; 2; 1; 1];

[3; 1; 1; 3; 1; 2; 1; 1; 1; 3; 1; 2; 2; 1];

=== With regular expressions in the Str library ===

let lookandsay =

num := lookandsay !num;

print_endline !num;

=== With regular expressions in the Pcre library ===

let lookandsay str =

num := lookandsay !num;

print_endline !num;

run this example with 'ocaml -I +pcre pcre.cma script.ml'

=== Imperative ===

let look_and_say s =

*)

=={{header|Oforth}}==

: lookAndSay ( n -- )

{{out}} for n = 10 :

=={{header|Oz}}==

%% e.g. "21" -> "1211"

fun {LookAndSayString S}

end

in

=={{header|PARI/GP}}==

my(v=eval(Vec(Str(n))),cur=v[1],ct=1,out="");

v=concat(v,99);

eval(out)

};

=={{header|Pascal}}==

{{works with|Delphi}}

{{libheader|SysUtils}}

{$IFDEF FPC}

number := LookAndSay(number);

end;

{{out}}

<pre>% ./LookAndSay

{{works with|Free_Pascal}}

{{libheader|SysUtils}}

program LookAndSayDemo(input, output);

{$IFDEF FPC}

writeln(i:4,length(number):16,l2/l1:10:6);

end;

{{out}}

<pre>1

=={{header|Perl}}==

my $str = shift;

$str =~ s/((.)\2*)/length($1) . $2/ge;

print "$num\n";

$num = lookandsay($num);

Using string as a cyclic buffer:

print $1;

$_ .= ($1 ne "\n" and length($1)).$2

=={{header|Phix}}==

<span style="color: #008080;">function</span> <span style="color: #000000;">lookandsay</span><span style="color: #0000FF;">(</span><span style="color: #004080;">string</span> <span style="color: #000000;">s</span><span style="color: #0000FF;">)</span>

<span style="color: #004080;">string</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;">s</span>

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