以下是问题描述： 由于您是Monk最喜欢的学生，因此您可以完成 N 过程。所有流程都有一个唯一的编号，从 1 到 N.
现在，你有两件事： - 调用所有进程的调用顺序。 - 应该执行所有过程的理想顺序。
现在，让我们通过一个例子来证明这一点。假设有 3个进程，进程的调用顺序为： 3 - 2 - 1。理想的顺序是： 1 - 3 - 2 < / strong>，即进程号3仅在进程号1完成后执行;进程号2只会在执行进程号3后执行。
- 迭代＃1 ：由于理想订单首先执行进程＃1，所以调整有序调用，即必须推送第一个元素到最后一个地方。更改元素的位置需要1个单位时间。新的呼叫顺序是：2 - 1 - 3.步骤＃1中的时间：1。
- 迭代次数＃2： 由于理想订单首先执行过程＃1，因此必须再次更改有序调用，即第一个元素具有被推到最后一个地方。新的呼叫顺序是：1 - 3 - 2.步骤2中所用的时间：1。
- 迭代次数＃3 ：由于调用顺序的第一个元素与理想顺序相同，因此将执行该过程。它会因此而突然出现。步骤＃3中采用的时间：1。
- 迭代＃4 ：由于调用顺序的新第一个元素与理想顺序相同，因此将执行该过程。步骤4中所用的时间：1。
- 迭代次数＃5 ：由于调用次序的最后一个元素与理想订单相同，因此将执行该过程。步骤＃5中所用的时间：1。 总时间：5个单位。
PS：执行一个过程需要1个单位时间。改变位置需要1个单位时间。
输入格式： 第一行是数字N，表示进程数。第二行包含进程的调用顺序。第三行包含过程的理想顺序。 输出格式： 打印执行整个进程队列所需的总时间。 的约束： 1 <= N <= 100
但我的输出是这样的：我做错了!!!!!
输入 3 3 2 1 1 3 2
您的代码输出 73
预期的正确输出 5
编辑日志 编译成功。
#include <stdio.h>
int *move_last(int a[],int n1)
{
int temp,i;
temp=a[0];
for(i=1;i<n1;i++)
{
a[i-1]=a[i];
}
a[n1-1]=temp;
return a;
}
int *remove_first(int a[],int n2)
{
int temp,i;
temp=a[0];
for(i=1;i<n2;i++)
a[i-1]=a[i];
return a;
}
int main()
{
//co:calling order array io:ideal order array
//ptime:process time**strong text**
int co[100],io[100];
int n,i,j,count=0,ptime=0;
scanf("%d",&n);
for(i=0;i<n;i++)
scanf("%d",&co[i]);
for(i=0;i<n;i++)
scanf("%d",&io[i]);
while(count!=n)
{
while(co[0]!=io[0])
{
int *p;
int size=sizeof(co)/sizeof(co[0]);
p=move_last(co,size);
for ( i = 0; i < size; i++ )
co[i]=*(p + i);
ptime++;
}
if(co[0]==io[0])
{
int *p;
int size=sizeof(co)/sizeof(co[0]);
p=remove_first(co,size);
size=size-1;
for ( i = 0; i < size; i++ )
co[i]=*(p + i);
count++;
ptime++;
}
}
printf("%d",ptime);
`enter code here`return 0;
}
答案 0 :(得分：1)
这是Java中的解决方案
$ sed '/objectMap\.getIdentifier(/{h;s/^.*objectMap\.getIdentifier(\([^)]*\)).*$/\1/;s/\./_/g;x;s/objectMap\.getIdentifier([^)]*)/#/;G;s/^\([^#]*\)#\(.*\)\n\(.*\)$/\1\3\2/}' ./infile
import java.io.File;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
public class TestingScript {
public void createNewItems(String itemName){
driver.click(new_dropdown, "DropDown clicking");
driver.click(("new_dropdown_notes_button", "Note from template....");
driver.click((getElement("modal_default_template".replace("$Template", "Default")), "Default", true);
driver.click((getElementByText(templateName), templateName);
driver.click(new_dropdown, "DropDown clicking");
driver.click(("modal_create_button", "Create");
}
}
答案 1 :(得分：0)
您的实施存在很多问题，我不知道从哪里开始......
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
int pop_front(int* p, int n)
{
int t = p[0];
memmove(&p[0], &p[1], (n - 1) * sizeof(p[0]));
return t;
}
void move_first_to_last(int* p, int n) // very similar to pop_front()
{
int t = pop_front(p, n);
p[n - 1] = t;
}
int* load_array(char* input, int n) // twice the same op = function + half the work.
{
int i;
char* p;
int* result = (int*)malloc(n * sizeof(int));
if (!result)
{
return NULL;
}
for (p = strtok(input, " \n"), i = 0; p != NULL && i < n; p = strtok(NULL, " \n"), ++i)
{
result[i] = atoi(p);
}
if (i != n)
{
free(result);
result = NULL;
}
return result;
}
#define MAX_LINE_LEN (4 << 10)
int main()
{
char* line;
int num_tasks, iter;
int* current_order, *desired_order;
line = (char*)malloc(MAX_LINE_LEN);
if (!line)
{
exit(1);
}
if (fgets(&line[0], MAX_LINE_LEN, stdin) != &line[0])
{
free(line);
exit(1);
}
num_tasks = atoi(line);
if (fgets(&line[0], MAX_LINE_LEN, stdin) != &line[0])
{
free(line);
exit(1);
}
current_order = load_array(line, num_tasks);
if (!current_order)
{
free(line);
exit(1);
}
if (fgets(&line[0], MAX_LINE_LEN, stdin) != &line[0])
{
free(line);
exit(1);
}
desired_order = load_array(line, num_tasks);
if (!desired_order)
{
free(line);
free(current_order);
exit(1);
}
iter = 0;
while (num_tasks)
{
++iter; // 1 task per iteration.
if (current_order[0] == desired_order[0])
{
pop_front(desired_order, num_tasks);
pop_front(current_order, num_tasks);
--num_tasks; // reducing the problem as we go.
}
else
{
move_first_to_last(current_order, num_tasks);
}
}
printf("%d\n", iter);
free(current_order);
free(desired_order);
free(line);
return 0;
}
答案 2 :(得分：0)
您的主要问题在于：int size=sizeof(co)/sizeof(co[0]);。当你只想处理使用的大小时（这里n = 3），你得到声明数组的大小（这里是100） - size的正确值是实际上是n - count。
此外，当move_last和remove_first实际更改数组时，在调用函数后再次复制它只是浪费时间：将数组复制到自身 - 返回值只是初始数组的第一个元素上的指针，C不返回数组...
快速修复此问题足以获得预期值：
#include <stdio.h>
int *move_last(int a[],int n1)
{
int temp,i;
temp=a[0];
for(i=1;i<n1;i++)
{
a[i-1]=a[i];
}
a[n1-1]=temp;
return a;
}
int *remove_first(int a[],int n2)
{
int temp,i;
temp=a[0];
for(i=1;i<n2;i++)
a[i-1]=a[i];
return a;
}
int main()
{
//co:calling order array io:ideal order array
//ptime:process time**strong text**
int co[100],io[100];
int n,i,j,count=0,ptime=0;
scanf("%d",&n);
for(i=0;i<n;i++)
scanf("%d",&co[i]);
for(i=0;i<n;i++)
scanf("%d",&io[i]);
while(count != n)
{
while(co[0]!=io[0])
{
int *p;
int size=n - count;
p=move_last(co,size);
/*for ( i = 0; i < size; i++ )
co[i]=*(p + i);*/
ptime++;
}
if(co[0]==io[0])
{
int *p;
int size=n - count;
p=remove_first(co,size);
remove_first(io, size);
size=size-1;
/*for ( i = 0; i < size; i++ )
co[i]=*(p + i);*/
count++;
ptime++;
}
}
printf("%d",ptime);
return 0;
}
但仍有许多可能的改进。首先，您应该控制所有scanf的返回值：当前输入文件中的错误将导致未定义的行为。恕我直言，这是一个最佳实践规则，可以帮助您以后避免许多麻烦
下一个size应该直接在主级别定义，并在循环之前初始化为n，然后循环条件可能是：while (size > 0)，使count无用。
if(co[0]==io[0])循环后 while(co[0]!=io[0])无效：如果您退出循环，则co[0]==io[0]必须为真。
temp中的{p> remove_first无用：您设置一次但不使用它
move_last和remove_first返回的值是无用的，因为它们只是指向其输入数组的第一个元素的指针：它们也可以是无效函数
答案 3 :(得分：0)
问题：给定N个进程，它们的调用顺序以及它们必须执行的顺序。找到在给定的执行顺序中执行所有这些操作所花费的时间。
说明：
现在，这个问题的解决方案是直接模拟，我们必须按照语句的要求进行模拟。
为了模拟它，我们可以使用队列数据结构。首先按照调用它们的顺序推送队列Q中的任务。现在，从前面迭代队列，并检查队列中的当前进程是否与执行顺序中的第一个进程匹配（如果匹配），然后执行它，另外在队列前面发送进程并再次重复此操作过程
此解决方案的伪代码为：
Q = queue containing the processes in the order they were called
time = 0
while Q is not empty :
time = time + 1
x = process in front of Q
if x == current process in execution order :
remove x from Q
else :
move the x from front to the back of the Q
对于最坏的情况，此算法的复杂性将为O（N2），例如：
通话单= 1 2 3 4 5执行顺序= 5 4 3 2 1
时间复杂度：O（N ^ 2）
#include <bits/stdc++.h>
using namespace std;
int main()
{
int N,Num;
cin>>N;
queue<int> Q;
for(int i=0;i<N;i++)
{
cin>>Num;
Q.push(Num);
}
int a[N];
for(int i=0;i<N;i++)
cin>>a[i];
int total_time = 0, executed_job = 0;
while(!Q.empty())
{
int job = Q.front();
if(job == a[executed_job]){
Q.pop();
total_time++;
executed_job++;
}
else
{
Q.pop();
Q.push(job);
total_time++;
}
}
cout<<total_time<<endl;
return 0;
}
答案 4 :(得分：0)
这是Swift 5的答案：
var callingOrderArr = [3,2,1]
var idealOrderArr = [1,3,2]
var counter = 0
while idealOrderArr.count > 0 {
counter += 1
if idealOrderArr[0] == callingOrderArr[0]{
idealOrderArr.remove(at: 0)
} else {
callingOrderArr.append(callingOrderArr[0])
}
callingOrderArr.remove(at: 0)
}
print(counter)