Pavel's questions

Item将工作表中的对象分组items为对象列表Group，每个组存储与一分钟相关的数据。

组内的数据value必须分组为给定间隔的算术平均值（以秒为单位）。如果源工作表中没有当前间隔 N 的数据，则重复上一个间隔的值。如果组中的第一个区间没有足够的数据，则复制前一组的最后一个区间。

间隔始终小于或等于 60 秒。并将一分钟分成相等的秒数，没有余数。

public class Item {
    private int id;
    private String time;
    private double value;
    // Getters, setters, constructors...
}
public class Group {
    private int id;
    private List<Item> items;
    // Getters, setters, constructors...
}

对于原始列表，持续时间间隔 = 30：

List<Item> items = List.of(
        new Item(1, "19/09/2020 1:03:00 AM", 1.0),
        new Item(2, "19/09/2020 1:03:03 AM", 1.3),
        new Item(3, "19/09/2020 1:03:15 AM", 1.1),
        new Item(4, "19/09/2020 1:03:47 AM", 1.2),
        new Item(5, "19/09/2020 1:03:57 AM", 1.6),
        new Item(6, "19/09/2020 1:04:04 AM", 1.8),
        new Item(7, "19/09/2020 1:04:43 AM", 1.9),
        new Item(8, "19/09/2020 1:04:44 AM", 2.1),
        new Item(9, "19/09/2020 1:05:30 AM", 1.8),
        new Item(10, "19/09/2020 1:05:46 AM", 2.3)
);

结果应该是：

List.of(
        new Group(1, List.of(
                new Item(1, "19/09/2020 1:03:00 AM", 1.13), // первые 30 сек value = (1.0 + 1.3 + 1.1) / 3
                new Item(2, "19/09/2020 1:03:30 AM", 1.4) // вторые 30 сек value = (1.2 + 1.6) / 2
        )),
        new Group(2, List.of(
                new Item(1, "19/09/2020 1:04:00 AM", 1.8), // первые 30 сек
                new Item(2, "19/09/2020 1:04:30 AM", 1.5) // вторые 30 сек
        )),
        new Group(2, List.of(
                new Item(1, "19/09/2020 1:05:00 AM", 1.5), // для первых 30 сек данных нет, в результат пойдет предыдущее значение
                new Item(2, "19/09/2020 1:05:30 AM", 2.05) // вторые 30 сек
        )));

签名List<Group> transform(List<Item> src, int intervalSize)

到目前为止，我所做的只是创建一个空的组列表

public class Transformer {

    SimpleDateFormat formatter = new SimpleDateFormat("dd/MM/yyyy hh:mm:ss a", Locale.ENGLISH);

    @SneakyThrows
    public List<Group> transform(List<Item> source, int intervalSize) {
        List<Group> target = getEmptyGroups(source);

        return target;
    }

    @SneakyThrows
    private List<Group> getEmptyGroups(List<Item> source) {
        Item start = source.get(0);
        Calendar startTime = Calendar.getInstance();
        startTime.setTime(formatter.parse(start.getTime()));
        Item end = source.get(source.size() - 1);
        Calendar endTime = Calendar.getInstance();
        endTime.setTime(formatter.parse(end.getTime()));
        long groupTotal = ChronoUnit.MINUTES.between(startTime.toInstant(), endTime.toInstant()) + 1;
        List<Group> groups = new ArrayList<>();
        IntStream.iterate(0, i -> i < groupTotal, i -> i + 1)
                .forEachOrdered(i -> {
                    Group group = new Group();
                    group.setId(i + 1);
                    groups.add(group);
                });
        return groups;
    }
}

我有一个算法，我无法挤出任何与答案近似的东西，所以这只是一个任务。

给定一个字符串数组S。N每条线的长度相同M。任务是在数组中找到一对字符串，S其中两个字符串在同一位置具有相同的字母。

例如：

S = ["abc", "bea", "dbe']，第 0 行"abc"和第 2 行在位置 1"dbe"具有相同的字母"b"。另一方面，对于字符串“abc”和“bea”，它们没有相同字母的位置。如果没有这样的对，该函数应该返回一个空数组。如果有多个正确答案，该函数可能会返回其中任何一个。

结果是一个由三个整数组成的数组。前两个整数是S 属于该对的字符串的索引。第三个整数是普通字母的位置。

更多示例：

S = ["abc", "bea", "dbe"]结果：[0, 2, 1]。另一个正确答案是[2, 0, 1]，因为行索引的顺序无关紧要。

S = ["abc", "bca", "dbe"]->[0, 2, 1]

S = ["zzzz", "ferz", "zdsr", "fgtd']可以返回[0, 1, 3]since "zzzz"，并且"ferz"在"z"位置 3。该函数还可以返回将按字母[1, 3, 0]匹配字符串。"ferz", "fgtd""f"

S = ["gr", "sd", "rg"]必须返回[]，因为没有符合条件的行对

S = ["bdafg", 'ceagi']该函数应该返回[0, 1, 2]

为以下假设编写一个有效的算法：

1. N它int在 [1..30000] 范围内；
2. M它int在 [1..2000] 范围内；
3. 每个元素S仅由小写拉丁字母 (az) 组成；
4. N * M < 30,000。

找出按升序排序的两个数组的并集中出现频率最高的元素的次数。元素可以重复。该算法必须在线性时间内运行。并且无法创建额外的数组以节省内存。

findMaxCount([1, 2, 9, 10], [2, 2, 10]) => 3

这个问题在面试中被抓到，我无法解决。据我了解，为了实现线性时间，您需要移动 2 个指针，但具体如何尚不清楚。

mapstruct 上有一个映射器，它根据票证的类型调用不同的 map 方法，所有这些都是通过 if else 条件实现的。我试图在策略模式或类似的东西上重写它，但在这种情况下，某些东西不会一直收敛。

// Хотелось бы как-то на месте инициализировать список условий
Map<Set<TicketType>, Function<TicketRequestDto, Ticket>> ticketMapStrategies = new ConcurrentHashMap<>(
    ... Как-то наполнить на месте, но как? ...
);


default Ticket ticketRequestDtoToTicket(TicketRequestDto dto) {
    TicketType type = dto.getType();

    if (type.equals(TicketType.EMERGENCY_STOP) || type.equals(TicketType.SETTING_UPLOAD)
            || dto.getType().equals(TicketType.SETTING_DOWNLOAD)) {
        return ticketEmergencyStopRequestDtoToTicket(dto);
    } else if (type.equals(TicketType.DEPOSIT_INCOME) || type.equals(TicketType.DEPOSIT_OUTCOME)) {
        return ticketAccountTransferRequestDtoToTicket(dto);
    } else if (type.equals(TicketType.PARTNER_REQUEST)) {
        return ticketPartnershipRequestDtoToTicket(dto);
    } else {
        return ticketInfoRequestDtoToTicket(dto);
    }
}

@Mapping(target = "instance.id", source = "instanceId")
@Mapping(target = "recipient.id", source = "recipientId")
Ticket ticketEmergencyStopRequestDtoToTicket(TicketRequestDto dto);

@Mapping(target = "account.id", source = "accountId")
@Mapping(target = "recipient.id", source = "recipientId")
Ticket ticketAccountTransferRequestDtoToTicket(TicketRequestDto dto);

@Mapping(target = "sender.id", source = "senderId")
@Mapping(target = "recipient.id", source = "recipientId")
Ticket ticketPartnershipRequestDtoToTicket(TicketRequestDto dto); 

Ticket ticketInfoRequestDtoToTicket(TicketRequestDto dto);

我想以某种方式在现场初始化条件列表，然后ticketRequestDtoToTicket按键获取。就像是：

    Set<TicketType> key = ticketMapStrategies.keySet().stream()
            .filter(set -> set.contains(dto.getType()))
            .findFirst()
            .orElse(new HashSet<>());
    return ticketMapStrategies.get(key).apply(dto);

如果可能的话，或者更紧凑的东西。

嗯，或者类似的东西。鉴于所有这些都发生在接口中，如何实现这一点？

爪哇 11

有一个带有索引的表需要修改，以便它也type以这样的方式限制字段，它只能type取三个值LONG，，，。SHORTUNIVERSAL

根据规则：任何一个字符串都必须UNIVERSAL通过组合没有重复symbol_id, account_id, enabled。或允许一LONG、一SHORT为组合symbol_id, account_id, enabled。

或者换句话说symbol_id, account_id, enabled，它enabled == TRUE可以是一个独特的组合：

1. 一个通用实例（UNIVERSAL这意味着它既可以工作又可以如何工作LONG）SHORT。

2. 两个实例，一个LONG和一个SHORT。

3. 每个实例至少有一个LONG，或者SHORT应该有true

LONG, 并且SHORT可以单独存在, 即例如LONG有, 但SHORT没有, 没有计划. 或相反亦然。

-- Instances
CREATE TABLE IF NOT EXISTS instances
(
    id            BIGSERIAL PRIMARY KEY,
    enabled       BOOLEAN      NOT NULL,
    title         VARCHAR(255) NOT NULL,
    type          VARCHAR(255) NOT NULL,
    status        VARCHAR(255) NOT NULL,
    updated_at    TIMESTAMP NOT NULL,
    last_callback TIMESTAMP,
    settings      VARCHAR(255),
    user_id       BIGINT REFERENCES users (id),
    symbol_id     BIGINT REFERENCES symbols (id),
    account_id    BIGINT REFERENCES accounts (id),
    strategy_id   BIGINT REFERENCES strategies (id)
);

和索引：

CREATE UNIQUE INDEX ui_symbol_account_enabled
    ON instances (symbol_id, account_id, enabled)
    WHERE (enabled IS TRUE);

它可能应该是这样的：

CREATE UNIQUE INDEX ui_symbol_account_enabled_type
    ON instances (symbol_id, account_id, enabled, type)
    WHERE (enabled IS TRUE
        AND (type = 'UNIVERSAL' OR type = 'SHORT' OR type = 'LONG')
        );

仅不是三个值之一，而是根据上述规则。如何正确书写？

有一个文件可以docker-compose.yaml启动一组容器和一个带有 Postgres 的容器。

据我了解，通过设置参数volumes，我可以设置容器外的目录与容器内Postgres本身的数据之间的关联：

volumes:
  - dbdata:/var/lib/postgresql/data

但是当我尝试跟随/var/lib/postgresql/data主机上的路径时，我没有找到任何数据。

docker-compose.yaml所有的：

version: "3.7"

services:
  db:
    image: postgres
    restart: always
    volumes:
      - dbdata:/var/lib/postgresql/data
    environment:
      POSTGRES_USER: postgres
      POSTGRES_PASSWORD: 1
      POSTGRES_DB: statistic
    ports:
      - 5432:5432
  api:
    build: api/
    restart: always
    depends_on:
      - db
    links:
      - db
    ports:
      - 8083:8080
  ui:
    build: ui/
    restart: always
    ports:
      - 8082:80

volumes:
  dbdata: {}

1. 为什么/var/lib/postgresql/data没有数据表明我误解了该条目的实际含义dbdata:/var/lib/postgresql/data？

2. 当volumes: dbdata: {}

3. 如何在帮助下创建到主机的适当链接，docker-compose.yaml以便在那里找到数据库数据？

有一个项目同时使用延迟加载模块和常规模块。

AppRoutingModule：

const routes: Routes = [
  // Пример ленивого модуля.
  {
    path: 'catalog',
    loadChildren: 'app/modules/catalog/catalog.module#CatalogModule'
  },
  ...
  // Модуль с 404й страницей
  {
     path: '**',
     loadChildren: 'app/modules/not-found/not-found.module#NotFoundModule'
  },
  // Не ленивые модули сдесь не объявленны они объявленны на прямую в AppModule
];

一切都会好起来的，但是模块不是AppModule在这个文件中声明的，而是在属性中声明为普通模块imports，

@NgModule({
  declarations: [
    AppComponent,
  ],
  imports: [
    AppRoutingModule,
    // Ленивый объевлен в AppRoutingModule
    CatalogModule, 
    // Обычный объявлен только тут и хранит свой path только внутри своего DictionaryRoutingModule
    DictionaryModule, 
  ]
})
export class AppModule {}
}

AppRoutingModule从声明 404 页面的位置来看，path: '**'没有DictionaryRoutingModule.

const routes: Routes = [
  {
    path: 'dictionary',
    component: DictionariesComponent,
  },
];
@NgModule({
  imports: [RouterModule.forChild(routes)],
  exports: [RouterModule]
})
export class DictionaryRoutingModule {
}

并且DictionaryRoutingModule, - 变得不可用。因为当你尝试浏览它们时，它成功了url，路由器重定向到 404 页面。因此，所有以通常非惰性方式声明的模块都不可用，而是显示 404。path: '**'AppRoutingModule

最明显的方法是声明所有模块为惰性，然后问题就消失了。但作为这项任务的条件，我收到了一个要求，不要将普通模块修改为惰性模块。

在这种情况下，如何实现一种通用机制来拦截不存在的地址，从而使现有的列表不仅考虑到延迟加载的模块，还考虑到普通的模块？

我正在寻找 RxJS (v6.x) 中的一种方法来向服务器发送循环请求，比如每 30 秒一次{ timer } from 'rxjs'，但问题是我没有考虑请求本身的时间。例如，如果返回响应 10 秒，那么请求之间的间隔将是在计时器设置中设置的 30 + 10 等待响应。

也许 RxJS 中的某些类正好适合这样的任务？调用将如下所示：

export class UserService {
    constructor(private readonly api: ApiService) {}

    public readonly user$ = new ReplaySubject<IUser>(1);

    ...

    private load(): void {
        this.api.getUser() // getUser(): Observable<IUser>
            .subscribe(user => this.user$.next(user));
    }
}

对于这样的缓存，您需要组织一个具有上述行为的调用计时器，也许在 RxJS 中有合适的东西不是拐杖？

也就是说，接下来的 30 秒倒计时应该只有在收到来自后面的响应后才开始，无论它可能是什么。

（ps不要问为什么在这种地方没有使用web sockets，我没有写）

正则表达式应该像这样格式化数字：

1000.999 -> 1000.999

10000.99 -> 10000.99

1000000 -> 1000000

function format(value) { ... }

该项目有主要分支develop和stable. 在某些情况下，每个单独功能的分支都是从 中创建的develop，在某些情况下是从 中创建的stable，但现在有必要找出其中一个旧功能，它是从哪个分支创建的。我怎样才能做到这一点？

有 2 个数组rows_1, rows_2，并且有一个查找字段匹配的函数：

compare(rows_1, rows_2) {
  rows_1.forEach(row_1 => {
    rows_2.forEach(row_2 => {
      row_1['checked'] = row_1.id === row_2.sub.id;
    });
  });
}

我有 2 个嵌套循环。

如果没有双循环或 O(n2)，这不能以某种方式更好地重写吗？

更新

对象结构：

rows_1 = [ {id: '1', title: '...'}, {id: '2', title: '...'}, ];
rows_2 = [ {sub: {id: '1', title: '...'}}, {sub: {id: '2', title: '...'}} ];

有一个没有聚集索引或主键的简单表示例：

create table non_pk (a int, b int);

已为此表创建索引：

create index non_pk_idx on non_pk (a, b);

索引表确认创建成功：

SELECT * FROM pg_indexes WHERE tablename = 'non_pk'                                                                                                                                                ;
 schemaname | tablename | indexname  | tablespace |                       indexdef                       
------------+-----------+------------+------------+------------------------------------------------------
 public     | non_pk    | non_pk_idx |            | CREATE INDEX non_pk_idx ON non_pk USING btree (a, b)

但是在查询这些字段之后：

select * from non_pk where a = 4 and b = 5;
 a | b 
---+---
 4 | 5
(1 row)

统计信息表未显示在搜索索引字段时使用了索引：

select relname, seq_scan, idx_scan from pg_stat_all_tables where relname = 'non_pk';
 relname | seq_scan | idx_scan 
---------+----------+----------
 non_pk  |       10 |        0
(1 row)

为什么索引不起作用以及在这种情况下需要什么才能使查询的搜索select * from non_pk where a = 4 and b = 5;使用索引create index non_pk_idx on non_pk (a, b);？

服务层有两种方法，其中一种使用第二种的结果作为参数：

export class ApiService {
    ... HttpClient и все прочее ...

    getType(request): Observable<any> {
        return this.http.post('api/type', request)
    }

    getCategory(type): Observable<any> {
        return this.http.post('api/category', type)
    }
}

在组件级别还有第三种方法应该返回Observable一个方法getCategory

searchCategory(serch): Observable<any> {
    this.apiService.getType(serch) // из него надо получить результат пусть type
    return this.apiService.getCategory(type) // и в качестве ответа отдать Observable второго метода
}

问题是如何在getType不使用subscribe(). 事实是模板中使用的组件searchCategory

<app-my-component
  [category]="searchCategory"
></app-my-component>

期望参数category是一个完全返回的方法Observable

我 RxJS 肯定有这个选项。如何从中获得结果getType？

在了解延迟加载模块如何在 Angular 2+ 中工作的过程中，我整理了一张图片。如果我正确理解它的工作原理，我想得到反馈，如果没有，它实际上是如何工作的？

延迟加载模块，作为一个独立的应用程序，有自己的依赖范围，被收集在一个单独的chunk中，在搜索其他模块中声明的组件、服务、指令或拦截器时，需要通过一个公共类型模块来导入它们SharedModule。共同实体被倾销。也就是说，在延迟加载模块的情况下，在查找依赖项时，角度不会上升到AppModule. 延迟加载模块本身是依赖图的顶部，并且直接将来自其他模块的实体添加到providers，打破了这种方法，使其成为通用依赖树的一部分，这迫使它立即以正常模块模式加载。providers可能在项目组装阶段连接来自。唯一的出路是使用imports因为这种结构很可能只​​在模块请求时起作用。这个问题大概包括了模块生命周期的问题，因为大家都在谈论组件的生命周期，而这个上下文中的模块不知何故不习惯讨论。

全部的：

1. providers上瘾和上瘾是真的imports在不同的时间吗？
2. 生命周期的哪些主要阶段会从根本上影响延迟加载模块的加载时间？

例如，有一个变量：

float f = 0.1692f;

你需要四舍五入才能得到它0.16。

有一个问题 - 消除工作日结束时间的错误。

我用拐杖解决了它，我真的很想看到一个好的解决方案的例子，我的代码如下，这里是问题陈述：

员工有 8 小时的 3 个班次：从 00:00 到 8:00 - 1 班，从 8:00 到 16:00 - 第二班，从 16:00 到第二天开始 - 第三班。同时，员工在不知道的时间内完成轮班的时间稍晚，但不超过一个轮班（或 8 小时）的规模。连续分配一名工人只工作一班。

移位数 1 或 2 或 3 称为输入参数。

如果员工已经工作并“爬”到其他人的班次，则有必要编写一个函数，该函数将返回上一班次最后一秒的日期和时间，而不是真正的结束时间。

例子：

1号班工人于2018年5月1日8:30交任务，函数应返回2018年5月1日7:59。在不准确的情况下，当从第 3 班转移到第 1 班时，必须考虑日期。

这是我的解决方案：

function computeLastUpdate(shiftNumber) {
    let lastUpdate = new Date();

    const beforeMidnight = new Date(lastUpdate.getFullYear(), lastUpdate.getMonth(), lastUpdate.getDate(), 23, 59, 59);
    const afterMidnight = new Date(lastUpdate.getFullYear(), lastUpdate.getMonth(), lastUpdate.getDate(), 0, 0, 0);
    const eightAM = new Date(lastUpdate.getFullYear(), lastUpdate.getMonth(), lastUpdate.getDate(), 8, 0, 0);
    const fourPM = new Date(lastUpdate.getFullYear(), lastUpdate.getMonth(), lastUpdate.getDate(), 16, 0, 0);

    if (shiftNumber === 1 && lastUpdate > eightAM && lastUpdate < fourPM) {

        lastUpdate = new Date(lastUpdate.getFullYear(), lastUpdate.getMonth(), lastUpdate.getDate(), 7, 59, 59);

    } else if (shiftNumber === 2 && lastUpdate > fourPM && lastUpdate < beforeMidnight) {

        lastUpdate = new Date(lastUpdate.getFullYear(), lastUpdate.getMonth(), lastUpdate.getDate(), 15, 59, 59);

    } else if (shiftNumber === 3 && lastUpdate > afterMidnight && lastUpdate < eightAM) {

        lastUpdate = new Date(lastUpdate.getFullYear(), lastUpdate.getMonth(), lastUpdate.getDate() - 1, 23, 59, 59);

    }

    return lastUpdate;
}

看起来很麻烦，而且措辞с 16:00 до начала следующих суток有些混乱。一般来说，是否有可能更优雅地解决这个问题？

Angular 6 上有一个应用程序，其中相应地使用了打字稿。有一个按钮可以从页面的不同部分复制统计信息。对于复制，它被写入ClipboardService有效ClipboardService.copyToClipboard(text);并且一切正常。

问题是数据需要分成几行，以便在将它们插入文本文件时，保留换行符。我试着这样做：

const text = 'a\nb';
ClipboardService.copyToClipboard(text);

但是分隔符作为字符而不是换行符复制到剪贴板。

并在文件中粘贴而不是：

a
b

我得到：

a\nb

如何实现此行为以便确定换行符的位置？

以防ClipboardService万一：

export class ClipboardService {
    static copyToClipboard(toCopy : any) : void {
        document.addEventListener('copy', (e : ClipboardEvent) => {
            const data = JSON.stringify(toCopy)
            e.clipboardData.setData('text/plain', data);
            e.preventDefault();
        });
        document.execCommand('copy');
    }
}

谢谢你。

有一个资源需要通过 REST API 分几个阶段从该资源中接收数据。在第一次请求之后，会发出一个令牌，之后需要每隔一段时间发出请求，检查数据是否准备好。

关键是如何在数据就绪检查之间实现暂停。到目前为止，我还没有找到比 更好的东西Thread.sleep();，但解决方案不是很好。另一方面，您不想连续发送请求，考虑到处理时间长达 20 分钟，而且您不想让人们去处分。

对于发送请求，我使用springframework.web.client.RestTemplate

到目前为止，调用看起来像这样：

private RestClient restClient;

public String get(Phone phone) {
    int counter = 0;
    String status = restClient.getStatus(phone.getActivationId());
    while (!status.contains("STATUS_ACCESS") && counter++ < 500) {
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        status = restClient.getStatus(phone.getActivationId());
    }
    restClient.setStatus(phone.getActivationId(), DONE);
    return status.contains("STATUS_ACCESS") ? status.split(":")[1] : "ERR";
}

在 RestClient 内部：

private RestTemplate restTemplate = new RestTemplate();

public String getStatus(String activationId) {
    String url = ...
    ResponseEntity<String> entity = restTemplate.getForEntity(url, String.class);
    return entity.getBody();
}

也许有一些方法可以处理RestTemplate这种情况。这Thread.sleep对我来说看起来很可怕。或不？在没有拐杖的情况下通常如何完成？

有一个请求的示例，RestTemplate其行为通过ClientHttpRequestFactory和配置RequestConfig。创建对象时，RequestConfig会设置三种不同的超时时间：ConnectTimeout、ConnectionRequestTimeout、SocketTimeout。请解释这是什么步骤，否则会得到油。尤其是setConnectTimeout和之间setConnectionRequestTimeout。有什么不一样的？如果我们基于请求-响应模型，怎么可能有请求之外的连接呢？

RestTemplate restTemplate = new RestTemplate(getClientHttpRequestFactory());

private ClientHttpRequestFactory getClientHttpRequestFactory() {
    int timeout = 5000;
    RequestConfig config = RequestConfig.custom()

      // Вот тут.
      .setConnectTimeout(timeout)
      .setConnectionRequestTimeout(timeout)
      .setSocketTimeout(timeout)

      .build();
    CloseableHttpClient client = HttpClientBuilder
      .create()
      .setDefaultRequestConfig(config)
      .build();
    return new HttpComponentsClientHttpRequestFactory(client);
}

我不小心将 API 密钥数据推送到公共 git 存储库中，我需要以某种方式将其删除，但所有尝试均未成功。我怎样才能摆脱存储库历史中的这些数据？

通过交互式变基尝试git rebase -i HEAD~4

但是得到了

line 267: mate: command not found
Could not execute editor