Search a list of records: Difference between revisions

The data structure to be used contains the names and populations (in millions) of the 10 largest metropolitan areas in Africa, and looks as follows when represented in JSON:

 

{ "name": "Lagos", "population": 21.0 },

{ "name": "Cairo", "population": 15.2 },

{ "name": "Abidjan", "population": 4.4 },

{ "name": "Casablanca", "population": 3.98 }

 

However, you shouldn't parse it from JSON, but rather represent it natively in your programming language.

 

<hr>

 

=={{header|8th}}==

8th uses JSON as its native data representation, so using it is quite natural:

{ "name": "Lagos", "population": 21.0 },

{ "name": "Cairo", "population": 15.2 },

) a:each drop rdrop

 

{{out}}

<pre>

The name of the first city in this list whose population is less than 5 million: Khartoum-Omdurman

The population of the first city in this list whose name starts with the letter "A": 4.58000

</pre>

 

{{works with|Ada|Ada|2005}}

 

with Ada.Text_IO;

 

Ada.Text_IO.Put_Line(+Element(Find(cities, Less_Than_Five_Million'Access)).name);

Ada.Text_IO.Put_Line(Element(Find(cities, Starts_With_A'Access)).population'Img);

{{out}}

<pre> 6

 

=={{header|ALGOL 68}}==

# type specific ones #

 

)

)

{{out}}

<pre>

{{Trans|JavaScript}}

 

 

property lstCities : [¬

end script

end if

 

{{Out}}

 

=== AppleScriptObjectiveC ===

While vanilla AppleScript doesn't provide filters for its own lists and records (and, by the way, has never officially supported square-bracket lists like the one used in the script above), its extension AppleScriptObjectiveC ''can'' filter the equivalent Foundation classes. So bridging between the classes may occasionally be useful. For efficiency, one would try to avoid repeatedly bridging the same objects.

 

use framework "Foundation"

 

return {result1, result2, result3} --> {6, "Khartoum-Omdurman", 4.58}

 

=={{header|C}}==

 

This solution makes use of the 'bsearch' and 'lfind' library functions. Note: 'lfind' is available only on Posix systems, and is found in the 'search.h' header. However it is also part of the Ming C Compiler for Windows.

#include <stdint.h> /* intptr_t */

#include <stdio.h>

return 0;

}

 

Output

 

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

using System.Collections.Generic;

 

}

}

{{out}}

<pre>

<tt>std::find_if</tt> accepts a lambda as predicate.

 

#include <string>

#include <vector>

std::cout << i3->population << "\n";

}

 

{{out}}

In order to not rely on the input ordering of the data records, this example adds an "idx" value to the records, for purposes of being able to report the answer to the queries which rely on the original ordering. The data records are then re-sorted to be ordered by city name. This helps to make it clear that the query relying on sort-by-population is properly handled in the query itself.

 

{:idx 7, :name "Alexandria", :population 4.58}

{:idx 1, :name "Cairo", :population 15.2}

 

(defn most-populous-city-below-n [recs limit]

 

{{out}}

 

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

(name nil :type string)

(population nil :type number))

(format t "Answer 1: ~A~%" answer1)

(format t "Answer 2: ~A~%" answer2)

{{out}}

<pre>Answer 1: 6

 

We demonstrate the '''vector-search''' primitive, which takes as input a vector, and a predicate.

(require 'struct)

(require 'json)

(city-pop -666) → (-666 . not-found)

(city-index "alexandra") → #f

 

=={{header|Elena}}==

import system'routines;

};

console.printLine(index);

console.printLine(name);

console.printLine(namePopulation)

{{out}}

<pre>

 

=={{header|Elixir}}==

[name: "Lagos", population: 21.0 ],

[name: "Cairo", population: 15.2 ],

IO.puts Enum.find_index(cities, fn city -> city[:name] == "Dar Es Salaam" end)

IO.puts Enum.find(cities, fn city -> city[:population] < 5.0 end)[:name]

 

{{out}}

 

Not only does <code>find</code> return the element, but also the index, which allows us to use <code>find</code> for all of the required tasks. Since Factor is a stack-based concatenative language, multiple return values are elegant to use. We can simply <code>drop</code> the sequence element on the top of the data stack if we are only interested in the index, or we can <code>nip</code> the index if we are only interested in the sequence element on the top of the stack.

IN: rosetta-code.search-list

 

 

! Print the population of the first city starting with 'A'.

{{out}}

<pre>

Such arrays involve the ability to access an individual city's information at random, simply by specifying the index into the CITY array, however the given problem requires only sequential access. In such a case, the storage for the city elements could be formed as a linked-list which would be followed sequentially. Even so, random access can be regained via an array such as XCNAME, which now would hold the storage address of the corresponding CITY element. And as ever, how long is a piece of string? Here, ten.

 

TYPE CITYSTAT !Define a compound data type.

CHARACTER*28 NAME !Long enough?

WRITE (6,3) BLAH,CITY(FIRSTMATCH(CITY.NAME(1:1),"A")).POPULATION

3 FORMAT (A,"whose name starts with A has population",F5.2)

 

The words NAME and TARGET can have special usages in F90, but fortran has ''no'' reserved words so these names can be put to ordinary use. Alas, the syntax highlighter does not recognise their non-special use and gives them colour. One could fuss further over the layout of the output, but here it is:

=={{header|Go}}==

'''Basic solution:'''

 

import (

fmt.Println(list[i].population)

}

{{out}}

<pre>

 

First, a package to define the data structure needed. This package will be imported by both the data conversion tool and the application.

 

type Element struct {

}

 

 

Then the data conversion tool. This program reads JSON from stdin and generates the Go code of a package "data" containing an equivalent Go literal.

 

import (

}

fmt.Fprintln(f, "}")

{{out}}

import "datadef"

8: {"Abidjan", 4.4},

9: {"Casablanca", 3.98},

 

The desired program imports the generated package containing the converted data. Program and imported data are JSON-free.

 

import (

fmt.Println(data.List[i].Population)

}

Output same as basic solution.

 

The population ordering is useful only for queries against population and so cannot be used, at least not in any simple way, by the general find function shown above. The sort package of the Go standard library however contains a function for making general queries against an ordered list. This solution shows how the population query can be done with this function.

 

 

import (

fmt.Println(data.List[i].Name)

}

{{out}}

<pre>

The same sort.Search function is general enough to be used for the other two queries of the task as long as appropriate indexes are constructed. sort.Search is interesting because it is in the standard library and is much like the function required by the task, being generalized to take a function as an argument. It does not completely meet task requirements though because it works on a single ordering that must already exist or already be computed. A function that would analyze a general query, use available orderings when possible, and fall back on linear search otherwise is surely beyond the task scope.

 

 

import (

fmt.Println(data.List[nx[i]].Population)

}

{{out}}

<pre>

=={{header|Haskell}}==

 

 

data City = City

=> Maybe a -> IO ()

mbPrint (Just x) = print x

 

{{Out}}

To represent the data in the task description, we will be using a tabular format as follows:

 

 

data=: 1 colnumeric |: fixcsv 0 :0

Abidjan, 4.4

Casablanca, 3.98

 

And here are the required computations:

 

6

(i. >./)@(* 5&>)@:>@{: data

Khartoum-Omdurman

(1 { data) {::~ 'A' i.~ {.&> 0 { data

 

The "general search function" mentioned in the task does not seem a natural fit for this set of data, because of the multi-column nature of this data. Nevertheless, we could for example define:

 

:

I. u x { y

 

This uses the single argument aspect of the definition of <code>I.</code> to convert a bit mask to the corresponding sequence of indices. And the column(s) we are searching on are exposed as a parameter for the interface, which allows us to ignore (for this problem) the irrelevant columns...

Thus, we could say:

 

 

But this doesn't seem any clearer or more concise than our previous expression which finds the index of the first example of the most populous city with a population less than five million. Not only that, but if there were multiple cities which had the same population number which satisfied this constraint, this version would return all of those indices where the task explicitly required we return the first example.

=== J: Another approach ===

The following approach is arguably more natural in J than requiring a dictionary-type structure.

popln=: 21 15.2 11.3 7.55 5.85 4.98 4.7 4.58 4.4 3.98

city i. <'Dar Es Salaam' NB. index of Dar Es Salaam

4.58

(popln {~ ({.&> city)&i.) 'A' NB. anonymous search function with first letter as argument

 

=={{header|Java}}==

{{works with|Java|8}}

 

import java.util.Collections;

import java.util.List;

}

}

 

{{Out}}

===ES5===

 

'use strict';

};

 

 

===ES6===

 

'use strict';

};

 

 

"jq" is so-name because it is a JSON Query Language, and thus all the abstractions are already available for the given searches, except that early versions of jq do not have `first/1` as a builtin. If your jq does not define `first/1`, then for present purposes, an appropriate definition would be:

 

 

This will emit `null` if the stream, s, is empty.

{{works with|Julia|0.6}}

 

 

dataset = DataFrame(name=["Lagos", "Cairo", "Kinshasa-Brazzaville", "Greater Johannesburg", "Mogadishu",

println(dataset[first(find(dataset[:population] .< 5)), :name])

print("Find the population of the first city in this list whose name starts with the letter \"A\": ")

 

{{out}}

 

=={{header|Kotlin}}==

 

class City(val name: String, val pop: Double)

val pop = cities.first { it.name[0] == 'A' }.pop

println("Population of first city whose name starts with 'A' = $pop")

 

{{out}}

 

=={{header|Lingo}}==

cnt = data.count

repeat with i = 1 to cnt

if value(condition) then return [#index:i-1, #record:record]

end repeat

 

[ "name": "Lagos", "population": 21.0 ],\

[ "name": "Cairo", "population": 15.2 ],\

res = findFirstRecord(data, "record.name.char[1]="&q&"A"&q)

if listP(res) then put res.record.population

 

=={{header|Lua}}==

Lua tables are well suited as the element type for this task. The master data structure is a table of tables.

local cityPops = {

{name = "Lagos", population = 21.0},

function (i, e) if e.name:sub(1, 1) == "A" then return e.population end end

}

{{out}}

<pre>6

Khartoum-Omdurman

4.58</pre>

 

=={{header|Maple}}==

table(["name"="Cairo","population"=15.2]),

table(["name"="Kinshasa-Brazzaville","population"=11.3]),

searchRec(rec, x->x["name"] = "Dar Es Salaam", (x,i)->print(i-1)): # minus 1 since Maple is 1-indexed

searchRec(rec, x->x["population"]<5, (x,i)->print(x["name"])):

{{out}}

<pre> 6

</pre>

 

<|"name" -> "Lagos", "population" -> 21.|>,

<|"name" -> "Cairo", "population" -> 15.2|>,

<|"name" -> "Casablanca", "population" -> 3.98|>

}]

data[Position["Dar Es Salaam"], "name"][1, 1] - 1

data[Select[#population < 5 &]][1, "name"]

 

 

=={{header|OCaml}}==

{{works with|OCaml|4.03+}}

#load "str.cma"

 

|> print_float

|> print_newline;

{{out}}

6

Khartoum-Omdurman

4.58

 

=={{header|Perl}}==

The <tt>first</tt> function from the core module <tt>List::Util</tt> provides short-circuiting search using a block as predicate. However, it can only return the value of the found element, not its index &ndash; so for the first test-case we need to operate on the list of indices.

 

use List::Util qw(first);

 

 

my $record3 = first { $_->{name} =~ /^A/ } @cities;

 

{{out}}

The CPAN module <tt>List::MoreUtils</tt> provides the <tt>first_index</tt> function which could be used to write that first case more elegantly:

 

 

 

=={{header|Phix}}==

The columnize function reorganises hetrogenous data into corresponding homogenous arrays, which can make this sort of thing much simpler,

at least for exact matches.

 

{{out}}

<pre>

</pre>

Note that Phix subscripts are 1-based, hence the output of 7 not 6.

 

=={{header|PHP}}==

<?php

 

 

Done...

 

=={{header|PicoLisp}}==

 

(de *Data

 

(test 4.58

 

=={{header|PowerShell}}==

The <code>ConvertFrom-Json</code> cmdlet converts a JSON formatted string to a custom PSCustomObject object that has a property for each field in the JSON string:

$jsonData = @'

[

 

$cities = $jsonData | ConvertFrom-JSON

The <code>$cities</code> variable contains an array of objects with '''Name''' and '''Population''' properties:

$cities

{{Out}}

<pre>

</pre>

Find the index of the first city in the list whose name is "Dar Es Salaam":

$cities.Name.IndexOf("Dar Es Salaam")

{{Out}}

<pre>

</pre>

Find the name of the first city in this list whose population is less than 5 million:

($cities | Where-Object -Property Population -LT 5)[0].Name

{{Out}}

<pre>

</pre>

Find the population of the first city in this list whose name starts with the letter "A":

($cities | Where-Object -Property Name -Match "^A")[0].Population

{{Out}}

<pre>

=={{header|Python}}==

 

{ "name": "Lagos", "population": 21.0 },

{ "name": "Cairo", "population": 15.2 },

first(city['name'] for city in cities if city['population'] < 5),

first(city['population'] for city in cities if city['name'][0] == 'A'),

 

{{out}}

 

The more idiomatic functions for the task is <code>findf</code> but it doesn't provide the position of the element in the list, so we write a variant. If the item is not found we return <code>#f</code> as most of the Racket primitives do in these cases.

#lang racket

 

[(proc (car lst)) pos]

[else (loop (cdr lst) (add1 pos))])))

Now we define the list that has the data for the task.

(define data '(#hash((name . "Lagos") (population . 21))

#hash((name . "Cairo") (population . 15.2))

#hash((name . "Abidjan") (population . 4.4))

#hash((name . "Casablanca") (population . 3.98))))

We write tiny wrappers to retrieve values from the hash.

(define get-name

(lambda (x) (hash-ref x 'name)))

(define get-population

(lambda (x) (hash-ref x 'population)))

For completeness, ensure the data is sorted by population largest to smallest.

(define sorted-data (sort data > #:key get-population))

Use an unnamed function with our findf/pos function to get the position of "Dar Es Salaam".

(findf/pos (lambda (x) (equal? "Dar Es Salaam" (get-name x))) sorted-data)

;; -> 6

Use unnamed functions with findf for the other two test cases.

(get-name (findf (lambda (x) (< (get-population x) 5)) sorted-data))

;; -> "Khartoum-Omdurman"

(get-population (findf (lambda (x) (regexp-match? #rx"^A" (get-name x))) sorted-data))

;; -> 4.58

{{out}}

<pre>

 

{{Works with|Rakudo|2016.08}}

{ name => 'Lagos', population => 21.0 },

{ name => 'Cairo', population => 15.2 },

say @cities.first(*<name> eq 'Dar Es Salaam', :k);

say @cities.first(*<population> < 5).<name>;

 

{{out}}

 

This REXX version does &nbsp; ''not'' &nbsp; rely on the list being sorted by population count.

$="Lagos=21, Cairo=15.2, Kinshasa-Brazzaville=11.3, Greater Johannesburg=7.55, Mogadishu=5.85,",

"Khartoum-Omdurman=4.98, Dar Es Salaam=4.7, Alexandria=4.58, Abidjan=4.4, Casablanca=3.98"

say /*▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ task 3: show 1st city with A* name.*/

c1= 'A' /*1st character of a city for search*/

'''output''' &nbsp; when using the default inputs:

<pre>

 

=={{header|Ring}}==

# Project : Search a list of records

 

ok

next

Output:

<pre>

=={{header|Ruby}}==

 

{name: "Lagos", population: 21},

{name: "Cairo", population: 15.2},

puts cities.find {|city| city[:population] < 5.0}[:name] # => Khartoum-Omdurman

puts cities.find {|city| city[:name][0] == "A"}[:population] # => 4.58

 

=={{header|Rust}}==

name: &'static str,

population: f64,

);

}

{{Out}}

<pre>Some(6)

=={{header|Scala}}==

{{Out}}See it in running in your browser by [https://scalafiddle.io/sf/8OlRzf8/0 ScalaFiddle (JavaScript executed in browser)] or by [https://scastie.scala-lang.org/fGhNDUNHRqq8h04x3Mm2Kw Scastie (remote JVM)].

val cities = Vector(

City("Lagos", 21.0e6),

f"Population of first city whose name starts with 'A' = ${pop.get}%,.0f")

 

{{Out}}

<pre>Index of first city whose name is 'Dar Es Salaam' = 6

In a similar way (srfi 132) provides sorting routines with user-defined predicates: one is illustrated to ensure the list of items is sorted in decreasing population order.

 

(import (scheme base)

(scheme char)

*items*)))

(newline)

 

{{out}}

=={{header|Sidef}}==

 

String name,

Number population,

say cities.index{|city| city.name == "Dar Es Salaam"}

say cities.first{|city| city.population < 5.0}.name

 

{{out}}

6

Khartoum-Omdurman

4.58

</pre>

=={{header|Standard ML}}==

 

 

val citys : city list = [

val firstCityi = #1 (valOf (List.findi (fn (_, city) => #name(city) = "Dar Es Salaam") citys))

val firstBelow5M = #name (valOf (List.find (fn city => #population(city) < 5.0) citys))

 

{{Output}}

Data:

 

var name: String

var population: Double

Place(name: "Abidjan", population: 4.4),

Place(name: "Casablanca", population: 3.98)

 

===Using built-in methods===

 

fatalError()

}

}

 

 

{{out}}

===Custom method using Key Paths===

 

func firstIndex<V: Equatable>(

withProperty prop: KeyPath<Element, V>,

}

 

 

{{out}}

 

=={{header|Tcl}}==

set records {

{ name "Lagos" population 21.0 }

# Find the population of the first city in this list whose name starts with the letter "A"

puts [search $records {[string match A* $name]} {return $population}]

 

{{out}}

Khartoum-Omdurman

4.58</pre>

 

=={{header|zkl}}==

SD("name","Cairo", "population",15.2),

SD("name","Kinshasa-Brazzaville", "population",11.3),

// Test case 3:

city:=list.filter1(fcn(city){ city["name"][0]=="A" });

where a SD is a small read only dictionary and filter1 is a filter that stops at the first match (returning the matched item). The filter method returns False on failure.

The YAJL library could be used to parse the JSON data directly (eg if the data is from the web).