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 write the following solution using R:
Given an array `nums` containing `n` distinct numbers in the range `[0, n]`, return _the only number in the range that is missing from the array._
**Example 1:**
**Input:** nums = \[3,0,1\]
**Output:** 2
**Explanation:** n = 3 since there are 3 numbers, so all numbers are ... | dolphin | [
0.012922096997499466,
0.03698251023888588,
-0.021439485251903534,
-0.028437988832592964,
0.044019099324941635,
-0.014845210127532482,
-0.033408667892217636,
0.05321580916643143,
0.033396169543266296,
-0.00588238425552845,
0.006399827543646097,
0.01722080260515213,
-0.026498833671212196,
-0... | 0.837111 | 0.783552 | 0.053559 |
Please write the following solution using F#:
Given a binary array `nums` and an integer `k`, return _the maximum number of consecutive_ `1`_'s in the array if you can flip at most_ `k` `0`'s.
**Example 1:**
**Input:** nums = \[1,1,1,0,0,0,1,1,1,1,0\], k = 2
**Output:** 6
**Explanation:** \[1,1,1,0,0,**1**,1,1,1,1,**... | dolphin | [
0.005208746995776892,
0.04373907297849655,
-0.000969182001426816,
-0.03955039754509926,
0.04265347123146057,
-0.028128622099757195,
-0.03308848291635513,
0.052387647330760956,
0.03434816375374794,
-0.024188276380300522,
0.027374528348445892,
0.021277733147144318,
-0.032111749053001404,
-0.... | 0.848623 | 0.790836 | 0.057787 |
Please explain the following problem in detail and provide code in ANSI C:
You are given an integer array `nums` and two integers `indexDiff` and `valueDiff`.
Find a pair of indices `(i, j)` such that:
* `i != j`,
* `abs(i - j) <= indexDiff`.
* `abs(nums[i] - nums[j]) <= valueDiff`, and
Return `true` _if such ... | dolphin | [
0.01297069899737835,
0.031842850148677826,
-0.0305880606174469,
-0.018957216292619705,
0.04957546293735504,
-0.02688284032046795,
-0.02711806446313858,
0.08389776945114136,
0.03558742627501488,
-0.02692803554236889,
0.02648734301328659,
0.01832376979291439,
-0.03945144638419151,
-0.0119776... | 0.847025 | 0.787234 | 0.05979 |
Please write the following solution using F#:
Given an array `arr` that represents a permutation of numbers from `1` to `n`.
You have a binary string of size `n` that initially has all its bits set to zero. At each step `i` (assuming both the binary string and `arr` are 1-indexed) from `1` to `n`, the bit at position ... | dolphin | [
0.02581661567091942,
0.03545770421624184,
-0.01603817567229271,
-0.04819262772798538,
0.05246035009622574,
-0.05043903365731239,
-0.029001079499721527,
0.0674801617860794,
0.032458752393722534,
-0.010533653199672699,
0.01822555623948574,
0.004268544260412455,
-0.02850944735109806,
-0.02857... | 0.858053 | 0.803008 | 0.055045 |
Please write the following solution using Fortran:
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... | dolphin | [
0.038386132568120956,
0.03644482046365738,
-0.016712380573153496,
-0.044526971876621246,
0.0346277691423893,
-0.02013486437499523,
-0.0041436851024627686,
0.059964071959257126,
0.041650526225566864,
-0.009511003270745277,
0.01582632213830948,
0.036087553948163986,
-0.025385912507772446,
0.... | 0.836705 | 0.782925 | 0.05378 |
Please focus on the algorithm of this problem and provide code in java:
A magical string `s` consists of only `'1'` and `'2'` and obeys the following rules:
* The string s is magical because concatenating the number of contiguous occurrences of characters `'1'` and `'2'` generates the string `s` itself.
The first f... | dolphin | [
0.024219736456871033,
0.033238813281059265,
-0.023045506328344345,
-0.036076195538043976,
0.031791023910045624,
-0.03571348264813423,
-0.027687450870871544,
0.05731953680515289,
0.009993700310587883,
-0.015302896499633789,
0.024052230641245842,
0.01961919106543064,
-0.02402491681277752,
-0... | 0.841966 | 0.779494 | 0.062472 |
Please explain the reasoning behind the following solution and provide code in Object Pascal:
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 i... | dolphin | [
0.03639793023467064,
0.02594148926436901,
0.0023765137884765863,
-0.03784339129924774,
0.03480616584420204,
-0.041135273873806,
-0.009431064128875732,
0.042900651693344116,
0.02814091369509697,
-0.017598265781998634,
0.039208605885505676,
0.033677104860544205,
-0.036874182522296906,
-0.015... | 0.836798 | 0.779784 | 0.057013 |
Please write the following solution using Dart:
You are given an integer array `nums`. A subsequence of `nums` is called a **square streak** if:
* The length of the subsequence is at least `2`, and
* **after** sorting the subsequence, each element (except the first element) is the **square** of the previous number... | dolphin | [
-0.003087008139118552,
0.03039596974849701,
-0.030308393761515617,
-0.04216192662715912,
0.039435550570487976,
-0.01033452432602644,
-0.038041774183511734,
0.06454300135374069,
0.04695509001612663,
-0.004866553004831076,
0.0265053603798151,
0.021698229014873505,
-0.02849087491631508,
-0.02... | 0.845142 | 0.78849 | 0.056652 |
Please explain the reasoning behind the following solution and provide code in javascript:
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]`.
* ... | dolphin | [
0.013152733445167542,
0.021551677957177162,
-0.034645695239305496,
-0.04161534085869789,
0.06151776388287544,
-0.044401831924915314,
-0.045377422124147415,
0.05161534994840622,
0.02998368814587593,
-0.022122446447610855,
0.006794839631766081,
0.016939638182520866,
-0.03367803245782852,
-0.... | 0.85702 | 0.800822 | 0.056198 |
Please write the following solution using F#:
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 als... | dolphin | [
0.021429847925901413,
0.02614813670516014,
-0.019803427159786224,
-0.040557555854320526,
0.05967586487531662,
-0.04742898792028427,
-0.028376691043376923,
0.05692439526319504,
0.03609992563724518,
-0.008812817744910717,
0.02143912762403488,
0.026395516470074654,
-0.04609578847885132,
-0.03... | 0.848406 | 0.788147 | 0.06026 |
Please focus on the functionality of this problem and provide code in Scheme:
You are given two **0-indexed** integer arrays `nums1` and `nums2`, each of size `n`, and an integer `diff`. Find the number of **pairs** `(i, j)` such that:
* `0 <= i < j <= n - 1` **and**
* `nums1[i] - nums1[j] <= nums2[i] - nums2[j] +... | dolphin | [
0.016526028513908386,
0.017584364861249924,
-0.03449731692671776,
-0.0265117809176445,
0.05012139678001404,
-0.002546357922255993,
-0.0413038432598114,
0.059485144913196564,
0.034757331013679504,
-0.012022161856293678,
0.01324666291475296,
0.025785207748413086,
-0.043741509318351746,
-0.00... | 0.858121 | 0.792223 | 0.065898 |
Please write the following solution using c++:
There is an `m x n` matrix that is initialized to all `0`'s. There is also a 2D array `indices` where each `indices[i] = [ri, ci]` represents a **0-indexed location** to perform some increment operations on the matrix.
For each location `indices[i]`, do **both** of the fo... | dolphin | [
0.014820652082562447,
0.020859811455011368,
-0.023460935801267624,
-0.03789612278342247,
0.04131066054105759,
-0.010133075527846813,
-0.03675141558051109,
0.11401303112506866,
0.057795196771621704,
-0.03211180120706558,
0.00801920797675848,
-0.00026644516037777066,
-0.03019232675433159,
-0... | 0.835422 | 0.775267 | 0.060155 |
Please write the following solution using Fortran:
You are given a positive integer **0-indexed** array `nums`.
A subset of the array `nums` is **square-free** if the product of its elements is a **square-free integer**.
A **square-free integer** is an integer that is divisible by no square number other than `1`.
Re... | dolphin | [
0.033339038491249084,
0.044260017573833466,
-0.03270795941352844,
-0.034335967153310776,
0.059346456080675125,
-0.025864817202091217,
-0.02183215320110321,
0.06303484737873077,
0.047699443995952606,
-0.015706298872828484,
0.024110086262226105,
0.014422519132494926,
-0.040030624717473984,
-... | 0.842367 | 0.783912 | 0.058455 |
Please write the following solution using c++:
You are given a **large integer** represented as an integer array `digits`, where each `digits[i]` is the `ith` digit of the integer. The digits are ordered from most significant to least significant in left-to-right order. The large integer does not contain any leading `0... | dolphin | [
0.026880022138357162,
0.03724287450313568,
-0.0095886941999197,
-0.050889257341623306,
0.031012870371341705,
-0.011498834006488323,
-0.02219860628247261,
0.09476577490568161,
0.030441682785749435,
-0.01806899718940258,
0.01978161185979843,
0.023937752470374107,
-0.0433138869702816,
-0.0039... | 0.833148 | 0.776601 | 0.056547 |
Please focus on the efficiency of this problem and provide code in c++:
The **numeric value** of a **lowercase character** is defined as its position `(1-indexed)` in the alphabet, so the numeric value of `a` is `1`, the numeric value of `b` is `2`, the numeric value of `c` is `3`, and so on.
The **numeric value** of ... | dolphin | [
0.015402291901409626,
0.03083156980574131,
-0.009221368469297886,
-0.050695691257715225,
0.04542047530412674,
-0.017023952677845955,
-0.014743746258318424,
0.06684798002243042,
0.031833451241254807,
-0.013454677537083626,
0.034065138548612595,
0.03786966949701309,
-0.032751794904470444,
-0... | 0.839233 | 0.782373 | 0.05686 |
Please explain the reasoning behind the following solution and provide code in 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.017875539138913155,
0.01884174533188343,
-0.025291645899415016,
-0.018771469593048096,
0.030763696879148483,
-0.03929080814123154,
-0.03545452281832695,
0.07542681694030762,
0.04025820642709732,
-0.014476091600954533,
0.030078234151005745,
0.046178773045539856,
-0.041967518627643585,
-0.... | 0.838042 | 0.780636 | 0.057405 |
Please focus on the efficiency of this problem and provide code in Objective-C:
Given a **0-indexed** integer array `nums` of length `n` and an integer `k`, return _the **number of pairs**_ `(i, j)` _such that:_
* `0 <= i < j <= n - 1` _and_
* `nums[i] * nums[j]` _is divisible by_ `k`.
**Example 1:**
**Input:** ... | dolphin | [
0.021058103069663048,
0.044087693095207214,
-0.050015855580568314,
-0.0188782699406147,
0.05055835843086243,
-0.023693295195698738,
-0.03574315831065178,
0.07868827134370804,
0.019736582413315773,
-0.011514036916196346,
0.023282771930098534,
0.017252137884497643,
-0.02358825132250786,
-0.0... | 0.847714 | 0.785347 | 0.062367 |
Please explain the reasoning behind the following solution and provide code in ANSI C:
You are given a positive integer `primeFactors`. You are asked to construct a positive integer `n` that satisfies the following conditions:
* The number of prime factors of `n` (not necessarily distinct) is **at most** `primeFacto... | dolphin | [
0.03641017526388168,
0.032712001353502274,
-0.013397570699453354,
-0.03532399237155914,
0.03073590248823166,
-0.033367544412612915,
-0.043714527040719986,
0.06716549396514893,
0.03204527497291565,
-0.013729128055274487,
0.022773457691073418,
0.04392553120851517,
-0.050469059497117996,
-0.0... | 0.824004 | 0.767511 | 0.056493 |
Please write the following solution using Mojo:
Given a **circular integer array** `nums` of length `n`, return _the maximum possible sum of a non-empty **subarray** of_ `nums`.
A **circular array** means the end of the array connects to the beginning of the array. Formally, the next element of `nums[i]` is `nums[(i +... | dolphin | [
0.011553933843970299,
0.029501287266612053,
-0.028025640174746513,
-0.02193155325949192,
0.029808051884174347,
-0.009619380347430706,
-0.03700551763176918,
0.029103411361575127,
0.03389943391084671,
0.0039794244803488255,
0.04225964844226837,
0.03326103091239929,
-0.03304605185985565,
-0.0... | 0.840289 | 0.771136 | 0.069153 |
Please focus on the functionality of this problem and provide code in ANSI C:
The Tribonacci sequence Tn is defined as follows:
T0 = 0, T1 = 1, T2 = 1, and Tn+3 = Tn + Tn+1 + Tn+2 for n >= 0.
Given `n`, return the value of Tn.
**Example 1:**
**Input:** n = 4
**Output:** 4
**Explanation:**
T\_3 = 0 + 1 + 1 = 2
T\_4 ... | dolphin | [
0.03886838257312775,
0.053473569452762604,
-0.024946870282292366,
-0.04303593933582306,
0.025543341413140297,
-0.02522864192724228,
-0.04006069526076317,
0.08618023991584778,
0.028121555224061012,
-0.008731386624276638,
0.047988004982471466,
0.031168589368462563,
-0.05759284272789955,
-0.0... | 0.829432 | 0.767636 | 0.061796 |
Please write the following solution using ANSI C:
You are given a positive integer `n`, you can do the following operation **any** number of times:
* Add or subtract a **power** of `2` from `n`.
Return _the **minimum** number of operations to make_ `n` _equal to_ `0`.
A number `x` is power of `2` if `x == 2i` wher... | dolphin | [
0.02296578325331211,
0.03525366634130478,
-0.0146492263302207,
-0.04339025914669037,
0.03472036123275757,
-0.024507978931069374,
-0.03023720718920231,
0.08429738879203796,
0.05307302996516228,
-0.017454367130994797,
0.0283204335719347,
0.02233901619911194,
-0.031241020187735558,
-0.0388008... | 0.839234 | 0.778734 | 0.0605 |
Please explain the following problem in detail and provide code in java:
Given an integer array `nums`, return `true` _if there exists a triple of indices_ `(i, j, k)` _such that_ `i < j < k` _and_ `nums[i] < nums[j] < nums[k]`. If no such indices exists, return `false`.
**Example 1:**
**Input:** nums = \[1,2,3,4,5\]... | dolphin | [
0.01598300039768219,
0.026852324604988098,
-0.025168441236019135,
-0.02312484197318554,
0.042890481650829315,
-0.024581868201494217,
-0.016231732442975044,
0.06449232995510101,
0.014735500328242779,
-0.01154123805463314,
0.0214131698012352,
0.0203497763723135,
-0.022420616820454597,
-0.025... | 0.84441 | 0.788729 | 0.055681 |
Please write the following solution using Objective-C:
Given an integer array `nums` sorted in **non-decreasing** order, return _an array of **the squares of each number** sorted in non-decreasing order_.
**Example 1:**
**Input:** nums = \[-4,-1,0,3,10\]
**Output:** \[0,1,9,16,100\]
**Explanation:** After squaring, t... | dolphin | [
0.02627500332891941,
0.045038409531116486,
-0.028937429189682007,
-0.0415513813495636,
0.03542019799351692,
-0.02517012692987919,
-0.018219182267785072,
0.05470127984881401,
0.03757983446121216,
-0.02000463753938675,
0.03943750262260437,
0.008698652498424053,
-0.058198969811201096,
-0.0161... | 0.818222 | 0.764908 | 0.053314 |
Please focus on the algorithm of this problem and provide code in Dart:
You are given the `head` of a linked list containing unique integer values and an integer array `nums` that is a subset of the linked list values.
Return _the number of connected components in_ `nums` _where two values are connected if they appear... | dolphin | [
0.010798662900924683,
0.017302578315138817,
-0.008236824534833431,
-0.015433804132044315,
0.03198001906275749,
-0.011848648078739643,
-0.020633144304156303,
0.06065471097826958,
0.035331957042217255,
0.0023905972484499216,
0.022899480536580086,
0.026749562472105026,
-0.007142122834920883,
... | 0.842319 | 0.788635 | 0.053684 |
Please write the following solution using R:
Given an integer array `nums` and an integer `k`, return `true` _if there are two **distinct indices**_ `i` _and_ `j` _in the array such that_ `nums[i] == nums[j]` _and_ `abs(i - j) <= k`.
**Example 1:**
**Input:** nums = \[1,2,3,1\], k = 3
**Output:** true
**Example 2:**... | dolphin | [
0.019374288618564606,
0.0303046815097332,
-0.02915383316576481,
-0.02878180518746376,
0.04492644965648651,
-0.019730810075998306,
-0.01829659193754196,
0.07227815687656403,
0.044572729617357254,
-0.018818123266100883,
0.013857390731573105,
0.02139946259558201,
-0.02429783158004284,
-0.0181... | 0.840191 | 0.7801 | 0.060091 |
Please focus on the efficiency of this problem and provide code in python:
You want to build some obstacle courses. You are given a **0-indexed** integer array `obstacles` of length `n`, where `obstacles[i]` describes the height of the `ith` obstacle.
For every index `i` between `0` and `n - 1` (**inclusive**), find t... | dolphin | [
0.02197282388806343,
0.026105640456080437,
-0.029602142050862312,
-0.027009746059775352,
0.012835021130740643,
-0.02272278256714344,
-0.0541645884513855,
0.033713094890117645,
0.037380240857601166,
-0.018810739740729332,
0.020356684923171997,
0.01445852406322956,
-0.022820843383669853,
-0.... | 0.84668 | 0.792068 | 0.054611 |
Please write the following solution using Scheme:
Given the array `queries` of positive integers between `1` and `m`, you have to process all `queries[i]` (from `i=0` to `i=queries.length-1`) according to the following rules:
* In the beginning, you have the permutation `P=[1,2,3,...,m]`.
* For the current `i`, fi... | dolphin | [
0.04386324808001518,
0.030125673860311508,
-0.01962028630077839,
-0.025819560512900352,
0.025114815682172775,
-0.03129762038588524,
-0.04778160899877548,
0.04591282084584236,
0.033013083040714264,
-0.02356388233602047,
0.02399754337966442,
0.013701324351131916,
-0.03407933935523033,
-0.010... | 0.843561 | 0.789953 | 0.053608 |
Please explain the following problem in detail and provide code in java:
There are several cards **arranged in a row**, and each card has an associated number of points. The points are given in the integer array `cardPoints`.
In one step, you can take one card from the beginning or from the end of the row. You have to... | dolphin | [
0.0049118464812636375,
0.022260000929236412,
-0.03113057278096676,
-0.032668281346559525,
0.024084540084004402,
-0.04470612853765488,
-0.013132505118846893,
0.022528519853949547,
0.019172383472323418,
-0.018016554415225983,
0.023041250184178352,
0.022450104355812073,
-0.03360278904438019,
... | 0.842525 | 0.785672 | 0.056853 |
Please focus on the efficiency of this problem and provide code in Julia:
Given an array `nums` of integers and integer `k`, return the maximum `sum` such that there exists `i < j` with `nums[i] + nums[j] = sum` and `sum < k`. If no `i`, `j` exist satisfying this equation, return `-1`.
**Example 1:**
**Input:** nums ... | dolphin | [
-0.00457007298246026,
0.03219040855765343,
-0.04094143956899643,
-0.032284896820783615,
0.04598744213581085,
0.0007878931355662644,
-0.025981033220887184,
0.05994034186005592,
0.0315999835729599,
-0.008428385481238365,
0.03383795917034149,
0.03929002955555916,
-0.02650846727192402,
0.00498... | 0.847225 | 0.788762 | 0.058463 |
Please write the following solution using Rust:
You are given an integer array `nums` and an integer `k`. You may partition `nums` into one or more **subsequences** such that each element in `nums` appears in **exactly** one of the subsequences.
Return _the **minimum** number of subsequences needed such that the diffe... | dolphin | [
0.026948843151330948,
0.022655930370092392,
-0.020376965403556824,
-0.01647113636136055,
0.03155703470110893,
-0.002466385718435049,
-0.028395183384418488,
0.06443741917610168,
0.04061022400856018,
-0.007854226045310497,
0.032895978540182114,
0.03584843873977661,
-0.02121337503194809,
0.00... | 0.845165 | 0.788684 | 0.056481 |
Please explain the following problem in detail and provide code in c++:
There is a **3 lane road** of length `n` that consists of `n + 1` **points** labeled from `0` to `n`. A frog **starts** at point `0` in the **second** lane and wants to jump to point `n`. However, there could be obstacles along the way.
You are gi... | dolphin | [
-0.01290065422654152,
0.010580570437014103,
-0.006655985023826361,
-0.020480891689658165,
0.029817884787917137,
0.0005360273062251508,
-0.03230012580752373,
0.09985006600618362,
0.0479910783469677,
-0.013878950849175453,
0.010234501212835312,
0.03916732221841812,
-0.014020146802067757,
-0.... | 0.844286 | 0.790631 | 0.053654 |
Please focus on the algorithm of this problem and provide code in Dart:
Given an integer array `nums`, partition it into two (contiguous) subarrays `left` and `right` so that:
* Every element in `left` is less than or equal to every element in `right`.
* `left` and `right` are non-empty.
* `left` has the smalles... | dolphin | [
0.015051678754389286,
0.014045003801584244,
-0.02305489219725132,
-0.014041748829185963,
0.01864812709391117,
-0.005287049803882837,
-0.028076013550162315,
0.0647013783454895,
0.031253498047590256,
-0.011712070554494858,
0.02286306396126747,
0.03065815381705761,
-0.018898572772741318,
-0.0... | 0.844362 | 0.790558 | 0.053804 |
Please focus on the functionality of this problem and provide code in ANSI C:
A permutation `perm` of `n` integers of all the integers in the range `[1, n]` can be represented as a string `s` of length `n - 1` where:
* `s[i] == 'I'` if `perm[i] < perm[i + 1]`, and
* `s[i] == 'D'` if `perm[i] > perm[i + 1]`.
Given... | dolphin | [
0.014266815967857838,
0.025843456387519836,
-0.007913661189377308,
-0.034292858093976974,
0.019676487892866135,
-0.034868791699409485,
-0.025347251445055008,
0.0766589343547821,
0.028443941846489906,
-0.027676759287714958,
0.02907620742917061,
0.01778249256312847,
-0.030474411323666573,
-0... | 0.835346 | 0.777813 | 0.057532 |
Please write the following solution using TypeScript:
You are given an integer array `nums` and an integer `k`.
Find the longest subsequence of `nums` that meets the following requirements:
* The subsequence is **strictly increasing** and
* The difference between adjacent elements in the subsequence is **at most*... | dolphin | [
0.02336321771144867,
0.03056832030415535,
-0.014249665662646294,
-0.03828838840126991,
0.036149460822343826,
-0.015648147091269493,
-0.03649130463600159,
0.07013320177793503,
0.04580189287662506,
-0.006641920190304518,
0.027950886636972427,
0.01981211081147194,
-0.027646254748106003,
0.024... | 0.837184 | 0.783081 | 0.054103 |
Please explain the following problem in detail and provide code in C#:
You are given a **0-indexed** integer array `nums`.
**Swaps** of **adjacent** elements are able to be performed on `nums`.
A **valid** array meets the following conditions:
* The largest element (any of the largest elements if there are multipl... | dolphin | [
0.023819411173462868,
0.039775215089321136,
-0.02111818827688694,
-0.020538950338959694,
0.037168800830841064,
-0.027378037571907043,
-0.025021370500326157,
0.06762590259313583,
0.027473246678709984,
-0.012054595164954662,
0.021777136251330376,
0.018214119598269463,
-0.03884278982877731,
-... | 0.846088 | 0.79035 | 0.055738 |
Please write the following solution using Scheme:
Given a binary array `nums` and an integer `k`, return _the maximum number of consecutive_ `1`_'s in the array if you can flip at most_ `k` `0`'s.
**Example 1:**
**Input:** nums = \[1,1,1,0,0,0,1,1,1,1,0\], k = 2
**Output:** 6
**Explanation:** \[1,1,1,0,0,**1**,1,1,1,... | dolphin | [
0.013855346478521824,
0.04473566636443138,
-0.007016689982265234,
-0.03414932265877724,
0.038231272250413895,
-0.0249720960855484,
-0.04527811333537102,
0.04668395221233368,
0.026578284800052643,
-0.026326622813940048,
0.029078446328639984,
0.01932462677359581,
-0.024745998904109,
0.006101... | 0.847613 | 0.780428 | 0.067185 |
Please focus on the efficiency of this problem and provide code in c++:
You are given a **0-indexed** integer array `nums` and a positive integer `k`.
We call an index `i` **k-big** if the following conditions are satisfied:
* There exist at least `k` different indices `idx1` such that `idx1 < i` and `nums[idx1] < ... | dolphin | [
0.018340710550546646,
0.03631414845585823,
-0.02535715512931347,
-0.034332744777202606,
0.022139964625239372,
0.0011754612205550075,
-0.03593612089753151,
0.09414378553628922,
0.026624862104654312,
-0.013542547821998596,
0.02878749370574951,
0.03398590162396431,
-0.030041281133890152,
-0.0... | 0.845816 | 0.780554 | 0.065262 |
Please explain the following problem in detail and provide code in Scheme:
You are given two integer arrays `nums1` and `nums2` of equal length `n` and an integer `k`. You can perform the following operation on `nums1`:
* Choose two indexes `i` and `j` and increment `nums1[i]` by `k` and decrement `nums1[j]` by `k`.... | dolphin | [
0.02251061424612999,
0.04047287628054619,
-0.029178202152252197,
-0.03825441375374794,
0.03776340186595917,
-0.02655641734600067,
-0.011667530052363873,
0.07835449278354645,
0.03462876379489899,
-0.025316745042800903,
0.01983894780278206,
-0.0017667681677266955,
-0.03080638125538826,
0.006... | 0.855828 | 0.797143 | 0.058685 |
Please focus on the functionality of this problem and provide code in Dart:
Given an binary array `nums` and an integer `k`, return `true` _if all_ `1`_'s are at least_ `k` _places away from each other, otherwise return_ `false`.
**Example 1:**
**Input:** nums = \[1,0,0,0,1,0,0,1\], k = 2
**Output:** true
**Explanati... | dolphin | [
0.0038413626607507467,
0.034104302525520325,
-0.014643777161836624,
-0.03388659283518791,
0.03868787735700607,
-0.024009015411138535,
-0.019751641899347305,
0.0716216191649437,
0.025777719914913177,
-0.01318601705133915,
0.018485473468899727,
0.01738274097442627,
-0.01689044013619423,
-0.0... | 0.849083 | 0.791827 | 0.057256 |
Please explain the following problem in detail and provide code in Kotlin:
You are given an array `nums` of size `n` consisting of **distinct** integers from `1` to `n` and a positive integer `k`.
Return _the number of non-empty subarrays in_ `nums` _that have a **median** equal to_ `k`.
**Note**:
* The median of ... | dolphin | [
0.02211608737707138,
0.02387443371117115,
-0.033077921718358994,
-0.02910078689455986,
0.0378190316259861,
-0.007193692494183779,
-0.024439483880996704,
0.04976977780461311,
0.020216265693306923,
-0.011705816723406315,
0.02705751173198223,
0.01584555022418499,
-0.02578124776482582,
-0.0004... | 0.834514 | 0.775617 | 0.058897 |
Please write the following solution using java:
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:** \[\[4,6\],\[4,6,7\],\[4,6,7... | dolphin | [
0.016658734530210495,
0.01592477597296238,
-0.013816132210195065,
-0.015873907133936882,
0.03942857310175896,
-0.014602034352719784,
-0.032095685601234436,
0.04512413963675499,
0.03832070901989937,
-0.01619906909763813,
0.03905390575528145,
0.016755735501646996,
-0.048124708235263824,
-0.0... | 0.83091 | 0.761627 | 0.069283 |
Please write the following solution using Haskell:
A **self-dividing number** is a number that is divisible by every digit it contains.
* For example, `128` is **a self-dividing number** because `128 % 1 == 0`, `128 % 2 == 0`, and `128 % 8 == 0`.
A **self-dividing number** is not allowed to contain the digit zero.
... | dolphin | [
0.032424475997686386,
0.024680087342858315,
-0.009909961372613907,
-0.044250208884477615,
0.028208259493112564,
-0.0249041635543108,
-0.011992232874035835,
0.04783310741186142,
0.04306510463356972,
-0.021215366199612617,
0.029647639021277428,
0.024885045364499092,
-0.027297243475914,
-0.03... | 0.831133 | 0.776392 | 0.054741 |
Please explain the following problem in detail and provide code in PHP:
You are given an array of integers `arr` and an integer `target`.
You have to find **two non-overlapping sub-arrays** of `arr` each with a sum equal `target`. There can be multiple answers so you have to find an answer where the sum of the lengths... | dolphin | [
0.008306226693093777,
0.02908712439239025,
-0.035959068685770035,
-0.02949155494570732,
0.05895838886499405,
-0.009797617793083191,
-0.0348544679582119,
0.04564962163567543,
0.0434536337852478,
-0.015865176916122437,
0.025454213842749596,
0.016803495585918427,
-0.033471882343292236,
-0.014... | 0.840775 | 0.78668 | 0.054095 |
Please focus on the algorithm of this problem and provide code in Rust:
Given an integer array `nums` and two integers `left` and `right`, return _the number of contiguous non-empty **subarrays** such that the value of the maximum array element in that subarray is in the range_ `[left, right]`.
The test cases are gene... | dolphin | [
0.026632731780409813,
0.020164180546998978,
-0.02492133527994156,
-0.017466485500335693,
0.01875968836247921,
0.002081408863887191,
-0.029630586504936218,
0.07216078042984009,
0.03794840723276138,
-0.007248205132782459,
0.03355272859334946,
0.052333634346723557,
-0.02299276366829872,
-0.01... | 0.847001 | 0.792622 | 0.054379 |
Please explain the following problem in detail and provide code in ANSI C:
Given an integer array `nums` of `2n` integers, group these integers into `n` pairs `(a1, b1), (a2, b2), ..., (an, bn)` such that the sum of `min(ai, bi)` for all `i` is **maximized**. Return _the maximized sum_.
**Example 1:**
**Input:** nums... | dolphin | [
0.015022441744804382,
0.0338001474738121,
-0.037973228842020035,
-0.019535282626748085,
0.039102185517549515,
-0.009684234857559204,
-0.02882564254105091,
0.05462566018104553,
0.030678117647767067,
-0.00875063519924879,
0.019372504204511642,
0.03713826835155487,
-0.04086364433169365,
-0.01... | 0.83924 | 0.771969 | 0.067271 |
Please explain the following problem in detail and provide code in java:
The **numeric value** of a **lowercase character** is defined as its position `(1-indexed)` in the alphabet, so the numeric value of `a` is `1`, the numeric value of `b` is `2`, the numeric value of `c` is `3`, and so on.
The **numeric value** of... | dolphin | [
0.014201031066477299,
0.03496227413415909,
-0.018922418355941772,
-0.050048694014549255,
0.05320438742637634,
-0.0340571403503418,
-0.008089988492429256,
0.027639327570796013,
0.02121175080537796,
-0.012294316664338112,
0.03356590121984482,
0.02633373625576496,
-0.03764653578400612,
-0.005... | 0.837482 | 0.779954 | 0.057528 |
Please explain the following problem in detail and provide code in c++:
You are given an array `nums` of size `n` consisting of **distinct** integers from `1` to `n` and a positive integer `k`.
Return _the number of non-empty subarrays in_ `nums` _that have a **median** equal to_ `k`.
**Note**:
* The median of an ... | dolphin | [
0.027058787643909454,
0.022322878241539,
-0.038375165313482285,
-0.02717515453696251,
0.03627457097172737,
0.007078074850142002,
-0.028211086988449097,
0.08045073598623276,
0.025326969102025032,
-0.008863651193678379,
0.03148603439331055,
0.017164155840873718,
-0.026680877432227135,
-0.003... | 0.833084 | 0.769469 | 0.063615 |
Please write the following solution using Ruby:
Given a positive integer `n`, return the number of the integers in the range `[0, n]` whose binary representations **do not** contain consecutive ones.
**Example 1:**
**Input:** n = 5
**Output:** 5
**Explanation:**
Here are the non-negative integers <= 5 with their corr... | dolphin | [
0.01181445550173521,
0.01869398169219494,
-0.029206465929746628,
-0.04472013935446739,
0.038752760738134384,
-0.019068174064159393,
-0.041398901492357254,
0.047006476670503616,
0.03440976142883301,
-0.026201531291007996,
0.03021058812737465,
0.019937997683882713,
-0.033872853964567184,
-0.... | 0.833123 | 0.777676 | 0.055448 |
Please explain the reasoning behind the following solution and provide code in R:
Given an integer array `nums`, return _the number of all the **arithmetic subsequences** of_ `nums`.
A sequence of numbers is called arithmetic if it consists of **at least three elements** and if the difference between any two consecuti... | dolphin | [
0.02636636607348919,
0.029225489124655724,
-0.02696307562291622,
-0.031797897070646286,
0.04541460797190666,
-0.007621834985911846,
-0.02765672095119953,
0.0570436529815197,
0.040410999208688736,
0.0029578853864222765,
0.009795821271836758,
0.024100275710225105,
-0.04203229397535324,
-0.01... | 0.833799 | 0.776468 | 0.057331 |
Please write the following solution using PHP:
You have two types of tiles: a `2 x 1` domino shape and a tromino shape. You may rotate these shapes.
Given an integer n, return _the number of ways to tile an_ `2 x n` _board_. Since the answer may be very large, return it **modulo** `109 + 7`.
In a tiling, every square... | dolphin | [
0.02926614321768284,
0.02716652676463127,
-0.02428005076944828,
-0.019438644871115685,
0.020522965118288994,
-0.02032260037958622,
-0.022865112870931625,
0.06477196514606476,
0.010987957939505577,
-0.003284752368927002,
0.04255605861544609,
0.05016573145985603,
-0.041442256420850754,
-0.02... | 0.832808 | 0.775964 | 0.056844 |
Please explain the following problem in detail and provide code in Objective-C:
You are given an integer array `nums` sorted in **non-decreasing** order.
Build and return _an integer array_ `result` _with the same length as_ `nums` _such that_ `result[i]` _is equal to the **summation of absolute differences** between_... | dolphin | [
0.013218010775744915,
0.028399407863616943,
-0.021357553079724312,
-0.027512453496456146,
0.0375346802175045,
-0.02999275177717209,
-0.043384723365306854,
0.06628187000751495,
0.03907212242484093,
-0.010486943647265434,
0.02878033183515072,
0.013406316749751568,
-0.05859360843896866,
-0.00... | 0.833728 | 0.779307 | 0.054421 |
Please write the following solution using F#:
You are given the `head` of a linked list containing unique integer values and an integer array `nums` that is a subset of the linked list values.
Return _the number of connected components in_ `nums` _where two values are connected if they appear **consecutively** in the ... | dolphin | [
0.02412865124642849,
0.025729870423674583,
-0.016228731721639633,
-0.025167305022478104,
0.048460233956575394,
-0.02233090251684189,
-0.01292344182729721,
0.053541410714387894,
0.04360527917742729,
0.0070358505472540855,
0.020123930647969246,
0.021761000156402588,
-0.026778429746627808,
-0... | 0.840801 | 0.781435 | 0.059366 |
Please explain the following problem in detail and provide code in C#:
You are given an integer `n` denoting the number of cities in a country. The cities are numbered from `0` to `n - 1`.
You are also given a 2D integer array `roads` where `roads[i] = [ai, bi]` denotes that there exists a **bidirectional** road conne... | dolphin | [
0.018107706680893898,
0.03531237319111824,
-0.030254455283284187,
-0.014699989929795265,
0.020603375509381294,
-0.020827941596508026,
-0.005355128087103367,
0.06934777647256851,
0.02506113052368164,
-0.012306932359933853,
0.019158439710736275,
0.04623245820403099,
-0.03649584949016571,
-0.... | 0.835272 | 0.779781 | 0.055491 |
Please focus on the functionality of this problem and provide code in ANSI C:
You are given the `root` of a binary tree where each node has a value `0` or `1`. Each root-to-leaf path represents a binary number starting with the most significant bit.
* For example, if the path is `0 -> 1 -> 1 -> 0 -> 1`, then this co... | dolphin | [
0.027402007952332497,
0.03791533038020134,
-0.03372340649366379,
-0.026431243866682053,
0.028627965599298477,
-0.061919890344142914,
-0.010367562994360924,
0.07704895734786987,
0.031100822612643242,
-0.01786092109978199,
0.043693311512470245,
0.021563159301877022,
-0.049298204481601715,
-0... | 0.830105 | 0.775557 | 0.054548 |
Please explain the reasoning behind the following solution and provide code in ANSI C:
There are `n` uniquely-sized sticks whose lengths are integers from `1` to `n`. You want to arrange the sticks such that **exactly** `k` sticks are **visible** from the left. A stick is **visible** from the left if there are no **lon... | dolphin | [
0.02430761605501175,
0.026143494993448257,
-0.011747472919523716,
-0.047497332096099854,
0.023291191086173058,
-0.023489423096179962,
-0.03017214499413967,
0.07598166167736053,
0.021340230479836464,
0.0011122478172183037,
0.03217730671167374,
0.036156922578811646,
-0.047230836004018784,
-0... | 0.852627 | 0.794237 | 0.05839 |
Please write the following solution using javascript:
Given an integer array `nums`, find a subarray that has the largest product, and return _the product_.
The test cases are generated so that the answer will fit in a **32-bit** integer.
**Example 1:**
**Input:** nums = \[2,3,-2,4\]
**Output:** 6
**Explanation:** \... | dolphin | [
0.03986506164073944,
0.039313022047281265,
-0.03545982763171196,
-0.009714167565107346,
0.04713929072022438,
-0.010486120358109474,
-0.03277810290455818,
0.06241496652364731,
0.04059997946023941,
-0.0207387562841177,
0.028848860412836075,
0.04059355705976486,
-0.03527110442519188,
-0.03344... | 0.838093 | 0.782941 | 0.055151 |
Please explain the following problem in detail and provide code in ANSI C:
Given string num representing a non-negative integer `num`, and an integer `k`, return _the smallest possible integer after removing_ `k` _digits from_ `num`.
**Example 1:**
**Input:** num = "1432219 ", k = 3
**Output:** "1219 "
**Explanatio... | dolphin | [
0.013222797773778439,
0.04764002934098244,
-0.014528514817357063,
-0.06046151742339134,
0.042882196605205536,
-0.04973381757736206,
-0.013309439644217491,
0.061705030500888824,
0.04008860886096954,
0.00022838724544271827,
0.024173058569431305,
0.02533186972141266,
-0.03968501091003418,
-0.... | 0.824798 | 0.769938 | 0.05486 |
Please write the following solution using Clojure:
Given an integer array `nums` and an integer `k`, return _the length of the shortest non-empty **subarray** of_ `nums` _with a sum of at least_ `k`. If there is no such **subarray**, return `-1`.
A **subarray** is a **contiguous** part of an array.
**Example 1:**
**... | dolphin | [
0.009138328954577446,
0.03846406564116478,
-0.028961127623915672,
-0.03390086442232132,
0.04756856709718704,
-0.01154873613268137,
-0.021961141377687454,
0.03136608749628067,
0.03845302015542984,
-0.0037811833899468184,
0.03526907414197922,
0.0303020142018795,
-0.024270547553896904,
-0.012... | 0.838561 | 0.781058 | 0.057502 |
Please explain the reasoning behind the following solution and provide code in Dart:
You are given an integer array `nums` and an integer `k`.
Find the longest subsequence of `nums` that meets the following requirements:
* The subsequence is **strictly increasing** and
* The difference between adjacent elements i... | dolphin | [
0.019221076741814613,
0.0344507098197937,
-0.015312678180634975,
-0.03975639119744301,
0.03902237489819527,
-0.017903722822666168,
-0.04548712447285652,
0.06861160695552826,
0.03996557369828224,
-0.01480687316507101,
0.025296887382864952,
0.02077575959265232,
-0.028884170576930046,
0.02853... | 0.8435 | 0.787401 | 0.056099 |
Please write the following solution using F#:
There is a tree (i.e. a connected, undirected graph with no cycles) consisting of `n` nodes numbered from `0` to `n - 1` and exactly `n - 1` edges.
You are given a **0-indexed** integer array `vals` of length `n` where `vals[i]` denotes the value of the `ith` node. You are... | dolphin | [
0.02020024135708809,
0.013583286665380001,
-0.02112152799963951,
-0.03342568129301071,
0.035917285829782486,
-0.03645304590463638,
-0.014258097857236862,
0.06007813289761543,
0.0385156087577343,
-0.0032119378447532654,
0.02589147724211216,
0.008954665623605251,
-0.02356128580868244,
-0.029... | 0.852698 | 0.796069 | 0.056629 |
Please explain the reasoning behind the following solution and provide code in Scheme:
You are given an integer array `arr`.
In one move, you can select a **palindromic** subarray `arr[i], arr[i + 1], ..., arr[j]` where `i <= j`, and remove that subarray from the given array. Note that after removing a subarray, the e... | dolphin | [
0.02727516181766987,
0.03367261588573456,
-0.03216123580932617,
-0.03648287057876587,
0.043694473803043365,
-0.02520539052784443,
-0.03174559399485588,
0.05141952261328697,
0.05016625300049782,
-0.009472000412642956,
0.022646863013505936,
0.00856521911919117,
-0.02691892720758915,
-0.01595... | 0.842351 | 0.779539 | 0.062812 |
Please write the following solution using Objective-C:
You are given an integer array `nums` consisting of `n` elements, and an integer `k`.
Find a contiguous subarray whose **length is equal to** `k` that has the maximum average value and return _this value_. Any answer with a calculation error less than `10-5` will ... | dolphin | [
0.02730284072458744,
0.03258829563856125,
-0.036531392484903336,
-0.041196275502443314,
0.06158445402979851,
-0.02872091718018055,
-0.04426313564181328,
0.047023944556713104,
0.030066248029470444,
-0.008116323500871658,
0.04356943070888519,
0.020724263042211533,
-0.03309018537402153,
0.001... | 0.827643 | 0.771277 | 0.056366 |
Please write the following solution using Groovy:
There is a pizza with `3n` slices of varying size, you and your friends will take slices of pizza as follows:
* You will pick **any** pizza slice.
* Your friend Alice will pick the next slice in the anti-clockwise direction of your pick.
* Your friend Bob will pi... | dolphin | [
0.00384127558209002,
0.013363741338253021,
-0.028297508135437965,
-0.028128614649176598,
0.015107604674994946,
-0.0112437903881073,
-0.029714593663811684,
0.01590237207710743,
0.027115095406770706,
-0.012614848092198372,
0.04623063653707504,
0.03888640180230141,
-0.042250607162714005,
-0.0... | 0.843507 | 0.787826 | 0.055682 |
Please write the following solution using ANSI C:
Given an array of integers `nums` and a positive integer `k`, check whether it is possible to divide this array into sets of `k` consecutive numbers.
Return `true` _if it is possible_. Otherwise, return `false`.
**Example 1:**
**Input:** nums = \[1,2,3,3,4,4,5,6\], k... | dolphin | [
0.012528806924819946,
0.04200435057282448,
-0.010141190141439438,
-0.03572244942188263,
0.041146669536828995,
-0.022392218932509422,
-0.018877239897847176,
0.09527307748794556,
0.03166264668107033,
-0.020326649770140648,
0.03366263955831528,
0.011688418686389923,
-0.04281051084399223,
-0.0... | 0.839149 | 0.776508 | 0.062641 |
Please write the following solution using Object Pascal:
Given an array of integers `nums` and an integer `threshold`, we will choose a positive integer `divisor`, divide all the array by it, and sum the division's result. Find the **smallest** `divisor` such that the result mentioned above is less than or equal to `th... | dolphin | [
0.012377758510410786,
0.03624098002910614,
-0.012889472767710686,
-0.03690154850482941,
0.05407870560884476,
-0.023627322167158127,
-0.029750682413578033,
0.0510532483458519,
0.039821285754442215,
-0.005762317683547735,
0.02453659102320671,
0.03179505467414856,
-0.020385507494211197,
-0.00... | 0.833963 | 0.777077 | 0.056886 |
Please write the following solution using Scala:
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 `k`, r... | dolphin | [
0.022078925743699074,
0.03148966282606125,
-0.012518905103206635,
-0.035878315567970276,
0.03534191474318504,
-0.009550882503390312,
-0.017125096172094345,
0.0526481494307518,
0.03361472114920616,
-0.02873753197491169,
0.03606114909052849,
0.03423807770013809,
-0.004926137626171112,
-0.023... | 0.851324 | 0.791428 | 0.059896 |
Please explain the following problem in detail and provide code in java:
Given the `root` of a binary tree, return _the length of the longest path, where each node in the path has the same value_. This path may or may not pass through the root.
**The length of the path** between two nodes is represented by the number ... | dolphin | [
0.02197648212313652,
0.018944151699543,
-0.034906577318906784,
-0.021219979971647263,
0.01727093756198883,
-0.05676481872797012,
0.0007557289791293442,
0.040116917341947556,
0.025128843262791634,
-0.028095971792936325,
0.05153476446866989,
0.004856420680880547,
-0.016379885375499725,
0.006... | 0.827833 | 0.769639 | 0.058194 |
Please write the following solution using Mojo:
You are given a numeric string `num`, representing a very large **palindrome**.
Return _the **smallest palindrome larger than**_ `num` _that can be created by rearranging its digits. If no such palindrome exists, return an empty string_ `" "`.
A **palindrome** is a numb... | dolphin | [
0.03974685072898865,
0.028265424072742462,
-0.004005969502031803,
-0.05855140462517738,
0.016361350193619728,
-0.003966447897255421,
-0.004734346177428961,
0.06491624563932419,
0.03277885913848877,
-0.002718952251598239,
0.02791213057935238,
0.03530007600784302,
-0.04927960783243179,
-0.01... | 0.82835 | 0.773628 | 0.054722 |
Please write the following solution using javascript:
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.
We define that a subse... | dolphin | [
0.016775203868746758,
0.04662143439054489,
-0.021569538861513138,
-0.019455749541521072,
0.04100064933300018,
-0.009435921907424927,
-0.022699832916259766,
0.04709439352154732,
0.048711515963077545,
-0.018082749098539352,
0.023888474330306053,
0.01970564015209675,
-0.04585795849561691,
-0.... | 0.844045 | 0.787413 | 0.056632 |
Please explain the following problem in detail and provide code in c++:
You are given two **sorted** arrays of distinct integers `nums1` and `nums2.`
A **valid path** is defined as follows:
* Choose array `nums1` or `nums2` to traverse (from index-0).
* Traverse the current array from left to right.
* If you ar... | dolphin | [
0.008616001345217228,
0.012777511961758137,
-0.026305120438337326,
-0.029199600219726562,
0.02299651689827442,
-0.013151454739272594,
-0.03953444957733154,
0.08078450709581375,
0.038940656930208206,
-0.02622118778526783,
0.033302586525678635,
0.03318548575043678,
-0.012767315842211246,
-0.... | 0.845368 | 0.780871 | 0.064497 |
Please write the following solution using Scala:
You are given a **0-indexed** integer array `nums`. An index `i` is part of a **hill** in `nums` if the closest non-equal neighbors of `i` are smaller than `nums[i]`. Similarly, an index `i` is part of a **valley** in `nums` if the closest non-equal neighbors of `i` are ... | dolphin | [
0.008474467322230339,
0.030702652409672737,
-0.0250319205224514,
-0.012681107968091965,
0.04769189655780792,
-0.02102513611316681,
-0.021693209186196327,
0.06194452568888664,
0.02253398671746254,
-0.027744058519601822,
0.023466598242521286,
0.027615997940301895,
-0.011896713636815548,
-0.0... | 0.846839 | 0.789376 | 0.057463 |
Please focus on the efficiency of this problem and provide code in c++:
A split of an integer array is **good** if:
* The array is split into three **non-empty** contiguous subarrays - named `left`, `mid`, `right` respectively from left to right.
* The sum of the elements in `left` is less than or equal to the sum... | dolphin | [
0.02772827446460724,
0.012033701874315739,
-0.03744680806994438,
-0.024242551997303963,
0.03169712424278259,
0.0018613307038322091,
-0.038721177726984024,
0.08753615617752075,
0.030018160119652748,
-0.013572564348578453,
0.02015158347785473,
0.03204171732068062,
-0.030123287811875343,
-0.0... | 0.843075 | 0.782322 | 0.060753 |
Please explain the following problem in detail and provide code in Visual Basic .NET:
You are given a **0-indexed** integer array `nums`, where `nums[i]` represents the score of the `ith` student. You are also given an integer `k`.
Pick the scores of any `k` students from the array so that the **difference** between t... | dolphin | [
0.004862046800553799,
0.015595365315675735,
-0.0254574753344059,
-0.025155970826745033,
0.04765668883919716,
-0.03850864619016647,
-0.020226750522851944,
0.06547607481479645,
0.051409125328063965,
-0.008416108787059784,
0.04296473041176796,
0.037574563175439835,
-0.03169506788253784,
0.004... | 0.845669 | 0.792343 | 0.053326 |
Please explain the following problem in detail and provide code in Object Pascal:
There is a robot on an `m x n` grid. The robot is 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 ... | dolphin | [
0.00901517178863287,
0.026486149057745934,
-0.011579597368836403,
-0.02778381109237671,
0.030758608132600784,
-0.018404141068458557,
-0.02135506458580494,
0.05399523675441742,
0.043112970888614655,
-0.004967845045030117,
0.024334093555808067,
0.05024571716785431,
-0.021093925461173058,
-0.... | 0.844415 | 0.788427 | 0.055989 |
Please explain the reasoning behind the following solution and provide code in Scheme:
Given an array `nums` of integers, a _move_ consists of choosing any element and **decreasing it by 1**.
An array `A` is a _zigzag array_ if either:
* Every even-indexed element is greater than adjacent elements, ie. `A[0] > A[1]... | dolphin | [
0.02447769045829773,
0.032091159373521805,
-0.020215895026922226,
-0.02523493580520153,
0.04779474437236786,
-0.019386200234293938,
-0.049205176532268524,
0.036679815500974655,
0.022938689216971397,
-0.002555660903453827,
0.020365478470921516,
0.01628083921968937,
-0.045767560601234436,
-0... | 0.839871 | 0.776607 | 0.063264 |
Please write the following solution using java:
You are given a **0-indexed** positive integer array `nums` and a positive integer `k`.
A pair of numbers `(num1, num2)` is called **excellent** if the following conditions are satisfied:
* **Both** the numbers `num1` and `num2` exist in the array `nums`.
* The sum ... | dolphin | [
0.013253694400191307,
0.023592133074998856,
-0.0399337112903595,
-0.022344425320625305,
0.03877183422446251,
-0.030329780653119087,
-0.044714171439409256,
0.042639248073101044,
0.03213973343372345,
-0.027817806228995323,
0.029961610212922096,
0.0182753037661314,
-0.03379014879465103,
-0.01... | 0.849126 | 0.78565 | 0.063477 |
Please explain the reasoning behind the following solution and provide code in javascript:
Given a **0-indexed** integer array `nums` of length `n` and an integer `k`, return _the **number of pairs**_ `(i, j)` _where_ `0 <= i < j < n`, _such that_ `nums[i] == nums[j]` _and_ `(i * j)` _is divisible by_ `k`.
**Example 1... | dolphin | [
0.016171524301171303,
0.029942939057946205,
-0.038356393575668335,
-0.012167908251285553,
0.05706039443612099,
-0.025612104684114456,
-0.013353824615478516,
0.05885517969727516,
0.026522202417254448,
-0.01095228735357523,
0.027788842096924782,
0.010341992601752281,
-0.02832937426865101,
-0... | 0.845371 | 0.78925 | 0.056121 |
Please write the following solution using java:
You have some number of sticks with positive integer lengths. These lengths are given as an array `sticks`, where `sticks[i]` is the length of the `ith` stick.
You can connect any two sticks of lengths `x` and `y` into one stick by paying a cost of `x + y`. You must conn... | dolphin | [
0.008846607990562916,
0.018617678433656693,
-0.02913089655339718,
-0.01903771609067917,
0.02623165212571621,
-0.011686773970723152,
-0.02210177294909954,
0.04011666774749756,
0.03664770722389221,
-0.019779421389102936,
0.02777084708213806,
0.026406606659293175,
-0.030379071831703186,
-0.01... | 0.845386 | 0.789852 | 0.055534 |
Please explain the following problem in detail and provide code in c++:
Given an array of integers `nums`, sort the array in ascending order and return it.
You must solve the problem **without using any built-in** functions in `O(nlog(n))` time complexity and with the smallest space complexity possible.
**Example 1:*... | dolphin | [
0.019604304805397987,
0.02852117083966732,
-0.008893254213035107,
-0.013085402548313141,
0.030452853068709373,
-0.01598968729376793,
-0.02998397871851921,
0.10157410055398941,
0.0353761725127697,
-0.013969137333333492,
0.024551453068852425,
0.015850180760025978,
-0.035874541848897934,
0.00... | 0.823339 | 0.765828 | 0.05751 |
Please explain the following problem in detail and provide code in javascript:
You are given a **0-indexed** binary array `nums` of length `n`. `nums` can be divided at index `i` (where `0 <= i <= n)` into two arrays (possibly empty) `numsleft` and `numsright`:
* `numsleft` has all the elements of `nums` between ind... | dolphin | [
0.024524929001927376,
0.025777308270335197,
-0.029131455346941948,
-0.014063790440559387,
0.031865496188402176,
-0.025043772533535957,
-0.026447677984833717,
0.05653128772974014,
0.04922287538647652,
-0.004331119358539581,
0.023182837292551994,
0.014495017006993294,
-0.025440994650125504,
... | 0.850738 | 0.788237 | 0.062501 |
Please explain the following problem in detail and provide code in c++:
You are given a **tree** (i.e. a connected, undirected graph that has no cycles) **rooted** at node `0` consisting of `n` nodes numbered from `0` to `n - 1`. The tree is represented by a **0-indexed** array `parent` of size `n`, where `parent[i]` i... | dolphin | [
0.022535087540745735,
0.011022403836250305,
-0.012963912449777126,
-0.03713718056678772,
0.02885502763092518,
-0.031654130667448044,
-0.0013504737289622426,
0.08522120863199234,
0.03834625706076622,
-0.018024958670139313,
0.038233786821365356,
0.027700835838913918,
-0.018212774768471718,
-... | 0.838752 | 0.782804 | 0.055948 |
Please explain the reasoning behind the following solution and provide code in Visual Basic .NET:
Given an integer array `arr` and an integer `k`, modify the array by repeating it `k` times.
For example, if `arr = [1, 2]` and `k = 3` then the modified array will be `[1, 2, 1, 2, 1, 2]`.
Return the maximum sub-array s... | dolphin | [
0.025088544934988022,
0.0345885306596756,
-0.019352003931999207,
-0.040911298245191574,
0.05202684924006462,
-0.03616508096456528,
-0.015835026279091835,
0.0727555975317955,
0.03880677744746208,
-0.02642684616148472,
0.030175596475601196,
0.020483318716287613,
-0.04583695903420448,
-0.0010... | 0.843493 | 0.787645 | 0.055848 |
Please write the following solution using Dart:
The [Hamming distance](https://en.wikipedia.org/wiki/Hamming_distance) between two integers is the number of positions at which the corresponding bits are different.
Given an integer array `nums`, return _the sum of **Hamming distances** between all the pairs of the inte... | dolphin | [
0.00458804564550519,
0.014646450988948345,
-0.01322638988494873,
-0.019472341984510422,
0.0478859469294548,
-0.019512653350830078,
-0.04754212871193886,
0.030004246160387993,
0.040464483201503754,
-0.014710758812725544,
0.022111859172582626,
0.031925588846206665,
-0.024558652192354202,
-0.... | 0.837495 | 0.778054 | 0.059441 |
Please focus on the functionality of this problem and provide code in Objective-C:
You are given an integer array `nums` and an integer `k`. Find the maximum subarray sum of all the subarrays of `nums` that meet the following conditions:
* The length of the subarray is `k`, and
* All the elements of the subarray a... | dolphin | [
0.01652921736240387,
0.025439366698265076,
-0.03933720290660858,
-0.026624061167240143,
0.04765094444155693,
-0.018411876633763313,
-0.030202075839042664,
0.06075964495539665,
0.018366416916251183,
-0.00362032325938344,
0.04035954177379608,
0.0319785438477993,
-0.04096638783812523,
0.00688... | 0.840049 | 0.783461 | 0.056588 |
Please write the following solution using Swift:
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 every integer in `nums`, a... | dolphin | [
0.011791304685175419,
0.01726096123456955,
-0.049415916204452515,
-0.016607962548732758,
0.04494798928499222,
-0.015417348593473434,
-0.03410031273961067,
0.03421158716082573,
0.03516211733222008,
-0.008340698666870594,
0.041704077273607254,
0.022080326452851295,
-0.0314730666577816,
0.009... | 0.832396 | 0.768664 | 0.063732 |
Please explain the following problem in detail and provide code in c++:
As the ruler of a kingdom, you have an army of wizards at your command.
You are given a **0-indexed** integer array `strength`, where `strength[i]` denotes the strength of the `ith` wizard. For a **contiguous** group of wizards (i.e. the wizards' ... | dolphin | [
0.03339456021785736,
0.03761361166834831,
-0.03602810204029083,
-0.05872393772006035,
0.05415255203843117,
-0.027571825310587883,
-0.03620560094714165,
0.08254286646842957,
0.04794144257903099,
-0.03293495625257492,
0.039160456508398056,
0.03864685446023941,
-0.051419731229543686,
-0.01723... | 0.836534 | 0.781734 | 0.0548 |
Please write the following solution using Object Pascal:
Given an integer array `nums`, return _the number of longest increasing subsequences._
**Notice** that the sequence has to be **strictly** increasing.
**Example 1:**
**Input:** nums = \[1,3,5,4,7\]
**Output:** 2
**Explanation:** The two longest increasing subs... | dolphin | [
0.014420682564377785,
0.03283857926726341,
-0.015185521915555,
-0.0249397624284029,
0.03306295722723007,
-0.011608317494392395,
-0.04135541617870331,
0.060285426676273346,
0.04461757466197014,
-0.010505923070013523,
0.02537103183567524,
0.016368454322218895,
-0.04698988422751427,
-0.004191... | 0.827859 | 0.76483 | 0.063029 |
Please focus on the functionality of this problem and provide code in Scheme:
Given an integer array `nums`, return _the maximum difference between two successive elements in its sorted form_. If the array contains less than two elements, return `0`.
You must write an algorithm that runs in linear time and uses linear... | dolphin | [
0.021107520908117294,
0.025340449064970016,
-0.02192286029458046,
-0.019814830273389816,
0.03567561134696007,
-0.012159873731434345,
-0.04375042766332626,
0.06410824507474899,
0.033732738345861435,
-0.02195407822728157,
0.029164275154471397,
0.03141380101442337,
-0.030671192333102226,
0.00... | 0.845377 | 0.780833 | 0.064544 |
Please focus on the efficiency of this problem and provide code in ANSI C:
You are given a **0-indexed** integer array `tasks`, where `tasks[i]` represents the difficulty level of a task. In each round, you can complete either 2 or 3 tasks of the **same difficulty level**.
Return _the **minimum** rounds required to co... | dolphin | [
0.01650078408420086,
0.0447319820523262,
-0.021894579753279686,
-0.03113485872745514,
0.033840399235486984,
-0.014256956055760384,
-0.0396902859210968,
0.07198196649551392,
0.025023814290761948,
-0.0038537061773240566,
0.01758149266242981,
0.019029630348086357,
-0.03000236116349697,
-0.016... | 0.846696 | 0.788906 | 0.05779 |
Please explain the reasoning behind the following solution and provide code in javascript:
An integer array is called arithmetic if it consists of **at least three elements** and if the difference between any two consecutive elements is the same.
* For example, `[1,3,5,7,9]`, `[7,7,7,7]`, and `[3,-1,-5,-9]` are arit... | dolphin | [
0.030840467661619186,
0.020106861367821693,
-0.03758497163653374,
-0.012994379736483097,
0.04715979844331741,
-0.0010375091806054115,
-0.028559645637869835,
0.0638420358300209,
0.03783121332526207,
-0.007297053467482328,
0.019373182207345963,
0.014410602860152721,
-0.03594470024108887,
-0.... | 0.83648 | 0.780935 | 0.055545 |
Please explain the reasoning behind the following solution and provide code in ANSI C:
Given an `m x n` matrix `mat` where every row is sorted in **strictly** **increasing** order, return _the **smallest common element** in all rows_.
If there is no common element, return `-1`.
**Example 1:**
**Input:** mat = \[\[1,... | dolphin | [
0.02589903399348259,
0.035497091710567474,
-0.022699549794197083,
-0.05036311596632004,
0.04234283044934273,
-0.03231784328818321,
-0.03454136103391647,
0.07602851092815399,
0.030674844980239868,
-0.02198190614581108,
0.016366373747587204,
-0.002296882914379239,
-0.04335756227374077,
-0.01... | 0.837267 | 0.783644 | 0.053623 |
Please explain the following problem in detail and provide code in Kotlin:
Given an integer array `nums` of size `n`, return _the minimum number of moves required to make all array elements equal_.
In one move, you can increment `n - 1` elements of the array by `1`.
**Example 1:**
**Input:** nums = \[1,2,3\]
**Outpu... | dolphin | [
0.01584732159972191,
0.011658528819680214,
-0.01685902290046215,
-0.037605151534080505,
0.03669207915663719,
-0.027051523327827454,
-0.014978225342929363,
0.06368133425712585,
0.023496178910136223,
-0.029741134494543076,
0.030612561851739883,
0.018596040084958076,
-0.04121541604399681,
-0.... | 0.852272 | 0.792079 | 0.060193 |
Please focus on the efficiency of this problem and provide code in java:
Given an integer `num`, return _the number of digits in `num` that divide_ `num`.
An integer `val` divides `nums` if `nums % val == 0`.
**Example 1:**
**Input:** num = 7
**Output:** 1
**Explanation:** 7 divides itself, hence the answer is 1.
*... | dolphin | [
0.022099869325757027,
0.01845509745180607,
-0.03167031332850456,
-0.033833373337984085,
0.028190698474645615,
-0.03681066259741783,
-0.029901543632149696,
0.044620513916015625,
0.015346350148320198,
-0.00347920716740191,
0.030489308759570122,
0.024793555960059166,
-0.043873757123947144,
-0... | 0.824517 | 0.769909 | 0.054608 |
Please explain the reasoning behind the following solution and provide code in Scheme:
Given an integer array `nums` and an integer `k`, you are asked to construct the array `ans` of size `n-k+1` where `ans[i]` is the number of **distinct** numbers in the subarray `nums[i:i+k-1] = [nums[i], nums[i+1], ..., nums[i+k-1]]... | dolphin | [
0.03155265375971794,
0.044935233891010284,
-0.026545468717813492,
-0.024467965587973595,
0.049004632979631424,
-0.03909479081630707,
-0.03182948753237724,
0.061155054718256,
0.03978654742240906,
-0.0005296685849316418,
0.029427368193864822,
0.025064561516046524,
-0.036268267780542374,
0.01... | 0.845937 | 0.789404 | 0.056533 |
Please explain the following problem in detail and provide code in javascript:
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 positiv... | dolphin | [
-0.013622866943478584,
0.012758934870362282,
-0.03527957946062088,
-0.033106304705142975,
0.04641404375433922,
-0.04126265272498131,
-0.018902713432908058,
0.026163768023252487,
0.028172213584184647,
0.0004140036762692034,
0.019407734274864197,
0.02051430009305477,
-0.03928560018539429,
-0... | 0.828208 | 0.768236 | 0.059972 |
Please write the following solution using javascript:
Given an integer array `nums`, return _the largest integer that only occurs once_. If no integer occurs once, return `-1`.
**Example 1:**
**Input:** nums = \[5,7,3,9,4,9,8,3,1\]
**Output:** 8
**Explanation:** The maximum integer in the array is 9 but it is repeate... | dolphin | [
0.0245664082467556,
0.031459301710128784,
-0.03226349875330925,
-0.025044506415724754,
0.031159697100520134,
-0.01911759003996849,
-0.02258952148258686,
0.053791798651218414,
0.024826550856232643,
-0.017934808507561684,
0.033197563141584396,
0.01029166392982006,
-0.03505859151482582,
-0.00... | 0.833573 | 0.770559 | 0.063015 |
Please write the following solution using java:
Given an `m x n` `matrix`, return _a new matrix_ `answer` _where_ `answer[row][col]` _is the_ _**rank** of_ `matrix[row][col]`.
The **rank** is an **integer** that represents how large an element is compared to other elements. It is calculated using the following rules:
... | dolphin | [
0.03135079890489578,
0.027072450146079063,
-0.03601456061005592,
-0.04560263082385063,
0.052709151059389114,
-0.028212938457727432,
-0.016649561002850533,
0.042352765798568726,
0.04527251049876213,
-0.021011706441640854,
0.016458047553896904,
0.013097790069878101,
-0.030357908457517624,
-0... | 0.837723 | 0.777442 | 0.060281 |
Please write the following solution using Erlang:
Given an integer array `arr` and an integer `k`, modify the array by repeating it `k` times.
For example, if `arr = [1, 2]` and `k = 3` then the modified array will be `[1, 2, 1, 2, 1, 2]`.
Return the maximum sub-array sum in the modified array. Note that the length o... | dolphin | [
0.03125803545117378,
0.03325631842017174,
-0.007577341981232166,
-0.053484879434108734,
0.043516065925359726,
-0.02539943903684616,
-0.02076270990073681,
0.049173884093761444,
0.03184569999575615,
-0.020477456972002983,
0.033391073346138,
0.0316762775182724,
-0.0348331592977047,
0.01470082... | 0.841872 | 0.785085 | 0.056787 |
Please explain the following problem in detail and provide code in c++:
Given an integer array `nums`, return `true` if any value appears **at least twice** in the array, and return `false` if every element is distinct.
**Example 1:**
**Input:** nums = \[1,2,3,1\]
**Output:** true
**Example 2:**
**Input:** nums = \... | dolphin | [
0.011947493068873882,
0.011959918774664402,
-0.019817138090729713,
-0.018249673768877983,
0.04004397243261337,
-0.023778077214956284,
-0.007396725006401539,
0.10464732348918915,
0.046866316348314285,
-0.01168915443122387,
0.02036418579518795,
0.013055401854217052,
-0.020187586545944214,
-0... | 0.835991 | 0.777447 | 0.058544 |
Please write the following solution using TypeScript:
Given an array of integers `arr` and an integer `k`. Find the _least number of unique integers_ after removing **exactly** `k` elements**.**
**Example 1:**
**Input:** arr = \[5,5,4\], k = 1
**Output:** 1
**Explanation**: Remove the single 4, only 5 is left.
**Exa... | dolphin | [
0.027336610481142998,
0.041599664837121964,
-0.020909788087010384,
-0.04056071862578392,
0.04785176366567612,
-0.032014209777116776,
-0.015088721178472042,
0.05321703478693962,
0.055031098425388336,
-0.009581067599356174,
0.019206492230296135,
-0.008677886798977852,
-0.005887656472623348,
... | 0.843896 | 0.786413 | 0.057483 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.