instruction_seed stringlengths 308 3.48k | source stringclasses 1
value | embeddings listlengths 1.02k 1.02k | mean_positive_score float64 0.8 0.86 | mean_negative_score float64 0.74 0.8 | difference_score float64 0.05 0.07 |
|---|---|---|---|---|---|
Please explain the reasoning behind the following solution and provide code in Julia:
You are given an array `nums` of positive integers and a **positive** integer `k`.
A subset of `nums` is **beautiful** if it does not contain two integers with an absolute difference equal to `k`.
Return _the number of **non-empty b... | dolphin | [
0.003112608101218939,
0.04158300906419754,
-0.03440128639340401,
-0.02763346955180168,
0.049302250146865845,
-0.024774348363280296,
-0.03387279808521271,
0.04825266823172569,
0.04826781898736954,
-0.0019106623949483037,
0.026920106261968613,
0.030707739293575287,
-0.026151450350880623,
0.0... | 0.8451 | 0.790488 | 0.054612 |
Please explain the reasoning behind the following solution and provide code in java:
Given an unsorted array of integers `nums`, return _the length of the longest **continuous increasing subsequence** (i.e. subarray)_. The subsequence must be **strictly** increasing.
A **continuous increasing subsequence** is defined ... | dolphin | [
0.021624868735671043,
0.0423259437084198,
-0.03128809109330177,
-0.022347746416926384,
0.03266545757651329,
-0.02420906536281109,
-0.04692932590842247,
0.059105996042490005,
0.034612417221069336,
-0.024423277005553246,
0.02560618706047535,
0.011515953578054905,
-0.0319332629442215,
0.01866... | 0.831619 | 0.772891 | 0.058728 |
Please write the following solution using Scheme:
You are given an array `nums` of non-negative integers. `nums` is considered **special** if there exists a number `x` such that there are **exactly** `x` numbers in `nums` that are **greater than or equal to** `x`.
Notice that `x` **does not** have to be an element in ... | dolphin | [
0.02187269926071167,
0.027847930788993835,
-0.020531782880425453,
-0.01739075966179371,
0.04164861515164375,
-0.031888898462057114,
-0.03089234046638012,
0.05605252832174301,
0.04379871115088463,
-0.01585731841623783,
0.02396150678396225,
0.02451343834400177,
-0.03940320387482643,
-0.01069... | 0.847959 | 0.793557 | 0.054401 |
Please write the following solution using java:
Given an array of positive integers `nums`, return the _maximum possible sum of an **ascending** subarray in_ `nums`.
A subarray is defined as a contiguous sequence of numbers in an array.
A subarray `[numsl, numsl+1, ..., numsr-1, numsr]` is **ascending** if for all `i... | dolphin | [
0.019597472622990608,
0.030699316412210464,
-0.023060789331793785,
-0.025209231302142143,
0.03067547269165516,
-0.020568449050188065,
-0.029947195202112198,
0.05080697312951088,
0.03905805945396423,
-0.012355889193713665,
0.036554936319589615,
0.023590993136167526,
-0.0540790818631649,
0.0... | 0.828877 | 0.760355 | 0.068522 |
Please write the following solution using c++:
You are given an array of strings `words` and a string `chars`.
A string is **good** if it can be formed by characters from chars (each character can only be used once).
Return _the sum of lengths of all good strings in words_.
**Example 1:**
**Input:** words = \[ "cat... | dolphin | [
0.008421641774475574,
0.006465309765189886,
-0.013348104432225227,
-0.03389823064208031,
0.044719453901052475,
-0.03645431995391846,
-0.040604546666145325,
0.047816574573516846,
0.023544611409306526,
-0.02442588284611702,
-0.0034175326582044363,
0.04007074981927872,
-0.040624894201755524,
... | 0.819276 | 0.756099 | 0.063178 |
Please focus on the efficiency of this problem and provide code in ANSI C:
An integer `x` is **numerically balanced** if for every digit `d` in the number `x`, there are **exactly** `d` occurrences of that digit in `x`.
Given an integer `n`, return _the **smallest numerically balanced** number **strictly greater** tha... | dolphin | [
0.023770859465003014,
0.02429714985191822,
-0.01081820297986269,
-0.02907540649175644,
0.03184825927019119,
-0.027323154732584953,
-0.012150761671364307,
0.08079696446657181,
0.031870272010564804,
-0.002876641694456339,
0.030360931530594826,
0.03566940873861313,
-0.04590142145752907,
-0.03... | 0.835533 | 0.777374 | 0.058159 |
Please write the following solution using java:
You are given two integer arrays of the same length `nums1` and `nums2`. In one operation, you are allowed to swap `nums1[i]` with `nums2[i]`.
* For example, if `nums1 = [1,2,3,8]`, and `nums2 = [5,6,7,4]`, you can swap the element at `i = 3` to obtain `nums1 = [1,2,3,... | dolphin | [
0.013695870526134968,
0.029777193441987038,
-0.021181931719183922,
-0.023117825388908386,
0.02408887818455696,
-0.01694204844534397,
-0.041345760226249695,
0.06955254077911377,
0.025937946513295174,
-0.03800933435559273,
0.009563328698277473,
-0.01605778932571411,
-0.026952331885695457,
-0... | 0.852174 | 0.789777 | 0.062398 |
Please write the following solution using java:
You are given an `m x n` integer matrix `grid` containing **distinct** positive integers.
You have to replace each integer in the matrix with a positive integer satisfying the following conditions:
* The **relative** order of every two elements that are in the same ro... | dolphin | [
0.020813923329114914,
0.027079764753580093,
-0.02537289261817932,
-0.04257581755518913,
0.0350557342171669,
-0.053360432386398315,
-0.029787126928567886,
0.03988487273454666,
0.03904496133327484,
-0.041122935712337494,
0.011571729555726051,
0.0015282579697668552,
-0.04353135824203491,
-0.0... | 0.848135 | 0.791285 | 0.05685 |
Please write the following solution using F#:
Given an array of integers `nums`, find the maximum length of a subarray where the product of all its elements is positive.
A subarray of an array is a consecutive sequence of zero or more values taken out of that array.
Return _the maximum length of a subarray with posit... | dolphin | [
0.017529455944895744,
0.017310205847024918,
-0.024797549471259117,
-0.026630427688360214,
0.045425642281770706,
-0.026732318103313446,
-0.03669099882245064,
0.05684448778629303,
0.041675008833408356,
-0.011824214830994606,
0.009010977111756802,
0.03869777172803879,
-0.039436373859643936,
-... | 0.843019 | 0.789053 | 0.053966 |
Please write the following solution using Haskell:
Given an array `nums`. We define a running sum of an array as `runningSum[i] = sum(nums[0]...nums[i])`.
Return the running sum of `nums`.
**Example 1:**
**Input:** nums = \[1,2,3,4\]
**Output:** \[1,3,6,10\]
**Explanation:** Running sum is obtained as follows: \[1, ... | dolphin | [
0.013879728503525257,
0.03753665089607239,
-0.016325373202562332,
-0.02559087984263897,
0.05165103077888489,
-0.01878707855939865,
-0.03232923895120621,
0.03130194544792175,
0.04199894145131111,
-0.017382247373461723,
0.020789505913853645,
0.024982517585158348,
-0.04046519100666046,
-0.024... | 0.825839 | 0.767303 | 0.058537 |
Please focus on the algorithm of this problem and provide code in Fortran:
Return the number of permutations of 1 to `n` so that prime numbers are at prime indices (1-indexed.)
_(Recall that an integer is prime if and only if it is greater than 1, and cannot be written as a product of two positive integers both smalle... | dolphin | [
0.029171118512749672,
0.022298168390989304,
0.0006513646803796291,
-0.03581387922167778,
0.03142520412802696,
-0.04270545393228531,
-0.012079602107405663,
0.052364688366651535,
0.02038358524441719,
-0.018011631444096565,
0.032744549214839935,
0.03529452160000801,
-0.03628905117511749,
-0.0... | 0.836535 | 0.780906 | 0.055629 |
Please explain the following problem in detail and provide code in python:
Given an integer array `nums`, return _the **third distinct maximum** number in this array. If the third maximum does not exist, return the **maximum** number_.
**Example 1:**
**Input:** nums = \[3,2,1\]
**Output:** 1
**Explanation:**
The firs... | dolphin | [
0.03428730368614197,
0.03294717147946358,
-0.03206980600953102,
-0.020311908796429634,
0.03587201237678528,
-0.02374386414885521,
-0.033450204879045486,
0.04839230328798294,
0.01582464575767517,
-0.005919588264077902,
0.03233467414975166,
0.020335065200924873,
-0.04290395230054855,
-0.0017... | 0.835557 | 0.780328 | 0.05523 |
Please explain the following problem in detail and provide code in ANSI C:
You are given a **0-indexed** 2D integer array of `events` where `events[i] = [startTimei, endTimei, valuei]`. The `ith` event starts at `startTimei` and ends at `endTimei`, and if you attend this event, you will receive a value of `valuei`. You... | dolphin | [
0.01728733815252781,
0.017254769802093506,
-0.02828851528465748,
-0.028386952355504036,
0.01928069442510605,
-0.026021456345915794,
-0.05713324621319771,
0.07659140974283218,
0.04909991845488548,
-0.004612840712070465,
0.04919564723968506,
0.0326063372194767,
-0.02786484733223915,
0.000830... | 0.841461 | 0.785459 | 0.056002 |
Please write the following solution using F#:
Given an unsorted array of integers `nums`, return _the length of the longest consecutive elements sequence._
You must write an algorithm that runs in `O(n)` time.
**Example 1:**
**Input:** nums = \[100,4,200,1,3,2\]
**Output:** 4
**Explanation:** The longest consecutive... | dolphin | [
0.018305519595742226,
0.011221594177186489,
-0.017210304737091064,
-0.038515858352184296,
0.0424489751458168,
-0.025743769481778145,
-0.03339799493551254,
0.058218784630298615,
0.048753537237644196,
-0.01810746267437935,
0.0242118202149868,
0.025793781504034996,
-0.04351292923092842,
-0.01... | 0.839274 | 0.776534 | 0.06274 |
Please explain the following problem in detail and provide code in PHP:
Given an integer array `nums`, your goal is to make all elements in `nums` equal. To complete one operation, follow these steps:
1. Find the **largest** value in `nums`. Let its index be `i` (**0-indexed**) and its value be `largest`. If there ar... | dolphin | [
0.022724993526935577,
0.033981386572122574,
-0.03255223482847214,
-0.03620266541838646,
0.027671366930007935,
-0.02259969711303711,
-0.018123231828212738,
0.07160931825637817,
0.03349994868040085,
-0.02246379293501377,
0.03676587715744972,
0.023053813725709915,
-0.038616959005594254,
-0.00... | 0.841974 | 0.786507 | 0.055467 |
Please explain the following problem in detail and provide code in Scheme:
You are given a **0-indexed** integer array `nums`. In one operation, you may do the following:
* Choose **two** integers in `nums` that are **equal**.
* Remove both integers from `nums`, forming a **pair**.
The operation is done on `nums`... | dolphin | [
0.02910410612821579,
0.033655568957328796,
-0.02798921801149845,
-0.025213535875082016,
0.039153434336185455,
-0.03289661556482315,
-0.02885456010699272,
0.06299953907728195,
0.0474250428378582,
-0.022075863555073738,
0.013413500040769577,
0.022498706355690956,
-0.02612721547484398,
-0.019... | 0.858812 | 0.798075 | 0.060737 |
Please focus on the algorithm of this problem and provide code in c++:
You are given a 2D integer array, `queries`. For each `queries[i]`, where `queries[i] = [ni, ki]`, find the number of different ways you can place positive integers into an array of size `ni` such that the product of the integers is `ki`. As the num... | dolphin | [
0.02600189670920372,
0.022262170910835266,
-0.016114557161927223,
-0.019058341160416603,
0.027484461665153503,
-0.008549408987164497,
-0.032472312450408936,
0.08957216143608093,
0.03471590578556061,
-0.018177716061472893,
0.022320907562971115,
0.03865094110369682,
-0.03513840213418007,
-0.... | 0.845073 | 0.784913 | 0.06016 |
Please write the following solution using Swift:
There are `n` cities numbered from `1` to `n`. You are given an array `edges` of size `n-1`, where `edges[i] = [ui, vi]` represents a bidirectional edge between cities `ui` and `vi`. There exists a unique path between each pair of cities. In other words, the cities form ... | dolphin | [
0.006118969060480595,
0.02063581347465515,
-0.0260314904153347,
-0.023411080241203308,
0.029423337429761887,
-0.012200737372040749,
-0.02609056420624256,
0.044784754514694214,
0.03655524179339409,
-0.01236304547637701,
0.04894546791911125,
0.025005683302879333,
-0.02302471548318863,
-0.001... | 0.841134 | 0.786445 | 0.05469 |
Please write the following solution using Kotlin:
You are given two integer arrays `nums1` and `nums2` both of the same length. The **advantage** of `nums1` with respect to `nums2` is the number of indices `i` for which `nums1[i] > nums2[i]`.
Return _any permutation of_ `nums1` _that maximizes its **advantage** with r... | dolphin | [
0.020031070336699486,
0.02453433908522129,
-0.010624882765114307,
-0.03095349110662937,
0.02922944352030754,
-0.018956471234560013,
-0.035018183290958405,
0.0645940899848938,
0.03715544939041138,
-0.021841365844011307,
0.011107648722827435,
0.023165147751569748,
-0.03783343359827995,
-0.01... | 0.836989 | 0.768935 | 0.068054 |
Please write the following solution using java:
Given the `root` of a **complete** binary tree, return the number of the nodes in the tree.
According to **[Wikipedia](http://en.wikipedia.org/wiki/Binary_tree#Types_of_binary_trees)**, every level, except possibly the last, is completely filled in a complete binary tree... | dolphin | [
0.02789561077952385,
0.04562617465853691,
-0.04377635568380356,
-0.028336726129055023,
0.033745307475328445,
-0.04838225990533829,
-0.0035311372485011816,
0.04061345010995865,
0.032463472336530685,
-0.017067380249500275,
0.028847983106970787,
0.019974853843450546,
-0.025030149146914482,
-0... | 0.835461 | 0.777143 | 0.058319 |
Please focus on the efficiency of this problem and provide code in PHP:
A decimal number is called **deci-binary** if each of its digits is either `0` or `1` without any leading zeros. For example, `101` and `1100` are **deci-binary**, while `112` and `3001` are not.
Given a string `n` that represents a positive decim... | dolphin | [
-0.015549828298389912,
0.01767078973352909,
-0.03341168165206909,
-0.03016703762114048,
0.04070355370640755,
-0.04491659253835678,
-0.02648426778614521,
0.03807847201824188,
0.03053607977926731,
0.00017038841906469315,
0.017636487260460854,
0.024146735668182373,
-0.03732940927147865,
-0.02... | 0.826645 | 0.767141 | 0.059504 |
Please write the following solution using ANSI C:
You are given an `m x n` binary matrix `grid`, where `0` represents a sea cell and `1` represents a land cell.
A **move** consists of walking from one land cell to another adjacent (**4-directionally**) land cell or walking off the boundary of the `grid`.
Return _the ... | dolphin | [
0.0021581256296485662,
0.028780188411474228,
-0.021181967109441757,
-0.039824970066547394,
0.045846324414014816,
-0.03847411274909973,
-0.046321623027324677,
0.0810803771018982,
0.02549293264746666,
-0.009192715398967266,
0.016853732988238335,
0.015339956618845463,
-0.041836414486169815,
-... | 0.844413 | 0.781349 | 0.063064 |
Please write the following solution using Swift:
You are given four integers `minLength`, `maxLength`, `oneGroup` and `zeroGroup`.
A binary string is **good** if it satisfies the following conditions:
* The length of the string is in the range `[minLength, maxLength]`.
* The size of each block of consecutive `1`'... | dolphin | [
0.015327323228120804,
0.01961992308497429,
-0.02982015535235405,
-0.04353294521570206,
0.06856945157051086,
-0.04096800461411476,
-0.04838882014155388,
0.05143728479743004,
0.03153669089078903,
-0.023165298625826836,
0.012354276143014431,
0.016486715525388718,
-0.029064951464533806,
-0.029... | 0.853578 | 0.796068 | 0.05751 |
Please write the following solution using Haskell:
You are given a **directed** graph of `n` nodes numbered from `0` to `n - 1`, where each node has **at most one** outgoing edge.
The graph is represented with a given **0-indexed** array `edges` of size `n`, indicating that there is a directed edge from node `i` to no... | dolphin | [
0.018940165638923645,
0.006775015499442816,
-0.023412704467773438,
-0.03691926598548889,
0.03156866133213043,
-0.034035809338092804,
-0.02019311860203743,
0.04947613552212715,
0.03467899560928345,
-0.024265898391604424,
0.03004220314323902,
0.007220041938126087,
-0.018941540271043777,
-0.0... | 0.83718 | 0.782619 | 0.054561 |
Please explain the following problem in detail and provide code in PHP:
Given the `root` of a binary tree, return _the length of the longest **consecutive sequence path**_.
A **consecutive sequence path** is a path where the values **increase by one** along the path.
Note that the path can start **at any node** in th... | dolphin | [
0.03231358900666237,
0.03230304643511772,
-0.019567320123314857,
-0.026552733033895493,
0.022768067196011543,
-0.04387242719531059,
-0.021531933918595314,
0.07513938844203949,
0.03772919625043869,
-0.019580742344260216,
0.04663520306348801,
0.018274730071425438,
-0.029042858630418777,
0.00... | 0.824923 | 0.771685 | 0.053238 |
Please explain the following problem in detail and provide code in Lua:
You are given an integer array of unique positive integers `nums`. Consider the following graph:
* There are `nums.length` nodes, labeled `nums[0]` to `nums[nums.length - 1]`,
* There is an undirected edge between `nums[i]` and `nums[j]` if `n... | dolphin | [
0.023335326462984085,
0.050195544958114624,
-0.03051338903605938,
-0.041574202477931976,
0.03501377999782562,
-0.008471883833408356,
-0.026494747027754784,
0.04050146043300629,
0.026019638404250145,
-0.012101100757718086,
0.03806173801422119,
0.03122301772236824,
-0.027137387543916702,
-0.... | 0.845756 | 0.788899 | 0.056857 |
Please explain the reasoning behind the following solution and provide code in R:
You are given an integer array `nums` and a **positive** integer `k`. You can choose any **subsequence** of the array and sum all of its elements together.
We define the **K-Sum** of the array as the `kth` **largest** subsequence sum tha... | dolphin | [
0.004503120668232441,
0.04064133018255234,
-0.029100075364112854,
-0.04205014556646347,
0.05418328568339348,
-0.009912469424307346,
-0.027609722688794136,
0.05172152817249298,
0.032615289092063904,
0.005767572205513716,
0.01925060898065567,
0.03753012791275978,
-0.043269749730825424,
0.013... | 0.826471 | 0.773182 | 0.05329 |
Please write the following solution using Go:
Given an integer array `nums` of size `n`, return _the number with the value **closest** to_ `0` _in_ `nums`. If there are multiple answers, return _the number with the **largest** value_.
**Example 1:**
**Input:** nums = \[-4,-2,1,4,8\]
**Output:** 1
**Explanation:**
The... | dolphin | [
0.022802943363785744,
0.042687710374593735,
-0.017794430255889893,
-0.03322537615895271,
0.04002847895026207,
-0.03237873315811157,
-0.03891284391283989,
0.04527430608868599,
0.03526024520397186,
-0.015523118898272514,
0.02336340770125389,
0.03132833540439606,
-0.036588918417692184,
-0.026... | 0.835512 | 0.776686 | 0.058826 |
Please write the following solution using java:
You are given an `m x n` integer array `grid`. There is a robot initially located at the **top-left corner** (i.e., `grid[0][0]`). The robot tries to move to the **bottom-right corner** (i.e., `grid[m - 1][n - 1]`). The robot can only move either down or right at any poin... | dolphin | [
0.0084843123331666,
0.02258222922682762,
-0.010347949340939522,
-0.03305509686470032,
0.03259512037038803,
-0.022748922929167747,
-0.03496980667114258,
0.04611365497112274,
0.043384626507759094,
-0.02472068928182125,
0.018156714737415314,
0.03163524717092514,
-0.015796124935150146,
-0.0437... | 0.849674 | 0.789377 | 0.060297 |
Please write the following solution using Visual Basic .NET:
You are given a string `s` of length `n` where `s[i]` is either:
* `'D'` means decreasing, or
* `'I'` means increasing.
A permutation `perm` of `n + 1` integers of all the integers in the range `[0, n]` is called a **valid permutation** if for all valid... | dolphin | [
0.007882414385676384,
0.01751900091767311,
-0.021037044003605843,
-0.03708372637629509,
0.038402918726205826,
-0.036493562161922455,
-0.01700153388082981,
0.0775609016418457,
0.03309052810072899,
-0.01750369742512703,
0.02806898020207882,
0.029644358903169632,
-0.03910069167613983,
-0.0286... | 0.856739 | 0.7982 | 0.058539 |
Please write the following solution using Mojo:
Given an integer array `nums`, your goal is to make all elements in `nums` equal. To complete one operation, follow these steps:
1. Find the **largest** value in `nums`. Let its index be `i` (**0-indexed**) and its value be `largest`. If there are multiple elements with... | dolphin | [
0.034725580364465714,
0.02290966920554638,
-0.03496171906590462,
-0.04855776205658913,
0.02757975272834301,
-0.025761675089597702,
-0.02543245069682598,
0.05469885841012001,
0.03765295073390007,
-0.030673127621412277,
0.037892501801252365,
0.01750192791223526,
-0.0442957878112793,
-0.01870... | 0.84642 | 0.788552 | 0.057868 |
Please focus on the efficiency of this problem and provide code in Scheme:
You are given a string `s` consisting of lowercase letters and an integer `k`. We call a string `t` **ideal** if the following conditions are satisfied:
* `t` is a **subsequence** of the string `s`.
* The absolute difference in the alphabet... | dolphin | [
0.03163600340485573,
0.023362956941127777,
-0.022049853578209877,
-0.04181092232465744,
0.03594992682337761,
-0.045507077127695084,
-0.028061147779226303,
0.03262379765510559,
0.041336122900247574,
-0.024721460416913033,
0.029791859909892082,
0.017406776547431946,
-0.025101324543356895,
-0... | 0.838055 | 0.782884 | 0.055171 |
Please focus on the functionality of this problem and provide code in Object Pascal:
You are given an integer array `nums`. You want to maximize the number of points you get by performing the following operation any number of times:
* Pick any `nums[i]` and delete it to earn `nums[i]` points. Afterwards, you must de... | dolphin | [
0.016334204003214836,
0.020418111234903336,
-0.017779754474759102,
-0.021537302061915398,
0.027493515983223915,
-0.03851638361811638,
-0.015523998998105526,
0.04595046862959862,
0.044049784541130066,
0.002281926339492202,
0.02013654261827469,
0.029485899955034256,
-0.03126303106546402,
-0.... | 0.849973 | 0.794312 | 0.055661 |
Please focus on the algorithm of this problem and provide code in Kotlin:
You are given two **0-indexed** arrays `nums1` and `nums2` of length `n`, both of which are **permutations** of `[0, 1, ..., n - 1]`.
A **good triplet** is a set of `3` **distinct** values which are present in **increasing order** by position bo... | dolphin | [
0.006341592408716679,
0.01207340694963932,
-0.012044783681631088,
-0.04074987396597862,
0.03191220387816429,
-0.017201697453856468,
-0.03213706612586975,
0.049630600959062576,
0.013743921183049679,
-0.008977724239230156,
0.014760340563952923,
0.023298513144254684,
-0.030642103403806686,
-0... | 0.846253 | 0.792322 | 0.053931 |
Please explain the following problem in detail and provide code in ANSI C:
You are given a string `s` and two integers `x` and `y`. You can perform two types of operations any number of times.
* Remove substring `"ab "` and gain `x` points.
* For example, when removing `"ab "` from `"cabxbae "` it becomes `"cx... | dolphin | [
0.02359299175441265,
0.019906703382730484,
-0.02540496177971363,
-0.031716421246528625,
0.03365149348974228,
-0.05383606255054474,
-0.021501505747437477,
0.06657007336616516,
0.054787229746580124,
-0.012144225649535656,
0.014724201522767544,
0.029129356145858765,
-0.05249340832233429,
-0.0... | 0.837743 | 0.778711 | 0.059032 |
Please write the following solution using R:
Given an integer array `nums` of length `n` where all the integers of `nums` are in the range `[1, n]` and each integer appears **once** or **twice**, return _an array of all the integers that appears **twice**_.
You must write an algorithm that runs in `O(n)` time and uses... | dolphin | [
0.014791307970881462,
0.032427605241537094,
-0.022085584700107574,
-0.017424482852220535,
0.028295347467064857,
-0.011759412474930286,
-0.03609795868396759,
0.06313546001911163,
0.02823830395936966,
-0.003279205644503236,
0.010524420998990536,
0.013599644415080547,
-0.021091939881443977,
-... | 0.836533 | 0.781151 | 0.055382 |
Please explain the reasoning behind the following solution and provide code in c++:
You are given a **0-indexed** integer array `candies`. Each element in the array denotes a pile of candies of size `candies[i]`. You can divide each pile into any number of **sub piles**, but you **cannot** merge two piles together.
Yo... | dolphin | [
0.009342484176158905,
0.02620476484298706,
-0.007881815545260906,
-0.044576697051525116,
0.03175206482410431,
-0.028548939153552055,
-0.01778375171124935,
0.098444364964962,
0.024943716824054718,
-0.02023348957300186,
0.028631042689085007,
0.026647184044122696,
-0.025590626522898674,
0.004... | 0.845869 | 0.791 | 0.054869 |
Please write the following solution using Julia:
You are given the `root` of a binary tree containing digits from `0` to `9` only.
Each root-to-leaf path in the tree represents a number.
* For example, the root-to-leaf path `1 -> 2 -> 3` represents the number `123`.
Return _the total sum of all root-to-leaf number... | dolphin | [
0.010120603255927563,
0.026732152327895164,
-0.050325024873018265,
-0.037046775221824646,
0.037380144000053406,
-0.0552121140062809,
0.005174780264496803,
0.050003618001937866,
0.028753377497196198,
-0.002268088050186634,
0.031170649453997612,
0.018198929727077484,
-0.043708596378564835,
-... | 0.830939 | 0.77481 | 0.056129 |
Please focus on the functionality of this problem and provide code in c++:
An integer has _sequential digits_ if and only if each digit in the number is one more than the previous digit.
Return a **sorted** list of all the integers in the range `[low, high]` inclusive that have sequential digits.
**Example 1:**
**In... | dolphin | [
0.01796623319387436,
0.020382575690746307,
-0.012448246590793133,
-0.034753136336803436,
0.022934524342417717,
-0.015138976275920868,
-0.033547136932611465,
0.09734071791172028,
0.014411251060664654,
-0.012148184701800346,
0.035071033984422684,
0.04305081069469452,
-0.03699750825762749,
-0... | 0.829862 | 0.775942 | 0.05392 |
Please write the following solution using Perl:
Given an integer array `nums`, return _the most frequent even element_.
If there is a tie, return the **smallest** one. If there is no such element, return `-1`.
**Example 1:**
**Input:** nums = \[0,1,2,2,4,4,1\]
**Output:** 2
**Explanation:**
The even elements are 0, ... | dolphin | [
0.02163444645702839,
0.029837660491466522,
-0.02984742447733879,
-0.0388977937400341,
0.03497402369976044,
-0.00491531565785408,
-0.01687438040971756,
0.06970405578613281,
0.03701319545507431,
-0.0030399770475924015,
0.028991691768169403,
0.03277960792183876,
-0.01925288513302803,
-0.01435... | 0.83204 | 0.77708 | 0.05496 |
Please focus on the algorithm of this problem and provide code in java:
Given a **0-indexed** integer array `nums`, return _the number of subarrays of_ `nums` _having an even product_.
**Example 1:**
**Input:** nums = \[9,6,7,13\]
**Output:** 6
**Explanation:** There are 6 subarrays with an even product:
- nums\[0..1... | dolphin | [
0.014616543427109718,
0.020224492996931076,
-0.03865368291735649,
-0.004612830933183432,
0.03444727137684822,
-0.010182657279074192,
-0.038920190185308456,
0.06587477028369904,
0.02206435240805149,
-0.016466867178678513,
0.009642823599278927,
0.025486227124929428,
-0.03402522951364517,
-0.... | 0.837354 | 0.780869 | 0.056485 |
Please write the following solution using ANSI C:
You are given an array `rectangles` where `rectangles[i] = [li, wi]` represents the `ith` rectangle of length `li` and width `wi`.
You can cut the `ith` rectangle to form a square with a side length of `k` if both `k <= li` and `k <= wi`. For example, if you have a rec... | dolphin | [
0.01634635403752327,
0.05135561153292656,
-0.026597369462251663,
-0.04856861010193825,
0.019086170941591263,
-0.009324473328888416,
-0.037873487919569016,
0.06814106553792953,
0.030573198571801186,
-0.011291525326669216,
0.04164423793554306,
0.036243509501218796,
-0.042970072478055954,
-0.... | 0.832319 | 0.770404 | 0.061915 |
Please focus on the functionality of this problem and provide code in Objective-C:
You are given an integer array `nums` of size `n`.
Consider a **non-empty** subarray from `nums` that has the **maximum** possible **bitwise AND**.
* In other words, let `k` be the maximum value of the bitwise AND of **any** subarray... | dolphin | [
0.018043076619505882,
0.019958212971687317,
-0.030096417292952538,
-0.015030843205749989,
0.030370088294148445,
-0.0297962985932827,
-0.041440095752477646,
0.06023731082677841,
0.02709493599832058,
-0.02209201455116272,
0.038370370864868164,
0.03630337491631508,
-0.03855340555310249,
0.000... | 0.838645 | 0.778088 | 0.060557 |
Please focus on the efficiency of this problem and provide code in C#:
You are given an integer array `nums` and an integer `k`. You can partition the array into **at most** `k` non-empty adjacent subarrays. The **score** of a partition is the sum of the averages of each subarray.
Note that the partition must use ever... | dolphin | [
0.018046565353870392,
0.019991043955087662,
-0.04513508826494217,
-0.011383534409105778,
0.022840438410639763,
-0.026523860171437263,
-0.029359839856624603,
0.06414846330881119,
0.04018576815724373,
-0.007951995357871056,
0.036367498338222504,
0.022385049611330032,
-0.032374367117881775,
-... | 0.83869 | 0.780431 | 0.05826 |
Please write the following solution using Kotlin:
The **diameter** of a tree is **the number of edges** in the longest path in that tree.
There is an undirected tree of `n` nodes labeled from `0` to `n - 1`. You are given a 2D array `edges` where `edges.length == n - 1` and `edges[i] = [ai, bi]` indicates that there i... | dolphin | [
0.013855894096195698,
0.016568895429372787,
-0.01290343701839447,
-0.04177187383174896,
0.034275416284799576,
-0.024383505806326866,
-0.022666480392217636,
0.05149448290467262,
0.02203814499080181,
-0.008862756192684174,
0.04643398895859718,
0.0236287172883749,
-0.027282753959298134,
-0.00... | 0.827736 | 0.772541 | 0.055195 |
Please write the following solution using C#:
In a linked list of size `n`, where `n` is **even**, the `ith` node (**0-indexed**) of the linked list is known as the **twin** of the `(n-1-i)th` node, if `0 <= i <= (n / 2) - 1`.
* For example, if `n = 4`, then node `0` is the twin of node `3`, and node `1` is the twin... | dolphin | [
0.032555412501096725,
0.03500208631157875,
-0.02144782245159149,
-0.039517663419246674,
0.028468135744333267,
-0.026325643062591553,
-0.005375472828745842,
0.07761892676353455,
0.04263066500425339,
-0.010057756677269936,
0.01644401252269745,
0.02837987244129181,
-0.028792129829525948,
-0.0... | 0.835587 | 0.778411 | 0.057176 |
Please explain the reasoning behind the following solution and provide code in R:
You are given an array of integers `nums` **(0-indexed)** and an integer `k`.
The **score** of a subarray `(i, j)` is defined as `min(nums[i], nums[i+1], ..., nums[j]) * (j - i + 1)`. A **good** subarray is a subarray where `i <= k <= j`... | dolphin | [
0.007143242750316858,
0.03296733275055885,
-0.032190002501010895,
-0.03649776056408882,
0.04764176905155182,
-0.0265011265873909,
-0.04412950947880745,
0.042533278465270996,
0.032999683171510696,
0.004566310904920101,
0.008131494745612144,
0.023121433332562447,
-0.028405094519257545,
0.011... | 0.838005 | 0.78124 | 0.056765 |
Please explain the following problem in detail and provide code in Visual Basic .NET:
A die simulator generates a random number from `1` to `6` for each roll. You introduced a constraint to the generator such that it cannot roll the number `i` more than `rollMax[i]` (**1-indexed**) consecutive times.
Given an array of... | dolphin | [
0.03498345986008644,
0.02096969448029995,
-0.019794879481196404,
-0.022176137194037437,
0.03999490290880203,
-0.022905828431248665,
-0.02755688689649105,
0.0827731341123581,
0.03392038866877556,
-0.015666930004954338,
0.04147296026349068,
0.026240123435854912,
-0.02650430239737034,
-0.0122... | 0.842578 | 0.786305 | 0.056274 |
Please write the following solution using PHP:
You are given a **0-indexed** integer array `nums`. For each index `i` (`1 <= i <= nums.length - 2`) the **beauty** of `nums[i]` equals:
* `2`, if `nums[j] < nums[i] < nums[k]`, for **all** `0 <= j < i` and for **all** `i < k <= nums.length - 1`.
* `1`, if `nums[i - 1... | dolphin | [
0.005242777056992054,
0.033826883882284164,
-0.025752950459718704,
-0.024696296080946922,
0.03735499829053879,
-0.016664715483784676,
-0.03401506692171097,
0.06865927577018738,
0.023372331634163857,
-0.0012290567392483354,
0.019940603524446487,
0.03001188300549984,
-0.04295594245195389,
-0... | 0.842889 | 0.785561 | 0.057328 |
Please write the following solution using Mojo:
You have an undirected, connected graph of `n` nodes labeled from `0` to `n - 1`. You are given an array `graph` where `graph[i]` is a list of all the nodes connected with node `i` by an edge.
Return _the length of the shortest path that visits every node_. You may start... | dolphin | [
0.009452388621866703,
0.0290097463876009,
-0.014194206334650517,
-0.02875778265297413,
0.03466980159282684,
-0.04172779247164726,
-0.03325052931904793,
0.028760937973856926,
0.03894960135221481,
-0.00455606821924448,
0.03176357224583626,
0.01107538491487503,
-0.004553602077066898,
-0.03019... | 0.836149 | 0.776166 | 0.059983 |
Please explain the following problem in detail and provide code in c++:
You are given an integer `n`. You have an `n x n` binary grid `grid` with all values initially `1`'s except for some indices given in the array `mines`. The `ith` element of the array `mines` is defined as `mines[i] = [xi, yi]` where `grid[xi][yi] ... | dolphin | [
0.022796278819441795,
0.024908890947699547,
-0.03679298236966133,
-0.024651547893881798,
0.02895297110080719,
-0.02364952862262726,
-0.02982165291905403,
0.09137655049562454,
0.038531579077243805,
-0.005943484604358673,
0.024823397397994995,
0.021860692650079727,
-0.029625222086906433,
-0.... | 0.846631 | 0.786183 | 0.060448 |
Please write the following solution using python:
You are given an integer array `nums` and an integer `x`. In one operation, you can either remove the leftmost or the rightmost element from the array `nums` and subtract its value from `x`. Note that this **modifies** the array for future operations.
Return _the **min... | dolphin | [
0.020040832459926605,
0.029010020196437836,
-0.05013366416096687,
-0.026363663375377655,
0.030581768602132797,
-0.022731149569153786,
-0.024190504103899002,
0.05715097486972809,
0.054735247045755386,
-0.007138015702366829,
0.019183872267603874,
0.018097544088959694,
-0.025812547653913498,
... | 0.844387 | 0.786686 | 0.057701 |
Please write the following solution using Scala:
You are given an array of binary strings `strs` and two integers `m` and `n`.
Return _the size of the largest subset of `strs` such that there are **at most**_ `m` `0`_'s and_ `n` `1`_'s in the subset_.
A set `x` is a **subset** of a set `y` if all elements of `x` are ... | dolphin | [
0.02302718721330166,
0.028654376044869423,
-0.021112589165568352,
-0.03408801555633545,
0.06072452664375305,
-0.047031596302986145,
-0.028869090601801872,
0.04436657577753067,
0.022651730105280876,
-0.008908180519938469,
0.020593363791704178,
0.027989208698272705,
-0.02994801104068756,
-0.... | 0.847619 | 0.785754 | 0.061865 |
Please explain the following problem in detail and provide code in PHP:
Given a string `n` representing an integer, return _the closest integer (not including itself), which is a palindrome_. If there is a tie, return _**the smaller one**_.
The closest is defined as the absolute difference minimized between two intege... | dolphin | [
0.03119969740509987,
0.040577005594968796,
-0.015318773686885834,
-0.03203380107879639,
0.027394646778702736,
-0.03274416923522949,
-0.006637269165366888,
0.05176936835050583,
0.04165155440568924,
0.0006423275335691869,
0.034230101853609085,
0.025001538917422295,
-0.037078287452459335,
-0.... | 0.829073 | 0.771534 | 0.057539 |
Please write the following solution using Scala:
You are standing at position `0` on an infinite number line. There is a destination at position `target`.
You can make some number of moves `numMoves` so that:
* On each move, you can either go left or right.
* During the `ith` move (starting from `i == 1` to `i ==... | dolphin | [
0.006762930192053318,
0.023959802463650703,
-0.011885395273566246,
-0.037077851593494415,
0.03900321200489998,
-0.009067162871360779,
-0.0375136099755764,
0.04076738283038139,
0.02385256625711918,
-0.027834590524435043,
0.038442544639110565,
0.026738328859210014,
-0.013279810547828674,
-0.... | 0.849303 | 0.794129 | 0.055175 |
Please explain the following problem in detail and provide code in Kotlin:
Let's say a positive integer is a **super-palindrome** if it is a palindrome, and it is also the square of a palindrome.
Given two positive integers `left` and `right` represented as strings, return _the number of **super-palindromes** integers... | dolphin | [
0.01283226814121008,
0.029623761773109436,
-0.01799194887280464,
-0.030669989064335823,
0.024491962045431137,
-0.012830270454287529,
-0.01327049732208252,
0.0450320728123188,
0.0282122939825058,
-0.013104317709803581,
0.027297476306557655,
0.030829742550849915,
-0.02790592610836029,
-0.029... | 0.840386 | 0.777442 | 0.062944 |
Please explain the following problem in detail and provide code in java:
You are given two positive integer arrays `nums1` and `nums2`, both of length `n`.
The **absolute sum difference** of arrays `nums1` and `nums2` is defined as the **sum** of `|nums1[i] - nums2[i]|` for each `0 <= i < n` (**0-indexed**).
You can ... | dolphin | [
0.006696540396660566,
0.029139172285795212,
-0.02652222104370594,
-0.028613466769456863,
0.03411025181412697,
-0.03987812623381615,
-0.03395921364426613,
0.04213232547044754,
0.04682886600494385,
-0.02811981737613678,
0.02344229817390442,
0.014134812168776989,
-0.03649257495999336,
0.00515... | 0.834945 | 0.778727 | 0.056218 |
Please write the following solution using Scala:
Given an integer array `arr` and an integer `difference`, return the length of the longest subsequence in `arr` which is an arithmetic sequence such that the difference between adjacent elements in the subsequence equals `difference`.
A **subsequence** is a sequence tha... | dolphin | [
0.04046794772148132,
0.01855435222387314,
-0.014606178738176823,
-0.03953033685684204,
0.039675962179899216,
-0.02716764062643051,
-0.03342563658952713,
0.053907427936792374,
0.05392390117049217,
-0.020325923338532448,
0.02593396231532097,
0.01212935708463192,
-0.024254515767097473,
0.0054... | 0.837198 | 0.775291 | 0.061907 |
Please explain the reasoning behind the following solution and provide code in c++:
You are given an array `nums` of positive integers and a **positive** integer `k`.
A subset of `nums` is **beautiful** if it does not contain two integers with an absolute difference equal to `k`.
Return _the number of **non-empty bea... | dolphin | [
0.010648577474057674,
0.03699403628706932,
-0.02864844724535942,
-0.02520672231912613,
0.04928387701511383,
-0.016800936311483383,
-0.03779393807053566,
0.08048725873231888,
0.04636739194393158,
-0.00726437708362937,
0.02689533680677414,
0.03585251793265343,
-0.03135537728667259,
0.0054639... | 0.843828 | 0.781212 | 0.062616 |
Please explain the following problem in detail and provide code in PHP:
Given an integer array `nums`, return _the number of elements that have **both** a strictly smaller and a strictly greater element appear in_ `nums`.
**Example 1:**
**Input:** nums = \[11,7,2,15\]
**Output:** 2
**Explanation:** The element 7 has ... | dolphin | [
0.0032387953251600266,
0.023345842957496643,
-0.020774072036147118,
-0.022527949884533882,
0.03535529598593712,
-0.005050589796155691,
-0.0294705368578434,
0.07450084388256073,
0.03680691495537758,
-0.012080802582204342,
0.028615251183509827,
0.03225501626729965,
-0.04608973488211632,
-0.0... | 0.839272 | 0.783092 | 0.05618 |
Please write the following solution using PHP:
Given a binary array `nums`, return _the maximum length of a contiguous subarray with an equal number of_ `0` _and_ `1`.
**Example 1:**
**Input:** nums = \[0,1\]
**Output:** 2
**Explanation:** \[0, 1\] is the longest contiguous subarray with an equal number of 0 and 1.
... | dolphin | [
0.026285849511623383,
0.027042491361498833,
-0.02239382080733776,
-0.02617611736059189,
0.031044121831655502,
-0.02011544071137905,
-0.04939674213528633,
0.06698267161846161,
0.046569570899009705,
-0.014811252243816853,
0.026692446321249008,
0.026116980239748955,
-0.03192229941487312,
-0.0... | 0.835332 | 0.770374 | 0.064958 |
Please explain the following problem in detail and provide code in Kotlin:
Given a **0-indexed** integer array `nums` of size `n`, find the **maximum difference** between `nums[i]` and `nums[j]` (i.e., `nums[j] - nums[i]`), such that `0 <= i < j < n` and `nums[i] < nums[j]`.
Return _the **maximum difference**._ If no ... | dolphin | [
0.023636868223547935,
0.020728817209601402,
-0.015308176167309284,
-0.023895472288131714,
0.04417753592133522,
-0.02568800002336502,
-0.04104097932577133,
0.05286840721964836,
0.04002886265516281,
-0.026217371225357056,
0.03015107288956642,
0.03217856213450432,
-0.04005228728055954,
0.0188... | 0.840958 | 0.780752 | 0.060206 |
Please explain the following problem in detail and provide code in python:
There is a **bi-directional** graph with `n` vertices, where each vertex is labeled from `0` to `n - 1`. The edges in the graph are represented by a given 2D integer array `edges`, where `edges[i] = [ui, vi]` denotes an edge between vertex `ui` ... | dolphin | [
-0.004031340591609478,
0.021534735336899757,
-0.03625258058309555,
-0.023993108421564102,
0.03290317580103874,
-0.03097853623330593,
-0.028685541823506355,
0.045527566224336624,
0.025837481021881104,
-0.0097744045779109,
0.031614113599061966,
0.003248921362683177,
-0.0032241283915936947,
-... | 0.836755 | 0.781772 | 0.054983 |
Please write the following solution using Scheme:
You are given an `n x n` integer matrix `grid` where each value `grid[i][j]` represents the elevation at that point `(i, j)`.
The rain starts to fall. At time `t`, the depth of the water everywhere is `t`. You can swim from a square to another 4-directionally adjacent ... | dolphin | [
0.010950885713100433,
0.017000174149870872,
-0.019093018025159836,
-0.03057733178138733,
0.03909771889448166,
-0.03770791366696358,
-0.04598128795623779,
0.04472736641764641,
0.03506192937493324,
-0.01485942117869854,
0.02804400585591793,
0.0279887393116951,
-0.025621363893151283,
-0.01709... | 0.846994 | 0.79107 | 0.055924 |
Please write the following solution using ANSI C:
There is a directed graph of `n` nodes with each node labeled from `0` to `n - 1`. The graph is represented by a **0-indexed** 2D integer array `graph` where `graph[i]` is an integer array of nodes adjacent to node `i`, meaning there is an edge from node `i` to each nod... | dolphin | [
0.027586935088038445,
0.04849347099661827,
-0.010740731842815876,
-0.0352473258972168,
0.035086072981357574,
-0.0398651622235775,
-0.023548388853669167,
0.07674850523471832,
0.03749384358525276,
-0.01657465472817421,
0.02654241770505905,
0.012154126539826393,
-0.015407408587634563,
-0.0294... | 0.849253 | 0.795925 | 0.053328 |
Please write the following solution using Objective-C:
You are given a non-negative integer array `nums`. In one operation, you must:
* Choose a positive integer `x` such that `x` is less than or equal to the **smallest non-zero** element in `nums`.
* Subtract `x` from every **positive** element in `nums`.
Return... | dolphin | [
0.018449950963258743,
0.026298893615603447,
-0.028054628521203995,
-0.023102177307009697,
0.04174591600894928,
-0.03384682908654213,
-0.03038330376148224,
0.06788239628076553,
0.0570504367351532,
-0.02575051411986351,
0.016906017437577248,
0.007145010866224766,
-0.026018857955932617,
-0.02... | 0.838456 | 0.782979 | 0.055477 |
Please explain the following problem in detail and provide code in R:
You are given `n` rectangles represented by a **0-indexed** 2D integer array `rectangles`, where `rectangles[i] = [widthi, heighti]` denotes the width and height of the `ith` rectangle.
Two rectangles `i` and `j` (`i < j`) are considered **interchan... | dolphin | [
0.006412137299776077,
0.042465630918741226,
-0.03848270699381828,
-0.01858224906027317,
0.029759317636489868,
-0.001532232970930636,
-0.034862667322158813,
0.05612286552786827,
0.02964964509010315,
-0.01968679018318653,
0.00798166822642088,
0.025445373728871346,
-0.031262852251529694,
-0.0... | 0.831216 | 0.774693 | 0.056523 |
Please explain the following problem in detail and provide code in Swift:
The **product difference** between two pairs `(a, b)` and `(c, d)` is defined as `(a * b) - (c * d)`.
* For example, the product difference between `(5, 6)` and `(2, 7)` is `(5 * 6) - (2 * 7) = 16`.
Given an integer array `nums`, choose four ... | dolphin | [
0.02686503902077675,
0.031024040654301643,
-0.022976305335760117,
-0.018986552953720093,
0.06364893168210983,
-0.011243011802434921,
-0.052197180688381195,
0.05908570811152458,
0.04665640369057655,
-0.010518345981836319,
0.023165808990597725,
0.03237465023994446,
-0.03167968988418579,
-0.0... | 0.843389 | 0.787637 | 0.055751 |
Please explain the following problem in detail and provide code in Kotlin:
Given an integer array `nums` and an integer `k`, return _the number of pairs_ `(i, j)` _where_ `i < j` _such that_ `|nums[i] - nums[j]| == k`.
The value of `|x|` is defined as:
* `x` if `x >= 0`.
* `-x` if `x < 0`.
**Example 1:**
**Inpu... | dolphin | [
0.011387295089662075,
0.02842560037970543,
-0.031405605375766754,
-0.01831948198378086,
0.038311298936605453,
-0.014791487716138363,
-0.027711838483810425,
0.05446149781346321,
0.04161126911640167,
-0.02056792937219143,
0.021792486310005188,
0.02446126751601696,
-0.03232678771018982,
0.003... | 0.849071 | 0.785394 | 0.063677 |
Please explain the following problem in detail and provide code in Object Pascal:
You are given an integer array `nums` of **even** length `n` and an integer `limit`. In one move, you can replace any integer from `nums` with another integer between `1` and `limit`, inclusive.
The array `nums` is **complementary** if f... | dolphin | [
0.003590040374547243,
0.044336944818496704,
-0.010582412593066692,
-0.020028574392199516,
0.027199160307645798,
-0.023661643266677856,
-0.011525514535605907,
0.06663944572210312,
0.040010128170251846,
-0.017088351771235466,
0.01667896844446659,
0.027001287788152695,
-0.040343042463064194,
... | 0.851616 | 0.797802 | 0.053814 |
Please explain the following problem in detail and provide code in Dart:
You are given a **positive** integer `num` consisting of exactly four digits. Split `num` into two new integers `new1` and `new2` by using the **digits** found in `num`. **Leading zeros** are allowed in `new1` and `new2`, and **all** the digits fo... | dolphin | [
-0.0012027571210637689,
0.01828441396355629,
-0.01297823991626501,
-0.03948311135172844,
0.04662805050611496,
-0.007882310077548027,
-0.03302803635597229,
0.04607347026467323,
0.05021463707089424,
-0.00453189667314291,
0.016105035319924355,
0.04108661413192749,
-0.01276842225342989,
-0.024... | 0.843163 | 0.78662 | 0.056543 |
Please write the following solution using Object Pascal:
You are given a positive integer `n` representing the number of nodes in a **connected undirected graph** containing **exactly one** cycle. The nodes are numbered from `0` to `n - 1` (**inclusive**).
You are also given a 2D integer array `edges`, where `edges[i]... | dolphin | [
0.009240775369107723,
0.02086343988776207,
-0.029843010008335114,
-0.03190184012055397,
0.044222231954336166,
-0.03342471271753311,
-0.014509828761219978,
0.041549064218997955,
0.04071580618619919,
-0.0009540301980450749,
0.037167757749557495,
0.03258742764592171,
-0.01173593383282423,
-0.... | 0.846519 | 0.788692 | 0.057827 |
Please explain the reasoning behind the following solution and provide code in Scala:
You are given an integer array `nums`. The unique elements of an array are the elements that appear **exactly once** in the array.
Return _the **sum** of all the unique elements of_ `nums`.
**Example 1:**
**Input:** nums = \[1,2,3,... | dolphin | [
0.0016064607771113515,
0.030515873804688454,
-0.01679174229502678,
-0.02824142761528492,
0.062156129628419876,
-0.024573782458901405,
-0.009683893993496895,
0.04111498221755028,
0.029370656237006187,
-0.005256632808595896,
0.018834998831152916,
0.015087949112057686,
-0.02095247060060501,
-... | 0.824783 | 0.770655 | 0.054128 |
Please focus on the functionality of this problem and provide code in python:
Given an integer array `nums` and a positive integer `k`, return _the most **competitive** subsequence of_ `nums` _of size_ `k`.
An array's subsequence is a resulting sequence obtained by erasing some (possibly zero) elements from the array.... | dolphin | [
0.01818171516060829,
0.04622868075966835,
-0.019304441288113594,
-0.01787540689110756,
0.0324346199631691,
-0.01287261862307787,
-0.030809815973043442,
0.04659153148531914,
0.03614802658557892,
-0.016872409731149673,
0.02073860540986061,
0.02491629496216774,
-0.04103584960103035,
0.0007730... | 0.843597 | 0.786229 | 0.057367 |
Please write the following solution using python:
You are given an array of non-negative integers `nums` and an integer `k`. In one operation, you may choose **any** element from `nums` and **increment** it by `1`.
Return _the **maximum** **product** of_ `nums` _after **at most**_ `k` _operations._ Since the answer ma... | dolphin | [
0.04002610221505165,
0.05138219892978668,
-0.020369842648506165,
-0.02532043866813183,
0.04804381728172302,
-0.030218521133065224,
-0.02864636480808258,
0.07010388374328613,
0.026464838534593582,
-0.009604530408978462,
0.02078048698604107,
0.02014993131160736,
-0.03216236084699631,
-0.0026... | 0.84407 | 0.786275 | 0.057795 |
Please write the following solution using Objective-C:
Given two integers n and k, return _an array of all the integers of length_ `n` _where the difference between every two consecutive digits is_ `k`. You may return the answer in **any order**.
Note that the integers should not have leading zeros. Integers as `02` a... | dolphin | [
0.02192818932235241,
0.03334175795316696,
-0.02868681214749813,
-0.05046704038977623,
0.03920578956604004,
-0.03671932965517044,
-0.02468743547797203,
0.054113492369651794,
0.03193054720759392,
-0.02062440663576126,
0.04711071401834488,
0.028007429093122482,
-0.041371770203113556,
-0.00068... | 0.82995 | 0.772728 | 0.057222 |
Please write the following solution using ANSI C:
Given a **0-indexed** integer array `nums` of size `n`, find the **maximum difference** between `nums[i]` and `nums[j]` (i.e., `nums[j] - nums[i]`), such that `0 <= i < j < n` and `nums[i] < nums[j]`.
Return _the **maximum difference**._ If no such `i` and `j` exists, ... | dolphin | [
0.033140942454338074,
0.02761942148208618,
-0.021423516795039177,
-0.02245437167584896,
0.03939216211438179,
-0.024826623499393463,
-0.05041879042983055,
0.06989981234073639,
0.040410224348306656,
-0.029036881402134895,
0.03776564076542854,
0.026287199929356575,
-0.0510261207818985,
0.0019... | 0.843425 | 0.774813 | 0.068612 |
Please write the following solution using ANSI C:
You are given a positive integer `n` representing the number of nodes in an **undirected** graph. The nodes are labeled from `1` to `n`.
You are also given a 2D integer array `edges`, where `edges[i] = [ai, bi]` indicates that there is a **bidirectional** edge between ... | dolphin | [
0.028466494753956795,
0.034313030540943146,
-0.03657201677560806,
-0.03433423861861229,
0.04406750202178955,
-0.04256235063076019,
-0.02959575690329075,
0.07827457040548325,
0.03728596121072769,
-0.009459514170885086,
0.02710641175508499,
0.014793617650866508,
-0.027818674221634865,
-0.018... | 0.856112 | 0.791154 | 0.064958 |
Please focus on the efficiency of this problem and provide code in Ruby:
Given an integer array `nums`, return _all the different possible non-decreasing subsequences of the given array with at least two elements_. You may return the answer in **any order**.
**Example 1:**
**Input:** nums = \[4,6,7,7\]
**Output:** \[... | dolphin | [
0.016602296382188797,
0.022804025560617447,
-0.018260201439261436,
-0.029663432389497757,
0.027949661016464233,
-0.012627721764147282,
-0.0303266029804945,
0.0546700656414032,
0.04540717229247093,
-0.025238610804080963,
0.04040558636188507,
0.024994809180498123,
-0.040911588817834854,
-0.0... | 0.84137 | 0.788132 | 0.053238 |
Please write the following solution using Objective-C:
You are given two **positive** integers `startPos` and `endPos`. Initially, you are standing at position `startPos` on an **infinite** number line. With one step, you can move either one position to the left, or one position to the right.
Given a positive integer ... | dolphin | [
0.02283238060772419,
0.035101521760225296,
-0.022477369755506516,
-0.03842933475971222,
0.03503737598657608,
-0.010685451328754425,
-0.02780536375939846,
0.06987274438142776,
0.0368044339120388,
-0.03245517984032631,
0.040448591113090515,
0.027166858315467834,
-0.016566619277000427,
-0.025... | 0.847405 | 0.78691 | 0.060496 |
Please explain the following problem in detail and provide code in java:
You are given an array `routes` representing bus routes where `routes[i]` is a bus route that the `ith` bus repeats forever.
* For example, if `routes[0] = [1, 5, 7]`, this means that the `0th` bus travels in the sequence `1 -> 5 -> 7 -> 1 -> 5... | dolphin | [
0.027637450024485588,
0.02030758559703827,
-0.025304405018687248,
-0.021747587248682976,
0.023105865344405174,
-0.021575188264250755,
-0.020400412380695343,
0.044454917311668396,
0.02661973237991333,
-0.02364993840456009,
0.025008659809827805,
0.026555635035037994,
-0.006002703681588173,
-... | 0.846812 | 0.786881 | 0.059931 |
Please explain the reasoning behind the following solution and provide code in ANSI C:
There is a street with `n * 2` **plots**, where there are `n` plots on each side of the street. The plots on each side are numbered from `1` to `n`. On each plot, a house can be placed.
Return _the number of ways houses can be place... | dolphin | [
0.02470194734632969,
0.02790011651813984,
-0.019821301102638245,
-0.016694793477654457,
0.02495763450860977,
-0.025584744289517403,
-0.03644305467605591,
0.0746464729309082,
0.04190492257475853,
-0.01464583445340395,
0.02159980870783329,
0.05645405873656273,
-0.040837135165929794,
-0.03210... | 0.839276 | 0.7822 | 0.057076 |
Please write the following solution using java:
Given an `m x n` matrix `grid` containing an **odd** number of integers where each row is sorted in **non-decreasing** order, return _the **median** of the matrix_.
You must solve the problem in less than `O(m * n)` time complexity.
**Example 1:**
**Input:** grid = \[\... | dolphin | [
0.020995447412133217,
0.005342660006135702,
-0.03979494795203209,
-0.053441014140844345,
0.03532715141773224,
-0.030625540763139725,
-0.04511411488056183,
0.03336170315742493,
0.03599247708916664,
-0.023598914965987206,
0.02037060633301735,
0.0033137635327875614,
-0.04267411679029465,
-0.0... | 0.815198 | 0.75922 | 0.055979 |
Please write the following solution using ANSI C:
You are given an array of `events` where `events[i] = [startDayi, endDayi, valuei]`. The `ith` event starts at `startDayi` and ends at `endDayi`, and if you attend this event, you will receive a value of `valuei`. You are also given an integer `k` which represents the m... | dolphin | [
0.02202075533568859,
0.01718508079648018,
-0.031495220959186554,
-0.03486178442835808,
0.015810169279575348,
-0.03533351048827171,
-0.047038886696100235,
0.06442080438137054,
0.04769687354564667,
-0.006152372341603041,
0.04971113055944443,
0.04018060117959976,
-0.0309580210596323,
-0.00271... | 0.844868 | 0.788023 | 0.056845 |
Please explain the reasoning behind the following solution and provide code in java:
You are given a **0-indexed** integer array `nums` of length `n`. The number of ways to **partition** `nums` is the number of `pivot` indices that satisfy both conditions:
* `1 <= pivot < n`
* `nums[0] + nums[1] + ... + nums[pivot... | dolphin | [
0.02756265550851822,
0.02800038643181324,
-0.034723732620477676,
-0.0037829172797501087,
0.027996081858873367,
-0.03092167340219021,
-0.016075368970632553,
0.045239467173814774,
0.025618886575102806,
-0.009684436954557896,
0.03041350655257702,
0.021832918748259544,
-0.03053467348217964,
0.... | 0.843097 | 0.784444 | 0.058653 |
Please write the following solution using Dart:
Given an array `arr` of integers, check if there exist two indices `i` and `j` such that :
* `i != j`
* `0 <= i, j < arr.length`
* `arr[i] == 2 * arr[j]`
**Example 1:**
**Input:** arr = \[10,2,5,3\]
**Output:** true
**Explanation:** For i = 0 and j = 2, arr\[i\] ... | dolphin | [
0.00940782856196165,
0.024126045405864716,
-0.025789743289351463,
-0.03749313950538635,
0.039627157151699066,
-0.02246217615902424,
-0.022135190665721893,
0.08413819968700409,
0.03240210935473442,
-0.01699795201420784,
0.014039606787264347,
0.002632644958794117,
-0.026696182787418365,
-0.0... | 0.84041 | 0.784083 | 0.056328 |
Please explain the following problem in detail and provide code in Dart:
You are given an integer array `nums` and a **positive** integer `k`. You can choose any **subsequence** of the array and sum all of its elements together.
We define the **K-Sum** of the array as the `kth` **largest** subsequence sum that can be ... | dolphin | [
-0.0008679948514327407,
0.037895359098911285,
-0.02336798794567585,
-0.04406319558620453,
0.04889947921037674,
-0.005606167018413544,
-0.022456055507063866,
0.04721910133957863,
0.03063366934657097,
0.0014178360579535365,
0.02922528237104416,
0.03272789716720581,
-0.03504318743944168,
0.02... | 0.834632 | 0.779756 | 0.054876 |
Please explain the following problem in detail and provide code in Haskell:
You are given an integer array `arr` of length `n` that represents a permutation of the integers in the range `[0, n - 1]`.
We split `arr` into some number of **chunks** (i.e., partitions), and individually sort each chunk. After concatenating... | dolphin | [
0.04542119428515434,
0.022580202668905258,
-0.0013189926976338029,
-0.016501272097229958,
0.03467165306210518,
-0.020969770848751068,
-0.02643723599612713,
0.0326397605240345,
0.020337320864200592,
-0.010893297381699085,
0.013465112075209618,
0.014154364354908466,
-0.028518997132778168,
-0... | 0.842744 | 0.787786 | 0.054959 |
Please explain the following problem in detail and provide code in Objective-C:
You may recall that an array `arr` is a **mountain array** if and only if:
* `arr.length >= 3`
* There exists some index `i` (**0-indexed**) with `0 < i < arr.length - 1` such that:
* `arr[0] < arr[1] < ... < arr[i - 1] < arr[i]`... | dolphin | [
0.026365552097558975,
0.03226811811327934,
-0.03931296244263649,
-0.04380777105689049,
0.024770401418209076,
-0.031093686819076538,
-0.048016875982284546,
0.07524946331977844,
0.023978782817721367,
-0.02727378159761429,
0.028118889778852463,
0.003719707252457738,
-0.029243694618344307,
-0.... | 0.840751 | 0.776232 | 0.064519 |
Please focus on the efficiency of this problem and provide code in C#:
Given a 2D integer array `circles` where `circles[i] = [xi, yi, ri]` represents the center `(xi, yi)` and radius `ri` of the `ith` circle drawn on a grid, return _the **number of lattice points**_ _that are present inside **at least one** circle_.
... | dolphin | [
-0.005404364317655563,
0.04257556051015854,
-0.02458960935473442,
-0.025201641023159027,
0.03657393902540207,
-0.015601417049765587,
-0.03830152377486229,
0.05808326229453087,
0.023980479687452316,
-0.003033263608813286,
0.023005692288279533,
0.02284984290599823,
-0.015609045512974262,
-0.... | 0.830873 | 0.777175 | 0.053698 |
port this code from ANSI C to Object Pascal:
```c
#include <stdio.h>
#define MAX_N 1000
#define MAX_F 30
#define MAX_S 60
#define MOD 1000000007
int nums[MAX_N];
int freq[MAX_F + 1];
int dp[MAX_S + 1][MAX_N + 1];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &nums... | dolphin | [
0.01981250010430813,
0.028538113459944725,
-0.02877567894756794,
-0.028885239735245705,
0.019673295319080353,
-0.024414604529738426,
-0.009618278592824936,
0.07019306719303131,
0.0365881472826004,
-0.0036706156097352505,
0.019626835361123085,
0.03086729906499386,
-0.025420965626835823,
-0.... | 0.850174 | 0.791715 | 0.058458 |
Please write the following solution using Dart:
You are given a **0-indexed** integer array `nums` consisting of `3 * n` elements.
You are allowed to remove any **subsequence** of elements of size **exactly** `n` from `nums`. The remaining `2 * n` elements will be divided into two **equal** parts:
* The first `n` e... | dolphin | [
0.012069547548890114,
0.017708905041217804,
-0.02710859850049019,
-0.0369720533490181,
0.0410650297999382,
-0.01981452666223049,
-0.03208736330270767,
0.06399060040712357,
0.04777934029698372,
-0.02119237184524536,
0.01733204908668995,
0.025575075298547745,
-0.03474130481481552,
-0.0084531... | 0.852462 | 0.794604 | 0.057857 |
Please write the following solution using ANSI C:
You are given a 2D integer array `groups` of length `n`. You are also given an integer array `nums`.
You are asked if you can choose `n` **disjoint** subarrays from the array `nums` such that the `ith` subarray is equal to `groups[i]` (**0-indexed**), and if `i > 0`, t... | dolphin | [
0.023016497492790222,
0.04182935878634453,
-0.02525228075683117,
-0.015039263293147087,
0.03229266405105591,
-0.031579744070768356,
-0.03042861819267273,
0.08123624324798584,
0.032594628632068634,
-0.0026203880552202463,
0.015741415321826935,
0.011328466236591339,
-0.03653348237276077,
-0.... | 0.845533 | 0.789291 | 0.056241 |
Please focus on the efficiency of this problem and provide code in c++:
You are given a **0-indexed** integer array `nums`. In one operation you can replace any element of the array with **any two** elements that **sum** to it.
* For example, consider `nums = [5,6,7]`. In one operation, we can replace `nums[1]` with... | dolphin | [
0.0018220986239612103,
0.021916761994361877,
-0.015491407364606857,
-0.024045739322900772,
0.021166697144508362,
0.0022670342586934566,
-0.040090709924697876,
0.087149977684021,
0.03319036215543747,
-0.01694507710635662,
0.017802618443965912,
0.0146564282476902,
-0.04389602690935135,
-0.01... | 0.843255 | 0.786714 | 0.05654 |
Please focus on the efficiency of this problem and provide code in Rust:
A sequence is **special** if it consists of a **positive** number of `0`s, followed by a **positive** number of `1`s, then a **positive** number of `2`s.
* For example, `[0,1,2]` and `[0,0,1,1,1,2]` are special.
* In contrast, `[2,1,0]`, `[1]... | dolphin | [
0.010088861919939518,
0.029265597462654114,
-0.017367331311106682,
-0.017768628895282745,
0.024956537410616875,
-0.020690198987722397,
-0.046694137156009674,
0.0693357065320015,
0.05675877258181572,
-0.01639283075928688,
0.019430141896009445,
0.029028408229351044,
-0.031110776588320732,
-0... | 0.849585 | 0.795487 | 0.054098 |
Please explain the following problem in detail and provide code in ANSI C:
You are given a **0-indexed** `m x n` binary matrix `grid`.
A **0-indexed** `m x n` difference matrix `diff` is created with the following procedure:
* Let the number of ones in the `ith` row be `onesRowi`.
* Let the number of ones in the ... | dolphin | [
0.012625472620129585,
0.026136962696909904,
-0.013841935433447361,
-0.0445440448820591,
0.04222901165485382,
-0.04409356787800789,
-0.05905323475599289,
0.08688504248857498,
0.051611702889204025,
-0.017820872366428375,
0.02258811704814434,
0.013059237971901894,
-0.054393939673900604,
-0.00... | 0.827178 | 0.773302 | 0.053876 |
Please write the following solution using Ruby:
You are given two **0-indexed** integer arrays `nums1` and `nums2` of equal length `n` and a positive integer `k`. You must choose a **subsequence** of indices from `nums1` of length `k`.
For chosen indices `i0`, `i1`, ..., `ik - 1`, your **score** is defined as:
* Th... | dolphin | [
0.012390312738716602,
0.04153428599238396,
-0.03171701729297638,
-0.03792053833603859,
0.04387630894780159,
-0.025630660355091095,
-0.02879181131720543,
0.047741372138261795,
0.03621195629239082,
-0.020423835143446922,
0.02970610000193119,
0.024538453668355942,
-0.027855081483721733,
-0.00... | 0.850163 | 0.794798 | 0.055365 |
Please write the following solution using Objective-C:
You are given an `n x n` `grid` representing a field of cherries, each cell is one of three possible integers.
* `0` means the cell is empty, so you can pass through,
* `1` means the cell contains a cherry that you can pick up and pass through, or
* `-1` mea... | dolphin | [
0.018150415271520615,
0.028913607820868492,
-0.024595247581601143,
-0.032869432121515274,
0.026691433042287827,
-0.03188057616353035,
-0.028769100084900856,
0.06484983116388321,
0.013341167941689491,
-0.028763486072421074,
0.019809702411293983,
0.03018183261156082,
-0.03252803534269333,
-0... | 0.840065 | 0.785366 | 0.054699 |
Please explain the reasoning behind the following solution and provide code in c++:
You are given `nums`, an array of positive integers of size `2 * n`. You must perform `n` operations on this array.
In the `ith` operation **(1-indexed)**, you will:
* Choose two elements, `x` and `y`.
* Receive a score of `i * gc... | dolphin | [
0.018770527094602585,
0.030391452834010124,
-0.02668578177690506,
-0.029812835156917572,
0.03766269236803055,
-0.02158277854323387,
-0.03886552155017853,
0.08706767857074738,
0.04509562999010086,
-0.005907632876187563,
0.01321995910257101,
0.021563569083809853,
-0.021128375083208084,
-0.00... | 0.849283 | 0.785806 | 0.063478 |
Please write the following solution using Rust:
You are given an array `nums` consisting of **positive** integers.
You have to take each integer in the array, **reverse its digits**, and add it to the end of the array. You should apply this operation to the original integers in `nums`.
Return _the number of **distinc... | dolphin | [
0.014744783751666546,
0.029922425746917725,
-0.005367313511669636,
-0.028425587341189384,
0.03805286064743996,
-0.012086267583072186,
-0.017521504312753677,
0.06404425203800201,
0.050147298723459244,
0.004190618637949228,
0.009611282497644424,
0.02277514711022377,
-0.03137797489762306,
-0.... | 0.83837 | 0.784306 | 0.054063 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.