]
: []
: {
[P in keyof T as CamelizeKey]: T[P] extends object
? Camelize
: T[P]
}
```
### Drop String
> Drop the specified chars from a string.
```typescript
type DropString = any
/* _____________ Test Cases _____________ */
import type { Equal, Expect } from '@type-challenges/utils'
type cases = [
Expect, 'butter fly!'>>,
Expect, 'butterfly!'>>,
Expect, 'er fly!'>>,
Expect, ' e r f l y ! '>>,
Expect, 'butterfly!'>>,
Expect, 'butterfly!'>>,
Expect, ' e r f l y ! '>>,
Expect, ' e r f l y ! '>>,
Expect, ' u t t e r f l y ! '>>,
Expect, ' b u e r f l y ! '>>,
]
```
需要一个 StringToUnion 的辅助类型：
```typescript
type StringToUnion = S extends `${infer F}${infer R}`
? F | StringToUnion
: never
```
然后就是字符串操作：
```typescript
type DropString> = S extends `${infer F}${infer Rest}`
? F extends U
? DropString
: `${F}${DropString}`
: S
```
### Split
> The well known `split()` method splits a string into an array of substrings by looking for a separator, and returns the new array. The goal of this challenge is to split a string, by using a separator, but in the type system!
```typescript
type Split = any
/* _____________ Test Cases _____________ */
import type { Equal, Expect } from '@type-challenges/utils'
type cases = [
Expect, ['Hi! How are you?']>>,
Expect, ['Hi!', 'How', 'are', 'you?']>>,
Expect, ['H', 'i', '!', ' ', 'H', 'o', 'w', ' ', 'a', 'r', 'e', ' ', 'y', 'o', 'u', '?']>>,
Expect, []>>,
Expect, ['']>>,
Expect, string[]>>,
]
```
字符串分隔，也是比较简单的操作：
```typescript
type Split = SEP extends ''
? S extends `${infer F}${infer R}`
? [F, ...Split]
: []
: SEP extends S
? S[]
: S extends `${infer F}${SEP}${infer R}`
? [F, ...Split]
: [S]
```
### ClassPublicKeys
> Implement the generic `ClassPublicKeys` which returns all public keys of a class.
```typescript
type ClassPublicKeys = any
/* _____________ Test Cases _____________ */
import type { Equal, Expect } from '@type-challenges/utils'
class A {
public str: string
protected num: number
private bool: boolean
constructor() {
this.str = 'naive'
this.num = 19260917
this.bool = true
}
getNum() {
return Math.random()
}
}
type cases = [
Expect, 'str' | 'getNum'>>,
]
```
只需要 keyof 即可：
```typescript
type ClassPublicKeys = keyof T
```
### IsRequiredKey
> Implement a generic ```IsRequiredKey``` that return whether ```K``` are required keys of ```T``` .
```typescript
type IsRequiredKey = any
/* _____________ Test Cases _____________ */
import type { Equal, Expect } from '@type-challenges/utils'
type cases = [
Expect, true>>,
Expect, false>>,
Expect, false>>,
]
```
只需要利用 [Required Keys](#Required Keys) 的知识即可：
```typescript
type RequiredKeys = keyof {
[P in keyof T as Omit extends T ? never : P]: T[P]
}
type IsRequiredKey = Equal, K>
```
### ObjectFromEntries
> Implement the type version of ```Object.fromEntries```
```typescript
type ObjectFromEntries = any
/* _____________ Test Cases _____________ */
import type { Equal, Expect } from '@type-challenges/utils'
interface Model {
name: string
age: number
locations: string[] | null
}
type ModelEntries = ['name', string] | ['age', number] | ['locations', string[] | null]
type cases = [
Expect, Model>>,
]
```
我的想法很简单，先把联合类型转成二维数组，然后就是普通的数组操作收集结果即可：
```typescript
/**
* UnionToFunc<1 | 2> => ((arg: 1) => void | (arg: 2) => void)
*/
type UnionToFunc = T extends unknown ? (arg: T) => void : never
/**
* UnionToIntersection<1 | 2> = 1 & 2
*/
type UnionToIntersection = UnionToFunc extends (arg: infer Arg) => void
? Arg
: never
/**
* LastInUnion<1 | 2> = 2
*/
type LastInUnion = UnionToIntersection> extends (x: infer L) => void
? L
: never
type UnionToTuple> = [L] extends [never]
? []
: [...UnionToTuple>, L]
type ObjectFromEntries, Result extends Record = {}> = D extends [infer F, ...infer R]
? F extends [infer FF extends string, infer FR]
? ObjectFromEntries<
never,
R,
{
[K in FF | keyof Result]: K extends FF
? FR
: K extends keyof Result
? Result[K]
: never
}
>
: never
: Result
```
### IsPalindrome
> Implement type ```IsPalindrome``` to check whether a string or number is palindrome.
```typescript
type IsPalindrome = any
/* _____________ Test Cases _____________ */
import type { Equal, Expect } from '@type-challenges/utils'
type cases = [
Expect, false>>,
Expect, true>>,
Expect, false>>,
Expect, true>>,
Expect, true>>,
Expect, false>>,
]
```
首先我们需要把数字转成字符串：
```typescript
type NumberToString = `${N}` extends `${infer S}`
? S
: N
```
然后就是头尾对比即可：
```typescript
type IsPalindrome> = S extends `${infer F}${infer R}`
? F extends S
? true
: R extends `${infer RR}${F}`
? IsPalindrome
: false
: false
```
### Mutable Keys
> Implement the advanced util type MutableKeys, which picks all the mutable (not readonly) keys into a union.
```typescript
type MutableKeys = any
/* _____________ Test Cases _____________ */
import type { Equal, Expect } from '@type-challenges/utils'
type cases = [
Expect, 'a'>>,
Expect, 'a'>>,
Expect, 'a' | 'c' | 'd'>>,
Expect, never>>,
]
```
只需要在取键时拿 Readonly 包裹后的值对比即可：
```typescript
type MutableKeys = keyof {
[P in keyof T as Equal<{ [K in P]: T[K] }, Readonly<{ [K in P]: T[K] }>> extends false ? P: never]: T[P]
}
```
### Intersection
> Implement the type version of Lodash.intersection with a little difference. Intersection takes an Array T containing several arrays or any type element including the union type, and returns a new union containing all intersection elements.
```typescript
type Intersection = any
/* _____________ Test Cases _____________ */
import type { Equal, Expect } from '@type-challenges/utils'
type cases = [
Expect, 2>>,
Expect, 2 | 3>>,
Expect, never>>,
Expect, 3>>,
Expect, 2 | 3>>,
Expect, never>>,
]
```
这题可以利用 Extract 来获取交集，不过需要注意的一点是：
```typescript
type A = Extract<1 | 2, unknown> // 1 | 2
type B = Extract<1 | 2, never> // never
type C = Extract // never
```
答案如下：
```typescript
type Intersection = T extends [infer F, ...infer R]
? F extends unknown[]
? Extract>
: Extract>
: unknown
```
### Binary to Decimal
> Implement `BinaryToDecimal` which takes an exact string type `S` consisting 0 and 1 and returns an exact number type corresponding with `S` when `S` is regarded as a binary.
>
> You can assume that the length of `S` is equal to or less than 8 and `S` is not empty.
```typescript
type BinaryToDecimal = any
/* _____________ Test Cases _____________ */
import type { Equal, Expect } from '@type-challenges/utils'
type cases = [
Expect, 2>>,
Expect, 3>>,
Expect, 0>>,
Expect, 255>>,
Expect, 170>>,
]
```
这题还是比较简单的，我们之前实现过快速生成指定长度数组的方法：
```typescript
type NumberToArray = Result['length'] extends N
? Result
: NumberToArray
type GetTwice = [
...T, ...T
]
type BinaryToDecimal = S extends `${infer F extends number}${infer R}`
? BinaryToDecimal, ...NumberToArray]>
: Result['length']
```
### Object Key Paths
> Get all possible paths that could be called by [_.get](https://lodash.com/docs/4.17.15#get) (a lodash function) to get the value of an object
```typescript
type ObjectKeyPaths = any
/* _____________ Test Cases _____________ */
import type { Equal, Expect, ExpectExtends } from '@type-challenges/utils'
const ref = {
count: 1,
person: {
name: 'cattchen',
age: 22,
books: ['book1', 'book2'],
pets: [
{
type: 'cat',
},
],
},
}
type cases = [
Expect, 'name' | 'age'>>,
Expect<
Equal<
ObjectKeyPaths<{
refCount: number
person: { name: string; age: number }
}>,
'refCount' | 'person' | 'person.name' | 'person.age'
>
>,
Expect, 'count'>>,
Expect, 'person'>>,
Expect, 'person.name'>>,
Expect, 'person.age'>>,
Expect, 'person.books'>>,
Expect, 'person.pets'>>,
Expect, 'person.books.0'>>,
Expect, 'person.books.1'>>,
Expect, 'person.books[0]'>>,
Expect, 'person.books.[0]'>>,
Expect, 'person.pets.0.type'>>,
Expect, 'notExist'>, false>>,
Expect, 'person.notExist'>, false>>,
Expect, 'person.name.'>, false>>,
Expect, '.person.name'>, false>>,
Expect, 'person.pets.[0]type'>, false>>,
]
```
首先需要一个辅助类型来实现路径拼接，需要注意的是路径有 `a.b` 、`a.[0]`、`a[0]` 这几种款式：
```typescript
type GetPath = [Prefix] extends [never]
? `${K}`
: K extends number
? `${Prefix}.${K}` | `${Prefix}[${K}]` | `${Prefix}.[${K}]`
: `${Prefix}.${K}`
```
接下来是对对象进行深度递归并取出它们的 key 作为最终结果：
```typescript
type ObjectKeyPaths = Result | {
[P in keyof T & (string | number)]: T[P] extends object
? ObjectKeyPaths>
: GetPath
}[keyof T & (string | number)]
```
### Two Sum
> Given an array of integers `nums` and an integer `target`, return true if two numbers such that they add up to `target`.
```typescript
type TwoSum = any
/* _____________ Test Cases _____________ */
import type { Equal, Expect } from '@type-challenges/utils'
type cases = [
Expect, true>>,
Expect, true>>,
Expect, false>>,
Expect, true>>,
Expect, false>>,
Expect, false>>,
Expect, false>>,
Expect, true>>,
Expect, true>>,
Expect, true>>,
Expect, false>>,
]
```
这题需要一些辅助函数：
```typescript
/**
* NumberToArray<1> // [0]
* NumberToArray<2> // [0, 0]
*/
type NumberToArray = Result['length'] extends N
? Result
: NumberToArray
/**
* Sum<1, 2> // 3
*/
type Sum = [...NumberToArray, ...NumberToArray]['length']
/**
* EachSum<[1, 2], 3> // [4, 5]
*/
type EachSum = T extends [infer F extends number, ...infer R extends number[]]
? EachSum & number]>
: Result
/**
* GetResult<[1, 2, 3]> // [3, 4, 5]
*/
type GetResult = T extends [infer F extends number, ...infer R extends number[]]
? GetResult]>
: Result
```
然后就是调用即可：
```typescript
type TwoSum = U extends GetResult[number] ? true : false
```
### ValidDate
> Implement a type `ValidDate`, which takes an input type T and returns whether T is a valid date.
```typescript
type ValidDate = any
/* _____________ Test Cases _____________ */
import type { Equal, Expect } from '@type-challenges/utils'
type cases = [
Expect, true>>,
Expect, true>>,
Expect, true>>,
Expect, false>>,
Expect, false>>,
Expect, false>>,
Expect, false>>,
Expect, true>>,
Expect, false>>,
Expect, false>>,
]
```
这题我用了一车的辅助类型来完成：
```typescript
/**
* StringToNumber<'01'> // 1
* StringToNumber<'1'> // 1
* SttringToNumber<''> // 0
*/
type StringToNumber = T extends `0${infer R extends number}`
? R
: T extends `${infer R extends number}`
? R
: 0
type PlusOne = R['length'] extends T
? [0, ...R]['length']
: PlusOne
/**
* GetDateAndMonth<'0'> // [0, 0]
* GetDateAndMonth<'0123'> // [1, 23]
* GetDateAndMonth<'01234'> // [1, 234]
*/
type GetDateAndMonth = C extends 2
? [StringToNumber, StringToNumber]
: T extends `${infer F}${infer R}`
? GetDateAndMonth, `${Date}${F}`>
: [StringToNumber, StringToNumber]
type NumberToTuple = Res['length'] extends T
? Res
: NumberToTuple
type MinusOne> = Res extends [infer F, ...infer R]
? R['length']
: never
type GT = T extends U
? true
: T extends 0
? false
: GT, U>
/**
* GreaterThan<1, 2> // false
* GreaterThan<2, 2> // false
* GreaterThan<3, 2> // true
*/
type GreaterThan = Equal extends true
? false
: GT
/**
* InRange<2, 1, 2> // false
* InRange<2, 1, 3> // true
*/
type InRange = GreaterThan extends true
? GreaterThan extends true
? true
: false
: false
```
最终：
```typescript
type ValidDate> = InRange extends true
? A[0] extends 2
? InRange extends true
? true
: false
: InRange extends true
? true
: false
: false
```
### Assign
> You have a target object and a source array of objects. You need to copy property from source to target, if it has the same property as the source, you should always keep the source property, and drop the target property. (Inspired by the `Object.assign` API)
```typescript
type Assign, U> = any
/* _____________ Test Cases _____________ */
import type { Equal, Expect } from '@type-challenges/utils'
// case1
type Case1Target = {}
type Case1Origin1 = {
a: 'a'
}
type Case1Origin2 = {
b: 'b'
}
type Case1Origin3 = {
c: 'c'
}
type Case1Answer = {
a: 'a'
b: 'b'
c: 'c'
}
// case2
type Case2Target = {
a: [1, 2, 3]
}
type Case2Origin1 = {
a: {
a1: 'a1'
}
}
type Case2Origin2 = {
b: [2, 3, 3]
}
type Case2Answer = {
a: {
a1: 'a1'
}
b: [2, 3, 3]
}
// case3
type Case3Target = {
a: 1
b: ['b']
}
type Case3Origin1 = {
a: 2
b: {
b: 'b'
}
c: 'c1'
}
type Case3Origin2 = {
a: 3
c: 'c2'
d: true
}
type Case3Answer = {
a: 3
b: {
b: 'b'
}
c: 'c2'
d: true
}
// case 4
type Case4Target = {
a: 1
b: ['b']
}
type Case4Answer = {
a: 1
b: ['b']
}
type cases = [
Expect, Case1Answer>>,
Expect, Case2Answer>>,
Expect, Case3Answer>>,
Expect, Case4Answer>>,
]
```
这题还是比较简单的，首先需要把不符合的数组项给过滤掉：
```typescript
type AllowArgs[] = []> = T extends [infer F, ...infer R]
? F extends Record
? AllowArgs
: AllowArgs
: Result
```
然后就是逐个处理数组的每一项进行合并即可：
```typescript
type MergeInterface<
T extends Record,
D extends Record
> = {
[P in keyof T | keyof D]: P extends keyof D
? D[P]
: P extends keyof T
? T[P]
: never
}
type Assign<
T extends Record,
U extends unknown[],
D extends Record[] = AllowArgs
> = D extends [infer F extends Record, ...infer R extends Record[]]
? Assign, never, R>
: T
```
这里需要注意的是，后面的键要覆盖前面相同的键。
### Capitalize Nest Object Keys
> Capitalize the key of the object, and if the value is an array, iterate through the objects in the array.
```typescript
type CapitalizeNestObjectKeys = any
/* _____________ Test Cases _____________ */
import type { Equal, Expect } from '@type-challenges/utils'
import { ExpectFalse, NotEqual } from '@type-challenges/utils'
type foo = {
foo: string
bars: [{ foo: string }]
}
type Foo = {
Foo: string
Bars: [{
Foo: string
}]
}
type cases = [
Expect>>,
]
```
这题也比较容易处理：
```typescript
type EachCapitalize = T extends [infer F, ...infer R]
? [CapitalizeNestObjectKeys, ...EachCapitalize]
: []
type CapitalizeNestObjectKeys = {
[K in keyof T as K extends string ? Capitalize : never]: T[K] extends unknown[]
? EachCapitalize
: T[K] extends Record
? CapitalizeNestObjectKeys
: T[K]
}
```
### Run-length encoding
> Given a `string` sequence of a letters f.e. `AAABCCXXXXXXY`. Return run-length encoded string `3AB2C6XY`.
>
> Also make a decoder for that string.
```typescript
namespace RLE {
export type Encode = any
export type Decode = any
}
/* _____________ Test Cases _____________ */
import type { Equal, Expect } from '@type-challenges/utils'
type cases = [
// Raw string -> encoded string
Expect, '3AB2C6XY'>>,
// Encoded string -> decoded string
Expect, 'AAABCCXXXXXXY'>>,
]
```
首先是 Encode 的处理，借助一个缓存的数组来完成相同字符的收集：
```typescript
type Encode<
S extends string,
Cache extends string[] = [],
Result extends string = ''
> = S extends `${infer F}${infer R}`
? Cache extends []
? Encode
: Cache[0] extends F
? Encode
: Encode
: `${Result}${Cache[0]}`
```
接下来是 Decode 的处理，需要一些辅助类型：
```typescript
/**
* ParseInt<'A'> // never
* ParseInt<'1'> // 1
*/
type ParseInt = T extends `${infer R extends number}`
? R
: never
/**
* FillString<'A', 0> // ''
* FillString<'A', 1> // 'A'
* FillString<'A', 3> // 'AAA'
*/
type FillString = R['length'] extends L
? To
: FillString
```
最后就是收集 Number 用于填充即可：
```typescript
type Decode<
S extends string,
N extends number = never,
Result extends string = ''
> = S extends `${infer F}${infer R}`
? [ParseInt] extends [never]
? [N] extends [never]
? Decode
: Decode}`>
: Decode
