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

11131221131211131231121113112221121321132132211331222113112211

311311222113111231131112132112311321322112111312211312111322212311322113212221</pre>

 

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

10 - 11131221133112132113212221

</pre>

 

=={{header|Gambas}}==

 

'''[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}}

13211311123113112211

11131221133112132113212221</pre>

 

=={{header|J}}==

'''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}}

"13211311123113112211"

</pre>

 

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

{{out}}

<pre>

 

=={{header|PHP}}==

 

function lookAndSay($str) {

}

 

 

=={{header|PicoLisp}}==

(make

(while Lst

(while (= (setq C (pop 'Lst)) (car Lst))

(inc 'N) )

Usage:

-> (1 1)

: (las @)

-> (1 1 1 3 2 1 3 2 1 1)

: (las @)

 

=={{header|PL/M}}==

BDOS: PROCEDURE (FN, ARG); DECLARE FN BYTE, ARG ADDRESS; GO TO 5; END BDOS;

EXIT: PROCEDURE; CALL BDOS(0,0); END EXIT;

END;

CALL EXIT;

{{out}}

<pre>1

=={{header|PowerBASIC}}==

This uses the <code>RLEncode</code> function from the [[Run-length encoding#PowerBASIC|PowerBASIC Run-length encoding entry]].

DIM tmp1 AS STRING, tmp2 AS STRING, outP AS STRING

DIM Loop0 AS LONG, count AS LONG

v = VAL(INPUTBOX$("Enter a number."))

MSGBOX lookAndSay(v)

 

=={{header|PowerShell}}==

$re = [regex] '(.)\1*'

$ret = ""

}

}

{{out}}

<pre>PS> Get-MultipleLookAndSay 8

Works with SWI-Prolog.

 

maplist(write, L), nl,

encode(L, L1),

run(Var,[Other|RRest], [1,Var],[Other|RRest]):-

dif(Var,Other).

 

{{out}}

 

=={{header|Pure}}==

 

// Remove the trailing "L" from the string representation of bigints.

 

// This prints the entire sequence, press Ctrl-C to abort.

 

=={{header|PureBasic}}==

Define i, j, cnt, txt$, curr$, result$

Print("Enter start sequence: "): txt$=Input()

PrintN(#CRLF$+"Press ENTER to exit."): Input()

CloseConsole()

 

{{out}}

=={{header|Python}}==

{{trans|C sharp|C#}}

result = ""

 

for i in range(10):

print num

 

Functional

{{works with|Python|2.4+}}

>>> def lookandsay(number):

return ''.join( str(len(list(g))) + k

>>> for i in range(10):

print numberstring

 

{{out}}

 

'''As a generator'''<br>

>>>

>>> def lookandsay(number='1'):

1113213211

31131211131221

 

'''Using regular expressions'''<br>

{{trans|Perl}}

 

def lookandsay(str):

for i in range(10):

print num

 

=={{header|Q}}==

{{Out}}

<pre>

=={{header|Quackery}}==

 

 

[ 1 instances put

[ dup echo$ cr

lookandsay ]

 

{{out}}

Returning the value as an integer limits how long the sequence can get,

so the option for integer or character return values are provided.

{

#convert number to character vector

#convert to number, if desired

if(return.an.int) as.integer(newstr) else newstr

Example usage:

for(i in 1:10)

{

x <- look.and.say(x)

print(x)

 

=={{header|Racket}}==

 

#lang racket

 

 

(for-each displayln (look-and-say-sequence 10))

 

{{out}}

In Raku it is natural to avoid explicit loops; rather we use the sequence operator to define a lazy infinite sequence. We'll print the first 15 values here.

 

 

{{out}}

 

===simple version===

parse arg N ! . /*obtain optional arguments from the CL*/

if N=='' | N=="," then N= 20 /*Not specified? Then use the default.*/

$= $ || _ || y /*build the "look and say" sequence. */

k= k + _ /*now, point to the next character. */

{{out|output|text=&nbsp; when using the default input values of: &nbsp; &nbsp; <tt> 20 &nbsp; 1 </tt>}}

<pre>

<br>it appends the sequence generated (so far) to the primary sequence, and starts with a null sequence.

<br>This avoids appending a small character string to a growing larger and larger character string.

parse arg N ! . /*obtain optional arguments from the CL*/

if N=='' | N=="," then N= 20 /*Not specified? Then use the default.*/

chSize= chSize + 100 /*bump the chunkSize (length) counter.*/

end /*k*/

{{out|output|text=&nbsp; is identical to the 1^st REXX version &nbsp; (the simple version).}}<br><br>

 

=={{header|Ring}}==

number = "1"

for nr = 1 to 10

end

return o

 

=={{header|Ruby}}==

The simplest one:

class String

def look_and_say

ss = '1'

12.times {puts ss; ss = ss.look_and_say}

{{out}}

<pre>

 

{{trans|Perl}}

str.gsub(/(.)\1*/) {$&.length.to_s + $1}

end

puts num

num = lookandsay(num)

{{out}}

<pre>

 

Using Enumerable#chunk

str.chars.chunk{|c| c}.map{|c,x| [x.size, c]}.join

end

9.times do

puts num = lookandsay(num)

The '''output''' is the same above.

 

Without regular expression:

 

module Enumerable

# clumps adjacent elements together

cluster

end

 

Using Array#cluster defined above:

 

return unless seq > 0

puts input_sequence.join

end

 

The '''output''' is the same above.

 

=={{header|Rust}}==

assert!(!in_seq.is_empty());

 

seq = next_sequence(&seq);

}

{{out}}

<pre>Sequence 0: [1]

 

=={{header|Sather}}==

look_and_say!: STR is

current ::= "1";

end;

end;

{{out}}

<pre>1

 

===Recursive===

 

object LookAndSay extends App {

}

 

{{Out}}See it running in your browser by [https://scalafiddle.io/sf/V5Jn5mf/0 (JavaScript, non JVM)] or by [https://scastie.scala-lang.org/7kn0fV3gTaqCDLIv4QGuMQ Scastie (JVM)].

===using Iterator===

val s = seed.toString

( 1 until s.size).foldLeft((1, s(0), new StringBuilder)) {

}

 

 

===using Stream===

 

def lookAndSay(previous: List[BigInt]): Stream[List[BigInt]] = {

 

(lookAndSay(1 :: Nil) take 10).foreach(s => println(s.mkString("")))

 

=={{header|Seed7}}==

 

const func string: lookAndSay (in integer: level, in string: stri) is func

writeln(lookAndSay(level, "1"));

end for;

 

{{out}}

</pre>

 

=={{header|Sidef}}==

{{trans|Perl}}

str.gsub(/((.)\2*)/, {|a,b| a.len.to_s + b });

}

say num;

num = lookandsay(num);

 

{{out}}

=={{header|Smalltalk}}==

{{works with|GNU Smalltalk}}

lookAndSay [ |anElement nextElement counter coll newColl|

coll := (self asOrderedCollection).

r displayNl.

r := r lookAndSay.

 

{{works with|Pharo}}

'lookAndSay |anElement nextElement counter coll newColl|

coll := (self asOrderedCollection).

]).

result.

 

Output:

This is by far the easiest solution.

 

define('rle(str)c,n') :(rle_end)

rle str len(1) . c :f(return)

* Test and display

looksay(1,10)

 

{{out}}

 

=={{header|SQL}}==

CREATE VIEW delta AS

SELECT sequence1.v AS x,

DELETE FROM sequence;

INSERT INTO sequence VALUES(-1,0);

 

Usage:

{{works with|Db2 LUW}} version 9.7 or higher.

With SQL PL:

SET SERVEROUTPUT ON @

 

END WHILE;

END @

Output:

<pre>

=={{header|Swift}}==

{{trans|Rust}}

var result = [Int]()

var cur = seq[0]

print("Seq \(i): \(seq)")

seq = lookAndSay(seq)

 

{{out}}

 

=={{header|Tcl}}==

set new ""

while {[string length $n] > 0} {

puts [next_lookandsay] ;# ==> 1211

puts [next_lookandsay] ;# ==> 111221

 

Alternatively, with coroutines:

{{works with|Tcl|8.6}}

coroutine $coroName apply {n {

for {} {[yield $n] ne "stop"} {set n $new} {

puts [next_lookandsay]

puts [next_lookandsay]

 

{{out}}

 

=={{header|TUSCRIPT}}==

$$ MODE TUSCRIPT,{}

num=1,say=""

IF (look==14) EXIT

ENDLOOP

{{out}}

<pre style='height:30ex;overflow:scroll'>

=={{header|UNIX Shell}}==

{{works with|bash}}

local num=$1 char seq i

for ((i=0; i<=${#num}; i++)); do

echo $num

num=$( lookandsay $num )

 

{{out}}

The look_and_say function returns the first n results

by iterating the function that maps a given sequence to its successor.

#import nat

 

#show+

 

{{out}}

<pre>1

 

=={{header|VBA}}==

Public Sub LookAndSay(Optional Niter As Integer = 10)

'generate "Niter" members of the look-and-say sequence

End If

End Sub

 

{{out}}

=={{header|VBScript}}==

=====Implementation=====

dim i

dim accum

loop

looksay = res

 

=====Invocation=====

m = 1

for i = 0 to 13

m = looksay(m)

wscript.echo m

 

{{out}}

10 sequences are created in this example.

 

BOL

Reg_Empty(20)

}

Ins_Newline Reg_Ins(20)

 

{{out}}

13211311123113112211

11131221133112132113212221

 

=={{header|Wren}}==

{{trans|Kotlin}}

var res = ""

var digit = s[0]

System.print(las)

las = lookAndSay.call(las)

 

{{out}}

<pre>

 

=={{header|Yabasic}}==

dim X$(2)

i = 0 // índice de cadena de entrada

next n

print

{{out}}La salida es similar a la de [[#FreeBASIC|FreeBASIC]], mostrada arriba.

 

=={{header|Yorick}}==

 

// Special case: one digit

if(strlen(input) == 1)

write, val;

val = looksay(val);

 

{{out}}

Treating the task as a string manipulation problem.

{{trans|Scala}}

len,c:=[1..seed.len()-1].reduce(fcn([(len,c)]lc,index,s,sb){

if(c!=s[index]) { sb.write(len); sb.write(c); lc.clear(1,s[index]) }

sb.write(len); sb.write(c);

sb.close();

 

{{out}}