You can check a DB fiddle of the solution here (without a function just raw SQL): https://www.db-fiddle.com/f/fR2JtQKVcQzrnuZ9SfpcNS/0 For the solution, I am providing some dummy data to show some real output as I don't have your data: create table if not exists users ( user_id serial primary key, name text ); create table if not exists games ( game_id serial primary key, user_id int references users(user_id), score numeric, inserted_at timestamptz ); insert into users (name) values ('5w3n'),('CCoX'),('FHWbb8f7'),('NhsX1XcP'),('OPP6A3j3'),('t4N'),('scdHS'),('Adve'),('yqy'), ('fALF'),('J77T'),('TAXQ5B3V'),('GQGtBXV'),('U2yx6o'),('4in74FhL'),('ZsoZs'),('9dn6'), ('ewhi3u6q'),('q18'); insert into games(user_id, score, inserted_at) values (5,589.53,'2022-01-01'),(9, 48.70,'2022-01-11'),(6, 27.05,'2022-02-01'), (1,952.81,'2022-02-23'),(11,23.80,'2022-02-15'),(5,732.60,'2022-03-02'), (7,460.05,'2022-03-09'),(4,402.98,'2022-03-29'),(7,375.06,'2022-03-30'), (3,325.03,'2022-04-12'),(2,363.32,'2022-04-15'),(12,34.60,'2022-04-19'), (6,370.70,'2022-04-22'),(6,462.08,'2022-05-01'),(2,575.39,'2022-05-02'), (13,14.56,'2022-05-03'); The function: create or replace function get_user_averages( p_start_date timestamptz, p_end_date timestamptz default now(), p_interval interval default '1 month', p_truncate text default 'month' ) returns table( user_id int, name text, data numeric[] ) language plpgsql as $$ begin return query select x.user_id, x.name, array_agg(x.average order by x.gen) from ( select gen, u.user_id, u.name, round(avg(g.score) filter(where gen = date_trunc(p_truncate, g.inserted_at)) ,2) as average from generate_series(p_start_date, p_end_date, p_interval) gen cross join games g join users u on u.user_id = g.user_id group by gen, u.user_id, u.name ) x group by x.user_id, x.name order by x.user_id; end; $$; This function allows you to input your own custom start and end date as well as choosing your own interval (it can be 1 month, 1 day etc.). The output of the array itself (data column) is intentionally ordered (so the array itself is ordered) by the generated dates in ascending order. It might not be a useful feature, however, considering you don't have the dates available in the final output you won't be able to know which average belongs to which generated date. For this reason I have sorted the array so that your application code may be able to at least do something with the dates if it needs to. I would recommend trying to use a jsonb output instead of array where you would have a {month1:average1, month2:average2 ...} kind of output which may be more useful. You have to match the p_interval and p_truncate parameters to get the correct output. As one is for date generation, the other specifies the truncation of the timestamptz of the real table's inserted_at (so if you're sending interval '1 month', you should send month in p_truncate parameter) Calling the function: select * from get_user_averages('2022-01-01'); The result: +-------+--------+-----------------------------------+ |user_id|name |data | +-------+--------+-----------------------------------+ |1 |5w3n |{null,952.81,null,null,null,null} | |2 |CCoX |{null,null,null,363.32,575.39,null}| |3 |FHWbb8f7|{null,null,null,325.03,null,null} | |4 |NhsX1XcP|{null,null,402.98,null,null,null} | |5 |OPP6A3j3|{589.53,null,732.6,null,null,null} | |6 |t4N |{null,27.05,null,370.7,462.08,null}| |7 |scdHS |{null,null,417.56,null,null,null} | |9 |yqy |{48.7,null,null,null,null,null} | |11 |J77T |{null,23.8,null,null,null,null} | |12 |TAXQ5B3V|{null,null,null,34.6,null,null} | +-------+--------+-----------------------------------+

The https://www.postgresql.org/docs/current/functions-array.html#ARRAY-OPERATORS-TABLE mostly does it: SELECT reference, word, spelling FROM word_mash_dictionary WHERE spelling This can be supported with a GIN index on the array, which makes it fast for big tables. Like: CREATE INDEX ON word_mash_dictionary USING gin (spelling); However, one element in the search array covers any number of matches in spelling. So '{a,n,o,y}' would find '{a,n,n,o,y}' etc. False positives for words with repeated letters. A set-operation with https://www.postgresql.org/docs/current/queries-union.html would be exact (consider each copy of the same element separately). Wrapped into a custom function: CREATE OR REPLACE FUNCTION f_arr_is_contained(arr1 text[], arr2 text[]) RETURNS bool LANGUAGE plpgsql IMMUTABLE STRICT PARALLEL SAFE AS $func$ DECLARE BEGIN PERFORM unnest(arr1) EXCEPT ALL SELECT unnest(arr2); RETURN NOT FOUND; END $func$; If every single letter is covered in the second term, no row is returned, and FOUND is false. So return NOT FOUND. I chose LANGUAGE plpgsql because the function cannot be "inlined" anyway, so plpgsql might be faster. You can test the equivalent alternative with LANGUAGE plpgsql: CREATE OR REPLACE FUNCTION f_arr_is_contained_sql(arr1 text[], arr2 text[]) RETURNS bool LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS 'SELECT NOT EXISTS (SELECT unnest (arr1) EXCEPT ALL SELECT unnest (arr2))'; The function cannot use any indexes, though, which would lead to expensive sequential scans over the whole table. Combine both to be fast and exact: SELECT reference, word, spelling FROM word_mash_dictionary WHERE spelling db<>fiddle https://dbfiddle.uk/?rdbms=postgres_14&fiddle=451858f812f6ab1f3fc6b8731d6b702a The first predicate finds all matches (and possibly some false positives) quickly with index support; the second predicate weeds out the (few!) false positives. Aside, word and spelling should probably be declared NOT NULL.

There are multiple more or less subtle differences. Some become obvious from looking at the description in the manual: https://www.postgresql.org/docs/current/intarray.html#INTARRAY-FUNC-TABLE idx ( integer[], item integer ) → integer Returns index of the first array element matching item, or 0 if no match. https://www.postgresql.org/docs/current/functions-array.html#ARRAY-FUNCTIONS-TABLE array_position ( anycompatiblearray, anycompatible [, integer ] ) → integer Returns the subscript of the first occurrence of the second argument in the array, or NULL if it's not present. If the third argument is given, the search begins at that subscript. The array must be one-dimensional. Comparisons are done using IS NOT DISTINCT FROM semantics, so it is possible to search for NULL. If not found, idx() returns 0, but array_position() returns null. idx() cannot handle null at all. intarray as a whole disallows arrays with null values. So it also makes no sense to search for it, you always get null when searching for null. array_position() allows null. Unlike idx(), array_position() allows an offset in the search as 3rd parameter. So you can iterate through arrays to find one match after the other. idx() can never find elements past the first occurrence. (intarray is mostly optimized to deal with sorted, unique array elements.) OTOH, idx() accepts multi-dimensional arrays (treats them as flat), while array_position() does not. Non-standard array subscripts are ignored by idx() (generally bypassing array dimensions and subscripts), but honored by array_position(). So results can differ for seemingly equivalent, simple expressions! It's best to stick with standard array subscripts, but one must be aware of possibilities. See: https://stackoverflow.com/q/12011569/939860 array_position() takes polymorphic arguments, so it works for any array type, while idx() works for integer exclusively. There are pros and cons to either. idx() is faster with function type resolution, and will never be confused with different types, but it's limited to integer: integer or die. All the added versatility of array_position() comes at a price. Most importantly, array_position() uses IS NOT DISTINCT FROM semantics to handle null values, and that is substantially more expensive. This leads to the possibly most important difference: idx() is much faster and scales much better with long arrays. (Your "very informal benchmarking" mislead you somehow.) db<>fiddle https://dbfiddle.uk/?rdbms=postgres_14&fiddle=b5d1bdda3aed30260c604e60fdc6ba99 - demonstrating all.

A B-tree index on an array cannot speed up the queries in your question. Somebody must have created them by mistake. The B-tree index should only index name. If that condition already narrows down the result set a lot, that would be good enough. If you need an index to speed up the condition on things as well, create a separate GIN index on that column. Note that only the condition using the @> operator can use the index, the condition on things in your first query cannot be indexed.

Use the contains operator to check if the tags array contains all elements of the "other" array SELECT name, tags FROM article WHERE tags https://dbfiddle.uk/?rdbms=postgres_14&fiddle=8d3cac22950f917993b883c9ecb8f4d4

select json_agg(u.a) from ( select bname, bfrom, json_build_array(bfrom,bval) a FROM stepchart union all select bname, bfrom, json_build_array(bto,bval) FROM stepchart order by bname, bfrom ) u; see https://dbfiddle.uk/?rdbms=postgres_14&fiddle=1991623d96797ad5738a7f18481c9410 [[63115200, 213.4], [139769280, 213.4], [139769280, 213.39], [160911360, 213.39], [160911360, -9999.9], [163853812, -9999.9]]

The best solution depends on missing details. A plain correlated subquery is one of various options (especially good for small selections). Using https://www.postgresql.org/docs/current/functions-aggregate.html#FUNCTIONS-AGGREGATE-TABLE to aggregate rows into an array of objects: SELECT *, (SELECT json_agg(m.*) FROM marks m WHERE m.subject_id = s.id) AS marks FROM subjects s; To use only a subset of columns, see: https://dba.stackexchange.com/questions/69655/select-columns-inside-json-agg/69658#69658

To unnest 1-dimensional arrays from N-dimensional arrays, I suggest this custom function: CREATE OR REPLACE FUNCTION unnest_nd_1d(a ANYARRAY, OUT a_1d ANYARRAY) RETURNS SETOF ANYARRAY LANGUAGE plpgsql IMMUTABLE PARALLEL SAFE STRICT AS $func$ BEGIN FOREACH a_1d SLICE 1 IN ARRAY a_2d LOOP RETURN NEXT; END LOOP; END $func$; See: https://stackoverflow.com/a/8142998/939860 Then to achieve your desired result: SELECT unnest(a1), unnest_nd_1d(a2) FROM ( SELECT '{id1,id2}'::text[] , '{{tag1},{tag2}}'::text[] ) t(a1, a2); db<>fiddle https://dbfiddle.uk/?rdbms=postgres_14&fiddle=482eedfd45a37a494cae76e74af72d8f About those multiple set-returning functions in the SELECT list: https://stackoverflow.com/a/39864815/939860 https://stackoverflow.com/a/27854382/939860 Your use of text[][] indicates a misunderstanding. Postgres does not enforce array dimensions. See: https://stackoverflow.com/a/34315117/939860 https://stackoverflow.com/a/10745524/939860

Don't use an array, use a junction table. First, as you found out, you cannot have referential integrity with arrays. Also, rearranging a large array is expensive. There are good reasons why the first normal form outlaws composite attributes. To model the ordering, add a double precision column to the junction table. That is better than an integral column, because you can add a value in the middle without reshuffling the whole set.

See https://dbfiddle.uk/?rdbms=postgres_13&fiddle=db83ca30180e59e684bdd8336db2e59a create function f() returns integer[][] as $$ declare count_value integer[] = '{5,6}'; count_values integer[][] = '{{1,2},{3,4}}'; begin return Array_cat(count_values,count_value); end; $$ language plpgsql; or, starting with an empty array, create function f() returns integer[][] as $$ declare count_value integer[] = '{5,6}'; count_values integer[][] ; new_cvs integer[][]; begin if count_values is null then new_cvs = array_cat(ARRAY[]::integer[][],ARRAY[count_value]); else new_cvs = Array_cat(count_values,count_value); end if ; return new_cvs; end; $$ language plpgsql; see https://dbfiddle.uk/?rdbms=postgres_13&fiddle=f82ef52ec2c836a58400cd99c30d3675

If there was unanimity, there would be no need for both. The dichotomy between these two doesn't make much sense.Unlike what people may find, a collection that is talking should be the type ICollection, and is something abstract, does not exist in fact. You use a specific collection, and there are several, so you should choose which one is most suitable for you for each situation. There is no single solution, each data structure (and this is the subject you should study) has advantages and disadvantages. Turn off your application at that time what to choose.Generally you should never use array in C#. It is too concrete, has limitations and almost no relevant advantage. Almost all data structures that implement ICollection has all the relevant advantages of array and a few more. The use of array in modern and well-written code should only use array because of legacy code or having some specific performance issue.Types that are collections often have the same basic structure of array, even internally has a array in many of them, but has the advantage of being able to do some operations that array cannot, for example, increase or reduce the size of the collection. You can see more about it in https://pt.stackoverflow.com/q/76316/101 . Reading there, a collection does not guarantee that you can insert or remove items in the middle of the collection, only one list (IList) allows this. Okay, she's a collection too, but there are collections that don't have this feature.A collection may or may not define types in them, but those that do not allow are considered obsolete and for all effects should not be used, forget that they exist, are problematic. Even if you want to put any type in the modern and efficient collection use the type object. And even in this case think well if this is what you want, it's almost always a mistake to do this. And you can do it array also, just use object[].It also does not make the slightest sense what the other answer (it was one, and it was erased, most of this answer is contestation of what was wrong in the other) says about the elements being read-only or not. In gross ties in any case that the structure is not explicitly readon so array how collections can have their data changed normally, already in links foreach there are limitations in both by an iterator account.It was also wrong that one of them is set in compilation time and another running. They are equal, both are written and defined in compilation time and both are instantiated in runtime, the difference is just how each can be manipulated, nothing more, even because most of the collections have a array internally.

I would do this:(code is commented)// ao chegar nesse valor de consultas agendada por horário é retirado o horário do array hours $chooseNumber = 3; $count = array_count_values( $schedule ); $array_com_horarios_livres = array(); foreach($hours as $hour){ # SE O HORÁRIO EM $hours ESTIVERM EM $count E A QUANTIDADE FOR MAIOR OU IGUAL AO LIMITE CONTINUE O LOOP SEM INSERIR if(isset($count[$hour]) && $count[$hour] >= $chooseNumber) continue; $array_com_horarios_livres[] = $hour; # INSERE NO NOVO ARRAY COM OS HORÁRIOS LIVRES } print_r($array_com_horarios_livres); https://ideone.com/uNvjFP

What's the matter?In multilinear code (multithread) collections must have data access synchronization so that calls from two or more competing threads are not in a standstill when deciding who will get first access to the data and consequently freeze the system.What's the solution?The error message is telling you that the collection in question https://docs.microsoft.com/pt-br/dotnet/api/system.collections.objectmodel.observablecollection-1?view=netframework-4.7.2 does not support that a different thread than that created it modify your data.The solution is to change ObservableCollection<T> by a class that supports multilinear calls. .NET Framework does not exist a class ObservableCollection<T> then to solve the problem you will have to create a class that will intercept the event https://docs.microsoft.com/pt-br/dotnet/api/system.collections.objectmodel.observablecollection-1.collectionchanged?view=netframework-4.7.2 and instead of granting the conventional alteration of the elements of the collection, this class will dispatch invocations to the methods necessary for the change on fly(synchronized by the system) of the elements of the collection.public class MyTObservableCollection<T> : ObservableCollection<T> { public override event NotifyCollectionChangedEventHandler CollectionChanged; protected override void OnCollectionChanged(NotifyCollectionChangedEventArgs e) { NotifyCollectionChangedEventHandler CollectionChanged = this.CollectionChanged; if (CollectionChanged != null) foreach (NotifyCollectionChangedEventHandler nh in CollectionChanged.GetInvocationList()) { DispatcherObject dispObj = nh.Target as DispatcherObject; if (dispObj != null) { Dispatcher dispatcher = dispObj.Dispatcher; if (dispatcher != null && !dispatcher.CheckAccess()) { dispatcher.BeginInvoke( (Action)(() => nh.Invoke(this, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset))), DispatcherPriority.DataBind); continue; } } nh.Invoke(this, e); } } } So it's just changing the classes of objects ObservableCollection<T> For MyTObservableCollection<T>.Note:That class MyTObservableCollection<T> in a global aspect it remains insecure with respect to the multilinear scope(thread unsafe) but resolves its problem. If similar error occurs in the future as another type of operation you should extend the same reasoning for such operation. If you extend this reasoning, convert the linear calls to on fly invocations, for the whole class this class becomes safe in relation to the multilinear scope(thread safe).

First, array is different from list. https://pt.stackoverflow.com/q/171023/5878 In many cases, commonly more information, the nomenclature error will not be an aggravating and will not harm the communication, but since we will be analyzing the internal functioning of the language I think it is interesting to stick to the correct terms. Given the questions, it became clear that the doubt is about the functioning of lists, not of arrays.The guy list is native to Python and was implemented in C under the structure PyListObject.typedef struct { PyVarObject ob_base; /* Vector of pointers to list elements. list[0] is ob_item[0], etc. */ PyObject **ob_item; /* ob_item contains space for 'allocated' elements. The number * currently in use is ob_size. * Invariants: * 0 &lt;= ob_size &lt;= allocated * len(list) == ob_size * ob_item == NULL implies ob_size == allocated == 0 * list.sort() temporarily sets allocated to -1 to detect mutations. * * Items must normally not be NULL, except during construction when * the list is not yet visible outside the function that builds it. */ Py_ssize_t allocated; } PyListObject; Where we have:ob_base, an object representing variable size structures, implements the field ob_size;ob_item, a pointer for pointer PyObject;allocated, an object Py_ssize_t which represents the allocated size;As you can see - including commented on the code - the items that make up the list in Python will be managed from ob_item. It, because it is a pointer, possesses the dynamism of being relocated according to the need for growth of the list, in which each position will point to another pointer PyObject which represents the item of the list. It is worth remembering here that all the structures that Python implements inherit from PyObject, then there will be no restrictions of the type that can be stored on the list.Whenever the size of a list needs to be changed, the function list_resize is invoked; it is responsible for implementing the relocation algorithm of a list. https://pt.stackoverflow.com/q/319164/5878 The source code of this function is:/* Ensure ob_item has room for at least newsize elements, and set ob_size to newsize. If newsize > ob_size on entry, the content of the new slots at exit is undefined heap trash; it's the caller's responsibility to overwrite them with sane values. The number of allocated elements may grow, shrink, or stay the same. Failure is impossible if newsize <= self.allocated on entry, although that partly relies on an assumption that the system realloc() never fails when passed a number of bytes <= the number of bytes last allocated (the C standard doesn't guarantee this, but it's hard to imagine a realloc implementation where it wouldn't be true). Note that self->ob_item may change, and even if newsize is less than ob_size on entry. */ static int list_resize(PyListObject *self, Py_ssize_t newsize) { PyObject **items; size_t new_allocated; Py_ssize_t allocated = self->allocated; /* Bypass realloc() when a previous overallocation is large enough to accommodate the newsize. If the newsize falls lower than half the allocated size, then proceed with the realloc() to shrink the list. */ if (allocated >= newsize && newsize >= (allocated >> 1)) { assert(self->ob_item != NULL || newsize == 0); Py_SIZE(self) = newsize; return 0; } /* This over-allocates proportional to the list size, making room for additional growth. The over-allocation is mild, but is enough to give linear-time amortized behavior over a long sequence of appends() in the presence of a poorly-performing system realloc(). The growth pattern is: 0, 4, 8, 16, 25, 35, 46, 58, 72, 88, ... */ new_allocated = (newsize >> 3) + (newsize < 9 ? 3 : 6); /* check for integer overflow */ if (new_allocated > PY_SIZE_MAX - newsize) { PyErr_NoMemory(); return -1; } else { new_allocated += newsize; } if (newsize == 0) new_allocated = 0; items = self->ob_item; if (new_allocated <= (PY_SIZE_MAX / sizeof(PyObject *))) PyMem_RESIZE(items, PyObject *, new_allocated); else items = NULL; if (items == NULL) { PyErr_NoMemory(); return -1; } self->ob_item = items; Py_SIZE(self) = newsize; self->allocated = new_allocated; return 0; } Just as Maniero commented in his response, Python basically allocates a new memory space already considering the new size of the list and considering plenty of spaces to then copy the content to that space in memory. Note that the space added to the size of the list will be proportional to the current size and it is done precisely to seek a linear amortization in the relocation time. That is, it's easier to relocate a larger space once and insert multiple elements than relocating whenever you enter. Also note that all relocation is made on the object items and not directly on self->ob_item:items = self->ob_item; if (new_allocated <= (PY_SIZE_MAX / sizeof(PyObject *))) PyMem_RESIZE(items, PyObject *, new_allocated); else items = NULL; if (items == NULL) { PyErr_NoMemory(); return -1; } self->ob_item = items; PyMem_RESIZE is a macro defined by:#define PyMem_RESIZE(p, type, n) ( (p) = ((size_t)(n) > PY_SSIZE_T_MAX / sizeof(type)) ? NULL : (type *) PyMem_REALLOC((p), (n) * sizeof(type)) ) That basically makes memory relocation on the specified pointer.

An array, in R, is a widespread form of the matrix. A vector has only one dimension: size. The matrix has only two dimensions: rows and columns. An array can be n dimensions. Vector Caselibrary(magrittr) array(1:12) %>% print() %>% dim() [1] 1 2 3 4 5 6 7 8 9 10 11 12 [1] 12 Case matrixarray(1:12, c(3, 4)) %>% print() %>% dim() [,1] [,2] [,3] [,4] [1,] 1 4 7 10 [2,] 2 5 8 11 [3,] 3 6 9 12 [1] 3 4 General casearray(1:12, c(2, 3, 2)) %>% print() %>% dim() , , 1 [,1] [,2] [,3] [1,] 1 3 5 [2,] 2 4 6 , , 2 [,1] [,2] [,3] [1,] 7 9 11 [2,] 8 10 12 [1] 2 3 2 General case with 4 dimensionsarray(1:16, c(2, 2, 2, 2)) %>% print() %>% dim() , , 1, 1 [,1] [,2] [1,] 1 3 [2,] 2 4 , , 2, 1 [,1] [,2] [1,] 5 7 [2,] 6 8 , , 1, 2 [,1] [,2] [1,] 9 11 [2,] 10 12 , , 2, 2 [,1] [,2] [1,] 13 15 [2,] 14 16 [1] 2 2 2 2 So, yes, it is useless in most cases because most cases we want to deal with these specific cases arrays that are vectors and matrices.what is the logic behind creating an array (as I did in the above example)?The logic is the same as the matrix. In the case given above the matrix was duplicated because it was recycled, you asked to be created an array with 18 elements (332), but provided only 9, so they were recycled.in which situations the use of the array is useful in r?An array can be useful when you need more than 2 dimensions. Imagine that you want to create a way to view and solve magic cubes (Rubik's cube). In this case a matrix or a vector would not be enough and we would end up handing out an array of dimensions c(3, 3, 6). Another possible application is to read colored images that are composed of 3 channels, each with a color intensity matrix. In this case an image with 800x600 pixel would have the dimensions c(800, 600, 3). img <- jpeg::readJPEG(system.file("img", "Rlogo.jpg", package="jpeg")) str(img) num [1:76, 1:100, 1:3] 1 1 1 1 1 1 1 1 1 1 ... is.array(img) [1] TRUE how to extract the arrays present in the array?Taking the last array as an example, it is possible to make a subset the same way we do with matrices, but respecting the number of dimensions of array.meu_array <- array(1:16, c(2, 2, 2, 2)) meu_array[2, 2, , ] [,1] [,2] [1,] 4 12 [2,] 8 16 In the example above we select the second row of the second column of each of the third and fourth dimensions.If the number of dimensions is not respected, we will have a mistake.meu_array[2, 2] Error in meu_array[2, 2] : incorrect number of dimensions

The condition of for It is i == N - 1, therefore the loop will perform whenever that condition is true. He does not need to perform if the face condition is already false. Just before you said that i is equal to 0, so the condition will only be true if the N for 1 (mathematical basic logic), in no other situation this is true, so any number that is entered and placed in N that it is not 1 the condition will be false and the bond will not perform, not once.Probably what I wanted to do would be something like this:for (int i = 0; i < N; i++) https://github.com/maniero/SOpt/blob/master/CSharp/Algorithm/BasicIteration.cs .That would at least be what everyone does. That way will be true whenever the value of i is smaller than N, so it makes sense for an accountant, he will of 0 until the value before in the total number. Just be careful not to do i < N - 1 because this would not go to the last item, or do i <= N because it would go one beyond and make a mistake. It could, but it is not ideal to do i <= N - 1, is doing an unnecessary arithmetic operation and in some architectures o <= is slower than the <.

If you have this data before json, or using json decode it will come an array, so you can do a foreach, and go comparing it to the content until you find the code you want. the moment you find the code you want you to separate and put into another array and json encode.foreach($jsonAcademy as $i){ if(strcmp($i['0'],""codTipo": "B"")==0){ $arraynovo['0'] = $i['0']; $arraynovo['1']= $i['1']; } }

Flavius what you can do is extract the id that is coming through Ural through one https://vuejs.org/v2/guide/computed.html with https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Guide/Regular_Expressions and in Html use https://vuejs.org/v2/guide/list.html#v-for-with-an-Object to go through the object estampas and one https://vuejs.org/v2/guide/conditional.html#v-if to make a condition of showing the stamping elements that have the id equal to that of the url: let app = new Vue({ el: '#app', data: { url: 'estampa/:1', // Mude o id de 1 para 2, será mostrado estampa 2 estampas: [{ id: '1', name: 'Estampa 1', content: [ { img: 'https://via.placeholder.com/500x300&amp;text=Estampa', caption: 'Legenda 1 estampa 1' }, { img: 'https://via.placeholder.com/500x300&amp;text=Estampa', caption: 'Legenda 2 estampa 1' }, { img: 'https://via.placeholder.com/500x300&amp;text=Estampa', caption: 'Legenda 3 estampa 1' } ] }, { id: '2', name: 'Estampa 2', content: [{ img: 'https://via.placeholder.com/500x300&amp;text=Estampa', caption: 'Legenda 1 estampa 2' }, { img: 'https://via.placeholder.com/500x300&amp;text=Estampa', caption: 'Legenda 2 estampa 2' } ] }] }, computed: { id_url() { const url = this.url; const idUrl = /[*0-9]/g; const id = url.match(idUrl)[0]; // retorna apenas o número do id da url return id; } } })<script src="https://cdn.jsdelivr.net/npm/vue"></script> <div id="app"> <div v-for="estampa in estampas"> <div v-if="estampa.id == id_url"> <p>ID: {{ estampa.id }} - nome: {{ estampa.name }}</p> <p> <img :src="estampa.content[0].img"> <figcaption>{{ estampa.content[0].caption }}</figcaption> </p> <p> <img :src="estampa.content[1].img"> <figcaption>{{ estampa.content[1].caption }}</figcaption> </p> </div> </div> </div>

I decided to help because it has an extraordinary amount of errors in the code. The ideal is to learn one thing at a time, so make only one mistake, learn from it, move on to the next and there will evolve knowledge. When you try to do what is not yet prepared you make many mistakes and do not learn from them. One of the mistakes and not put the code more organized to help better. Programming is a lot of organization, who cannot do this will have difficulties in the profession.#include <stdio.h> typedef struct { int id; char nome[201]; char endereco[101]; char cidade [31]; } Pessoa; void preencherPessoas(Pessoa pessoas[], int qtde) { for (int i = 0; i < qtde; i++) { printf(" Digite o ID do funcionário: "); scanf("%d", &pessoas[i].id); printf(" Digite a nome do funcionário: "); scanf("%s", pessoas[i].nome); printf(" Digite o endereco do funcionário: "); scanf("%s", pessoas[i].endereco); printf(" Digite o cidade do funcionário: "); scanf("%s", pessoas[i].cidade); printf(" DADOS DO FUNCIONARIO DE ID %d CADASTRADOS! \n", pessoas[i].id); } } int main() { printf("Insira a quantidade de funcionários que serão cadastrados: "); int qtde; scanf("%d", &qtde); printf("\nQTD: %d", qtde); Pessoa pessoas[qtde]; preencherPessoas(pessoas, qtde); } See https://ideone.com/bRJIc6 . And https://repl.it/join/sgsffaia-maniero . Also https://github.com/maniero/SOpt/blob/master/C/Function/ArrayPass.c .I gave a name that means something in the kind of structure created. Code is expression, it is important to give good names to things to better understand what you are doing. Every experienced programmer does that, only novice gives no value to this.I put another 1 byte in strings to fit https://pt.stackoverflow.com/q/177619/101 . The sizes are absurdly large and waste a lot of space and any amount of larger data will burst the stack. I'm not going to go into detail, but all that idea of organizing the struct It's wrong and real codes aren't like that. It serves only to understand other things in this little code, keep it in mind.Do not declare global variables unless you have a very large domain of what you are doing, just declare local variables.Give a better name for the function. What would happen if I had to fill something else?If you created a guy then use it not using the struct to declare variables and parameters.No need to pass array by reference because it is already a reference. I would only need to pass this way if I were to change the whole object, which is not the case, even you can't even do it in the planned form.Do not need to declare the variable before its use, in fact this makes the code less readableNames using ALL_CAPS notation should only be used for macros, and still should be avoided. And you don't need to abbreviate so much, use a more common abbreviation.A function that must fill people's data should not ask how many people will be in total. This is the responsibility of another function.If the data is a string then he's already a array, therefore it is already a reference and scanf() asks for a reference, so you do not need to create another reference when you pass this data, it is already naturally what you expect.I created a main() that makes sense.If you didn't understand anything, it's because you jumped too far. Here on the site has almost everything you need to know before continuing.

Your code can set a value well for the queue size and heights of the people who are in it. In my view, what only lacks to solve well the problem is to apply the constraints of the statement in the code and perhaps improve the best solution to find the amount of people who can see the queue. To put the restrictions, I will use the while structure. Now, to find the amount I will use the following logic. The first person will always see the box office and at the beginning of the queue will be considered the largest, then sum = 1 and greater = array[0]. After that, we will compare the people behind to find out who the greatest after the first, always when we find out we will update the value of greater and add a value to the sum. Below is the code I used to solve this problem.#include <iostream> using namespace std; int array[101]; int main() { int x; //testando restrição de pessoas na fila do{ cout<<"Digite a quantidade de pessoas na fila "; cin >> x; }while(x < 1 || x > 100); //obtendo as alturas for(int i = 0; i < x; i++) { //testando restrição de altura do{ cout<<"Digite as alturas: "; cin >> array[i]; }while(array[i] < 1 || array[i] > 1000); } int sum = 1; int maior = array[0]; //encontrar a maior altura for(int i = 0; i < x - 1; i++) { if(array[i +1] &gt; array[i] &amp;&amp; array[i + 1] &gt; maior) { sum += 1; maior = array[i +1]; } } cout <<"A quantidade de pessoas que podem ver a bilheteria é: "<< sum << endl; return 0; )