공지: 기존 사이트는 old.codingdojang.com에서 확인할 수 있으며, 2026년 8월 3일 종료됩니다.
다음 입사문제 중에서
1차원의 점들이 주어졌을 때, 그 중 가장 거리가 짧은 것의 쌍을 출력하는 함수를 작성하시오. (단 점들의 배열은 모두 정렬되어있다고 가정한다.)
예를들어 S={1, 3, 4, 8, 13, 17, 20} 이 주어졌다면, 결과값은 (3, 4)가 될 것이다.
+2
답들을 보니까 다들 S = {1, 3 ,4 ,8, 13 ,17, 20}을 전제로 놓고 푸시던데 문제에선 단지 예의 하나로 되어있지 않나요? 그럼 1차원 점들까지 입력을 하고 해야한다는 얘기 같은데..?
-
李愼言(이신언),
2017/03/21 07:10
+7
만약 S 안에 최소거리가 같은 점들의 쌍이 두개 이상이라면 모두 찾아야 하지 않을까요? 주어진 풀이를 보면 차이가 1인 (3,4) 가 하나이기 때문에 그렇게 나오지만 s = [1,2,4,5,8,15,19] 라면 (1,2), (4,5) 를 모두 찾아야 할텐데요.풀이들을 보면 첫 (1,2) 만 나오게 되네요. 정렬되어 있다는 것은 가정되어 있지만 숫자집합은 예를 든것이므로, 모두 표시하는 구문이 더 필요합니다.
-
예강효빠,
2017/04/13 05:13
732개의 풀이가 있습니다.
python 2.7
>>> s= [1, 3, 4, 8, 13, 17, 20]
>>> pairs = zip(s[0:], s[1:])
>>> pairs.sort(key=lambda x:x[1]-x[0])
>>> print pairs[0]
(3, 4)
오 zip 과 lambda를 이렇게 이용하는군요 코드올려주셔서 감사합니다
-
정지원,
2015/11/30 21:06
s= [1,3, 7, 4, 8, 13, 17, 20]로 하면,
(7, 4)이 나와요.. 정답은 (3,4)인데요..
-
hana11,
2015/12/30 20:06
+1
hana11 // 문제가 정렬되어 있다는 가정이 있어서...
-
카카달려,
2016/01/07 21:34
이거 2.7 버전에서 돌아가나요? 3.5에선 내장함수 zip 은 sort 가 없다고 나오는데 말이죠
2.7 레퍼런스도 찾아 봤지만 없는거 같아서요
zip 으로 묶어주는 발상은 천재적이네요
-
Lee Do Yun,
2016/07/27 17:24
+2
python2에서는 zip의 return이 list였어서 sort를 호출할 수 있었습니다.
python3에서는 zip의 return이 zip object입니다.
list()로 감싸주시면 list가 나옵니다.
python 3.5
>>> s= [1, 3, 4, 8, 13, 17, 20]
>>> pairs = list(zip(s[0:], s[1:]))
>>> pairs.sort(key=lambda x:x[1]-x[0])
>>> print pairs[0]
(3, 4)
-
Park Minwoo,
2016/07/27 17:51
+5
zip 과 lambda 를 사용하는 것은 인상적입니다. 그러나
만약 S 안에 최소거리가 같은 점들의 쌍이 두개 이상이라면 모두 찾아야 하지 않을까요? 주어진 풀이를 보면 차이가 1인 (3,4) 가 하나이기 때문에 그렇게 나오지만 s = [1,2,4,5,8,15,19] 라면 (1,2), (4,5) 를 모두 찾아야 할텐데요.
코드대로라면 (1,2) 만 나오게 되네요.
-
예강효빠,
2017/04/13 04:10
어느 한점과 바로 옆의 점의 거리가 최소값이라면 이방식으로 정답을 구하면 엄청 빠르겠네요 대단하네요
-
박영호ㅋㅋ,
2017/08/09 13:50
python 3.8.1에서 아래와 같이 위 식을 응용했습니다. 정말 대단합니다.
>>>s= [1, 3, 4, 8, 13, 17, 20]
>>>pairs = zip(s[0:], s[1:])
>>>print (list(sorted(pairs,key=lambda x:x[1]-x[0]))[0])
위의 식에서 아래와 같이 바꾸어 반복되는 최솟값을 출력할 수 있도록 해보았습니다.
>>>print(pairs[0])
-> >>>print (list( pairs[x] for x in range(len(pairs)) if int(pairs[x][1])-int(pairs[x][0]) == int(pairs[0][1]) - int(pairs[0][0])))
-
mr. gimp,
2020/01/16 03:46
print (list( pairs[x] for x in range(len(pairs)) if int(pairs[x][1])-int(pairs[x][0]) == int(pairs[0][1]) - int(pairs[0][0]))) 위에서 list 해줬는데 여기서 왜 다시 list 해야 하는지 설명 해 주실 수 있으실까요?
-
yunjae,
2022/04/12 18:01
def spair(S):
dict = {}
for (x, y) in zip(S[:-1], S[1:]):
if not dict.get(y-x):
dict[y-x] = [(x,y)]
else:
dict[y-x] = dict[y-x] + [(x,y)]
return dict[min(dict.keys())]
S = [1, 3, 4, 8, 13, 17, 20]
#S = [1,2,4,5,8,15,19]
print(spair(S))
님 풀이가 가장 훌륭하네요. ㅇㅈ.
-
추천은 다 읽음,
2018/02/07 10:42
최소값이 여러개라도 정확하게 걸러지는군요! 멋집니다.
-
mr. gimp,
2020/01/16 02:21
# 한글 처리 in Atom 1.21.1 + Anaconda(Python 3.6.3)
import sys
import io
sys.stdout = io.TextIOWrapper(sys.stdout.detach(), encoding='utf-8')
sys.stderr = io.TextIOWrapper(sys.stderr.detach(), encoding='utf-8')
# 다음 입사문제 중에서
# 1차원의 점들이 주어졌을 때, 그 중 가장 거리가 짧은 것의 쌍을 출력하는 함수를 작성하시오. (단 점들의 배열은 모두 정렬되어있다고 가정한다.)
import random
# points = list({1, 3, 4, 8, 13, 17, 20})
points = list(set(list([random.randint(1,100) for i in range(10)])))
points.sort()
print("수직선 위 점들은 ", points)
# 최소 거리의 점쌍을 모음
distances = [[points[0], points[1], points[1]-points[0]]]
for p1 in range(1,len(points)-1):
left = points[p1]
right = points[p1+1]
distance = right - left
if distances[0][2] > distance:
distances = [[left, right, distance]]
elif distances[0][2] == distance:
distances += [[left, right, distance]]
print("가장 짧은 거리는", distances[0][2], ": ", end='')
for i in range(len(distances)):
if i == len(distances)-1:
print(distances[i][0],"~",distances[i][1],end='')
else:
print(distances[i][0],"~",distances[i][1],end=', ')
이 분이 하신게 '진짜'네! 다른사람들은 예를 든걸로 coding 했지만, 이분은 랜덤으로 돌려서 하시네 으..존경
-
june davis,
2017/12/19 11:31
어쩌피 거리가 가장 짧은 두 점을 찾는거니까, 미리 sort 해 두어 이웃한 점 끼리만 거리를 비교해도 충분하군요... 감사합니다!
-
Choi BH,
2019/06/27 15:23
더 깔끔하게 짜주실 분 있을거라 믿습니다. ㅜ,ㅠ
public class MinDistance {
public static void main(String[] args) {
int[] s={1, 3, 4, 8, 13, 17, 20};
System.out.println(findMinDist(s));
}
private static String findMinDist(int[] input) {
int mVal = 0;
String result = null;
for(int i=0;i<input.length-1;i++){
int tempVal = input[i+1] - input[i];
if(result != null){
if(tempVal < mVal){
mVal = tempVal;
result = "(" + input[i] + "," + input[i+1] +")";
}
}else{
mVal = tempVal;
result = "(" + input[i] + "," + input[i+1] +")";
}
}
return result;
}
}
S = [1, 3, 4, 8, 13, 17, 20]
shortest = S[1]-S[0]
index = 0
for g in range(1,len(S)):
if S[g]-S[g-1] < shortest:
shortest = S[g]-S[g-1]
index = g
print S[index-1], S[index]
/* C++ code 1차원 배열의 최대길이가 주어지지 않았으므로 그냥 O(n^2) brute force algorithm 으로 해결합니다. Sample input: 7 1 3 4 8 13 17 20 Sample output: (3,4) */ #include <iostream> #include <cstdio> #include <vector> #include <algorithm> using namespace std; #define INF 987654321 // 어떤 큰 수 int main(){ int n; scanf("%d",&n); // 배열의 길이 vector<int> v; for (int i = 0; i < n; i++){ int num; scanf("%d",&num); v.push_back(num); } int idx1,idx2,min_dist = INF; for (int i = 0; i < n; i++){ for (int j = i+1; j < n; j++){ if (min_dist > abs(v[i]-v[j])){ idx1 = i,idx2 = j; min_dist = abs(v[i]-v[j]); } } } printf("(%d,%d)\n",v[idx1],v[idx2]); return 0; }
#include <stdio.h>
int main (void)
{
int S[] = { 1,3,4,8,13,17,20 };
int i = 0, j = 0;
int MIN = 0;
int MIN_INDEX1 = 0, MIN_INDEX2 = 0;
MIN = S[6] - S[0];
for (i = 0; i < 6; i++)
{
for (j = 6; j > 0+i; j--)
{
if (S[j] - S[i] < MIN && (S[j] - S[i] > 0))
{
MIN = S[j] - S[i];
MIN_INDEX1 = S[i];
MIN_INDEX2 = S[j];
}
}
}
printf("%d , %d\n", MIN_INDEX1, MIN_INDEX2);
return 0;
}
알고리즘을 정말 못해서...하하핳ㅎ하하하
(C언어 사용)
#include <stdio.h>
void minDistance(int* p_arr, int len)
{
int i, dis, mindis; // 두 점 사이의 거리, 두 점 사이의 거리의 최소값
for (i = 1; i < len; i++) // [두 점 사이의 거리의 최소값] 먼저 구하기
{
dis = p_arr[i] - p_arr[i-1];
if (i == 1)
mindis = dis;
else if (dis < mindis)
mindis = dis;
}
for (i = 1; i < len; i++) // [두 점 사이의 거리]가 [두 점 사이의 거리의 최소값]과 같을때 [두 점]을 출력하기
{
if ((p_arr[i] - p_arr[i-1]) == mindis)
printf("(%d, %d)\n", p_arr[i-1], p_arr[i]);
}
}
void main() //메인함수에서 각 점들의 배열을 임의적으로 입력하면 최소값이 중복되더라도 모두 출력됨
{
int arr[] = {1, 3, 4, 8, 13, 17, 20};
minDistance(arr, sizeof(arr)/sizeof(int));
}
i = 0
s = []
while i < 7:
s.append(int(input('점 입력 : ')))
i += 1
s.sort()
print(s)
i = 0
min = 0
dd = []
ss = abs(s[i] - s[i+1])
min = ss
while i < 6:
ss = abs(s[i] - s[i+1])
if ss < min:
dd[i] = [s[i],s[i+1]]
min = ss
elif ss == min:
dd.append([s[i],s[i+1]])
i += 1
print(dd)
Ruby.
def get_min_distance_ponts(points)
points.each_cons(2).to_a.min{|a, b| a.inject(&:-).abs <=> b.inject(&:-).abs}
end
package test;
/*
* S={1, 3, 4, 8, 13, 17, 20}
*/
public class Daum {
static int[] S={1, 3, 4, 8, 13, 17, 20} ;
public static void main(String args[]) {
new Daum().findMinDistance(S);
}
void findMinDistance(int[] S) {
int min = 10000 ;
int[] result = new int[2];
for ( int i=0 ; i < S.length-1 ; i++) {
int distance = S[i] - S[i+1];
if ( distance < 0 ) distance *= -1;
if ( min > distance) {
min = distance;
result[0]=S[i];
result[1]=S[i+1];
}
}
System.out.println(min + " " + result[0] + " " + result[1]);
}
}
/*
* 1차원의 점들이 주어졌을 때, 그 중 가장 거리가 짧은 것의 쌍을 출력하는 함수를 작성하시오. (단 점들의 배열은 모두 정렬되어있다고 가정한다.)
예를들어 S={1, 3, 4, 8, 13, 17, 20} 이 주어졌다면, 결과값은 (3, 4)가 될 것이다.
*/
public class b_arrayMinDist {
public static void main(String[] args) {
int[] s = {1,3,4,8,13,17,20};
int min = 100000; int idx = 0;
for(int i = 0 ; i < s.length-1 ; i ++){
if(min > s[1+i]-s[i]){
min = s[i+1]-s[i];
idx = i;
}
}
System.out.println("result = (" + s[idx] + "," + s[idx+1]+")");
}
}
#데이터
s = [1,3,4,8,13,17,20]
#처리
def short(src):
distance = []
for k in range(len(src)-1):
distance.append(src[k+1]-src[k])
m = min(distance)
for l in range(len(distance)):
if distance[l] == m :
return print(src[l],src[l+1])
#입출력
short(s)
% MATLAB
function p = Solution(S)
[~,ind] = min(abs(difference(S)));
p = S(ind+(0:1));
end
function m = difference(S)
% 정렬이 되어있으므로 S(i+1) - S(i) 값이 가장 가까운 차이가 됨
m = S(2:end) - S(1:end-1);
end
파이썬입니다.
data = [1, 3, 4, 8, 13, 17, 20]
def shortest(lst):
result_list = []
for i in range(len(data)-1):
result_list.append(lst[i+1] - lst[i]) # 거리를 차례로 계산해 리스트에 저장
index = result_list.index(min(result_list)) # 가장 짧은 길이의 인덱스
return (lst[index], lst[index+1]) # 인풋 데이터 리스트에서 대응하는 값을 리턴한다
print(shortest(data))
그런데 이런 코드의 경우 만약 min 값이 여러개리냔 어떻게하나요?
-
Biz,
2016/12/06 07:48
// 문제에 최소의 거리를 모두 표시하라는 이야기는 없지만 왠지 모두 표시하는게 적합할것 같아서
// 모든 최소거리를 출력 해봤습니다
// 이미 정렬 되어있다는 가정이 있으므로 그부분은 제외하고 짜봤습니다
// 만약 데이타 형식이 int 형이 아닌 부동소수점이라면 제대로 작동되지 않습니다
// 부동 소수점 자료형은 연산 과정에서 그 값이 딱 떨어지지 않기 때문입니다
// 비교 함수를 사용하거나, 다른 방법으로 구현하여야 합니다
int[] s = { -10, -5, -4, 0, 1, 3, 7, 8, 13, 17, 20 };
if (s.Length < 2) return;
List<int> minIndexList = new List<int>();
int min = s[1] - s[0];
for (int i = 0; i < s.Length - 1; i++)
{
int dis = Math.Abs(s[i + 1] - s[i]);
if (dis < min)
{
min = dis;
minIndexList = new List<int>();
minIndexList.Add(i);
}
else if (dis == min) minIndexList.Add(i);
}
foreach (int minIndex in minIndexList)
{
Console.WriteLine(string.Format(
"Minimum Distance(index[{0},{1}]) : ({2}, {3})",
minIndex, minIndex + 1, s[minIndex], s[minIndex + 1]));
}
결과
- Minimum Distance(index[1,2]) : (-5, -4)
- Minimum Distance(index[3,4]) : (0, 1)
- Minimum Distance(index[6,7]) : (7, 8)
s = [1,3,4,8,13,14,20]
#a = int(input("입력할 수의 갯수 : "))
#s = sorted([int(input("입력 : ")) for i in range(a)])
b = [[s[i],s[i+1]] for i in range(len(s)-1)]
c = [b[i][1]-b[i][0] for i in range(len(b))]
d = [b[i] for i, j in enumerate(c) if j == min(c)]
print(d)
enumerate를 활용해봤습니다.
C언어로 작성했습니다.
#include<stdio.h>
#include<math.h>
#include<stdlib.h>
#define 실행1차원 1 // 1차원 2차원 3차원 모두 짜봤습니다. 조건부 컴파일 (기본값 1차원)
// 정렬 여부 상관없고 음수 가능하며, 정수만 입력 받을수 있습니다. 2차원 이상의 경우 거리값은 실수 출력
// 본 문제는 f1d 에 해당 될겁니다.
void f1d();
void f2d();
void f3d();
double diagonal2d(int x1, int y1, int x2, int y2);
double diagonal3d(int x1, int y1, int z1, int x2, int y2, int z2);
int main() {
#if(실행1차원)
f1d();
#elif(실행2차원)
f2d();
#elif(실행3차원)
f3d();
#endif
return 0;
}
void f1d()
{
int iPointquantity, iTemp = -1, iPrintcount = 0;
int *aPoint;
printf("1차원상 점들의 개수를 입력해주세요 : ");
scanf("%d", &iPointquantity);
aPoint = (int*)malloc(sizeof(int)*iPointquantity); // 점 개수만큼 메모리 확보
printf("1차원상 점들의 좌표를 입력해주세요 \n");
for (int i = 0; i<iPointquantity; i++)
{
printf("%d번 좌표:", i + 1);
scanf("%d", &aPoint[i]); //입력받은 개수 만큼 좌표를 입력 받습니다.
}
for (int i = 0; i<(iPointquantity - 1); i++) // 일단은 최소거리만 구합니다.
{ //최소거리 점 쌍이 두개 이상 일 수 있으니까요
for (int j = i + 1; j<iPointquantity; j++)
{
if (iTemp == -1)
{
iTemp = abs(aPoint[j] - aPoint[i]);
}
else if (iTemp>abs(aPoint[j] - aPoint[i]))
{
iTemp = abs(aPoint[j] - aPoint[i]);
}
}
}
printf("최소거리 : %d\n", iTemp); //최소거리 출력
for (int i = 0; i<(iPointquantity - 1); i++) //이제 최소거리와 일치하는 점쌍을 출력합니다.
{
for (int j = i + 1; j<iPointquantity; j++)
{
if (iTemp == abs(aPoint[j] - aPoint[i]))
{
iPrintcount++;
printf("최소거리 두 지점 %d번째: %d, %d\n", iPrintcount, aPoint[i], aPoint[j]);
}
}
}
free(aPonint);
return;
}
void f2d() //1차원가 마찬가지. 다만 2차원 거리 구하기를 별도의 함수로 두고 실수를 결과값으로 받습니다.
{
int iPointquantity, iPrintcount = 0;
int *aPoint_x, *aPoint_y;
double dTemp = -1.0;
printf("2차원상 점들의 개수를 입력해주세요 : ");
scanf("%d", &iPointquantity);
aPoint_x = (int*)malloc(sizeof(int)*iPointquantity);
aPoint_y = (int*)malloc(sizeof(int)*iPointquantity);
printf("2차원상 점들의 좌표를 입력해주세요 \n");
for (int i = 0; i<iPointquantity; i++)
{
printf("%d번 x 좌표:", i + 1);
scanf("%d", &aPoint_x[i]);
printf("%d번 y 좌표:", i + 1);
scanf("%d", &aPoint_y[i]);
}
for (int i = 0; i<(iPointquantity - 1); i++)
{
for (int j = i + 1; j<iPointquantity; j++)
{
if (dTemp == -1)
{
dTemp = diagonal2d(aPoint_x[i], aPoint_y[i], aPoint_x[j], aPoint_y[j]);
}
else if (dTemp>diagonal2d(aPoint_x[i], aPoint_y[i], aPoint_x[j], aPoint_y[j]))
{
dTemp = diagonal2d(aPoint_x[i], aPoint_y[i], aPoint_x[j], aPoint_y[j]);
}
}
}
printf("최소거리 : %f\n", dTemp);
for (int i = 0; i<(iPointquantity - 1); i++)
{
for (int j = i + 1; j<iPointquantity; j++)
{
if (dTemp == diagonal2d(aPoint_x[i], aPoint_y[i], aPoint_x[j], aPoint_y[j]))
{
iPrintcount++;
printf("최소거리 두 지점 %d번째: %d(%d,%d) , %d(%d,%d)\n", iPrintcount, i + 1, aPoint_x[i], aPoint_y[i], j + 1, aPoint_x[j], aPoint_y[j]);
}
}
}
free(aPoint_x);
free(aPoint_y);
return;
}
void f3d()
{
int iPointquantity, iPrintcount = 0;
int *aPoint_x, *aPoint_y, *aPoint_z;
double dTemp = -1.0;
printf("3차원상 점들의 개수를 입력해주세요 : ");
scanf("%d", &iPointquantity);
aPoint_x = (int*)malloc(sizeof(int)*iPointquantity);
aPoint_y = (int*)malloc(sizeof(int)*iPointquantity);
aPoint_z = (int*)malloc(sizeof(int)*iPointquantity);
printf("3차원상 점들의 좌표를 입력해주세요 \n");
for (int i = 0; i<iPointquantity; i++)
{
printf("%d번 x 좌표:", i + 1);
scanf("%d", &aPoint_x[i]);
printf("%d번 y 좌표:", i + 1);
scanf("%d", &aPoint_y[i]);
printf("%d번 z 좌표:", i + 1);
scanf("%d", &aPoint_z[i]);
}
for (int i = 0; i<(iPointquantity - 1); i++)
{
for (int j = i + 1; j<iPointquantity; j++)
{
if (dTemp == -1)
{
dTemp = diagonal3d(aPoint_x[i], aPoint_y[i], aPoint_z[i], aPoint_x[j], aPoint_y[j], aPoint_z[j]);
}
else if (dTemp>diagonal2d(aPoint_x[i], aPoint_y[i], aPoint_x[j], aPoint_y[j]))
{
dTemp = diagonal3d(aPoint_x[i], aPoint_y[i], aPoint_z[i], aPoint_x[j], aPoint_y[j], aPoint_z[j]);
}
}
}
printf("최소거리 : %f\n", dTemp);
for (int i = 0; i<(iPointquantity - 1); i++)
{
for (int j = i + 1; j<iPointquantity; j++)
{
if (dTemp == diagonal3d(aPoint_x[i], aPoint_y[i], aPoint_z[i], aPoint_x[j], aPoint_y[j], aPoint_z[j]))
{
iPrintcount++;
printf("최소거리 두 지점 %d번째: %d(%d,%d,%d) , %d(%d,%d,%d)\n",
iPrintcount, i + 1, aPoint_x[i], aPoint_y[i], aPoint_z[i], j + 1, aPoint_x[j], aPoint_y[j], aPoint_z[j]);
}
}
}
free(aPoint_x);
free(aPoint_y);
free(aPoint_z);
return;
}
double diagonal2d(int x1, int y1, int x2, int y2) //2차원 두점 거리 구하기
{
double diagonal;
diagonal = sqrt((double)((x2 - x1)*(x2 - x1)) + (double)((y2 - y1)*(y2 - y1)));
return diagonal;
}
double diagonal3d(int x1, int y1, int z1, int x2, int y2, int z2) // 3차원 두점 거리 구하기
{
double diagonal;
diagonal = sqrt((double)((x2 - x1)*(x2 - x1)) + (double)((y2 - y1)*(y2 - y1))+ (double)((z2 - z1)*(z2 - z1)));
return diagonal;
}
초보라 할당해제 빼먹었었네요 ㅜㅜ;; 추가했습니다.
- 가장 가까운 점들의 쌍이 복수일 경우, 모두 출력합니다.
- '0'을 제외한 모든 정수를 지원합니다. (1차원 점들은 모든 음수가 위치할 수 있기 때문)
- 100개 까지의 점만 지원합니다. (ArrayList 제한을 임의로 늘릴 수는 있지만, '999999' 등의 숫자는 깔끔해보이지 않아서 100으로 설정했습니다. 배열을 임의로 추가하는 점 갯수까지만 생성하는 방법을 모르겠습니다.
문제를 완벽히 해결하는 코드는 아닙니다. '0'을 점의 위치로 지정할 수 없습니다.(코드 내에서 0이 점 생성을 취소하는 명령으로 대체되었기 때문)
일일이 점을 추가하는게 불편해서 while문으로 점을 계속 추가하게 해뒀는데, 그 과정에서 점 생성을 취소하는 명령을 '0' 입력으로 대체했습니다. 스캐너 입력을 String으로 하고, String 입력된 수를 int로 변환한다면 이 단점마저 개선되지만, 아직까지는 String > int 변환 방법을 알지 못해서 우선 이렇게만 코딩했습니다.
import java.util.*;
public class DaumMatter {
public static void main(String[] args) {
@SuppressWarnings("resource")
Scanner sc = new Scanner(System.in);
int[] pointArray = new int[101]; boolean setting = true; int choose;
while(setting) {
System.out.println("┌────────────────────┐");
System.out.println("│ 1. 점 생성 2. 점 목록 3. 거리 계산 │");
System.out.println("└────────────────────┘");
choose = sc.nextInt();
System.out.println("");
if(choose == 1) {
if(pointArray[1] == 0) {
System.out.println("NOTICE : 최대 100번째 수 까지 입력 가능합니다.");
System.out.println("NOTICE : 입력 취소를 원할 경우 '0'을 입력하세요.");
for(int pointNum = 1; pointNum <= 100; pointNum++) {
System.out.print(pointNum +"번째 수를 입력하세요 > ");
int inputNum = sc.nextInt();
if(inputNum == 0) {
break;
} else if(pointNum == 1 || pointArray[pointNum-1] < inputNum) {
pointArray[pointNum] = inputNum;
} else {
System.out.println("이전에 입력한 점의 수(" +pointArray[pointNum-1] +")보다 더 큰 수를 입력해야 합니다.");
pointNum--;
}
}
System.out.println("점 세팅을 완료합니다.");
} else {
System.out.println("이미 입력된 점(들)이 있기 때문에 프로그램 재가동이 필요합니다.");
System.out.println("시스템을 종료합니다.");
setting = false;
}
} else if(choose == 2) {
for(int pointNum = 1; pointNum < 100; pointNum++) {
if(pointArray[pointNum] != 0) {
System.out.println(pointNum +"번째 점 : " +pointArray[pointNum]);
}
}
} else if(choose == 3) {
System.out.println("점 거리 계산을 시작합니다.");
System.out.println(".");
int[] pointDistance = new int[100];
for(int count = 1; count < 100; count++) {
if(pointArray[count + 1] != 0) {
pointDistance[count] = (pointArray[count + 1] - pointArray[count]);
}
}
System.out.println("모든 점들 사이의 가장 가까운 거리들을 추출합니다.");
System.out.println(".");
int minDistance = pointDistance[1];
for(int count = 2; count < 100; count++) {
if(minDistance > pointDistance[count]) {
if(pointDistance[count] != 0) {
minDistance = pointDistance[count];
}
}
}
System.out.println("가장 가까운 거리들의 쌍을 모두 출력합니다.");
System.out.println(".");
System.out.println(minDistance);
for(int count = 1; count < 100; count++) {
if(minDistance == pointDistance[count]) {
System.out.println("(" +pointArray[count] +", " +pointArray[count+1] +")");
}
}
setting = false;
} else {
System.out.println("잘못된 입력입니다.");
}
}
}
}
s <- c(1, 3, 4, 8, 13, 17, 20)
sh <- function(s){
res <- NULL
for(i in 1:NROW(s)-1){ res <- c(res, s[i+1] - s[i]) }
return(paste("(",s[which(res == min(res))],",",s[which(res == min(res))+1],")",sep = ''))
}
sh(s)
S={1, 3, 4, 8, 13, 17, 20} # 문제
sList = list(S) # sort하기 위하여 list로 형변환
sList.sort() # 점 위치순 정렬 (문제에서 이미 정렬되었다고 했으므로 사실 불필요)
dic = {} # {거리: [(점1, 점2),..]}로 정리하기 위한 딕셔너리 변수 선언
for (x1,x2) in zip(sList[:-1], sList[1:]): # zip으로 두 점 좌표 생성 후 반복문 돌림
if not dic.get(x2-x1): # 키(거리)가 없으면,
dic[x2-x1] = [(x1,x2)] # 키(거리) 및 해당 값(두 점 좌표) 신규 생성
else: # 키(거리)가 이미 등록되어 있으면,
dic[x2-x1].append((x1,x2)) # 해당 키에 값(두 점 좌표) 추가
print(dic[min(dic.keys())]) # 최소 키값에 대한 value 출력
c = []
while True :
s = input("Input : ") #점 입력
if s == "done" :
break
c.append(int(s))
c.sort() #점 정렬
m = c[len(c)-1]-c[0]
result = []
for n in range(0, len(c)-1) :
if c[n+1]-c[n] < m : #최소값 갱신
m = c[n+1]-c[n]
result = [[c[n], c[n+1]]]
elif c[n+1]-c[n] == m : #최소값과 같은 거리가 나왔을 때 처리
result.append([c[n], c[n+1]])
print(result)
결과
Input : 1
Input : 2
Input : 4
Input : 5
Input : 8
Input : 15
Input : 19
Input : done
[[1, 2], [4, 5]]
(fn [S]
(let [values (for [pair (partition 2 1 S)]
[pair (apply - pair)])]
(-> (sort-by second values) last first)))
Clojure 코드입니다.
파이썬입니다. 아닉 내공이 모잘라서 1차원적인 풀이네요^^;
s={1,3,5,8,13,17,20,21,56,99,131}
_list = list(s)
_list.sort()
chkNumber = 0
currentAnswer = ""
for n in range(1,len(_list)):
if n == 1:
chkNumber = _list[n] - _list[n-1]
currentAnswer = str(_list[n-1])+","+str(_list[n])
else:
if(_list[n] - _list[n-1]) < chkNumber:
chkNumber = _list[n] - _list[n-1]
currentAnswer = str(_list[n-1])+","+str(_list[n])
print(currentAnswer)
sort(combn(c, 2)[,which.min(apply(combn(c, 2), 2, function(x) diff(range(x))))])
R로 풀었습니다
입력 받는 벡터는 정렬되어 있지 않아도 상관 없습니다
> c=c(1, 3, 12, 8, 13, 24, 20)
> sort(combn(c, 2)[,which.min(apply(combn(c, 2), 2, function(x) diff(range(x))))])
[1] 12 13
clojure
(defn get-shortest [lst]
(->> lst
reverse
(partition 2 1)
(sort-by #(apply - %))
first
reverse))
(get-shortest [1 3 4 8 13 17 20])
s = [1,3,4,8,13,17,20]
def near_point (s):
difference = []
index = 0
for i in range(len(s)):
if s[i] != s[len(s)-1]:
difference.append(s[i+1]-s[i])
index += difference.index(min(difference))
print "(%d,%d)" % (s[index], s[index+1])
near_point(s)
i번째와 i+1번째 들의 각 숫자의 차이값을 difference 리스트로 저장한 다음 그 중 가장 작은 값의 i번째와 i+1번째의 숫자를 출력하는 알고리즘
list=[1,5,6,9,13,17,20]
Min=100000
for n in range(len(list)-1):
distance=list[n+1]-list[n]
if distance < Min :
MinPair=(list[n],list[n+1])
Min=distance
print MinPair
살짝 자바스럽게 코딩해 봤습니다.
import static org.junit.Assert.*;
import java.util.ArrayList;
import org.junit.Test;
class Set {
public class Pair {
int first;
int last;
public int distance() {
return last-first;
}
}
ArrayList<Pair> pairs = new ArrayList<Pair>();
public Set(int[] set) {
for(int i=0; i<set.length-1; i++) {
Pair pair = new Pair();
pair.first = set[i];
pair.last = set[i+1];
pairs.add(pair);
}
}
public Pair shortest() {
int min = Integer.MAX_VALUE;
Pair result = null;
for(Pair pair: pairs) {
if (pair.distance() < min) {
result = pair;
min = pair.distance();
}
}
return result;
}
}
public class DaumTest {
@Test
public void test() {
Set set = new Set(new int[]{1,3,4,8,13,17,20});
assertEquals(3, set.shortest().first);
assertEquals(4, set.shortest().last);
}
}
int min = 100;
String minVlaue = "";
int arr[]= {1, 3, 4, 8, 13, 17, 20};
for(int i=0; i<arr.length; ++i) {
for(int k=0; k<arr.length; ++k) {
int point = 0;
if(arr[i] < arr[k]) {
point = arr[k] - arr[i];
} else {
point = arr[i] - arr[k];
}
if(0 != point && min > point) {
min = point;
minVlaue = arr[i] +","+ arr[k];
}
}
}
Log.v("", "kdw vlaue:"+minVlaue);
public class FindPair {
public static int length = 9999;
public static int firstPair =0;
public static int secondPair =0;
public static void main(String[] args) {
int[] array = {19,3,15,8,13,25,20};
findPair(array, 0);
System.out.println(firstPair+" "+secondPair);
}
public static void findPair(int[] array,int index) {
int standard = array[index];
if(index==array.length-1) return;
for(int i=index+1;i<array.length;i++){
int result = Math.abs(standard-array[i]);
if(result<length){
length = result;
firstPair = standard;
secondPair= array[i];
}
}
findPair(array, index+1);
}
}
Python 2.7 입니다 가장 짧은곳이 여러군데 일경우 먼저 나온것만 출력됩니다..
s = [1,3,4,8,13,17,20]
s.sort()
result = []
for i in range(len(s)):
if i <len(s)-1:
result.append((s[i+1]-s[i]))
i = result.index(min(result))
print 'minimum couple = %d and %d'% (s[i],s[i+1])
public class DistanceFinder {
private int[] num=new int[]{1,3,4,8,13,17,20};
public int minDt=num[num.length-1];
public int[] result=new int[2];
public void finder(){
for(int i=0;i<num.length-1;i++)
minDt=compareValue(minDt,num[i+1],num[i]);
}
public int compareValue(int compare, int prv, int nxt){
int minusNum=prv-nxt;
if(compare>minusNum) {
result[0]=prv;
result[1]=nxt;
return minusNum;
}else return compare;
}
public static void main(String args[])throws Exception{
DistanceFinder c=new DistanceFinder();
c.finder();
System.out.println("result : "+Arrays.toString(c.result) +"minValue : "+c.minDt);
}
}
파이썬 기능활용법좀 알려주세요ㅠㅠ
s = [1,5,8,12,17,20]
n1 = s[0]
n2 = s[1]
def STAR (s):
global n1,n2
m = len(s)-1
if s[m] - s[m-1] <= n2 - n1:
n1 = s[m-1]
n2 = s[m]
if m == 1: print(n1,n2)
else:STAR(s[0:m])
STAR(s)
s=[1, 3, 8, 5, 10, 31, 20]
s.sort()
min=32767
for i in range(0,6):
dist=s[i+1]-s[i]
if dist<min:
pair_a=s[i+1]
pair_b=s[i]
min=dist
print(pair_a,'-',pair_b, '=', min)
import random
class S:
s=[]
min_index=0
def setRandom(self):
for i in range(0, 10):
while(1):
a=random.randint(0,1000)
try:
self.s.index(a)
except:
self.s.append(a)
break
self.s.sort()
def cmpAB(self):
min=self.s[len(self.s)-1] - self.s[0]
for i in range(0, 9):
if min > (self.s[i+1]-self.s[i]):
min=(self.s[i+1]-self.s[i])
self.min_index=i
def main():
a=S()
a.setRandom()
a.cmpAB()
print(a.s)
print(a.s[a.min_index],a.s[a.min_index+1],
"차이값 :",(a.s[a.min_index+1]-a.s[a.min_index]))
main()
초기 리스트 값을 랜덤으로 만들고 최소값 초기값을 유동적이게 만들었습니다.
파이썬 입니다.
# cod_chai.py
s = [1,3,4,8,13,17,20]
leastnum = 0
chainum = 0
result =""
for num in range(1,len(s)):
chainum = s[num] - s[num-1]
if num == 1 or chainum < leastnum:
leastnum = chainum
result = str(s[num-1])+","+str(s[num])
print("result = %s" % result)
결과
result = 3,4
def shortpath(S):
i = 0
path = 0
shortest = [0,0]
shortpath = []
while i < len(S)-1:
path = S[i+1] - S[i]
if path < shortest:
shortest = path
shortpath = [S[i],S[i+1]]
i += 1
print shortpath
S = [1,3,4,8,13,17,20]
shortpath(S)
javascript 버전 입니다. 다른 분이 올려주시는 소스는 정말 신기하내요...
function findMinDistance(input){
var returnValue = [-1, -1];
// javascript에서는 이렇게 sort 할수 있내요..
input.sort(function(a,b){return a-b});
// 빈 배열을 만들고, 0으로 설정..
var max = input[input.length-1];
var data = new Array();
for(var j=0; j<=max; j++){
data.push(0);
}
// 넘어온 배열의 값을 index로 해서, 1로 설정..
// 0,1,0,1,1,0,.... 이렇게 변경.
for(var j=0; j<input.length; j++){
data[input[j]] = 1;
}
// 거리를 증가시키면서, 배열에서 2가지가 모두 1인 것을 찾음.
for (var distance=1; distance<data.length-1; distance++){
for (var index=0; index<data.length-1; index++){
if (data[index]==1 && data[index+distance]==1){
returnValue[0] = index;
returnValue[1] = index+distance;
break;
}
}
if (returnValue[0]>-1) {
break;
}
}
return returnValue;
}
console.log(findMinDistance([1,3,4,8,13,17,20]));
console.log(findMinDistance([13,28,5,18,31,23]));
console.log(findMinDistance([1,3,5,8,13,17,20,21,56,99,131]));
결과
[3, 4] [28, 31] [20, 21]
python 2.7.3 이미 정렬되어있다고 가정했기때문에 minDiff값은 index의 마지막값과 처음값의 차이보다 클 수가 없음 처음부터 하나씩 pop하여 diff가 minimum인 경우 answer List를 refresh하는 방법을 사용했음.
arrayIn = raw_input()
problemL = arrayIn.split(' ') #input type : "1 3 4 8 13 17 20"
problemArray = [int(i) for i in problemL]
minDiff = problemArray[-1]-problemArray[0]
answerL = []
while len(problemArray) > 1 :
checkNum = problemArray.pop(0)
diff = 1
while 1 :
if checkNum+diff in problemArray :
if diff < minDiff :
minDiff = diff
answerL = [checkNum,diff]
break
else :
diff += 1
print "Answer : {%d,%d}"%(answerL[0],(answerL[0]+answerL[1]))
파이썬3
tmp_list = [1, 3, 4, 8, 13, 17, 20]
tmp_num = ''
for x in range(0,len(tmp_list)):
if x <= len(tmp_list)-2:
if tmp_num == '':
tmp_num = abs(tmp_list[x] - tmp_list[x+1])
tmp_idx = str(tmp_list[x]) + ', ' + str(tmp_list[x+1])
elif tmp_num > abs(tmp_list[x] - tmp_list[x+1]):
tmp_num = abs(tmp_list[x] - tmp_list[x+1])
tmp_idx = str(tmp_list[x]) + ', ' + str(tmp_list[x+1])
print(tmp_idx)
파이썬3입니다
list=[1,3,4,8,13,17,20]
def shortest(list):
min=list[-1]
index=-1
for i in range(0,len(list)-1):
if min>list[i+1]-list[i]:min=list[i+1]-list[i];index=i
return list[index],list[index+1]
print(shortest(list))
외부 메모리를 사용한 날코딩입니당 --
public class MinDistance {
public static void main(String args[]) {
int[] intArray = {1, 3, 4, 8, 13, 17, 20};
int minus = 0;
Map<Integer, String> map = new HashMap<Integer, String>();
for(int i=0; i<intArray.length-1; i++) {
minus = intArray[i+1] - intArray[i];
map.put(minus, intArray[i] + "," + intArray[i+1]);
}
Map.Entry<Integer, String> next = map.entrySet().iterator().next();
Logger.log(next.getValue());
}
}
PHP 입니다..
function print3($str=FALSE) {
if( ! $str)
$str = "1,3,4,8,13,17,20";
$arr = explode(',',$str);
sort($arr);
$cnt = count($arr);
$cal_cnt = $cnt - 1;
$tval1 = $tval2 = 0;
$ans = '';
for($i=0;$i<$cal_cnt;$i++) {
$tval1 = $arr[$i+1] - $arr[$i];
if($tval2 === 0 OR $tval2 > $tval1) :
$tval2 = $tval1;
$ans = "(".$arr[$i].",".$arr[$i+1].")";
endif;
}
echo $ans;
}
vals = [1, 3, 4, 8, 13, 17, 20]
min = 65534
result = []
for i in range(0, len(vals) - 1, 1):
for j in range(i + 1, len(vals), 1):
diff = abs(vals[i] - vals[j])
if min >= diff:
result = [vals[i], vals[j]]
min = diff
print(result)
오늘도 하나 풀고갑니다~
public class FirstDimensionMinDistance {
public static void main(String[] args) {
// 정렬된 1차원의 점
int[] points = {-20,-13,-7,-2,4,11,17,20,35};
System.out.println(getMinDistance(points));
}
public static String getMinDistance(int[] points){
int distance = Math.abs(points[0] - points[1]);
int num = 0;
for(int i=1;i<points.length-1;i++){
if(distance > Math.abs(points[i] - points[i+1])){
distance = Math.abs(points[i] - points[i+1]);
num = i;
}
}
return("("+points[num]+","+points[num+1]+")");
}
}
public class DaumTest {
static int[] a = {1, 3, 4, 8, 13, 17, 20};
volatile static int minValue = a[1] - a[0];
volatile static int[] winner = {a[0], a[1]};
static void findMin(int i, int j, int z) {
System.out.println(i + " / " + j);
if(z < minValue) {
minValue = z;
winner[0] = i;
winner[1] = j;
}
}
public static void main(String[] args) {
for(int i=1; i < a.length-1; i++) {
findMin(a[i], a[i+1], a[i+1]-a[i]);
}
System.out.println("Winner is " + winner[0] + " and " + winner[1] + " and minValue is " + minValue);
}
}
s = [1, 3, 4, 8, 13, 17, 20]
d = list(map(lambda x, y: abs(x-y), s[1:], s[0:-1]))
print('(%d, %d)' % (s[d.index(min(d))], s[d.index(min(d)) + 1]) )
c++11
#include <iostream>
#include <vector>
class Pair {
public:
Pair(int a, int b):pair_(std::make_pair(a, b)) {}
int first() const {return pair_.first;}
int second() const {return pair_.second;}
int distance() const {return pair_.second - pair_.first;}
bool operator<(const Pair& rhs) const {
return distance() < rhs.distance();
}
private:
std::pair<int, int> pair_;
};
std::ostream& operator<<(std::ostream& out, const Pair& pair) {
return out << "(" << pair.first() << ", " << pair.second() << ")";
}
class Dots {
public:
Dots(const std::vector<int>& v) {
for(size_t i = 0; i < v.size() - 1; ++i)
pairs_.push_back(Pair(v[i], v[i + 1]));
}
Pair closestPair() const {
Pair closest = pairs_[0];
for (auto x : pairs_) if (x < closest) closest = x;
return closest;
}
private:
std::vector<Pair> pairs_;
};
int main() {
std::cout << Dots({1, 3, 4, 8, 13, 17, 20}).closestPair() << std::endl;
return 0;
}
실행
$ g++ 408.cpp -std=c++11 && ./a.out
(3, 4)
파이썬 3.x
def getMinDistance(points) :
i=0
answer = [points[i],points[i+1]]
minNum = points[i+1] - points[i]
for i in range(0,len(points)-1) :
diff = points[i+1] - points[i]
if diff < minNum :
minNum = diff
answer = [points[i],points[i+1]]
i = i+1
return answer
s=[1,3,4,8,13,17,20]
print(getMinDistance(s))
결과
C:\>minDistance.py
[3, 4]
python 3.4로 짠 코드입니다.
import unittest
def distance(dots):
return abs(dots[0] - dots[1])
def separate(array):
a = []
for i in range(len(array) - 1):
a.append([array[i], array[i+1]])
return a
def method1(array):
a = separate(array)
min = a[0]
for i in a:
if distance(i) < distance(min) :
min = i
return min
class TestDistance(unittest.TestCase):
def test_distance(self):
self.assertEqual(distance([0, 1]), 1)
self.assertEqual(distance([2, 5]), 3)
def test_separate(self):
self.assertEqual(separate([1, 2, 3]), [[1, 2], [2, 3]])
def test_solution(self):
s = [1, 3, 4, 8, 13, 17, 20]
self.assertEqual(method1(s), [3, 4])
if __name__ == "__main__":
unittest.main()
my_list = [1, 3, 4, 8, 13, 17, 20]
my_list.sort()
def shortest_path(nodes):
shortest_dis = nodes[1] - nodes[0]
result = ""
for i in range(len(nodes)):
if i == 0:
dis = nodes[i+1] - nodes[i]
if shortest_dis >= dis:
shortest_dis = dis
result = "(" + str(nodes[i]) + "," + str(nodes[i+1]) + ")"
elif i == (len(nodes) - 1):
dis = nodes[i] - nodes[i-1]
if shortest_dis >= dis:
shortest_dis = dis
result = "(" + str(nodes[i-1]) + "," + str(nodes[i]) + ")"
else:
if (nodes[i] - nodes[i-1]) > (nodes[i+1] - nodes[i]):
dis = nodes[i+1] - nodes[i]
if shortest_dis >= dis:
shortest_dis = dis
result = "(" + str(nodes[i]) + "," + str(nodes[i+1]) + ")"
else:
dis = nodes[i] - nodes[i-1]
if shortest_dis >= dis:
shortest_dis = dis
result = "(" + str(nodes[i-1]) + "," + str(nodes[i]) + ")"
return result
print shortest_path(my_list)
scala> val a = Array(1, 3, 4, 8, 17, 30)
scala> ( for(i<-0 until a.length-1) yield (a(i),a(i+1)) ).reduceLeft( (x:Tuple2[Int,Int],y:Tuple2[Int,Int])=>if( (y._2-y._1) > (x._2-x._1) ) x else y )
res70: (Int, Int) = (3,4)
스칼라 버전인데 깔끔하지 못하네요 ^^;;
Java로 다시 짧게.
public class MinDistance {
// 거리가 짧은 것의 쌍을 출력하는 함수
// S={1, 3, 4, 8, 13, 17, 20} 이 주어졌다면, 결과값은 (3, 4)
public static void main(String[] args) {
int[] array = {1, 3, 4, 8, 13, 17, 20};
int min = Integer.MAX_VALUE;
int gap = 0;
String pair = "";
for(int i=0; i<array.length-1; i++){
gap = array[i+1] - array[i];
if(gap < min){
min = gap;
pair = array[i] + "," + array[i+1];
}
}
System.out.println(pair);
}
}
package test;
//전 JAVA 재귀함수로 한번 풀어봤습니다.
public class jTest {
public static void main(String args[]){
// 거리가 짧은 것의 쌍을 출력하는 함수
// S={1, 3, 4, 8, 13, 17, 20} 이 주어졌다면, 결과값은 (3, 4)
int r[] = fac2(6);
System.out.println("가장짧은 값의 쌍은 "+r[1]+"과"+r[0]);
}
static int gap = 1000;
static int distances[] = {0,0};
public static int[] fac2(int n){
int C[] = {1, 3, 4, 8, 13, 16, 20};
if(n < 1){
return distances;
}
if(C[n]-C[n-1] < gap ){
gap = C[n]-C[n-1];
distances[0] = C[n];
distances[1] = C[n-1];
}
return (fac2(n-1));
}
}
#include <stdio.h>
#define SIZE 7
int main(void)
{
int arr[] = {1, 3, 4, 8, 13, 17, 20};
int min = 1000, num1, num2;
for(int i = 0; i < SIZE-1; i++) {
if(min >= arr[i+1] - arr[i]) {
min = arr[i+1] - arr[i];
num1 = arr[i]; num2 = arr[i+1];
}
}
printf("%d %d \n", num1, num2);
return 0;
}
C 버젼입니다. 지적부탁드립니다.
// 언어 : Swift
import Foundation
var data = [ 1, 3, 4, 8, 13, 17, 20 ];
var result = data[1] - data[0]; // 두점의 길이
var index = 0; // 어떤 인덱스의 시작점이 가장 짧은지
for var x=0; x<data.count-1; x++
{
if ( data[x+1] - data[x] < result )
{
result = data[x+1] - data[x];
index = x;
} // 앞의 두점 길이보다 짧으면 시작점 인덱스 저장
}
println("( \(data[index]) \(data[index+1]) )");
public class Thrid {
public static void main(String [] args){
Vector<Integer> v = new Vector<Integer>();
StringTokenizer token;
System.out.println("점들의 위치를 입력해 주세요.");
Scanner scan = new Scanner(System.in);
String point = scan.nextLine();
token = new StringTokenizer(point," ");
while(token.hasMoreTokens()){
v.add(Integer.parseInt(token.nextToken()));
}
minDis(v);
}
private static void minDis(Vector<Integer> v){
int resultLocate = 0;
int result;
if(v.size() > 2)
result = v.elementAt(1) - v.elementAt(0);
else
result = 0;
for(int i=0; i<v.size()-1; i++) {
int temp = v.elementAt(i + 1) - v.elementAt(i);
if (temp < result){
result = temp;
resultLocate = i;
}
}
System.out.println("( " + v.elementAt(resultLocate) + " , "
+v.elementAt(resultLocate+1) + ")");
}
}
s = [1, 3, 4, 8, 13, 17, 20]
min_idx = 1
min_distance = 1000000
idx = 0
for i in range(len(s)-1):
idx = idx+1
dist = s[idx] - s[idx-1]
if dist < min_distance:
min_distance = s[idx]-s[idx-1]
min_idx = idx
var
IntArrary: array[0..6] of Integer = (1,3,4,8,13,17,20);
strTemp: String;
i,Index,subResult,subTemp:Integer;
begin
try
{ TODO -oUser -cConsole Main : Insert code here }
strTemp := 'S={';
subTemp := 10;
for I := 0 to Length(IntArrary) - 1 do
begin
strTemp := strTemp + IntToStr(IntArrary[i]) + ',';
subResult := IntArrary[i+1] - IntArrary[i];
if (subResult < subTemp) then
begin
subTemp := subResult;
Index := i;
end;
end;
strTemp := LeftStr(strTemp,Length(strTemp)-1) + '}';
Writeln(strTemp);
strTemp := 'Result=(';
for i := Index to Index +1 do
strTemp := strTemp + IntToStr(IntArrary[i]) + ',';
strTemp := LeftStr(strTemp,Length(strTemp)-1) + ')';
Write(strTemp);
Readln;
except
on E: Exception do
Writeln(E.ClassName, ': ', E.Message);
end;
파이썬 3.4 입니다.
def min_dist(data):
dist_list=[]
for x in range (len(data)-1):
dist = data[x+1] - data[x]
dist_list.append(dist)
pos = dist_list.index(min(dist_list))
return data[pos:pos+2]
data = [1, 3, 4, 8, 13, 17, 20]
print (min_dist(data))
public static void main(String[] args) {
int[] s={1, 3, 4, 8, 13, 17, 20};
int min=s[1]-s[0];
int minIdx=0;
for(int i=1;i<s.length-1;i++){
if((s[i+1]-s[i])<min){
min=s[i+1]-s[i];
minIdx=i;
}
}
System.out.println(s[minIdx]+","+s[minIdx+1]);
}
using System;
class Program
{
static int[] Points = new int[] { 1, 3, 4, 8, 13, 17, 20 };
static void Main()
{
int point1 = Points[0];
int point2 = Points[1];
int shortest = point2 - point1;
for (var i = 1; i < Points.Length - 1; i++)
{
int distance = Points[i + 1] - Points[i];
if (distance < shortest)
{
shortest = distance;
point1 = Points[i];
point2 = Points[i + 1];
}
}
Console.WriteLine("Answer:: {0}, {1}", point1, point2);
}
}
#include <stdio.h>
#define ARRSIZE(Arr) sizeof(Arr)/sizeof(Arr[0])
int main() {
int arr[] = {1, 3, 4, 8, 13, 17, 20};
int d, dmin = 100, min = 0;
for(int i = 0; i < ARRSIZE(arr) - 1; i++) {
d = arr[i+1] - arr[i];
if(d < dmin) {
dmin = d;
min = i;
}
}
printf("%d, %d", arr[min], arr[min+1]);
return 0;
}
public class Main {
public static void main(String[] ar){
int[] s = {1, 3, 4, 8, 13, 17, 20};
int[] s2 = s.clone();
int min = -1;
int index = -1;
for(int i = 1; i<s.length;i++){
if(i == 1){
min = s2[i]-s[i-1];
index = 0;
}
else if(min > (s2[i]-s[i-1])){
min = s2[i]-s[i-1];
index = i-1;
}
}
System.out.println(s[index]+", "+s[index+1]);
}
}
입력받은 배열을 복사해서 한칸씩 뒤로 밀려서 뺀 후 가작 작은 수의 인덱스를 찾아서 출력하도록 했습니다..
C로 구현하였습니다. 배열이 모두 정렬되어있다고 가정하였으므로 배열의 처음부터 두개씩 비교해 나가면서 최소값을 갱신시키는 알고리즘 입니다. 최소값이 갱신되었을때의 두 점(p1, p2)의 정보도 함께 갱신한 뒤 반복문이 종료된 후 저장되어 있는 최종 값을 출력합니다.
void getClosestPoints( int arr[], int len )
{
int p1, p2, i, min;
if( len < 2 )
return;
i = 0;
p1 = arr[0];
p2 = arr[1];
min = p2 - p1;
for( i = 0; i < len - 1; i++ )
{
if( arr[i+1] - arr[i] < min )
{
p1 = arr[i];
p2 = arr[i+1];
min = p2 - p1;
}
}
printf("(%d, %d)\n", p1, p2);
}
파이썬입니다.
def short(lis):
n_list = []
for x in range(len(lis)) :
for n in range(x+1, len(lis)):
n_list.append(abs(lis[x] - lis[n]))
a = min(n_list)
for x in range(len(lis)) :
for n in range(x+1, len(lis)):
if abs(lis[x] - lis[n]) == a:
print "(%s, %s)" % (lis[x], lis[n])
function find_min_distance($num){
for( $i = 0; $i < count($num)-1; $i++){
$distance[$i] = abs($num[$i+1] - $num[$i]);
}
$key = array_search(1, $distance);
$haha = [$num[$key], $num[$key+1]];
return $haha;
}
class PageTest extends PHPUnit_Framework_TestCase{
public function testDaum()
{
$arr1= [1, 3, 14, 15, 26];
$arr2= [0, 1, 4, 5, 6];
$arr3= [11, 12, 14, 15, 116];
$arr4= [15, 20, 24, 30, 31];
$this->assertEquals([14, 15], find_min_distance($arr1));
$this->assertEquals([0, 1], find_min_distance($arr2));
$this->assertEquals([11, 12], find_min_distance($arr3));
$this->assertEquals([30, 31], find_min_distance($arr4));
}
}
루비
num = [1, 3, 4, 8, 13, 17, 33, 13, 14, 20,21];
def find_min_distance(num)
n = 0
a = Array.new
while n < num.count-1 do
distance = num[n+1] - num[n]
a << distance.abs
n += 1
end
min_dis = a.sort[0]
min_points = a.each_index.select{|i| a[i] == min_dis}
min_points.each do |min_point|
puts "이 배열중 가장 가까운 숫자는 #{num[min_point]}, #{num[min_point+1]} 입니다."
end
end
Python 으로 짜봄
list=[1,3,4,8,13,17,20]
j=0
i=0
tmp=0
index1=0
index2=0
min=abs(list[0]-list[1])
while i<len(list):
j=i
while j<len(list)-1:
if(min>=abs(list[i]-list[j+1])):
min=abs(list[i]-list[j+1])
index1=int(list[i])
index2=int(list[j+1])
j=j+1
i=i+1
print(index1,index2)
fig = (1, 3, 4, 8, 13, 17, 20)
def Daum_Corp(fig):
num = int(len(fig))
listA = []
for i in range(0, num - 1):
k = fig[i + 1] - fig[i]
listA.append(k)
min_Value = min(listA)
print "숫자 리스트 = %s" % (fig)
print "숫자 간 간격은 = %s" % (listA)
print "숫자 간 간격의 최솟값은 = %s" % (min_Value)
for j in range(0, num - 1):
if listA[j] == min_Value:
k = j
print "최솟값을 가진 숫자의 값은 %s 와 %s 입니다." % (fig[k], fig[k + 1])
python 2.7
s = [1,3,4,8,13,17,20]
def naer_point(s):
nearPoint = 0
near = s[-1] - s[0]
index = 0
while index+1 < len(s):
sub = s[index+1] - s[index]
if near > sub:
near = sub
nearPoint = index
index += 1
print(s[nearPoint], s[nearPoint+1])
naer_point(s)
거리가 같은 원소쌍이 2개 이상일 때는 고려하지 않았습니다.
s = [1, 3, 4, 8, 13, 17, 20]
def findNearest(iterable):
dists = dict(((abs(x-y), (x, y)) for x in iterable for y in iterable if x != y))
return dists[sorted(dists.keys())[0]]
print findNearest(s)
python 입니다.
import unittest
def func(l):
diff = []
for i in range(len(l)-1):
diff.append(l[i+1] - l[i])
return l[diff.index(min(diff))], l[diff.index(min(diff))+1]
class Test(unittest.TestCase):
def test1(self):
self.assertEqual((3,4), func([1,3,4,7,11]))
self.assertEqual((19,21), func([4,7,19,21,51,231,34984]))
if __name__ == "__main__":
unittest.main()
파이썬 2.7입니다.
S=[1, 3, 4, 8, 13, 17, 20]
def f(vector):
vector.sort()
dist = map(lambda x,y: x-y,vector[1:],vector[0:-1])
temp_dist = dist[:]
temp_dist.sort()
position = dist.index(temp_dist[0])
return (vector[position],vector[position+1])
print f(S)
Scala로 풀었습니다. 왼쪽 끝 원소를 뺀 배열과 오른쪽 끝 원소를 뺀 배열을 묶어서 쌍(tuple)의 배열로 만들고, 각 쌍의 두 값의 차가 가장 작은 쌍을 구했습니다.
def minDistancePoints(s:Array[Int]) = s.drop(1).zip(s.dropRight(1)).reduce((x,y) => { if(math.abs(x._1 - x._2) > math.abs(y._1 - y._2)) y else x})
S = raw_input().split(',')
S = [int(x) for x in S]
S_diff = [S[i+1]-S[i] for i in range(len(S)-1)]
print(S[S_diff.index(min(S_diff))], S[S_diff.index(min(S_diff))+1])
coding by python beginner
s = [1, 3, 4, 8, 13, 17, 20]
s1 = s[:2]
min = abs( s[1] - s[0] )
for i in range( len(s) ):
for j in range( i+1, len(s) ):
if abs( s[i] - s[j] ) < min:
min = abs( s[i] - s[j] )
s1 = [s[i], s[j]]
print(s1)
swift입니다. 식빵님의 풀이와 동일하네요
import UIKit
var data=[1,3,4,8,13,17,20]
var result = data[1]-data[0]
var index = 0
for (var x = 0;x < data.count-1;++x){
if(data[x+1]-data[x] < result){
result = data[x+1]-data[x]
index = x
}
}
println("\(data[index]) \(data[index+1]) 사이가 가장 짧은 거리이다")
C로 작성해봤습니다.
int nArray[] = {1, 3, 4, 8, 13, 17, 20};
int nPair[2] = {0,};
int nDist=0, nTemp=0;
for( int i = 0; i < 7 - 1; i++)
{
nTemp = nArray[i+1] - nArray[i] ;
if( i == 0 )
{
nDist = nTemp;
nPair[0] = nArray[i];
nPair[1] = nArray[i+1];
}
else
{
if( nTemp < nDist )
{
nDist = nTemp;
nPair[0] = nArray[i];
nPair[1] = nArray[i+1];
}
}
}
Java
public class FindMinDistance {
public static void main(String args[]){
int arr[] = {1, 3, 4, 8, 13, 17, 20};
int len = arr.length ;
int minDis = arr[len-1]-arr[0];
int lower = 0 ;
int upper = 0;
for(int i=0; i<len-1;i++)
{
int tmpDis = arr[i+1] - arr[i];
if( minDis > tmpDis)
{
minDis = tmpDis;
upper = arr[i+1] ;
lower = arr[i] ;
}
}
System.out.println("shortest distance is ["+lower+"]-["+upper+"]");
}
}
public class ShortestLength {
public static void main(String[] args){
System.out.println("Hello world!");
int[] s = {1, 3, 5, 8, 13, 17, 20};
int minX = 0;
int minY = 0;
int minValue = -1;
for (int i=0; i<s.length - 1; i++){
if (minValue == -1 || s[i+1] - s[i] < minValue){
minValue = s[i+1] - s[i];
minX = s[i];
minY = s[i+1];
}
}
System.out.println(String.format("(%d,%d)", minX, minY));
}
}
Using python 뭔가 불편해 보이는 코드네요...
def daum2(a):
s = 0
b = []
for i in range(len(a)-1):
if s== 0:
s = a[i+1]- a[i]
b.append([a[i],a[i+1]])
elif s > a[i+1]- a[i]:
b.append([a[i],a[i+1]])
print b[-1]
a = [1,3,4,8,13,17,20]
daum2(a)
package rootcucu.codefight.old;
public class AAAA {
static class Pair {
int a;
int b;
Pair(int a, int b){
this.a = a;
this.b = b;
}
public String toString(){
return "Pair [" + a + ", " + b + "]";
}
}
static Pair findShortestPair(int[] points){
int shortest = Integer.MAX_VALUE;
int old = points[0]-(points[1] - points[0]);
Pair pair = null;
for (int p:points){
int distance = p - old;
if (distance < shortest){
shortest = distance;
pair = new Pair(old, p);
}
old = p;
}
return pair;
}
public static void main(String[] args){
System.out.println("shortestPair = " +findShortestPair(new int[]{1,6,11,15,20}) );
}
}
#include <stdio.h>
int main(void)
{
int arr[7] = {1,3,4,8,13,17,20};
int i,j;
int min[200] = {0};
int k = 0;
int ard[1000] = {0};
int ard1[1000] = {0};
int temp = 0;
for( i = 1 ; i <= 6 ; i++)
{
for( j = 0 ; j < i ; j++)
{
min[k] = (arr[i] - arr[j]);
if(min[k] < 0)
min[k] = min[k] * -1;
ard[k] = arr[j];
ard1[k] = arr[i];
k++;
}
}
for( i = 1; i <= 200 ; i++)
{
for(j=0;j<=i; j++)
{
if(min[j] <= min[i])
temp = min[j];
}
}
for( i = 0 ; i <= 200 ; i++)
{
if(ard[i] == 0)
break;
if(temp == min[i])
printf("( %d , %d) \n",ard[i] ,ard1[i]);
}
return 0;
}
어휴 더럽네요... ㅜㅜㅜ
python 입니다. 여러개가 최소값이어도 각각을 모두 출력합니다. 좀더 쉽게 해주실분 있나요. 매쓰랩에 find함수같은게 있으면 좋을텐데.
val=[1,4,19,20,25,26]
def shortway(numbers):
result=[]
for i,j in enumerate(numbers):
result.append(j-numbers[i-1])
realresult=result[1:]
return realresult
ab=shortway(val)
min_index=[x for x,y in enumerate(ab) if y==min(ab)]
#min 값들을 가지는 index를 구하는 함수.
answer=[(val[x],val[x+1]) for x in min_index]
print answer
C로 풀었습니다.
int min_distance(int, int);
typedef struct {int x; int y;}Ponts;
int main()
{
int arr[]={1, 3, 4, 8, 13, 17, 20};
int i, j, result, min;
Ponts pont;
for(i=0; i<sizeof(arr)/sizeof(int); i++)
for(j=i+1; j<sizeof(arr)/sizeof(int); j++){
result = min_distance(arr[i], arr[j]);
if(i==0 && j==1)
min=result;
if(result > min)
break;
else{
min=result;
pont.x=arr[i];
pont.y=arr[j];
}
}
printf("결과 : (%d, %d)\n", pont.x, pont.y);
return 0;
}
int min_distance(int num1, int num2)
{
return num2-num1;
}
By Python
def sort(num):
for i in range(1, len(num)):
for j in range(i):
while num[i] < num[j]: num[i], num[j] = num[j], num[i]
print(num)
diff(num)
def diff(numbers):
pairs = zip(numbers[0:],numbers[1:])
pairs.sort(key = lambda x:x[1]-x[0])
print(pairs[0])
num = [5,12,98,46,23,77,14,99,8,3,4,17,32]
sort(num)
Sub main()
Dim s() As Integer = {1, 3, 4, 8, 13, 17, 20}
Dim distance As Integer = s.Last, di As Integer, dj As Integer
For i As Integer = 0 To s.Length - 1
For j As Integer = 0 To s.Length - 1
If i <> j Then
Dim d As Integer = Math.Abs(s(i) - s(j))
If d < distance Then
distance = d
di = i : dj = j
End If
End If
Next
Next
Console.WriteLine("Result: {0} {1}", s(di), s(dj))
Console.ReadLine()
End Sub
Java코드입니다. 빨리 내공좀 쌓구싶어요 ㅠ
public class Main {
public static void main(String[] args) {
int S[] = {1, 3, 4, 8, 13, 17, 20};
int result[] = {0, 0};
int temp = S[S.length-1], temp2;
for(int i=0; i< S.length - 1; i++){
temp2 = Math.abs(Math.abs(S[i]) - Math.abs(S[i+1]));
if (temp > temp2)
{
temp = temp2;
result[0] = S[i];
result[1] = S[i+1];
}
}
System.out.println("(" + result[0] + "," + result[1] + ")");
}
}
혼자 연습하려고 아무런 순서대로 입력해서 자동 정렬 후에 최단 값과 동점인 순열을 전부 표시하게 프로그래밍했습니다.
import java.util.*;
public class dojo4
{
static Scanner sc = new Scanner(System.in);
public static void main(String[] args)
{
int ans = 0;
int[] ansrg1 = new int[100];
int count = 0;
int count2 = 0;
//initializing arraydata
ArrayList<Integer> arr1 = new ArrayList<Integer>(30);
for(int i=0;i<1000;i++){
System.out.println("The "+i+" number?(9999 to exit) : ");
while(!sc.hasNextInt()){
sc.nextLine();
System.out.println("enter an integer or 9999 to exit");
}
int tt = sc.nextInt();
if (tt != 9999)
{
arr1.add(tt);
}
else{break;}
}
Collections.sort(arr1);
System.out.println(arr1);
//calculating distance array
int[] arr2 = new int[arr1.size() - 1];
arr2[0] = arr1.get(1)-arr1.get(0);
ans = arr2[0];
//verifying minimum distance and points
for(int i = 1 ; i < arr2.length ; i++)
{
arr2[i] = arr1.get(i+1)-arr1.get(i);
if(arr2[i] < ans)
{
ans = arr2[i];
}
}
for(int i = 0 ; i < arr2.length ; i++)
{
if(arr2[i]==ans)
{
ansrg1[count] = arr1.get(i);
ansrg1[count+1] = arr1.get(i+1);
count +=2;
}
}
//printing answer
System.out.println(ans);
for(int i = 0 ; i<100; i++){
if(ansrg1[i] != 0 )
{
count2+=1;
}
}
int[] ansrg2 = new int[count2];
for(int i = 0 ; i<count2 ; i++)
{
ansrg2[i] = ansrg1[i];
}
for(int i = 0 ; i < count2; i+=2){
System.out.println("("+ansrg2[i]+","+ansrg2[i+1]+")");
}
}
}
# 중복 허용한 경우입니다.
s = [1,3,4,8,13,17,20,21]
srt = [ s[i+1]-s[i] for i in range( len(s)-1 ) ]
print [ (s[i],s[i+1]) for i in range( len(srt) ) if srt[i]==min(srt) ]
def short(a):
import sys
r =lambda: sys.stdin.readline()
s =map(int,r().split())
s = list(s)
s.sort()
p=list()
for i in range(0,len(s)-1):
p.append(s[i+1]-s[i])
p.sort()
print (p[0])
static void exce22()
{
Scanner scan = new Scanner(System.in);
String[] str = scan.nextLine().split(" ");
int[] arr = new int[str.length];
int a, b;
for (int i = 0; i < str.length; i++)
{
arr[i] = Integer.parseInt(str[i]);
}
a = arr[0];
b = arr[1];
for (int i = 1; i < arr.length - 1; i++)
{
if (arr[i + 1] - arr[i] < b - a)
{
a = arr[i];
b = arr[i + 1];
}
}
System.out.printf("%d %d",a,b);
}
points = [1,4,5,6,7,8,9,19]
index = 0
length = len(points)
delta = points[length-1];
for i in range(length-1):
if(points[i+1] - points[i]) < delta:
delta = points[i+1] - points[i]
index = i
print (points[index] , points[index+1])
theset = []
theset = input().split(" ")
for ii in range(0, len(theset)):
theset[ii] = int(theset[ii])
set(sorted(theset))
former = theset[0]; latter = theset[1]; diff = latter - former
for i in range(0, len(theset)-1):
if (theset[i+1] - theset[i]) < diff:
former = theset[i]; latter = theset[i+1]; diff = latter - former
print("(", former, ", ", latter, ")", sep = "")
공백으로 원소들이 서로 구분되는 일련의 리스트를 입력받은 뒤, 그것을 적절히 정수형으로 형변환 및 재정렬하고 가장 서로의 거리가 짧은 두 항을 추출하는 방식입니다. 원소들은 1차원의 선 위에 나열되어야 하므로, 원소 간의 길이가 최단거리가 되는 모든 원소는 반드시 서로 이웃해 있어야 합니다. 따라서 매 루프마다 원소와 원소 간의 차를 구하여 이전 루프의 차와 대조하는 반복문을 활용하면 반드시 서로의 거리가 가장 짧은 두 원소의 튜플을 구할 수 있습니다.
#include <iostream>
using namespace std;
int check_distance(int s[]){
int len,point,min=100;
for(int i=0;i<6;i++){
len=s[i+1]-s[i];
if(len<min){
min=len;
point=i;
}
}
return point;
}
int main(){
int s[]={1,3,4,8,13,17,20};
int result=check_distance(s);
cout<<"("<<s[result]<<" , "<<s[result+1]<<")"<<endl;
return 0;
}
숫자 배열값이 고정되지 않은 경우 어떻게 해결할지에 대해 더 고민해보겠습니다.
#include "stdafx.h"
int _tmain(int argc, _TCHAR* argv[])
{
int S[]={1,3,4,8,13,17,20};
int i, distance, min_distance;
int min_p1,min_p2;
min_distance=10000000000000;
for(i=0;i<(sizeof(S)/sizeof(int))-1;i++){
distance=S[i+1]-S[i];
if(distance<min_distance){
min_distance=distance;
min_p1=S[i];
min_p2=S[i+1];
}
}
printf("%d , %d", min_p1, min_p2);
return 0;
}
C언어입니닷 '-'틀린거 지적해주셔도 감사하구요^^
JAVA 초보자
class Daum {
private static int[] s = {1, 3, 4, 8, 13, 17, 20};
private static int len = s.length;
public static void main(String args[]){
run();
}
private static void run(){
int sub=s[len-1], temp=0, p1=0, p2=0;
for(int i=len-1; i>0; i--){
temp = s[i] - s[i-1];
if(sub > temp){
sub = temp;
p1=s[i-1];
p2=s[i];
}
}
System.out.println("("+p1+","+p2+")");
}
}
points, distances = [1,5,8,12,14,15], []
for i in range(1, len(points)):
distances.append(points[i]-points[i-1])
print(min(distances))
s=[1, 3, 4, 8, 13, 17, 20]
a=[]
for i in s[:-1]:
a.append(s[s.index(i)+1]-i)
print (s[(a.index(min(a)))], s[(a.index(min(a)))+1])
Java8
public static void main(String[] args){
int[] list = {1,5,8,12,14,20};
OptionalInt min = IntStream.range(0, list.length-1)
.map(i -> list[i+1] - list[i])
.min();
System.out.println(min.getAsInt());
}
python3입니다. 중복따위 고려하지 않았습니다 ㅜㅠ
s = [1, 3, 4, 8, 13, 17, 20]
print(min([(s[n], s[n + 1]) for n in range(0, len(s) - 1)], key=lambda x: x[1] - x[0]))
python, 중복에 값이 있을 경우를 생각해서 코딩해보았습니다
import copy
from collections import Counter
S = {1, 3, 4, 8, 13, 15, 16, 17, 20, 21, 22}
def minDistance():
_S = list(S)
R = []
for x in range(len(_S) - 1):
d = _S[x + 1] - _S[x]
R.append(d)
O = copy.copy(R)
cnt = Counter(O)
m = min(R)
for x in range(cnt[m]):
idx = O.index(m) + x
O.remove(m)
result = (_S[idx], _S[idx + 1])
print(result)
minDistance()
### C언어로 구현했습니다.
#include <stdio.h>
void main()
{
int dot[7]={1,3,4,8,13,17,20};
int min= dot[6] - dot[0];
int temp, min_index;
for(int i = 0; i < 5; i++){
temp = dot[i+1] - dot[i];
if (temp<min) {
min = temp;
min_index = i;
}
}
printf(“(%d, %d)”, dot[min_index], dot[min_index + 1]);
}
Python3
def shortest_distance(points):
min_dis = 10000
point = 1
idx = 1
while idx < len(points):
tmp = points[idx] - points[idx-1];
if tmp < min_dis:
min_dis = tmp
point = idx
idx += 1
return points[point - 1], points[point]
파이썬 2.7
s = [1, 3, 2, 8, 6, 13, 17, 5, 20]
result = []
dist = max(s) - min(s)
for i in range(len(s)):
for j in range(i+1, len(s)):
if dist > abs(s[i] - s[j]):
result=[]
result.append([s[i], s[j]])
dist = abs(s[i] - s[j])
elif dist == abs(s[i] - s[j]):
result.append([s[i], s[j]])
print result
결과값:
[[1, 2], [3, 2], [6, 5]]
java로 풀었습니다.
public class Example2 {
public static void main(String[] args) {
int[] intArray = {1,3,4,8,13,17,20};
int res = 100;
int j = 0;
int k = 0;
for(int i = 0; i<intArray.length - 1; i++) {
int sum = intArray[i+1]- intArray[i];
if(res > sum) {
res = sum;
k = intArray[i+1];
j = intArray[i];
}
}
System.out.print("{" + j + ", " + k + "}");
}
}
n = input("수열의 길이:")
lst = []
for i in range(n):
lst.append(input("하나씩 숫자 입력:"))
lst = sorted(lst)
print lst
diff = []
for i in range(len(lst)-1):
diff.append(lst[i+1] - lst[i])
for i in range(len(lst)-1):
if lst[i+1] - lst[i] == min(diff):
print lst[i], lst[i+1]
수열의 길이와 각 숫자를 입력받아서 수열과 최소 거리의 두 숫자를 출력합니다
- python으로 작성하였습니다.
def shortestPoints(s):
distance=[s[i+1]-s[i] for i in range(len(s)-1)]
return s[distance.index(min(distance))],s[distance.index(min(distance))+1]
print shortestPoints([1,3,4,8,13,17,20])
package coding_test;
public class coding_test2 {
public static void main(String[] args) {
int[] v1 = {1,3,4,8,13,17,20};
int t1, t2, min;
int ta1=0;
int ta2=0;
int[] tmp = new int[6];
for(int i = 0; i < v1.length -1 ; i++) {
t1 = v1[i];
t2 = v1[i+1];
tmp[i] = Math.abs(t1-t2);
}
min = tmp[0];
for(int i = 0; i < tmp.length -1 ; i++) {
if (min >= tmp[i]) {
min = tmp[i];
ta1 = v1[i];
ta2 = v1[i+1];
}
}
System.out.println(ta1+","+ta2);
}
}
#include <stdio.h>
#include <stdlib.h>
int shortfind(int * arr);
int main(void){
int * arr;
int n=1,i;
printf("배열의 크기 입력:");
scanf("%d",&n);
arr=(int *)malloc(n*sizeof(int));
printf("배열 입력:");
for(i=0;i<n;i++){
scanf("%d",&arr[i]);
}
i=shortfind(arr);
printf("결과값:(%d %d)\n",arr[i],arr[i+1]);
}
int shortfind(int * arr){
int smallest[2]={0,arr[1]-arr[0]},i;
for(i=0;arr[i+1]!='\0';i++){
if(smallest[1]>arr[i+1]-arr[i]){
smallest[0]=i;
}
}
return smallest[0];
}
그냥 배열의 크기랑 배열을 직접 입력까지 할수 있도록 해봤습니다.
public static void main(String[] args) {
int[] a = {1, 3, 4, 8, 13, 17, 20};
Map<Integer, String> map = new HashMap<>();
for (int i = 0; i < a.length - 1; i++) {
for (int j = i+1; j < a.length; j++) {
map.put(Math.abs(a[i]-a[j]), "("+a[i]+","+a[j]+")");
}
}
List<Integer> list = new ArrayList<>();
for (Iterator iterator = map.keySet().iterator(); iterator.hasNext();) {
int keyValue = (int) iterator.next();
list.add(keyValue);
}
int val = Collections.min(list);
System.out.println(map.get(val));
}
문제를 잘못읽고 연속된 점이 아니라고 생각하고 풀어서 이렇게 한심하게 풀었네요 -_-;
Ruby
min_pair = ->p { p.each_cons(2).min_by{|a,b|b-a} }
Test
expect(min_pair.([1,3,4,8,13,17,20])).to eq [3,4]
def minimum_pair(lista):
shortest=100
diff_list=[]
for i in range(1, len(lista)):
diff = lista[i] - lista[i-1]
diff_list.append(diff)
k = min(diff_list)
indexed_min = diff_list.index(k)
return lista[indexed_min], lista[indexed_min+1]
lista = [1,3,5,8,13,17,20,21,100,101]
print minimum_pair(lista)
초보자라 그런지.. 우선 차이값을 리스트로 저장한 다음에 그 차이값의 인덱스를 기준으로 원 리스트의 양옆값을 도출해 내었습니다.
#coding: CP949
S=[2,3,4,5,1,3,4,5]
S=sorted(S)
result1=[]
result2=[]
i=0
while i<=len(S)-2:
result1.append(abs(S[i]-S[i+1])) #정렬된 리스트 S로부터 두 점 사이 거리 구하기.
result2.append(eval('(S[i],S[i+1])')) #result1과 동일한 순서로 두 점 사이 거리에 해당하는
#좌표리스트 작성.
i+=1
final_result=[]
j=0
while j<=len(result1)-1:
if result1[j] == min(result1): # 최소값이 여러 개임을 감안하여 final_result에 넣어 최종값 출력.
final_result.append(result2[j])
j+=1
else:
j+=1
continue
print(final_result)
python 3.5
def find_shortest(number_list):
result = 0
min_val = max(number_list)-min(number_list)
for i in range(len(number_list)-1):
val = number_list[i+1] - number_list[i]
if min_val > val:
min_val = val
result = i
return print(number_list[result], number_list[result+1])
int [] returnSortestLengthFromArray(int [] arr) {
int [] result = new int[2];
int minLength = Integer.MAX_VALUE;
for(int i=1; i<arr.length; i++) {
if(minLength > arr[i]-arr[i-1]) {
minLength = arr[i]-arr[i-1];
result[0] = arr[i-1];
result[1] = arr[i];
}
}
return result;
}
java 코드
s=[1, 3, 4, 8, 13, 17, 20]
a=list(s[i+1]-s[i] for i in range(len(s)-1));b=a.index(min(a));print(s[b:b+2])
어렵진 않아서 줄이는 데 노력했습니다. 파이썬 3.5.1
python3
def f(s):
'리스트 s에서 가장 먼저 발견되는 최소 거리의 두점을 튜플로 리턴'
diff = [abs(a - b) for a, b in zip(s, s[1:])]
ret = diff.index(min(diff))
return s[ret], s[ret + 1]
Python 2.7
def mindist(L):
A = [(L[i],L[i+1]) for i in xrange(len(L)-1)]
sub = lambda a: a[1]-a[0]
return min(A, key=sub)
public class Two { / * 1차원의 점들이 주어졌을 때, 그 중 가장 거리가 짧은 것의 쌍을 출력하는 함수를 작성하시오. (단 점들의 배열은 모두 * 정렬되어있다고 가정한다.) 예를들어 S={1, 3, 4, 8, 13, 17, 20} 이 주어졌다면, 결과값은 (3, 4)가 될 * 것이다. / public static void main(String[] args) { int[] s = {2, 3, 5, 8, 13, 17, 20}; System.out.println(findMinDist(s));
}
public static String findMinDist(int[] a){
int MIN_distance=a[6]-a[0];
int distance;
String asw= null;
for(int i=0;i<a.length-1;i++){
distance = a[i+1] - a[i];
if(MIN_distance > distance){
asw = " " + a[i]+ "," + a[i+1]+ " ";
MIN_distance = distance;
}
}
return asw;
}
}
s=[1,3,4,8,13,17,20]
a=s[len(s)-1]
for i in range(0,6):
for x in range(0,5):
if s[x]-s[i]<a and s[x]-s[i]>0:
a=s[x]-s[i]
b=s[x]
c=s[i]
else:
pass
print("%s 와 %s의 차가 가장 적으며 차는 %s 입니다."%(b,c,a))
C로 풀었습니다.
#include<stdio.h>
int main(void){
int array[10];
int key[9]={0};
int i, j, tmp;
int min=100;
for(i=0; i<10;i++){
scanf("%d", &array[i]);
}
for(i=0; i<9; i++){
for(j=i+1;j<10; j++){
if(array[i]>array[j]){
tmp=array[j];
array[j]=array[i];
array[i]=tmp;
}
}
}
for(i=0; i<10;i++){
printf("%d ", array[i]);
}
printf("\n");
for(i=0; i<9; i++){
j=i+1;
if((array[i]-array[j])>0){
key[i]=(array[i]-array[j]);
}
else{
key[i]=(array[j]-array[i]);
}
}
printf("\n");
for(i=0; i<9;i++){
if(key[i]<min){
min= key[i];
}
}
printf("최소값은 %d \n", min);
for(i=0; i<9;i++){
if(min==key[i]){
printf("결과값은 (%d, %d)\n", array[i], array[i+1]);
}
}
}
입력받는 거랑 정렬이랑 따로 했습니다.
int min = Math.abs(array[0] - array[1]);
int x = 0 , y =0;
for(int i= 0 ; i < array.length - 1 ;i++){
if(Math.abs(array[i], array[i+1]) < min) {
min = Math.abs(array[i]-array[i+1]);
x = array[i];
y = array[i+1];
}
}
System.out.println("("+x+","+y+")");
}
ls = [1,4,8,13,17,20,7,30,38,33]
ss_a=100
for i in ls:
for j in ls:
ss_b= i-j
if ss_a>ss_b and ss_b>0:
ss_a=ss_b
ls2=[i,j]
print(ls2)
a = [1,3,4,8,13,17,20,21]
b = abs(a[0]-a[1])
ans = [0,0]
for i in range(len(a)-1):
min = abs(a[i]-a[i+1])
if (b>min):
b = min
ans[0] = a[i]
ans[1] = a[i+1]
print(ans)
Python.
input = list({1, 3, 4, 8, 13, 17, 20})
pairs = zip(input[0:], input[1:])
pairs.sort(key=lambda x: x[1] - x[0])
print(pairs[0])
distance = []
for i in range(1,len(s)):
distance.append(s[i]-s[i-1])
index = distance.index(min(distance))
result = s[index], s[index+1]
print(result)
a=[1, 3, 4, 8, 13, 17, 20]
b= 0
c=a[6]
e=0
f=0
while b<6:
d=(a[b+1]-a[b])
b=b+1
if d<c:
c=d
e=a[b-1]
f=a[b]
print(e, f)
파이썬 3.5.1 입니다
정렬 되어있을 때
a = [1, 3, 4, 8, 13, 17, 20]
def sort(number):
b = a[number] - a[number - 1]
if not b == (1 or -1):
return sort(number - 1)
else:
return a[number], a[number - 1]
print (sort(len(a) - 1) )
정렬 안 되어있을 때
a = [20, 3, 17, 13, 8, 4, 1]
def sort(number):
if number == 0:
return "There is no result."
else:
for i in range(0, (number + 1) ):
b = a[number] - a[number - i]
if b == (1 or -1):
return a[number], a[number - i]
return sort(number - 1)
print (sort(len(a) - 1) )
s=list({1,3,4,8,13,17,20})
absdata=[]
for i in range(1,len(s)):
absdata.append(abs(s[i]-s[i-1]))
print(s[absdata.index(min(absdata))],s[absdata.index(min(absdata))+1])
C
#include <stdio.h>
int main()
{
int S[] ={1,3,4,8,13,17,20};
int size= sizeof(S)/sizeof(int);
int min,temp,x,y;
min=S[1]-S[0];
x=S[0];
y=S[1];
for(int i=1; i<size-1;++i)
{
temp=S[i+1]-S[i];
if(temp<min)
{
min=temp;
x=S[i];
y=S[i+1];
}
}
printf("( %d , %d )", x,y);
}
Python
S = [1, 3, 4, 8, 13, 17, 20]
def DistCal(num1, num2):
return pow(num1-num2, 2)
min = DistCal(S[0], S[len(S)-1])
idx = 0
while True:
if idx + 1 >= len(S):
break
if min >= DistCal(S[idx], S[idx+1]):
min = DistCal(S[idx], S[idx+1])
numIdx = idx
numIdx2 = idx+1
idx += 1
print(S[numIdx], S[numIdx2])
S = [4, 8, 23, 1, 789, 34, ...]
S = S.sort()
n = len(S)
R = int(S[n-1]) - int(S[0]) #처음 for문의 x를 비교하기 위한 의미없는 값
W = 0
for i in range(n,2,-1)
x = int(S[i-1]) - int(S[i-2])
if x < R:
R = x
W = i-1
print('%d,%d' %(int(S[W]),int(S[W-1])))
파이썬 시작하는 초보입니다. 일단 리스트를 오름차순으로 정리한 뒤 끝에서부터 한쌍씩 차를 구하여, 제일 작은 값을 가지는 번호를 리턴하였습니다. 혹시 오류가 있으면 많은 지적 부탁드립니다
파이썬 3.5로 작성되었습니다.
점들의 입력, 최소의 거리가 중복되었을 때 등의 처리를 고려한 코드입니다.
배운지 얼마 안되지만 코멘트를 달아보았습니다. 부족한 점이 많습니다.
#p22.py
#160526 19:30 ~ 20:40 (1h 10m)
#1차원의 점 입력
point = []
ib = input().split(' ')
for i in range(len(ib)):
if int(ib[i]) in point: continue #거리가 0인 것은 두 점사이의 거리가 아니므로 중복을 방지
point.append(int(ib[i])) #점들을 입력받아 'point'라는 리스트에 추가
point.sort() #리스트를 낮은 숫자순으로 정렬
sub = []
for i in range(len(point)-1):
sub.append(abs(point[i] - point[i+1])) #두개의 점의 거리를 절대값으로 구해 'sub' 리스트에 추가
minimum = min(sub) #거리의 최소값을 구함
lo = []
for i in range(len(sub)):
if sub[i] == minimum: #최소값이 여러개일 경우 'lo' 리스트에 거리 리스트의 위치를 추가
lo.append(i)
for i in range(len(lo)):
print("(%d, %d)" % (point[lo[i]], point[lo[i]+1]))
#거리가 최소인 두개의 점은 거리 리스트의 위치를 이용해 구하고 이를 출력
s = [1, 3, 4, 8, 13, 17, 20]
list = []
for n in range(len(s)-1):
list.append(s[n+1] - s[n])
idx = list.index(min(list))
print 'result is (%s,%s)' %(s[idx], s[idx+1])
python 2.7
자바로 풀었습니다.
package javaCoding;
import java.util.ArrayList; import java.util.Collections; import java.util.List;
/ * * 다음 입사 문제 . * 내가 배열에 넣은값중에서 가장 근접해 있는 두 값을 리턴해 오기. * @author pc02 /
public class Coding004 {
static int num1;
static int num2;
public static void main(String[] args) {
List<Integer> list=new ArrayList<Integer>();
list.add(1);
list.add(9);
list.add(12);
list.add(13);
list.add(29);
list.add(56);
list.add(78);
list.add(90);
int tmp=0;
int tmp2=0;
tmp=list.get(1)-list.get(0);
for (int i = 2; i < list.size(); i++) {
tmp2=list.get(i)-list.get(i-1);
//tmp를 기준으로 잡고 여기 보다 작으면 tmp를 tmp2에 담고 다시 돌림.
if(tmp2<tmp){
//변경..
num1=list.get(i);
num2=list.get(i-1);
tmp=tmp2;
}
}
//System.out.println(tmp);
System.out.println(num2+"과"+num1+"입니다.");
}```
```
}
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
int main(void)
{
int i, j, num, distance, po1, po2;
int *arr;
printf("The number of points: ");
scanf("%d", &num);
arr = (int*)malloc(sizeof(int)*num);
for (i = 0; i < num; i++) {
scanf("%d", arr + i);
}
distance = abs(arr[0] - arr[1]);
for (i = 0; i < num - 1; i++) {
for (j = i + 1; j < num; j++) {
if (abs(arr[i] - arr[j]) < distance) {
distance = abs(arr[i] - arr[j]);
po1 = arr[i];
po2 = arr[j];
}
else
continue;
}
}
printf("The closest points: (%d, %d)\n", po1, po2);
printf("Distance: %d\n", distance);
free(arr);
return 0;
}
Javascript
(function() {
'use strict';
var array = [1, 3, 4, 8, 13, 17, 20];
var min = Number.MAX_VALUE;
var pos;
for (var i = 0; i < array.length - 1; i++) {
var temp = array[i + 1] - array[i];
if (min > temp) {
min = temp;
pos = [array[i], array[i + 1]];
}
}
console.log('거리 : ' + min, ', 쌍 : ' + pos[0] + ', ' + pos[1]);
}());
파이썬 2.7
lista=[1,3,4,8,13,17,20]
listb=[]
count=0
listc=[]
listd=[]
for i in lista:
for j in lista:
if i==j:
pass
else:
a=abs(i-j)
count=count+1
if listb==[]:
listb.append(a)
else:
if listb[0]<a:
pass
else:
listb[0]=a
b=count
if listc==[]:
listc.append(i)
else:
listc[0]=i
if listd==[]:
listd.append(j)
else:
listd[0]=j
print (listd[0], listc[0])
package main
import (
"fmt"
)
func main() {
s := []int{ 1, 3, 4, 8, 13, 17, 20 }
shortest := s[1] - s[0]
index := 0
for i := 0; i < len(s)-1; i++ {
distance := s[i+1] - s[i]
if shortest > distance {
shortest = distance
index = i
}
}
fmt.Printf("(%d, %d)", s[index], s[index+1])
}
int s[] = {1, 3, 4, 8, 13, 17, 20};
int m=0; int n=0;
int min = s[1]-s[0];
for (int i = 0; i < s.length; i++) {
for (int j = i+1; j < s.length; j++) {
if (s[j]-s[i]<min) {
min=s[j]-s[i];
m=i; n=j;
}
}
}
System.out.println(s[m]+","+s[n]);
System.out.println(min+"");
c++###
//이렇게 하는게 맞는지 모르겠네요 ..ㅎ
int dot[8] = { 2,5,10,30,35,120,150}; //임의의 수를 넣었습니다~ int min=dot[6], mini, minj;
int distance[8] = { 0, };
int i;
for (i = 0; i < 6; i++){
if (min > dot[i + 1] - dot[i]){
mini = i;
minj = i + 1;
min = dot[i + 1] - dot[i];
}
}
cout << dot[mini] << ", " << dot[minj];
}
1차원적으로 풀었습니다. 다른 분 소스보며 많이 배워갑니다 ㅎ
python3.5
S = [1, 3, 4, 8, 13, 17, 20]
sLen = len(S)
sub = 0
i = 0
minIdx = 0
while i < sLen-1:
tempSub = abs(S[i] - S[i + 1])
if sub == 0 or sub > tempSub:
sub = tempSub
minIdx = i
i += 1
print(S[minIdx:minIdx+2])
public class num01 { // 1차원의 점들이 주어졌을 때, 그 중 가장 거리가 짧은 것의 쌍을 출력하는 함수 구하기
private static ArrayList<Integer> mArrayList;
static int[] s = {1, 3, 4, 8, 13, 17, 20};
static int result = 0;
static int abResult = 0;
static int min = 99999;
public static void main(String[] args) {
mArrayList = new ArrayList<Integer>();
for(int i=0;i<s.length-1;i++) {
for(int j=i+1;j<s.length;j++) {
result = s[i] - s[j];
abResult = Math.abs(result);
mArrayList.add(abResult);
if(mArrayList.size() > 1) {
for(int p=0;p<mArrayList.size();p++) {
if(mArrayList.get(p) < min) {
min = mArrayList.get(p);
}
}
}
}
}
System.out.println("최소값 = "+min);
compare();
}
public static void compare() {
for(int i=0;i<s.length-1;i++) {
for(int j=i+1;j<s.length;j++) {
result = s[i] - s[j];
abResult = Math.abs(result);
if(abResult == min) {
System.out.println("("+s[i]+", " + s[j]+")");
}
}
}
}
}
public class test {
public static void main(String[] argv) {
int[] s = {1,3,4,8,13,17,20};
System.out.println(result(s));
}
public static String result(int[] s){
int val = 0;
int x = 0;
int y = 0;
for(int i =0; i<s.length -1; i++){
int tempVal = s[i+1] - s[i];
if(val == 0 || val > tempVal){
val = tempVal;
x = s[i];
y = s[i+1];
}
}
return "(" + x + "," + y + ")";
}
}
GCC
i;S[]={1,3,4,8,13,17,20};main(a){for(;++i<7;)S[a]-S[a-1]>S[i]-S[i-1]&&(a=i);printf("(%d, %d)",S[a-1],S[a]);}
C#으로 작성했습니다.
using System;
using System.Collections.Generic;
public void MinDistance(List<int> inputs)
{
var index = 0;
var min = inputs[1] - inputs.First();
for (int i = 1; i < inputs.Count - 1; i++)
{
var temp = inputs[i + 1] - inputs[i];
if (min > temp)
{
index = inputs[i];
min = temp;
}
}
var output = index + min;
Console.Write(index + ", " + output);
}
3,4 나오긴 하는데 잘 만든건지는 모르겟네요ㅜ 아직 초보고 배우는 단계라서. ,..
public static void main(String[] args) {
int[] s ={1,3,4,8,13,17,20};
int result =0;
int s1 =0;
int s2 =0;
for (int i = 0; i <= s.length-2; i++) {
if (result == 0) {
result = s[i+1] -s[i];
}
if (result >s[i+1]-s[i]) {
result = s[i+1] -s[i];
s1 = s[i];
s2 = s[i+1];
}
}
System.out.println(s1+","+s2);
}
}
int main() { int s[7] = { 1, 3, 5, 8, 13, 17, 18 }; int temp = 0; int min = 0; int res = 0;
for (int i = 0; i < 6; i++) {
min = s[i + 1] - s[i];
if (temp == 0)
temp = min;
else if (temp > min) {
temp = min;
res = i;
}
}
cout << temp << " / 결과값 : (" << s[res] << ", " << s[res + 1] << ")" << endl;
}
def shortest(list):
result_list = []
min_value = abs(list[0] - list[1])
print(min_value)
for i in range(len(list)-1):
for j in range(i+1,len(list)):
if min_value > abs(list[j]- list[i]) :
min_value = abs(list[j]- list[i])
result_list=[list[i],list[j]]
return result_list
data = [1, 3, 4, 6, 8, 10, 13, 17, 20, 25, 27]
print(shortest(data))
자바코드로 풀어보았습니다.
public class 다음입사문제중에서 {
public static void main(String[] args) {
int s[] = {1, 3, 4, 8, 13, 17, 20};
int min = Integer.MAX_VALUE;
int first = -1;
int second = -1;
for(int i=0; i<s.length; i++) {
for(int j=i+1; j<s.length; j++) {
int left = s[i];
int right = s[j];
int value = right - left;
if(min > value) {
min = value;
first = s[i];
second = s[j];
}
}
}
System.out.println(first+", "+second);
}
}
package 코딩도장;
public class Q5 {
public static void main(String[] args) {
int s[] = {1,3,4,8,13,17,20};
int point;
int result1 = 0,result2=0;
int max=Integer.MAX_VALUE;
for(int i = 0; i<s.length; i++)
{
for(int j = 0 ;j<s.length;j++)
{
if(s[i] < s[j])
{
point = s[j] - s[i];
}
else
{
point = s[i] - s[j];
}
if(point != 0 && max > point)
{
max = point;
result1 = s[i];
result2 = s[j];
}
}
}
System.out.println(result1 + " "+ result2);
}
}
S=[1, 3, 4, 8, 13, 17, 20]
Sub=[]
for k in range(1, len(S)):
sub=S[k]-S[k-1]
Sub.append(sub)
a=min(Sub)
b=Sub.index(a)
print('(%d, %d)에서 최소' %(S[a], S[a+1]))
c언어로 작성했습니다.
#include <stdio.h>
int *sh_distance(int s[], int len);
int main(void)
{
int S[] = {1, 3, 4, 8, 13, 17, 20};
int *value = NULL;
int len;
len = sizeof(S)/sizeof(int);
value = sh_distance(S, len);
printf("최단거리 : %d\n", (*value));
printf("(%d,%d)\n",*(value+1), *(value+2));
return 0;
}
int *sh_distance(int s[], int len)
{
int temp = 100;
int i;
static int arr[3] ={0,};
for(i=0;i<len-1;i++){
if(temp>s[i+1]-s[i]){
temp = s[i+1]-s[i];
arr[0] = temp;
arr[1] = s[i];
arr[2] = s[i+1];
}
}
return arr;
}
S = [1,3,4,8,13,17,20]
Min_val = max(S)
for Key_F in S :
for Key_B in S :
Re = Key_F - Key_B
if Re == 0 or Re < 0 : pass
elif Min_val > Re : Min = Re ; x = [Key_F, Key_B]
x.sort()
print(x)
파이썬 초급자 입니다. 비교 횟수는 N^2으로 성능은 좋지 않습니다...
public static void main(String[] args) {
int[] arr = {1,3,4,8,13,17,20};
int min = arr[1]-arr[0];
for(int i=1; i<arr.length; i++){
for(int j=1; j<i; j++){
if(min>arr[j+1]-arr[j]){
System.out.println("("+arr[j]+","+arr[j+1]+")");
return;
}
}
}
}
정렬 되어있단 가정이 있기에 이렇게 했습니다
-
Oh Tae Gyeoung,
2016/07/26 13:59
s=[1, 3, 4, 8, 13, 17, 20]
s1=s[1:]
s2=[]
for i in range(len(s1)):
s2+=[s1[i]-s[i]]
print("%d, %d"%(s[s2.index(min(s2))],s[s2.index(min(s2))+1]))
Python 3.5.2
int arr[] = { 1, 3, 4, 8, 13, 17, 20 };
int num = 2;
for (int i = 0; i < arr.length - 1; i++) {
for (int j = 1; j < i; j++) {
if (num > (arr[j + 1] - arr[j])) {
System.out.println(arr[j] + "," + arr[j + 1]);
}
}
}
Python
S = [1, 3, 4, 8, 13, 17, 20]
gap = S[1] - S[0]
pair = (S[0], S[1])
for indexNumber in range(1,len(S)-1):
currentGap = S[indexNumber+1] - S[indexNumber]
if gap > currentGap:
gap = currentGap
pair = (S[indexNumber],S[indexNumber+1])
print gap
print pair
def shortest(list):
list.sort()
result = []
for i in list:
list.remove(i)
for a in list:
result.append(abs(i-a))
if abs(i-a) == min(result):
return (i,a)
print shortest([1, 3,4,5,6])
#include <iostream>
#include <stdio.h>
using namespace std;
void main()
{
int arr[10] = { 1, 3, 5, 6, 10, 17, 25, 29, 31, 39 };
int num = 0;
int minNum1 = 0;
int minNum2 = 0;
int size = _countof(arr);
for (int i = 0; i < size - 1; i++)
{
int temp = arr[i + 1] - arr[i];
if (i == 0)
{
num = temp;
continue;
}
if (num > temp)
{
num = temp;
minNum1 = i;
minNum2 = i + 1;
}
}
cout << arr[minNum1] << " " << arr[minNum2] << endl;
}
- javascript 언어 사용
var arr = [1,3,4,8,13,17,20];
var result = [];
for( var i=0; i<arr.length; i++ ){
if( i == arr.length - 1 )
break;
result.push({"pair":"("+arr[i]+","+arr[i+1]+")","diff":arr[i+1] - arr[i]});
}
result.sort(function (a, b) { return a.diff - b.diff; });
console.log("가장 거리가 짧은 것의 쌍은 "+result[0].pair+"이며 차이는 "+result[0].diff);
python 3.5 소팅 알고리즘처럼 풀이..
def extract_distance(arr):
i=0
while i < len(arr)-1:
distance = arr[i+1] - arr[i]
if i == 0:
short_distance = distance
if distance < short_distance:
short_distance = distance
result = (arr[i],arr[i+1])
i+=1
return result
print(extract_distance([1, 3, 4, 8, 13, 17, 20]))
Python 2.7
s=[1,3,4,8,13,17,20]
coordinates=[]
min=100
for i in range(0,len(s)):
for j in range(i+1,len(s)):
r=abs(s[i]-s[j])
if(r<min):
min = r
coordinates=[s[i],s[j]]
print coordinates
int solution(int *array, int len)
{
int k=0,j=0,imin=0,inum=0;
int byTmp[1024];
memcpy(byTmp,0x00,sizeof(byTmp));
memcpy(byTmp,array,len);
imin = byTmp[1] - byTmp[0];
for(k=2; k<len+2; k++)
{
inum = byTmp[k] - byTmp[k-1];
if(imin > inum)
{
imin=inum;
j=k;
}
}
printf("result : [%d,%d]\n",byTmp[j-1], byTmp[j]);
return SUCCESS;
}
문제는 임의의 배열이 주어졌을때 최소값을 구하는 문제 이기 때문에 배열값과 그 배열의 인덱스 길이를 인자값으로 받았을때 처리하는 방식 입니다.
S=[1, 3, 4, 8, 13, 17, 20]
def FindShortestPath(s):
path = abs(s[0] - s[1]); #store first path value
a = 0
for i in range(0, len(s)-1):
if path > abs(s[i]-s[i+1]): #compare path value
path = abs(s[i]-s[i+1])
a = i
return path, s[a], s[a+1]
print(FindShortestPath(S))
public string GetClosest(int[] input)
{int temp2 = input[input.Length-1];
string Points = "1";
for (int i = 0; i < input.Length - 1; i++)
{
int temp1 = input[i + 1] - input[i];
if ((temp1) < (temp2))
{
Points = Convert.ToString( input[i]) +","+ Convert.ToString(input[i + 1]);
temp2 = temp1;
}
}
return Points;
}
InPut : 1, 3, 4, 8, 13, 17, 20 OutPut : 3,4
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ConsoleApplication3
{
class Program
{
static void Main(string[] args)
{
int[] arr = {1, 3, 4, 8, 13, 17, 20};
FindShorttest(arr);
}
static void FindShorttest(int [] _arr)
{
int num1 = _arr[0];
int num2 = _arr[1];
int shorttest = Math.Abs(_arr[0] - _arr[1]);
for(int i = 0; i < _arr.Length-1; i++)
{
for(int j = i+1; j < _arr.Length; j++)
{
if(Math.Abs(_arr[i]-_arr[j]) < shorttest)
{
num1 = _arr[i];
num2 = _arr[j];
shorttest = Math.Abs(_arr[i] - _arr[j]);
}
}
}
Console.WriteLine("{0} , {1}", num1, num2);
}
}
}
numbers = [1, 3, 4, 8, 13, 17, 20]
returnVal = 99999999999999999999
tmpVal = 0
for totalSeq in range(0, len(numbers)-1) :
for subSeq in range(totalSeq+1, len(numbers)) :
tmpVal = numbers[totalSeq] - numbers[subSeq]
if tmpVal < 0 :
tmpVal = tmpVal*(-1)
if tmpVal < returnVal :
returnVal = tmpVal
print(returnVal)
S = [1,3,4,8,13,17,20]
def mindistant(n):
distant=[n[i+1]-n[i] for i in range(len(n)-1)]
for i in range(len(distant)):
if distant[i] == min(distant):
return print(n[i]n[i+1])
mindistant(S)
문제에 의하면 정렬이 되어 있기때문에 모든 점들과 O(n^2)의 경우를 생각할 필요는 없으며 인접한 점간의 차이만 계산하면되고, 그차이의 최소값을 구한후, 두점의 차이가 최소값인 두점의 쌍이 둘 이상 일수 있으므로 복수개의 결과를 검색하기 위해 루프를 한버더 돌게 한다. O(n) 시간 복잡도 내에서 문제해결이 가능, 단 정렬이 되어 있기때문.
using System;
namespace ConsoleApplication
{
class Program
{
static void Main(string[] args)
{
int[] a = { 1, 3, 4, 8, 13, 17, 20 };
int min = int.MaxValue;
int diff = int.MinValue;
for (int i = 0; i < a.Length - 1; i++)
{
diff = a[i + 1] - a[i];
if (diff < min)
{
min = diff;
}
}
for (int i = 0; i < a.Length - 1; i++)
{
diff = a[i + 1] - a[i];
if (min == diff)
{
Console.WriteLine("({0}, {1})", a[i], a[i + 1]);
}
}
}
}
}
public class Test05 {
public static void main(String[] args) {
int[] su = {1,3,4,8,13,17,20};
int min = 100;
int min_su1 = 0;
int min_su2 = 0;
for (int i = 0; i <su.length-1; i++) {
int su1 = su[i];
for (int j = i+1; j < su.length; j++) {
int su2 = su[j];
int result = Math.abs(su[i]-su[j]);
System.out.println(su1+" "+su2+" "+result);
if(result<=min){
min_su1 = su[i];
min_su2 = su[j];
min = result;
}
}
}
System.out.println("("+min_su1+","+min_su2+")");
}
}
#include <stdio.h>
int main()
{
int n,i,r[10],s,t;
printf("점의 갯수(최대 10개) : ");
scanf("%d",&n);
for(i=1;i<=n;i++)
{
printf("%d번째 점 : ",i);
scanf("%d",&r[i-1]);
}
s=r[1]-r[0];
t=1;
for(i=2;i<n;i++)
{
if(s>r[i]-r[i-1])
{
s=r[i]-r[i-1];
t=i;
}
}
printf("(%d,%d)\n",r[t-1],r[t]);
}
만들고 보니 {1,2,3,4,5,6,7,8,9,10}이라고 할때 무조건 1,2가 답이 되는군요...
#define _CRT_SECURE_NO_WARNINGS
#include <windows.h>
#include <stdio.h>
int main(void) {
int s[] = { 1, 2, 3, 6, 19, 23, 54 };
int x, y, min = 9999;
for (int i = 0; i < sizeof(s) / sizeof(int); i++) {
for (int j = i+1; j < sizeof(s) / sizeof(int); j++) {
if (min > s[j] - s[i]) {
x = i, y = j;
min = s[j] - s[i];
}
}
}
printf("%d 와 %d의 거리가 %d으로 제일 짧다\n", x, y, min);
system("pause");
return 0;
}
#include <stdio.h>
#include <stdlib.h>
int main() {
int arr[7] = {1, 3, 4, 8, 13, 17, 20};
int arrLen = sizeof(arr)/sizeof(int);
int i, comp, num1, num2;
int min = arr[arrLen-1];
for(i=0; i<arrLen-1; i++)
{
comp = arr[i+1]-arr[i];
if(min > comp)
{
min = comp;
num1 = arr[i];
num2 = arr[i+1];
}
}
printf("{%d, %d} \n", num1, num2);
return 0;
}
void closure(int str[])
{
int min = str[1] - str[0];
int tarkets[2];
for (int i = 2; str[i]!=NULL; i++){
if (str[i] - str[i - 1] < min) {
min = str[i] - str[i - 1];
tarkets[0] = str[i - 1];
tarkets[1] = str[i];
}
}
printf("[%d, %d]\n", tarkets[0], tarkets[1]);
}
int main()
{
int str[20] = { 1,3,4,8,13,17,20 };
closure(str);
return 0;
}
def getProximatePoints(s) :
idx = 0
for i in range(len(s)-1) :
n = s[i+1] - s[i]
min = s[idx + 1] - s[idx]
if min > n :
idx = i
return s[idx:(idx+2)]
s = [1, 3, 4, 8, 13, 17, 20]
print(getProximatePoints(s))
파이썬
s = [1,3,4,8,13,17,20]
minGap = 0
for i in range(len(s)):
if i >= 1:
gap = s[i] - s[i-1]
if minGap == 0 or minGap > gap:
minGap = gap
g = i
print(s[g-1], s[g])
public class Main {
public static void main(String[] args){
int[] arr = {1, 3 ,4, 8, 13, 17, 20};
int min = arr[arr.length-1]; //정렬되어 있다는 가정하에 최대값 지정
int temp_a = 0;
int temp_b = 0;
for(int i=0; i<arr.length; i++){
if(i+1==arr.length){
break;
}
if(min>arr[i+1]-arr[i]){
min = arr[i+1] - arr[i];
temp_a = arr[i];
temp_b = arr[i+1];
}
}
System.out.print("("+temp_a+", "+temp_b+")" );
}
}
Python코드입니다.
S = list(input("Enter (a) point(s): ").split(' '))
s = []
for i in range(len(S)): s.append(int(S[i]))
TMP = 10000000000000000000000000000
for i in s[:-1]:
a = [i, s[s.index(i)+1]]
A = abs(a[0]-a[1])
for j in s[s.index(i)+2:]:
b = [i,j]
B = abs(i-j)
if min(A,B) == B: a=b; A=B
if min(TMP,A) == A: tmp=a; TMP=A
tmp.sort()
print("{"+"{}, {}".format(tmp[0],tmp[1])+"}")
파이썬 초보입니다. 많은 피드백 부탁드립니다!!
#include <iostream>
#include <math.h>
using namespace std;
int main() {
int size;
cin>>size;
int* S = new int[size];
for(int i = 0; i<size ; i++)
cin>>S[i];
int indexI, indexJ;
int min = 1000;
for(int i = 0; i<size ; i++) {
for(int j = i+1; j<size ; j++) {
if(abs(S[i]-S[j]) < min) {
min = abs(S[i]-S[j]);
indexI = i;
indexJ = j;
}
}
}
cout<<S[indexI]<<" "<<S[indexJ];
return 0;
}
def Count(x): ## x는 list y.index(z)
x.sort()
y=[]
z=[]
for i in range(0,len(x)-1):
y+=[x[i+1]-x[i]]
for i in range(len(y)):
if y[i]==min(y):
z+=[[x[i],x[i+1]]]
return z
python3.5
def find_min_value(s):
result = {} # key와 value를 저장하기 위한 빈 딕셔너리입니다.
for i in range(len(s)-1): # s 안에 있는 숫자들의 차를 구하기 위한 for문입니다.
test = s[i+1] - s[i] # 이미 정렬된 리스트의 두번째와 첫번째 숫자의 차를 구합니다.
result[test] = (i, i+1) # 숫자간의 차와 숫자들을 빈 딕셔너리에 저장합니다. 예를 들면 { 1 : (3, 4)}
key = min(result) # 숫자간의 차 중 최솟값을 찾습니다.
value = result[key] # 딕셔너리인 result에서 key에 해당하는 value를 찾습니다.
print(value) # value를 출력합니다.
후기 1. 위 문제에서는 s가 리스트가 아닌 딕셔너리로 저장되어 있는데, 딕셔너리가 아닌 리스트로 생각하고 문제를 풀었습니다. 2. 만약 딕셔너리로 문제를 풀어야 한다면, s는 모두 딕셔너리의 key 이므로 이 key들을 모두 리스트에 다시 저장하는 과정이 필요합니다.
import static org.junit.Assert.assertEquals;
import org.junit.Test;
public class MinDistance {
public static void main(String[] args) {
}
public String getShortestDistance(int[] s) {
int min = Integer.MAX_VALUE;
int point1 = 0;
int point2 = 0;
for(int i = 1; i < s.length; i++) {
if(s[i] - s[i - 1] < min) {
min = s[i] - s[i - 1];
point1 = s[i - 1];
point2 = s[i];
}
}
String result = "(" + point1 + ", " + point2 + ")";
return result;
}
@Test
public void testGetShortestDistance() {
int[] s = {1, 3, 4, 8, 13, 17, 20};
String result = getShortestDistance(s);
assertEquals("(3, 4)", result);
}
}
public static void main(String[] args) { int[] spots = {1, 2, 5, 8, 10, 13, 255}; int location = 0; int temp = 0;
for(int i = 0; i < spots.length - 1; i++) {
int minusValue = Math.abs(spots[i] - spots[i + 1]);
if (temp == 0) {
temp = minusValue;
}else {
if(temp > minusValue) {
temp = minusValue;
location = i;
}
}
}
int[] closest = {spots[location], spots[location + 1]};
System.out.println(Arrays.toString(closest));
}
가장 거리가 짧은 것의 쌍을 출력
int main(int argc, const char * argv[]) {
int points[] = {1, 3, 4, 8, 13, 17, 20};
int minIndex = findClosestPairIndex(points, 7);
printf("%d,%d\n", points[minIndex], points[minIndex+1]);
return 0;
}
점들의 배열은 모두 정렬되어있다고
int findClosestPairIndex(int points[], int numPoints) {
int minIndex = 0;
int minDistance = points[1] - points[0];
for (int i=1; i<numPoints-1; i++) {
int distance = points[i+1] - points[i];
if (minDistance > distance) {
minDistance = distance;
minIndex = i;
}
}
return minIndex;
}
def Nearest(S):
cha=[] # 입력값 list의 구성요소들간의 차를 모아둘 새로운 리스트.
for i in S :
for j in S :
cha.append(abs(i-j))
for x in cha :
if x == 0 :
cha.remove(x)
for a in S :
for b in S :
if abs(a-b) == min(cha):
return a,b
S = [1,3,4,8,13,17,20]
print(Nearest(S))
#include <iostream>
using namespace std;
int main()
{
int S[]={1, 3, 4, 8, 13, 17, 20};
const int Size = sizeof(S)/sizeof(S[0]);
int gap[Size-1];
int index=0;
for(int i=0 ;i<Size-1;i++){
gap[i]=S[i]-S[i+1];
}
for(int i=0;i<Size-1;i++){
if(gap[i]>gap[index]) index = i;
}
cout<<"("<<S[index]<<", "<<S[index+1]<<")"<<endl;
return 0;
}
public class Main {
/**
* @param args
*/
public static void main(String[] args) {
int[] S={1, 3, 4, 8, 13, 17, 20,21};
int minIndex = 0;
int preValue = Integer.MAX_VALUE;
for(int i = 0 ; i < S.length-1; i++){
int currentValue = Math.abs(S[i]-S[i+1]);
if(currentValue < preValue){
minIndex = i;
preValue = currentValue;
}
}
System.out.println(S[minIndex]+" "+ S[minIndex+1]);
}
}
static void Main(string[] args)
{
int[] list = { 1, 3, 4, 8, 13, 17, 20 };
List<int> dif = new List<int>();
for(int i=0; i<list.Length; i++)
{
int diffval = 0;
if(i < list.Length-1)
{
diffval = Math.Abs(list[i] - list[i + 1]);
dif.Add(diffval);
}
}
var mimdiffindex = dif.IndexOf(dif.Min());
Console.WriteLine(list[mimdiffindex] + "," + list[mimdiffindex+1]);
}
points = [1, 3, 5, 8, 13, 17, 20]
min_length = max(points) - min(points)
temp_result = 0
ptr = 0
for i in range(1,len(points)):
temp_result = points[i] - points[i-1]
if points[i] - points[i-1] < min_length:
min_length = temp_result
print (min_length)
파이썬 3.5로 풀었습니다.
def min_dist(lst):
dist = []
for i in range(len(lst)-1):
dist.append(lst[i+1] - lst[i])
result = [lst[dist.index(min(dist))], lst[dist.index(min(dist)) + 1]]
return result
source = [1, 3, 4, 8, 13, 17, 20]
min_distance = source[1] - source[0]
shortest_idx = 0
for i in range(1, len(source) - 1):
right_distance = source[i + 1] - source[i]
if right_distance < min_distance:
min_distance = right_distance
shortest_idx = i
print(source[shortest_idx], source[shortest_idx + 1])
include
include
void main(void) { int S[] = { 1,3,4,8,13,17,20 }; int i, j, min, result[2];
min = S[1] - S[0];
result[0] = S[0];
result[1] = S[1];
for (i = 1; i < sizeof(S) / sizeof(int); i++)
{
if (S[i] - S[i - 1] < min)
{
min = S[i] - S[i - 1];
result[0] = S[i - 1];
result[1] = S[i];
}
}
printf("%d %d\n", result[0], result[1]);
}
def func(arg):
x = list(arg)
size = len(x)
if size < 2:
return
offset = None
result = None
for i in range(1, size):
v = (x[i - 1], x[i])
if offset == None or offset > v[1] - v[0]:
offset = v[1] - v[0]
result = v
return result
print(func({1, 3, 4, 8, 13, 17, 20}))
Python 3.5.2에서 작성하였습니다.
List<int> points = new List<int>() { 1, 3, 4, 8, 13, 17, 20, 21 };
Dictionary<Tuple<int, int>, int> gapinfos = new Dictionary<Tuple<int, int>, int>();
for(int i = 0; i < points.Count - 1; i++)
gapinfos.Add(new Tuple<int, int>(points[i], points[i + 1]), points[i + 1] - points[i]);
int minvalue = gapinfos.Min(z => z.Value);
foreach(var v in gapinfos.Where(k => k.Value == minvalue)) {
Console.WriteLine(v.Key);
}
자바로 단순하게 처리했습니다
public int[] CheckArrayDist(ArrayList<Integer> input){
int minValue = input.get(input.size()-1) - input.get(0);
int[] fair = {input.get(0), input.get(input.size()-1) };
for(int i = 0; i < input.size() - 1; i++){
int tmpMinValue= input.get(i+1) - input.get(i);
if(tmpMinValue < minValue){
minValue = tmpMinValue;
fair[0] = input.get(i);
fair[1] = input.get(i+1);
}
}
return fair;
}
Python 3
def point(array):
idx = 1
tmp = []
result = array[1] - array[0]
while idx < len(array)-1:
result2 = array[idx+1] - array[idx]
if result2 < result:
result = result2
tmp.clear()
tmp.append(array[idx])
tmp.append(array[idx+1])
idx += 1
return tmp
print(point([1,3,4,8,13,17,20]))
include
include
void main() { int i, n;
printf("점 개수\n");
scanf("%d", &n);
int* a = (int*)malloc(n*sizeof(int));
for (i = 0; i < n; i++) { scanf("%d", a+i); }
int d = a[1] - a[0];
int x = 0, y = 1;
for (i = 1; i < (n-1); i++) {
if (d > (a[i+1] - a[i])) {
d = (a[i+1] - a[i]);
x = a[i], y = a[i+1];
}
}
printf("(%d, %d)\n", x, y);
free(a);
}
a = [1,3,4,8,13,17,20]
a.sort()
c = []
for i in range(0,len(a)-1):
b = a[i+1] - a[i]
c.append(b)
d = c.index(min(c))
print(a[d], a[d+1])
S = [1,3,4,8,13,17,20]
dict_ = {S[x+1] - S[x]: (S[x],S[x+1]) for x in range(len(S)-1)}
print(dict_[min(dict_.keys())])
#### 2016.12.09 D-440 ####
public class Distance {
private int[] s = {1, 3, 7, 8, 13, 17, 20};
private int[] result = {this.s[0], this.s[1]};
public void getDistance() {
int sub = Math.abs(this.s[0] - this.s[1]);
for(int i = 0, size = this.s.length - 2; i < size; i++) {
if(Math.abs(this.s[i] - this.s[i + 1]) < sub ) {
result[0] = s[i];
result[1] = s[i + 1];
}
}
System.out.println(this.result[0] + ", " + this.result[1]);
}
public static void main(String[] args) {
new Distance().getDistance();
}
}
자바 결과 : 3, 4
public class test {
public static void main(String[] args) {
int[] test = {1, 3, 4, 8, 13, 17, 20};
int minimum = 0; // 두 수의 차가 저장될 변수
int index = 0; // 두 수의 차가 최소 값일 경우 index 번지 저장
minimum = test[1]-test[0]; // 초기값 (1번지 - 0번지)
for(int i = 1 ; i <= test.length-2 ; i++) { // 0,1번지 제외
if(minimum > (test[i+1]-test[i])){ // 현재 저장된 값보다 작을경우
minimum = test[i+1]-test[i]; // minumum에 대입
index = i;
}
}
System.out.println(test[index] + " ," + test[index+1]);
}
}
#include<stdio.h>
#include<stdlib.h>
#include<time.h>
#define MAX 10000
int main(void)
{
int i,j,a,b[MAX];
int least,tmp,mini=100;
srand((unsigned)time(NULL));
printf("갯수\n");
scanf("%d",&a);
for(i=0;i<a;i++)
b[i]=rand()%300;
for(i=0;i<a-1;i++)
{
least=i;
for(j=i+1;j<a;j++)
if(b[j]<b[least])
{
tmp=b[j];
b[j]=b[least];
b[least]=tmp;
}
}
printf("\n");
for(i=0;i<a-1;i++)
{
if(b[i+1]-b[i]==0) continue;
if((b[i+1]-b[i])<mini)
{
mini=b[i+1]-b[i];
printf("결과값은(%d,%d)차이는 %d입니다\n",b[i],b[i+1],mini);
}
}
for(i=0;i<a;i++)
printf("%d\t",b[i]);
return 0;
}
a=(1, 3, 4, 8, 13, 17, 20)
a=b
c=100000
for num in a:
for num2 in b:
if (num-num2)==0:
continue
elif (num-num2)>0 and (num-num2)<c:
c=(num-num2)
print('최종숫자두개',num,num2)
Python 3
S = [1, 3, 4, 8, 13, 17, 20]
pairs = zip(S[:-1], S[1:])
print(sorted(pairs, key=lambda pair:abs(pair[0]-pair[1]))[0])
실행결과
(3, 4)
Haskell로 작성하였습니다.
import Data.List
s = [1, 3, 4, 8, 13, 17, 20]
main = print $ sortBy (\(x1, y1) (x2, y2) -> if abs(x1-y1) > abs(x2-y2) then GT else LT) (zip (init s) (tail s)) !! 0
실행결과
(3, 4)
Python 2.7
def minVector(s):
minusList = []
for i in range(0,len(s)-1):
v = s[i+1] - s[i]
minusList.append(v)
return s[minusList.index(min(minusList))],s[minusList.index(min(minusList))+1]
public static void main(String[] args) {
int[] S = {1,3,5,8,13,17,20};
System.out.println("("+S[findMin(S)]+", "+S[findMin(S)+1]+")");
}
private static int findMin(int[] s) {
int min = s[1] - s[0];
int res=0;
for(int i=1; i<s.length-1; i++) {
if(min > s[i+1] - s[i]) {
min = s[i+1] - s[i];
res = i;
}
}
return res;
}
public class test03 { public static void main(String[] args) {
int[] su = {10, 20, 14, 15};
int tmp=0;
//내림차순 select sort
for(int j=0; j < su.length; j++){
for(int i=0; i < su.length-1; i++){
if(su[i] < su[i+1]){
tmp = su[i];
su[i] = su[i+1];
su[i+1] = tmp;
}
}
}
int min=9999;
//차가 적은 수 확인
for(int idx=0;idx < su.length - 1 ;idx++){
if(min > su[idx] -su[idx+1]){
min = su[idx] - su[idx+1];
}
}
//결과 값
for(int idx=0;idx < su.length - 1 ;idx++){
if(min == su[idx] - su[idx+1]){
System.out.println("차가 적은 수 : " + su[idx+1] + ", " + su[idx]);
}
}
}
}
$nums= array(1, 3, 4, 8, 13, 17, 20);
sort($nums);
foreach($nums as $key => $num){
if(max($nums) == $num) continue;
$diff[$key] = abs($nums[$key+1] - $num);
}
echo sprintf("{%s} - {%s,%s}",join(",",$nums),$nums[min($diff)],$nums[min($diff)+1]);
import java.lang.reflect.Array;
public class Closet {
public static void main(String[] args) {
int[] Points = {1, 3, 4, 8, 13, 17, 20};
int numberOfPoints = Array.getLength(Points);
int[] Dist = new int[numberOfPoints -1];
for (int i=0; i<numberOfPoints-1; i++) {
Dist[i] = Points[i+1] - Points[i];
}
int minPosition = 0;
int minValue = Dist[0];
for (int i=0; i<numberOfPoints-2; i++) {
if (Dist[i+1] < minValue) {
minPosition = i+1;
minValue = Dist[i+1];
}
}
System.out.println("Answer : {" + Points[minPosition] + ", " + Points[minPosition+1] + "}");
}
}
public class daum {
public static void main(String arge[]){
//Scanner s=new Scanner(System.in);
int[] S={1, 3, 4, 8, 13, 17, 20};
int min=-1;
int num1=-1,num2=-1;
for(int i=1;i<S.length;i++){
if(min>S[i-1]-S[i]){
min=S[i-1]-S[i];
num1=i-1;
num2=i;
}
}
System.out.println("("+num1+","+num2+")");
}
}
미숙한 실력이지만 풀어봤습니다
#include <iostream>
using namespace std;
int main()
{
int iPtr[7] = {1, 3, 4, 8, 13, 17, 20};
int iCnt = 0;
int iNum1 = 0;
int iNum2 = 0;
int iMinDis = 1000;
iCnt = sizeof(iPtr) / sizeof(*iPtr);
for(int i = 0; i < iCnt - 1; ++i)
{
if(iMinDis >= iPtr[i + 1] - iPtr[i])
{
iMinDis = iPtr[i + 1] - iPtr[i];
iNum1 = iPtr[i];
iNum2 = iPtr[i + 1];
}
}
cout << iNum1 << " " << iNum2 << endl;
return 0;
}
def mindistance_1d(a):
a=list(map(lambda x,y:(x,y), a[:len(a)], a[1:]))
md=min(map(lambda x: x[1]-x[0], a))
return [x for x in a if x[1]-x[0]==md]
// C++
int main()
{
int nValue = 0;
set< int > snData;
while( true )
{
cin >> nValue;
if( nValue == 0 )
{
break;
}
snData.insert( nValue );
}
set< pair< int, int > > spairResult;
set< int >::iterator iterPoint = snData.begin();
set< int >::iterator iterEnd = snData.end();
unsigned int uMin = -1;
int nCur = 0;
int nNext = 0;
while( iterPoint != iterEnd )
{
nCur = *iterPoint;
++iterPoint;
if( iterPoint != iterEnd )
{
nNext = *iterPoint;
if( uMin >= ( unsigned int )( nNext - nCur ) )
{
uMin = ( nNext - nCur );
spairResult.insert( make_pair( nCur, nNext ) );
}
}
}
set< pair< int, int > >::iterator iterPointResult = spairResult.begin();
set< pair< int, int > >::iterator iterEndResult = spairResult.end();
while( iterPointResult != iterEndResult )
{
cout << iterPointResult->first << "," << iterPointResult->second << "\n";
++iterPointResult;
}
return 0;
}
def find_minimal_distance(a):
a = list(a)
a.sort()
list_distance = []
for x in range(len(a)-1):
y = a[x+1] - a[x]
list_distance.append(y)
b = list_distance.index(min(list_distance))
result = (a[b], a[b+1])
return result
var arr = new List<int> { 1, 3, 4, 8, 13, 17, 20 };
var result = new List<int[]>(arr.Count - 1);
int min = int.MaxValue;
for(int i = 0; i < arr.Count - 1; i++)
{
int abs = Math.Abs(arr[i] - arr[i + 1]);
if(abs < min)
{
min = abs;
result.Clear();
result.Add(new int[2] { arr[i], arr[i + 1] });
}
else if(abs == min)
{
result.Add(new int[2] { arr[i], arr[i + 1] });
}
}
foreach(var i in result)
{
Console.WriteLine($"result : {i[0]}, {i[1]}");
}
public static void main(String[] args) {
int[] S={1,3,4,8,13,17,20};
int min=100,v1=0,v2=0;
for(int i=0;i<S.length;i++){
for(int j=i+1;j<S.length;j++){
int _dis = Math.abs(S[i]-S[j]);
if(_dis<min){
min=_dis;
v1=i;
v2=j;
}
}
}
System.out.println("( "+S[v1]+" , "+S[v2]+" )");
}
#include <stdio.h>
#pragma warning(disable:4996)
int _short(int *arr,int n) {
int min = 999999;
int k;
for (int i = 0; i < n-1; i++) {
if (arr[i + 1] - arr[i] < min) {
min = arr[i + 1] - arr[i];
k = i;
}
}
return k;
}
int main(void) {
int arr[7] = { 1,3,4,8,13,17,20 };
printf("(%d,%d)", arr[_short(arr,7)],arr[_short(arr,7)+1]);
}
s= [1, 3, 4, 8, 13, 17, 20]
def pairFn(s):
index=0
temp=0
for i in range(0, len(s)-1):
pair = s[i+1] - s[i]
if(temp==0 or temp>pair):
temp=pair
index=i
return (s[index], s[index+1])
print('%d, %d' % (pairFn(s)))
public static void main(String[] args) {
int[] point = {1, 3, 4, 8, 13, 17, 20};
int start = 0;
int end = 0;
int minDistance = 10000;
for (int i = 1; i < point.length; i++) {
if (minDistance > Math.abs(point[i - 1] - point[i])) {
minDistance = Math.abs(point[i - 1] - point[i]);
start = point[i - 1];
end = point[i];
}
}
System.out.println("start : " + start);
System.out.println("end : " + end);
System.out.println("minDistance : " + minDistance);
}
파이썬으로 대충 짜 보았습니다.
def func(S):
distance = list() # 점들간의 거리를 저장할 리스트
for index in range(len(S)-2):
distance.append(S[index+1]-S[index]) # distance[index] == S[index+1] - S[index]
return (S[distance.index(min(distance))], S[distance.index(min(distance))+1])
# └→S[distance의 최솟값의 인덱스]
def min_dist(data):
result=[0,data[1]-data[0]]
for i in range(len(data)-2):
if result[1] > data[i+2]-data[i+1]:
result=[i+1,data[i+2]-data[i+1]]
return [data[result[0]],data[result[0]+1]]
/*
DAUM 입사문제
1차원의 점들이 주어졌을 때, 그 중 가장 거리가 짧은 것의 쌍을 출력하는 함수를 작성하시오. (단 점들의 배열은 모두 정렬되어있다고 가정한다.)
예를들어 S={1, 3, 4, 8, 13, 17, 20} 이 주어졌다면, 결과값은 (3, 4)가 될 것이다.
*/
#include <iostream>
using namespace std;
const int MAX_NUM = 10000;
int main(void)
{
int arr[] = { 1, 3, 4, 8, 13, 17, 20 };
int indexMinNumber = 0;
int minNumber = MAX_NUM;
for (int i = 0; (i < (sizeof arr / (sizeof(int)))-1); i++)
{
if (minNumber > arr[i + 1] - arr[i])
{
minNumber = arr[i + 1] - arr[i];
indexMinNumber = i;
}
}
cout << "결과값 : (" << arr[indexMinNumber] << ", " << arr[indexMinNumber +1] << ")" << endl;
}
import java.util.*;
public class Daum {
public static void main(String[] args) {
Integer[] s = {1, 3, 4, 8, 13, 17, 20};
Map<Integer, String> r = new HashMap();
Arrays.asList(s).stream().reduce((a, b) -> {
if (r.get(b - a) == null) {
r.put(b - a, "(" + a + ", " + b + ")");
} else {
r.put(b - a, r.get(b - a).concat(", (" + a + ", " + b + ")"));
}
return b;
});
System.out.println(r.entrySet().stream().min(Map.Entry.comparingByKey()).orElse(null).getValue());
}
}
s=[1,3,4,8,13,17,20]
min_dist = s[1]-s[0]
x=s[0]
y=s[1]
for item in range(2, len(s)):
temp = s[item] - s[item-1]
if temp < min_dist:
x=s[item-1]
y=s[item]
min_dist = temp
print(x, y)
var distanceList = new List<int>() { 2, 8, 55, 8, 13, 17, 20, 23, 3, 5 };
var lastIndex = distanceList.Count;
var minValue = int.MaxValue;
int findIndex = 0;
int currentIndex = 0;
int nextIndex = 0;
int diffValue = 0;
distanceList.ForEach(d =>
{
nextIndex = currentIndex + 1;
if(lastIndex > nextIndex)
{
diffValue = Math.Abs(d - distanceList[nextIndex]);
if (minValue > diffValue)
{
minValue = diffValue;
findIndex = currentIndex;
}
}
currentIndex++;
});
Console.Write(string.Format("{0} , {1}", distanceList[findIndex], distanceList[findIndex + 1]));
python 3.5.2
answer is 3, 4 사이
S={1,3,4,8,13,17,20}
S2 = list(S)
min_dist = 100
for i in range(len(S2)) :
if i < len(S2)-1 :
temp = abs(S2[i] - S2[i+1])
if temp < min_dist :
min_dist = temp
temp_idx = i
print('anser is (%s, %s)' % (temp_idx, temp_idx+1))
List = [1,3,4,8,13,17,20,21,34,42,54]
Diff = [List[x+1]-List[x] for x in range(0,len(List)-1)]
Answer = [(List[index],List[index+1]) for index in range(0,len(Diff)) if Diff[index] == min(Diff)]
Python 3.6
S=[1, 3, 4, 8, 13, 17, 20]
term = S[1]-S[0]
idx = 1
for i in range(1,len(S)):
if S[i] - S[i-1] < term:
term = S[i]-S[i-1]
idx = i
print(S[idx-1],S[idx])
전형적인 입문자 수준 풀이
/***********************************************************************************
1차원의 점들이 주어졌을 때, 그 중 가장 거리가 짧은 것의 쌍을 출력하는 함수를 작성하시오. (단 점들의 배열은 모두 정렬되어있다고 가정한다.)
예를들어 S={1, 3, 4, 8, 13, 17, 20} 이 주어졌다면, 결과값은 (3, 4)가 될 것이다.
************************************************************************************/
#include<stdio.h>
#include<math.h>
#include<limits.h>
#define ARR_SIZE 100
void Init_Arr(int* arr, int size);
int main(void)
{
int arr[ARR_SIZE];
int size_temp,input_size,i,j;
int result,d1,d2;
Init_Arr(arr,ARR_SIZE);
scanf("%d",&input_size);
for(i=0;i<input_size;i++)
{
scanf("%d",&arr[i]);
}
result=INT_MAX;
for(i=0;i<input_size-1;i++)
{
for(j=i+1;j<input_size;j++)
{
if(result>abs(arr[i]-arr[j]))
{
result=abs(arr[i]-arr[j]);
d1=arr[i];
d2=arr[j];
}
}
}
printf("%d %d %d",result,d1,d2);
return 0;
}
void Init_Arr(int* arr, int size)
{
int i;
for(i=0;i<size;i++)
arr[i]=0;
}
파이썬 3.5.3 으로 작성하였습니다.
s=[1,5,7,8,13,17,20]
compare = 9999999999
result1 = 0
result2 = 0
for x in range(0,len(s)):
for y in range(x+1,len(s)):
if s[y]-s[x] < compare:
result1 = s[x]
result2 = s[y]
compare = s[y]-s[x]
print(result1)
print(result2)
다른분들걸 보기전에 올리는 연습용 코드이니 크게 신경쓰지 말아주세요
static void Main(string[] args)
{
int[] chArray = { 1, 3, 4, 8, 13, 17, 20 };
int min;
min = chArray[1] - chArray[0];
for (int i = 0; i < chArray.Length-1; i++)
{
if (chArray[i + 1] - chArray[i] < min)
{
Console.WriteLine(chArray[i] + " " + chArray[i + 1]);
}
}
}
public class GetMultiples {
public static void main(String[] args){
GetMultiples obj = new GetMultiples();
int[] s = {1,6,9,11,17,20};
obj.getShorter(s);
}
public void getShorter(int[] arr){
int result = arr[1]-arr[0];
int resultTemp;
int answer = 0;
for(int i =1; i<arr.length-1; i++){
resultTemp = arr[i+1]-arr[i];
result = (result > resultTemp) ? resultTemp : result;
if( result == resultTemp ){
answer = i;
}
}
System.out.print("{"+arr[answer]+","+arr[answer+1]+"}");
}
}
var s= [1,3,4,8,13,17,20];
var arr = new Array();
for(var i=1;i<s.length;i++){
arr.push(s[i]-s[i-1]);
}
var result = arr.indexOf(Math.min.apply(null,arr));
document.write(s[result]+','+s[result+1]);
public void go(int num[]) {
int a=num.length-1;
for(int i=a ; i>1 ; i--) {
if((num[a] - num[a-1]) > (num[i-1] - num[i-2]))
a = i-1 ;
}
System.out.print("("+num[a-1]+","+num[a]+")");
}
s = [1, 3, 7, 14, 19, 35, 36, 58]
def short(t):
num = []
for n in range(0, len(t)-1):
x = abs(t[n+1] - t[n])
num += str(x)
return sorted(num)[0]
min = short(s)
for n in range(0, len(s)-1):
x = abs(s[n+1]-s[n])
if x == int(min):
print(s[n], s[n+1])
#include<iostream>
using namespace std;
int main()
{
int S[] = { 1, 3, 4, 8, 13, 17, 20 };
int min_length = 1000;
int min_value1, min_value2;
for (int i = 0; i < (sizeof(S) / sizeof(int))-1; i++)
{
if (min_length > S[i + 1] - S[i])
{
min_length = S[i + 1] - S[i];
min_value1 = S[i];
min_value2 = S[i + 1];
}
}
cout << "원소값의 거리가 가장짧은 값은 : (" << min_value1 << "," << min_value2 << ") 입니다." << endl;
return 0;
}
sol=[]
diff_min=S[6]-S[0]
for a in S:
for b in S:
diff_val=abs(a-b)
if diff_val < diff_min and diff_val != 0:
diff_min=diff_val
sol=[a,b]
print(sol)
include
include
using namespace std;
void f_abs(int *arr, int rangarr) { int rangshort; int shortindex; int i;
rangshort = arr[1] - arr[0];
shortindex = arr[0];
for (i = 0; i < rangarr; i++)
{
cout << arr[i] << ", ";
}
cout << "\n\n" << "배열 길이: " << rangarr << '\n' << endl;
for (i = 0; i < rangarr - 1; i++)
{
if (arr[i + 1] - arr[i] < rangshort)
{
rangshort = arr[i + 1] - arr[i];
shortindex = i;
}
cout << "(" << arr[i] << ", " << arr[i + 1] << ")" << endl;
}
cout << rangshort << endl;
cout << "(" << arr[shortindex] << ", "<< arr[shortindex + 1] << ")" << endl;
}
int main() { int S[] = { 1, 3, 4, 8, 13, 17, 20 };
cout << "배열 길이: " << sizeof(S) / sizeof(int) << '\n' << endl;
f_abs(S, sizeof(S) / sizeof(int));
}
c언어로 했읍니다.
#include <stdio.h>
void main() {
int ar[10];
int distance=100000000, index[2];
int i, j, temp;
printf("1차원 점들 입력 : ");
for(i=0;i<10;i++)
scanf("%d", &ar[i]);
for (i = 0; i < 10; i++) {
for (j = i + 1; j < 10; j++) {
temp = ar[i] - ar[j];
if (temp < 0) temp *= -1;
if (distance > temp) {
distance = temp;
index[0] = i;
index[1] = j;
}
}
}
printf("가장 짧은 거리의 쌍 :%d %d\t 거리 값 : %d \n ", ar[index[0]], ar[index[1]], distance);
}
package lvl1;
/*1차원의 점들이 주어졌을 때, 그 중 가장 거리가 짧은 것의 쌍을 출력하는 함수를 작성하시오. (단 점들의 배열은 모두 정렬되어있다고 가정한다.)
예를들어 S={1, 3, 4, 8, 13, 17, 20} 이 주어졌다면, 결과값은 (3, 4)가 될 것이다.*/
public class Dim_1_array {
private static void f_dim(String str) {
// TODO Auto-generated method stub
String[] input = str.split(",");
int[] temp = new int[input.length-1];
int min_diff=9999;
// input[i] < input[i+1]
for (int i = 0; i < input.length-1; i++) {
temp[i] = Integer.parseInt(input[i+1])-Integer.parseInt(input[i]);
if (temp[i]<min_diff){min_diff = temp[i];}
}
for (int i = 0; i < temp.length; i++) {
if (temp[i]==min_diff){
System.out.println("("+input[i]+","+input[i+1]+")");
}
}
}
public static void main(String[] args) {
// TODO Auto-generated method stub
String s = "1,3,4,8,13,17,18,20";
f_dim(s);
}
}
package training;
public class FindNearPair {
public static void main(String[] args) {
int[] iArr = {1, 3, 4, 8, 13, 17, 20};
int[] iArr2 = new int[2];
int iGap = 0;
for(int i=0;i<iArr.length-1;i++){
if(i == 0){ // first gap
iGap = iArr[i+1]-iArr[i];
iArr2[0] = iArr[i];
iArr2[1] = iArr[i+1];
} else if(iGap > iArr[i+1]-iArr[i]){
iGap = iArr[i+1]-iArr[i];
iArr2[0] = iArr[i];
iArr2[1] = iArr[i+1];
}
}
// print result
System.out.println("{"+iArr2[0]+","+iArr2[1]+"}");
System.out.println("GAP ===> " + iGap);
}
}
Python 3.5.1
#원하는 1차원점 입력받음. 입력 완료시 '0'
s=[]
while True:
num = int(input('위치를 입력하세요. 입력완료시: 0 입력.'))
if num == 0: break
if s.count(num) == 1: continue
s.append(num)
s.sort()
print(min(zip(s[:-1], s[1:]), key=lambda x: x[1]-x[0]))
private static void minDistance(int[] array){
if(array.length < 2){
System.out.println("입력한 배열의 길이가 2보다 작습니다");
}else{
int minIndex = 0;
int minValue = array[1] - array[0];
for(int i=1; i<array.length-1; i++){
if(array[i+1] - array[i] < minValue){
minIndex = i;
minValue = array[i+1] - array[i];
}
}
System.out.println("(" + array[minIndex] + "," + array[minIndex+1] + ")");
}
}
def minimum_distance(nums):
min = nums[1]-nums[0]
pair = (nums[0], nums[1])
for i in range(1, len(nums)-1):
if nums[i+1] - nums[i] < min:
min = nums[i+1] - nums[i]
pair = (nums[i], nums[i+1])
return pair
S1 = [1, 3, 4, 8, 13, 17, 20]
print(minimum_distance(S1))
S2 = [2, 10, 14, 20, 22, 39]
print(minimum_distance(S2))
파이썬 3.5입니다. 숫자들이 정렬되어 있다는 조건이 있어서 붙어있는 숫자들 중에 가장 적은 차이를 갖는 숫자들의 쌍을 반환하는 함수를 만들었습니다. S1을 함수에 입력으로 넣어줬을 때는, (3, 4)가 출력되고, S2를 입력해줄 때는, (20, 22)가 출력됩니다.
def shortest(nums):
couple= list( (nums[i], nums[i+1], abs(nums[i]-nums[i+1])) for i in range(len(nums)-1) )
result = []
for coup in couple:
if coup[2] == min( list (coup[2] for coup in couple)) : result.append(coup[:2])
return result
print ( shortest([1, 3, 4, 8, 13, 17, 19, 20]) )
package Problems;
public class MoseClosestOne_Daum { public static void main(String[] args) { //S={1, 3, 4, 8, 13, 17, 20} 이 주어졌다면, 결과값은 (3, 4)
int[] S = {1, 3, 4, 8, 13, 17, 20};
int num = 0;
int[] result = new int[2];
num = S[1] - S[0];
for (int i =0; i < S.length-1; i++){
System.out.println(num);
if (S[i+1] - S[i] < num ){
result[0] = S[i];
result[1] = S[i+1];
}
}
System.out.println("result: "+ result[0] + " " + result[1]);
}
}
만약에 최소값이 두개 이상인 경우 즉, s = [1, 2, 3, 4, 5, 8, 10, 15, 19] 일 경우
s = [1,2,3,4,5,8,10,15,19]
s_pair = list(zip(s[0:],s[1:])) # 튜풀쌍으로 묶기
s_sorted = sorted(s_pair, key=lambda x:x[1]-x[0]) # 튜플쌍을 최소값차로 정렬하여
min_diff = s_sorted[0][1] - s_sorted[0][0] # 첫번째 인자의 차이를 최소값 저장
for i in range(len(s)):
if min_diff == s[i][1]-s[i][0]: print(s[i])
else: break
결과
...
(1, 2)
(2, 3)
(3, 4)
(4, 5)
#include <iostream>
#include <stdio.h>
int main( int argc , char** argv )
{
vector< int > rVec;
rVec.push_back( 1 );
rVec.push_back( 3 );
rVec.push_back( 4 );
rVec.push_back( 8 );
rVec.push_back( 13 );
rVec.push_back( 17 );
rVec.push_back( 20 );
int distance = 0;
int temp = 0;
int result[ 2 ] = { 0 , 0 };
for( size_t i = 0 ; i < rVec.size() - 1 ; ++i )
{
if( i == 0 )
{
distance = rVec[ i + 1 ] - rVec[ i ];
result[ 0 ] = rVec[ i ];
result[ 1 ] = rVec[ i + 1 ];
}
else if( ( temp = rVec[ i + 1 ] - rVec[ i ] ) < distance )
{
distance = temp;
result[ 0 ] = rVec[ i ];
result[ 1 ] = rVec[ i + 1 ];
}
}
printf( "(%d,%d)\n" , result[ 0 ] , result[ 1 ] );
}
# 1. global result를 [왼쪽 점의 좌표, 거리(당연히 최소값)]으로 정의한다.
# 어짜피 오른쪽 점의 좌표는 왼쪽 점의 좌표에 +1이니까...
# 따라서 초기화 값은 [0, 1, 맨 마지막 점의 좌표]하면 된다.
# 점들 간의 거리가 가장 큰 값은 맨 마지막 점의 죄표가 되기 때문에 min값의 초기화로 적합하다.
# 간단하게 max로 구해도 된다.
#
# 2. for와 i in range(0, len(점들의 배열)-1)을 이용해서 하나씩 숫자를 늘려간다.
# 마지막 점은 어짜피 쌍이 없으니 계산하지 않아도 된다. 따라서 len()-1까지만 한다.
#
# 3.1. 점들간의 거리를 측정한다.
# 3.2. 점들간의 거리가 global result[2]보다 작으면 기존 global result 값을 날리고(1)
# [새로운 왼쪽 점, 새로운 오른쪽 점, 점간 거리]로 새로 세팅한다.
S = [1, 3, 4, 8, 13, 17, 20]
result_min_distance = [0, S[-1]] # 1.
for i in range(0, len(S)-1): # 2.
distance = S[i+1] - S[i] # 3.1
if distance < result_min_distance[1]: # 3.2
result_min_distance = [i, distance]
print("거리가 최소인 점은 (%d, %d)이며 거리는 %d입니다." %(S[result_min_distance[0]], S[result_min_distance[0]+1], result_min_distance[1]))
[결과값] 거리가 최소인 점은 (3, 4)이며 거리는 1입니다.
S=[1, 3, 4, 8, 13, 17, 20]
near=[]
for i in range(len(S)-1):
result=S[i+1]-S[i]
near.append(result)
a=S[near.index(min(near))]
print(a,a+1)
public static void main(String[] args) {
int[] S ={1,5,15,27,65,3};
int A = 0,B = 0;
int min = Math.abs(S[0]-S[1]);
for(int i=0;i<S.length;i++){
for(int j=0;j<S.length;j++){
if(i==j)
continue;
else if(Math.abs(S[i]-S[j])<min){
min = Math.abs(S[i]-S[j]);
A = S[i]; B=S[j];
}
}
}
System.out.println(min);
System.out.print(A+" "+B);
저같은 비전공 노가다꾼도 있을거라고 생각합니다. ㅋ
s = [1,3,4,8,13,17,20]
result_set = []
result = []
for i in range(len(s)):
for j in range(len(s)-1,-1,-1):
s1 = s[i]
s2 = s[j]
# print(s1,s2)
result_set.append([s1,s2])
if((s2 - s1) > 0):
result.append(s2 - s1)
print(result_set[result.index(min(result))+1])
class Practice01 {
public static void main(String[] args) {
/*
1차원의 점들이 주어졌을 때, 그 중 가장 거리가 짦은 것의 쌍을 출력하는 함수를 작성하시오.
(단 점들의 배열은 모두 정렬 되어있다고 가정한다.)
예를 들어 S = {1, 3, 4, 8, 13, 17, 20} 이 주어졌다면, 결과값은 (3, 4)가 될 것이다.
*/
int[] arr = new int[]{1,3,4,8,13,17,20};
int temp = 0;
for(int i = 1 ; i < arr.length-1 ; i++){
int compare = arr[1]-arr[0];
if(compare > arr[i+1]-arr[i]){
temp = i;
}
}
System.out.println("("+arr[temp]+", "+arr[temp+1]+")");
}
}
s = [1,3,4,8,13,17,20] s.sort() result = [] for i in range(len(s)): if i <len(s)-1: result.append((s[i+1]-s[i]))
i = result.index(min(result)) print('Minimum couple = %d and %d'% (s[i],s[i+1]))
JAVA
class Practice01 {
public static void main(String[] args) {
int[] ar = new int[]{1, 3, 4, 8, 13, 17, 20};
int subData = ar[1] - ar[0];
int[] ary = new int[]{ar[0], ar[1]};
for(int i = 0 ; i<ar.length ; i++){
for(int e = i+1; e<ar.length ; e++){
if(ar[e] - ar[i] < subData ){
ary[0] = ar[i];
ary[1] = ar[e];
// ary = new int[]{ar[i], ar[e]};
}
}
}System.out.println("가장 거리가 짧은 쌍: "+ary[0]+".."+ ary[1]);
}
}
class 연습4 {
public static void main(String[] args) {
// 1차원의 점들이 주어졌을 때, 그 중 가장 거리가 짧은 것의 쌍을 출력하는 함수를 작성하시오. (단 점들의 배열은 모두 정렬되어있다고 가정한다.)
// 예를들어 S={1, 3, 4, 8, 13, 17, 20} 이 주어졌다면, 결과값은 (3, 4)가 될 것이다.
int[] a = new int[]{1,3,4,8,13,17,17};
int m = a[1] - a[0];
int cnt = 0;
for(int i=0 ; i<a.length-1 ; i++) {
if(m>a[i+1]-a[i]) {
cnt = i;
}
}
System.out.println(a[cnt]+","+a[cnt+1]);
}
}
import java.util.ArrayList;
import java.util.HashSet;
public class test3 {
public static void main(String[] args) {
int sampleSet[] = {1, 3, 4, 8, 13, 17, 18, 20};
ArrayList minArray0 = new ArrayList();
ArrayList minArray1 = new ArrayList();
minArray0.add(sampleSet[0]);
minArray1.add(sampleSet[1]);
ArrayList minArraySet = new ArrayList();
minArraySet.add(minArray0);
minArraySet.add(minArray1);
int count = 0;
for (int i = 0; i < sampleSet.length-1; i++) {
if((sampleSet[i+1] - sampleSet[i])<
((Integer)minArray1.get(count)-(Integer)minArray0.get(count))){
minArray0.set(count, sampleSet[i]);
minArray1.set(count, sampleSet[i+1]);
}
}
for (int i = 0; i < sampleSet.length-1; i++) {
if((sampleSet[i+1] - sampleSet[i])==
((Integer)minArray1.get(count)-(Integer)minArray0.get(count))){
count++;
minArray0.add(sampleSet[i]);
minArray1.add(sampleSet[i+1]);
}
}
HashSet noDupl0 = new HashSet(minArray0);
HashSet noDupl1 = new HashSet(minArray1);
ArrayList minArray0Fixed = new ArrayList(noDupl0);
ArrayList minArray1Fixed = new ArrayList(noDupl1);
for (int i = 0; i < minArray0Fixed.size(); i++) {
System.out.println(minArray0Fixed.get(i)+","+minArray1Fixed.get(i));
}
}
}
//1차원 점들은 0~100까지 랜덤으로 정하겠다.
public class Shortpair{
public static void main(String[] args){
int[] a=new int[6];
for(int i=0;i<6;i++){
a[i]=(int)(Math.random()*101);
}
System.out.println("랜덤배정 된 수");
for(int k:a){
System.out.print(k+ " ");
}
System.out.println();
int min=100;
String result="";
for(int i=0;i<6;i++){
for(int j=i+1;j<6;j++){
int length=Math.abs(a[i]-a[j]);
if(min>length){
if(a[i]==a[j])
continue;
min=length;
result=a[i]+" "+a[j]+" ";
}
else if(min==length){
result=result+a[i]+" "+a[j]+" ";
}
}
}
System.out.println("최단거리 점들"+result);
}
}
void distance (int [] point){
int min = 9999;
int [] result = new int [2];
for (int i=0; i<point.length-2; i++){
int temp = point[i+1]-point[i];
if (temp < min) {
min = temp;
result[0] = point[i];
result[1] = point[i+1];
}
}
print("(" + result[0] + ", " + result[1] + ")");
}
#get list of dots(no two are the same)
num_list = []
while True:
dot = int(input("Input an integer. > "))
if dot not in num_list:
num_list.append(dot)
cont = input("Continue? Press n to stop, else to continue. > ")
if str(cont) == "n":
break
#put them in order
num_list = sorted(num_list)
#get shortest distance
def short(list):
min_distance = list[1] - list[0]
for a in range(1, len(list)-1):
if list[a+1] - list[a] < min_distance:
min_distance = list[a+1] - list[a]
return min_distance
#print results
for a in range(len(num_list)-1):
if num_list[a+1] - num_list[a] == short(num_list):
print ("(" + str(num_list[a]) + ", " + str(num_list[a+1]) + ")")
box = []
imsi = []
result = []
while True:
a = input("숫자를 입력하세요 :")
box.append(a)
b = int(input("입력이 완료되었으면 1을 눌르세요 아니면 그 외 숫자를 눌르세요 :"))
if b == 1:
break
box.sort()
for i in range(2,len(box)-1):
c = int(box[i+1])-int(box[i])
d = int(box[i])-int(box[i-1])
imsi.append(c)
imsi.append(d)
mi=min(imsi)
for i in range(1,len(box)-1):
e = int(box[i+1])-int(box[i])
if(e==mi):
result.append(box[i+1])
result.append(box[i])
print(result)
S=[1, 3, 4, 8, 13, 17, 20]
lst=[]
for i in range(1, len(S)):
a=int(S[i])-int(S[i-1])
lst.append(a)
for i in range(len(lst)):
if int(lst[i])==min(lst):
print("[%s, %s]입니다." %(S[i] ,S[i+1]))
s=list(map(int,input().split())
s.sort()
result=list()
for i in range(1,len(s)):
result.append(s[i]-s[i-1])
shortest=min(result)
for x in range(0,len(result)):
if result[x]==shortest:
print("(%d,%d)입니다" % (s[x],s[x+1]))
# coding = utf-8
n_input = input('숫자를 ","로 구분하여 입력하십시요 : ')
n_split = n_input.split(',')
minimun = float(n_split[1])-float(n_split[0])
for n in range(1,len(n_split)):
if float(n_split[n])-float(n_split[n-1]) <= minimun :
minimun = float(n_split[n])-float(n_split[n-1])
print(n_split[n - 1], n_split[n])
with open("00.in", "r") as f:
string = f.read()
series = [int(i) for i in string.split()]
distance = []
for x in range(len(series)-1):
distance.append(series[x+1] - series[x])
[(series[x], series[x+1]) for x in range(len(series)-1) if distance[x]==min(distance)]
00.in은 인풋파일로서, 1 3 4 5 8 13 17 20 형태로 주어집니다.
#include <stdio.h>
#include <math.h>
void main() {
typedef struct pair {
int x;
int y;
}pair;
pair ans;
int min = 99999;
int tmp;
int list[] = { 1,3,4,8,13,17,20 };
int length = (sizeof(list) / sizeof(list[0]));
for (int i = 0; i < length; i++) {
for (int j = i+1; j < length; j++) {
tmp = abs(list[i] - list[j]);
if (tmp <= min){
min = tmp;
ans.x = list[i];
ans.y = list[j];
}
}
}
printf("최소값은 %d 입니다. (%d , %d) ", min, ans.x, ans.y);
}
- 최소값의 쌍을 저장할 구조체 pair 선언
- 최소값을 저장할 min 변수 선언
- 반복문의 시행에 대하여 점사이의 거리를 저장하는 tmp 변수 선언
- i (0:배열의 길이) 반복문 실행
- 4에서 하나의 시행에 대하여
5-1. j (i+1:배열의 길이) 반복문 실행
5-2. 5-1 에서 하나의 시행에 대하여
5-2-1. tmp 에 list[i] - list[j] 의 절대값 저장
5-2-2. min(최소값) 이 tmp 보다 크면 min 에 tmp 대입
5-2-3. 구조체에 i,j 저장 - 최소값과 최소값이 나올때의 배열 인덱스 출력
def fun(*args):
l = list(args)
m = []
min = abs(args[0] - args[1])
for i in range(len(args)-1):
temp = l.pop()
for j in l:
if min > abs(j-temp):
min = abs(j-temp)
m[0:2] = [j, temp]
elif min == abs(j-temp):
m.append([j,temp])
return m
``````{.python}
fun(46,99,33,44,656,32,55,34,45)
[46, 45, [44, 45], [33, 34], [33, 32]] 저는 굳이 sorting하지 않고 만들어봤습니다 입력은 list로 넣으면 안됩니다
// 1차원의 점들 중 가장 가까운 점 찾기 - C#
// 랜덤으로 점이 나올 수 있게 했습니다.
using System;
using System.Collections;
namespace Point
{
class Program
{
static void Main(string[] args)
{
// 랜덤의 모두 다른 1차원 8개의 점 생성(1 ~ 200).
int[] row = new int[8];
Random r = new Random();
for (int i = 0; i < 8; i++)
{
RESET:
row[i] = r.Next(1, 201);
for (int j = 0; j <= i; j++)
{
if (i != j && row[i] == row[j])
goto RESET;
}
}
Array.Sort(row);
for (int i = 0; i < 8; i++)
{
Console.Write("{0} ", row[i]);
}
Console.Write("\n여기서 가장 가까운 점들은...\n");
Queue indexer = new Queue();
int shorter = 200;
for (int i = 0; i < 7; i++)
{
if (row[i + 1] - row[i] <= shorter)
{
if (shorter != row[i + 1] - row[i])
indexer.Clear();
shorter = row[i + 1] - row[i];
indexer.Enqueue(i);
}
}
try
{
while(true)
{
int i = (int)indexer.Dequeue();
Console.Write("({0}, {1})", row[i], row[i + 1]);
}
}
catch
{
Console.Write("입니다.");
}
}
}
}
data = [1, 3, 4, 8, 13, 17, 20, 22, 23, 24, 25,31,32,35,76,546,547]
shortest_list=[]
def shortest(list):
n = 1
result_list = []
for i in range(len(list)-1):
result_list.append(list[i+1] - list[i])
index = result_list.index(min(result_list))
kk=result_list[index]
shortest_list.append([list[index], list[index+1]])
del result_list[index]
new_index = result_list.index(min(result_list))
nkk=result_list[new_index]
while True:
while kk==nkk:
shortest_list.append([list[new_index+n], list[new_index +(n+1)]])
del result_list[new_index]
new_index = result_list.index(min(result_list))
nkk=result_list[new_index]
n=n+1
return(shortest_list)
break
print(shortest(data))
출력: [[3, 4], [22, 23], [23, 24], [24, 25], [31, 32], [546, 547]]
파이썬 초보라.....최소거리가 같은 점들을 모두 표시하는 조건으로 문제를 풀어봤는데 어렵더군요 ㅠㅠ 다양한 분들의 풀이를 참조해서 어찌저찌 풀긴 했는데 코드가 너무 조잡해진것 같네요...
while True, break는 지워도 될 것 같아요
-
이정환,
2017/06/30 12:43
a = input('input number list with ",":')
b = a.split(",")
c = []
for i in b:
c.append(int(i))
c.sort()
print ("c is :", c)
d = 0
e = 100
for j in range(0,len(c)-1):
d = (c[j+1]-c[j])
if d < e:
e = d
else:
pass
for k in range(0, len(c)-1):
if (c[k+1]-c[k]) == e:
print ("Minimum distance among the list is %d and %d. (distance : %d)" %(c[k],c[k+1],e))
else :
pass
c로 풀이
#include <stdio.h>
int main(void)
{
int i,j=0,s[]={1,2,4,5,8,13,17,20},result[10]={-1};
result[0]=0;
for(i=1;i<sizeof(s)/4-1;i++)
{
if ((s[i+1]-s[i])<(s[result[j]+1]-s[result[j]]))
{
j=0;
result[j]=i;
}
else if((s[i+1]-s[i])==(s[result[j]+1]-s[result[j]])) result[++j]=i;
}
for(i=0;i<=j;i++)
{
if (result[i]==-1) break;
printf("(%d,%d) ",s[result[i]],s[result[i]+1]);
}
return 0;
}
public class Length {
public static void main(String[] args) {
int[] s={1, 3, 4, 8, 13, 17, 20};
int n1=0,n2=0;
int min=s[s.length-1]; // 최소값을 제일 큰값으로 초기화
for(int i=0;i<s.length-1;i++){
if(s[i+1]-s[i]<min){ // 차의 최소값을 구한다.
n1=s[i];
n2=s[i+1];
min = n2 - n1;
}
}
System.out.println("(" + n1 + ", " + n2 + ")");
}
}
public class Length2 {
/*
만약 S 안에 최소거리가 같은 점들의 쌍이 두개 이상이라면 모두 찾아야 하지 않을까요?
주어진 풀이를 보면 차이가 1인 (3,4) 가 하나이기 때문에 그렇게 나오지만
s = [1,2,4,5,8,15,19] 라면 (1,2), (4,5) 를 모두 찾아야 할텐데요.
*/
public static void main(String[] args) {
// int[] s={1, 3, 4, 8, 13, 17, 20};
int[] s={1,2,4,5,8,15,19};
int[] diff = new int[s.length-1]; // 차를 저장할 배열
int n1=0,n2=0;
int min=s[s.length-1]; // 최소값을 제일 큰값으로 초기화
for(int i=0;i<s.length-1;i++){
diff[i] = s[i+1]-s[i]; // 차를 저장
if(diff[i]<min) min = diff[i]; // 차의 최소값을 구한다.
}
// 차가 최소값과 같다면 모두 출력
for(int i=0;i<diff.length;i++){
if(diff[i]==min){
System.out.println("(" + s[i] + ", " + s[i+1] + ")");
}
}
}
}
import java.util.ArrayList;
public class Ex5 {
public static void main(String[] args) {
int[] num={2, 7, 10,13 ,23, 34, 66 , 119,118,105,107};
ArrayList<TwoPoint> list = new ArrayList<TwoPoint>();
TwoPoint tp = null;
for(int i=0;i<num.length-1;i++){
for(int j=i+1;j<num.length;j++){
tp = new TwoPoint();
tp.a =num[i];
tp.b =num[j];
tp.PointLength=Math.abs(tp.a-tp.b);
list.add(tp);
}
}//list에 쌍이될수있는 모든 경우의 수와 그 길이를 집어넣음
int min = list.get(0).PointLength;
for(int i=1;i<list.size();i++){
if(min>list.get(i).PointLength){
min = list.get(i).PointLength;
}
}//제일짧은 길이를 찾음
for(int i=0;i<list.size();i++){
if(min==list.get(i).PointLength){
System.out.println(list.get(i).a);
System.out.println(list.get(i).b);
break;
}
}//찾은 제일짧은 길이로 list를 검색하고 제일 짧은 길이를 가지고있는 TwoPoint클래스의 멤버들을 출력
}
}
class TwoPoint{
int a;
int b;
int PointLength;
}
문제를 살짝 더 꼬았습니다. 점들의 배열이 정렬되어있다는 가정을 무시하고 풀었습니다.
s=[1, 3, 4, 8, 13, 17, 20]
def find_minimum(s):
subnum=[]
for i in range(len(s)-1):
subnum.append(s[i+1]-s[i])
min=subnum[0]
for i in range(len(subnum)):
if subnum[i]<min:
min=subnum[i]
min_num=i
print("(",s[min_num],",",s[min_num+1],")")
find_minimum(s)
javascript(ES6)
1 최소값 저장하기
var s = [1, 3, 4, 8, 13, 17, 20];
var shortests = [],
MIN = Number.MAX_VALUE;
s.reduce(function(a, b) {
var d = Math.abs(a - b);
if (d === MIN) {
shortests.push([a, b]);
}
if (d < MIN) {
MIN = d;
shortests = [[a, b]];
}
return b;
});
for (s of shortests) {
console.log(`(${s[0]}, ${s[1]})`);
}
2 dictionary 자료구조 이용 (정렬 가정)
var s = [1, 3, 4, 8, 13, 17, 20];
var dictionary = [];
s.reduce((a, b) => {
dictionary[b - a] ? dictionary[b - a].push([a, b]) : dictionary[b - a] = [[a, b]];
return b;
});
for (d of dictionary.filter(v => v)[0]) {
console.log(`(${d[0]}, ${d[1]})`);
}
def fun(S):
L=list(S)
n=len(L)
result=[]
new_result=[]
new_new_result=[]
for x in range(n-1):
result.append(L[x+1]-L[x])
for x in range(n - 1):
if L[x+1]-L[x]==min(result):
new_result.append(L[x])
new_result.append(L[x+1])
t1=tuple(new_result)
new_new_result.append(t1)
new_result=[]
return new_new_result
print(fun(S))
#include<iostream>
using namespace std;
void main()
{
int arr[7]={1,3,4,8,13,17,20};
int temp=0,min=100,num1=0,num2=0;
for(int i=0;i<6;i++)
{
temp=arr[i+1]-arr[i];
if(temp<=min)
{
min=temp;
num1=i;
num2=i+1;
}
}
cout<<arr[num1]<<","<<arr[num2];
}
#include<stdio.h>
int main(void)
{
int arr[100];
int choice = 0;
int i = 0;
int j;
int count;
int min;
printf("menu\n");
printf("1. Add number\n");
printf("3. End\n");
printf("고르세요:");
scanf("%d", &choice);
while (choice != 3) {
if (choice == 1) {
printf("정수를 입력하세요: ");
scanf("%d", &arr[i]);
i++;
printf("고르세요:");
scanf("%d", &choice);
}
else
break;
}
min = arr[1] - arr[0];
count = i;
for (i = 0; i < count - 1; i++) {
for (j = i + 1; j < count; j++) {
if (min > arr[j] - arr[i])
min = arr[j] - arr[i];
}
}
for (i = 0; i < count - 1; i++) {
for (j = i + 1; j < count; j++) {
if (min == arr[j] - arr[i])
printf("(%d, %d)", arr[i], arr[j]);
}
}
return 0;
}
두 점 사이가 가장 작은 거리가 여러개 있을 수 있어서 튜플 배열을 이용하였습니다
import numpy as np
def get_min_distance_dot(arr):
arr = np.array(arr)
length = len(arr)
arr1 = arr[:length - 1]
arr2 = arr[1:]
result = arr2 - arr1
min_distance_dots = []
min_val = min(result)
min_distance_dots = [(arr1[i], arr2[i]) for i in range(len(result)) if result[i] == min_val]
#for i in range(len(result)):
# if (min_val == result[i]):
# min_distance_dots.append((arr1[i], arr2[i]))
return min_distance_dots
Python으로 푼 O(n) time-complexity입니다. (n은 S의 길이) range는 최소 거리를 구하는데 1번, 최소 거리 쌍을 찾는데 1번, 총 2번 사용됩니다.
def solve(S):
diff = lambda idx: S[idx] - S[idx-1]
pair = lambda idx: (S[idx-1], S[idx])
min_diff = diff(min(range(1, len(S)), key=diff))
return [pair(idx) for idx in range(1, len(S)) if diff(idx) is min_diff]
#include <iostream>
#include <cstdio>
#include <vector>
#include <algorithm>
using namespace std;
#define INF 987654321
bool check_min_dist(int& pIdx1, int& pIdx2, const vector<int>& v, const int n)
{
int min_dist = INF;
for (int i = 0; i < n; i++) {
for (int j = i+1; j < n; j++) {
if (min_dist > abs(v[i] - v[j])) {
pIdx1 = i;
pIdx2 = j;
min_dist = abs(v[i] - v[j]);
}
}
}
return 1;
}
int main()
{
int n;
cin >> n;
vector<int> v;
for (int i = 0; i < n; i++)
{
int num;
cin >> num ;
v.push_back(num);
}
int idx1, idx2 = INF;
if ( check_min_dist(idx1, idx2, v, n) == 0)
cout << "check error" << endl;
cout << v[idx1] << ", " << v[idx2] << endl;
return 0;
}
diff = None
ex = [1,4,5,9,11,13,14,15,16]
output = []
for i in range(0,len(ex)-1):
if diff == None:
diff = ex[i+1] - ex[i]
output.append((ex[i],ex[i+1]))
continue
if diff >= ex[i+1] - ex[i]:
diff = ex[i+1] - ex[i]
output.append((ex[i],ex[i+1]))
for i in range(len(output)-1,-1,-1):
std = output[len(output)-1][1] - output[len(output)-1][0]
if (output[i][1] - output[i][0]) != std:
output.pop(i)
print output
public static void main(String[] args) {
int[] s = {1,2,4,5,8,15,19};
// int[] s = {1, 3, 4, 8, 13, 17, 20};
getMinDistance(s);
}
private static void getMinDistance(int[] s){
int sub = s[1]-s[0];
ArrayList<Integer> pointList = new ArrayList<>();
for ( int i = 0 ; i < s.length-1 ; i++ ){
for ( int j = i + 1 ; j < s.length ; j++ ){
if( s[j] - s[i] == sub ){
pointList.add(s[i]);
pointList.add(s[j]);
}
if( s[j] - s[i] < sub ){
pointList.clear();
pointList.add(s[i]);
pointList.add(s[j]);
sub = s[j] - s[i];
}
}
}
for ( int i = 0 ; i < pointList.size(); i ++ ){
System.out.println("("+pointList.get(i)+","+pointList.get(i+1)+")");
i++;
}
}
public class Ex004 {
public static void main(String[] args) {
// TODO Auto-generated method stub
int[] arr = {1,3,4,8,13,17,20};
proxDist(arr);
}
static private void proxDist(int[] arr) {
int[] couple = null;
for(int i=0; i < arr.length-1; i++) {
if(couple == null) {
couple = new int[2];
couple[0] = arr[i];
couple[1] = arr[i+1];
continue;
}
if(couple[1] - couple[0] > arr[i+1] - arr[i]) {
couple[1] = arr[i+1];
couple[0] = arr[i];
}
}
System.out.println("가장짧은거리쌍 : (" + couple[0] + "," + couple[1] + ")");
}
}
딕셔너리로 풀어봤습니다.
def shortestDistance(insertList):
dic = {}
for x in insertList:
for y in insertList:
if x != y and x < y:
if abs(x-y) not in dic:
dic[abs(x-y)] =set([(x,y)])
if abs(x-y) in dic:
location = dic[abs(x-y)]
location.add((x,y))
result = list(dic.keys())
print(list(dic[min(result)]))
shortestDistance([1,2,4,5,8,15,19])
def distance(s): l1=0 l2=0 m=100 # temporary random number
for i in range(0,len(s)-1):
for k in range (i+1,len(s)):
d = pow(s[i]-s[k],2)
if(d<m):
m=d
l1=s[i]
l2=s[k]
a = (l1,l2)
return a
s = (1,3,4,8,13,17,20) print(distance(s))```{.python}
```
package java_tutorial;
public class MinDistance {
public static void main(String[] args) {
int [] dots = {1, 2, 3, 5, 7, 8, 11, 15, 16, 17};
int distance = dots[1] - dots[0];
for(int i = 0; i < dots.length; i++)
{
for(int j = i+1; j < dots.length; j++)
{
if(dots[j]-dots[i] < distance)
{
distance = dots[j]-dots[i];
}
}
}
for(int i = 0; i < dots.length; i++)
{
for(int j = i+1; j < dots.length; j++)
{
if(dots[j]-dots[i] == distance)
{
System.out.println("정답은 (" + dots[i] + "," + dots[j] + ") 이고 거리는 " + distance + "입니다.");
}
}
}
}
}
public class Pb1 { public static void main(String[] args) { int[] arrPoint = {1,3,4,8,17,20}; int minDistance = 100; int point = 0;
for (int i = 0; i < arrPoint.length-1; i++) {
int distance = arrPoint[i+1]-arrPoint[i];
if(minDistance>=distance){
minDistance = distance;
point = i;
}
}
System.out.println("("+arrPoint[point]+","+arrPoint[point+1]+")");
}
}
public class Pb1 {
public static void main(String[] args) {
int[] arrPoint = {1,3,4,8,17,20};
int minDistance = 100;
int point = 0;
for (int i = 0; i < arrPoint.length-1; i++) {
int distance = arrPoint[i+1]-arrPoint[i];
if(minDistance>=distance){
minDistance = distance;
point = i;
}
}
System.out.println("("+arrPoint[point]+","+arrPoint[point+1]+")");
}
}
파이썬3
시작한 지 3일밖에 안 돼서 괄호도 많고 깔끔하지 못하네요 딕셔너리 사용했습니다
a = [1,5,8,12,17,20]
dict = { (x,y) : (x-y) **2 for x,n in zip(a,range(0,len(a))) for y in a[n+1:len(a)] } # 원소 2개 : 원소 2개의 거리 ** 2
for z in range(0, int(int(len(a)*(len(a)-1))/2)): # z가 0부터 원소가 2개인 부분집합 개수까지 순환
if dict[list((dict.keys()))[z]] == sorted(list(set(dict.values())))[0]: # 만약 z번째 딕셔너리의 키의 값 == 리스트에서 정렬된 값 중 첫 번째 값이면
print(list(dict.keys())[z]) # z번째 딕셔너리의 키의 값 출력
def nearestpair(numbers) :
tuplelist = []
valuelist = []
for n in range(0, len(numbers)) :
for i in range(n, len(numbers)) :
if n == i :
pass
else :
tuplelist.append((numbers[n], numbers[i]))
valuelist.append((numbers[n]-numbers[i])**2)
result = []
for s in range(0, len(tuplelist)) :
if min(valuelist) == valuelist[s] :
result.append(tuplelist[s])
return result
import itertools
def most_near(s):
com = list(itertools.combinations(s,2))
diff = [(x[0] - x[1]) for x in com]
diff2 = [y*-1 for y in diff if y < 0]
result = com[diff2.index(min(diff2))]
return result
import java.util.*;
public class MinDist {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String input = sc.nextLine();
StringTokenizer token = new StringTokenizer(input);
Vector<Integer> location = new Vector<Integer>();
while(token.hasMoreTokens()) {
location.add(Integer.parseInt(token.nextToken()));
}
Collections.sort(location);
int min = location.elementAt(1)-location.elementAt(0);
for(int i = 1; i<location.size(); i++) {
if(location.elementAt(i)-location.elementAt(i-1) < min) {
min = location.elementAt(i)-location.elementAt(i-1);
}
}
for(int i = 1; i<location.size(); i++) {
if(location.elementAt(i)-location.elementAt(i-1) == min) {
System.out.println("("+location.elementAt(i-1)+","+location.elementAt(i)+")");
}
}
}
}
package one;
import java.io.IOException;
public class Main {
public static void main(String[] args) throws IOException {
int s[]= {1,3,4,8,13,17,20};
int arr[] = new int[2];
int min = 0;
for(int i=0;i<s.length-1;i++){
int temp = s[i+1]-s[i];
if(min==0 || temp<min){
min = temp;
arr[0] = s[i];
arr[1] = s[i+1];
}
}
System.out.println(min+" "+arr[0]+","+arr[1]);
}
}
import copy
list_data=[1,3,4,8,13,17,20] list_data2=copy.deepcopy(list_data) len_data=len(list_data) list_data2.sort() c=len(list_data2) MAX=abs(list_data2[c-1]-list_data2[0])
for i in range(len_data-1): del_number=abs(list_data[i]-list_data[i+1]) if del_number<MAX: min_list=[list_data[i],list_data[i+1]] MAX=del_number print(min_list) print(MAX)
import java.util.Arrays;
public class Lv1 {
public int[] func(int[] arr){
System.out.println("입력된 배열 : " + Arrays.toString(arr));
Arrays.sort(arr);
System.out.println("정렬된 배열 : " + Arrays.toString(arr));
int min = Integer.MAX_VALUE;
int[] point = new int[2];
for(int i = 0; i < arr.length; i++){
for (int j = 0; j< arr.length; j++){
if(i==j) continue;
else{
if (min > Math.abs(arr[i]-arr[j])){
min = Math.abs(arr[i]-arr[j]);
point[0] = arr[i];
point[1] = arr[j];
}
}
}
}
return point;
}
public static void main(String[] args){
Lv1 obj = new Lv1();
int[] s = {20, 1,3,4,8,13,17};
System.out.println("거리가 가장 짧은 쌍 : " + Arrays.toString(obj.func(s)));
}
}
public static void line(){
int input;
int num;
int close = 9999;
int temp = 0;
System.out.print("문자길이를 입력하시오");
Scanner scan = new Scanner(System.in);
input = scan.nextInt();
int[] line = new int[input];
int[] close2 = new int[2];
for (int i = 0; i < line.length ; i++){
num = scan.nextInt();
line[i] = num;
}
System.out.print("입력받은 숫자:");
for (int i =0; i < line.length ; i ++){
System.out.print(line[i]+"");
}
System.out.println("");
for (int i = 0; i < line.length; i++){
for (int j = i + 1; j < line.length; j++){
if(line[i] > line[j]){
temp = line[i] - line[j];
}else if (line[j] > line[i]){
temp = line[j] - line [i];
}
if(temp < close){
close = temp;
close2[0] = line[i];
close2[1] = line[j];
}
}
}
System.out.println("가장가까운거리 : "+close);
System.out.println("["+close2[0]+","+close2[1]+"]");
}
import numpy as np
def shortest(list_a):
st = list(np.array(list_a[1:]) - np.array(list_a[:-1]))
min_index = st.index(min(st))
print([list_a[min_index],list_a[min_index+1]])
[Python 3.6]
def findNearestPoints(points):
nearestDist = points[len(points) - 1] - points[0];
resultPoints = ()
for i in range(1, len(points)):
if nearestDist > points[i] - points[i - 1]:
nearestDist = points[i] - points[i - 1]
resultPoints = (points[i - 1], points[i])
return resultPoints
points = [1, 3, 4, 8, 13, 17, 20]
print(findNearestPoints(points))
package com.test;
import java.util.ArrayList;
import java.util.List;
public class shortestPair {
public static void main(String[] args) {
int[] s = {1, 3, 4, 8, 13, 17, 20, 21};
findShortestPair(s);
}
public static void findShortestPair(int[] inArr) {
// 입력길이가 짧으면 의미 없음
if ( inArr.length < 2 )
return;
// 가장 짧은 인덱스를 여기에 add
List<Integer> shortestIndex = new ArrayList<Integer>();
// 처음 비교할 길이
int betweenLen = inArr[1] - inArr[0];
shortestIndex.add(1);
for ( int i=2; i<inArr.length; i++ ) {
int len = inArr[i] - inArr[i-1];
if ( len == betweenLen ) {
shortestIndex.add(i);
}
else if ( len < betweenLen ) {
betweenLen = len;
shortestIndex.clear();
shortestIndex.add(i);
}
}
// shortestIndex에 있는 index 출력
for (int i : shortestIndex) {
System.out.println("{" + inArr[i-1] + ", " + inArr[i] + "}");
}
}
}
def between(a, b):
return abs(a - b)
def ans(a):
answer = []
min = between(a[0], a[1])
for i in range(0, len(a) - 1):
if between(a[i], a[i + 1]) < min:
answer = [a[i], a[i + 1]]
min = between(a[i], a[i + 1])
elif between(a[i], a[i + 1]) == min:
answer = answer+["and",a[i], a[i + 1]]
return answer
a = [1,3,4,5,8,13,17,19,20]
print(ans(a))
C입니다.
#include <stdio.h>
main() {
int S[] = { 1,3,4,8,13,17,20 };
int size;
size = sizeof(S) / sizeof(S[0]);
cacul_min_dis(S, size);
system("pause");
}
/*******************************************/
cacul_min_dis(int *pS, int size) {
int i, dis,min;
for (i = 1; i < size; i++) {
dis = *(pS + i) - *(pS + i - 1);
if (i == 1)
min = dis;
else if (dis < min)
min = dis;
}
// 중복을 검사하는 부분
for (i = 1; i < size; i++) {
if (*(pS + i) - *(pS + i - 1) == min)
printf("(%d,%d)\n", *(pS + i - 1), *(pS + i));
}
}
s=[1, 3, 4, 8, 13, 17, 20]
ob = 0
min = s[-1]
output_list = []
for i in range(len(s)-1):
s_m = abs(s[i] - s[i+1])
if min > s_m:
min = s_m
j = i
elif min == s_m:
output_list.append( (s[j], s[j+1]) )
j = i
output_list.append( (s[j], s[j+1]) )
print(output_list)
리스트의 원소의 차를 구한뒤 절대값이 제일 작은 값을 빈 리스트에 추가합니다. s=[1, 3, 4, 5, 13, 17, 18] 같이 연속되는 숫자도 전부 구해서 출력할수 있습니다.
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int main()
{
int S[7] = { 2,3,4,8,13,14,20 };
int Min;
int m, n;
int k, l;
Min = S[1] - S[0];
m = S[0];
n = S[1];
for (int i = 1; i < 6; i++) {
if (Min > S[i + 1] - S[i])
{
Min = S[i + 1] - S[i];
m = S[i];
n = S[i+1];
}
}
printf("(%d,%d)", m, n);
Min = S[1] - S[0];
for (int i = 1; i < 6; i++)
{
if (Min == S[i + 1] - S[i])
{
k = S[i];
l = S[i + 1];
printf("(%d,%d)", k, l);
}
if (Min > S[i + 1] - S[i])
{
Min = S[i + 1] - S[i];
}
}
return 0;
}
C
#include <stdio.h>
#include <math.h>
int main(int argc,char* argv)
{
int arr[] = {1, 3, 4, 5, 9, 11, 15, 16};
int tmp=0;
tmp = arr[0]-arr[1];
for(int i=0;i<sizeof(arr)/sizeof(arr[0])-1;i++)
{
if(arr[i+1]-arr[i]<tmp)
tmp = arr[i+1] - arr[i];
tmp = abs(tmp);
}
for(int i=0;i<sizeof(arr)/sizeof(arr[0])-1;i++)
{
if(arr[i+1]-arr[i]==tmp)
{
printf("%d , %d\n",arr[i],arr[i+1]);
}
}
return 0;
}
def Shortest_distance(dot_List):
min_num=0
a=dot_List
b=len(a)
result=[]
for i in range(b-1):
for j in range(b-1-i):
result.append(abs(a[i]-a[i+j+1]))
min_num=min(result)
for c in range(b - 1):
for d in range(b - 1 - c):
if min_num == abs(a[c] - a[d +c+ 1]):
print(a[c],a[d+1+c])
s=[1,3,4,8,13,17,20]
Shortest_distance(s)
def Find_Twins(list):
shortest = list[1] - list[0] + 1
for i in range(1,len(list)):
if(list[i]-list[i-1]<shortest):
shortest = list[i]-list[i-1]
result = []
result.append((list[i-1], list[i]))
elif(list[i]-list[i-1]==shortest):
result.append((list[i-1], list[i]))
return result;
list = [1,2,3,5,6,9,11]
print(Find_Twins(list))
#include <stdio.h>
#include <math.h>
#define MAX 65535
int main()
{
int data[7]={1, 3, 4, 8, 13, 17, 20};
int size = sizeof(data)/sizeof(data[0]);
int min = MAX;
int i,j,res;
for(i=0;i<size;i++)
{
for(j=i+1;j<size-i;j++)
{
res = abs(data[i]-data[j]);
if(min>res)
min = res;
}
}
printf("min : %d",min);
}
정렬과 숫자 입력을 한것
public static void main(String[] args) {
int[] num = new int[3];
int staic = 0;
int length = 0;
Scanner scanner = new Scanner(System.in);
System.out.print("숫자를 입력하세요. ");
for(int i=0; i<num.length; i++){
num[i] = scanner.nextInt();
}
Arrays.sort(num);
System.out.println(Arrays.toString(num));
for(int i =0;i<num.length-1;i++){
staic = num[i+1] - num[i];
if(length<staic){
length = staic;
}
}
System.out.println(staic);
}
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class Main {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String input = br.readLine();
String [] tmpArr = input.split(" ");
int [] arr = new int[tmpArr.length];
for (int i=0; i<arr.length; i++) {
arr[i] = Integer.parseInt(tmpArr[i]);
}
int min = Integer.MAX_VALUE;
for (int i=0; i<arr.length-1; i++) { // 최솟값을 구하는 반복문
if ((arr[i+1] - arr[i]) < min) {
min = arr[i+1] - arr[i];
}
}
for (int i=0; i<arr.length-1; i++) { // 최솟값과 비교하여 결과 출력
if ((arr[i+1] - arr[i]) == min) {
System.out.println("(" + arr[i] + ", " + arr[i+1] + ")");
}
}
br.close();
}
}
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
void get_S(int * S);//점들의 배열을 입력받는 함수, 문제조건에 배열은 정렬된 상태로 입력된다고 해서 정렬하지 않습니다
void main()
{
int i, point=0, mingap;
int S[100];
get_S(S);//점들의 배열을 입력받는다
mingap = abs(S[point]-S[point+1]);
for (i = 0; S[i] - S[i + 1] < 0;i=i+1) {
if (abs(S[i] - S[i + 1]) < mingap) {
point = i;
mingap = abs(S[i] - S[i + 1]);
}
}//S[i] - S[i + 1]가 가장 작은 값 출력
printf("(%d,%d)",S[point],S[point+1]);
}
void get_S(int*S) {
int num, i;
printf("입력하실 숫자들의 갯수를 입력하세요: ");
scanf_s("%d",&num);
printf("숫자들을 입력하세요\n");
for (i = 0; i <num ; i = i + 1) {
printf("%d번째 숫자: ", i+1);
scanf_s("%d", &S[i]);
}
}
Python으로 작성하였습니다.
#shortest distance
s=[1,3,4,8,13,19,20]
gap=[]
for i in range(len(s)):
try:
gap.append(s[i+1]-s[i])
except IndexError:
pass
for i in range(len(gap)):
if (gap[i]==min(gap)):
print("(%d, %d)"% (s[i], s[i+1]))
#include <iostream>
using namespace std;
void main()
{
int S[] = { 1,4,6,8,12,16,25 };
int Count = (sizeof(S)/sizeof(S[0])) -1 ;
int min = 0;
int max = 0;
int temp = 10000;
for (int i = Count; i >=0; i--)
{
for (int j = i-1; j >= 0; j--)
{
if ((S[i] - S[j]) < temp)
{
temp = S[i] - S[j];
max = S[i];
min = S[j];
}
}
}
cout << "("<<min <<","<< max <<")"<< endl;
}
s = [1, 3, 4, 8, 13, 17, 20]
def short(list): sub = list[1]-list[0] C=[]
for i in range(len(list)-1): if (list[i+1] - list[i]) <= sub: C = [list[i],list[i+1]] sub = list[i+1] - list[i] print(C) return (C)
short(s)
S=[1, 3, 4, 8, 13, 17, 20]
min = 0
max = 1
result = S[1]-S[0]
for i in range(len(S)):
try:
if result >= S[i + 1] - S[i]:
min = S[i]
max = S[i + 1]
result = S[i + 1]-S[i]
except IndexError:
pass
print("(%d,%d)" %(min, max))
S=[1,3,4,8,13,17,20]
minDist=S[1]-S[0]
for i in range(2,len(S)):
if S[i]-S[i-1]<minDist:
minDist=S[i]-S[i-1]
index=i
print(S[index-1],S[index])
def result(arr):
arr.sort()
cnt = 0
aaa = []
for idx, num in enumerate(arr):
if idx == 0:
cnt = arr[idx + 1] - arr[idx]
elif (idx+1) == len(arr):
break
else:
if cnt >= (arr[idx + 1] - arr[idx]):
cnt = arr[idx + 1] - arr[idx]
aaa.append((arr[idx], arr[idx + 1]))
print(aaa)
result([1, 3, 4, 8, 13, 17, 20, 100])
package test;
import java.util.Scanner;
/*
1차원의 점들이 주어졌을 때, 그 중 가장 거리가 짧은 것의 쌍을 출력하는 함수를 작성하시오. (단 점들의 배열은 모두 정렬되어있다고 가정한다.)
예를들어 S={1, 3, 4, 8, 13, 17, 20} 이 주어졌다면, 결과값은 (3, 4)가 될 것이다.
*/
public class test {
public static void main(String[] args)
{
int len, num=0, min=0;
Scanner scan = new Scanner(System.in);
System.out.println("배열의 크기를 입력하세요.");
len = scan.nextInt();
int[] s = new int[len];
int[] save = new int[len];
System.out.println("값을 입력 하세요.");
for (int i=0; i < len; i ++)
{
s[i] = scan.nextInt();
}
min = s[1] - s[0];
for (int i=0; i < len-1 ; i++)
{
if(min == (s[i+1] - s[i]))
{
min = s[i+1] - s[i];
save[num] = i;
num++;
}
else if(min > (s[i+1] - s[i]))
{
min = s[i+1] - s[i];
num--;
save[num] = i;
}
}
if (num == 0)
{
System.out.println("(" + s[save[num]] + ", " + s[save[num]+1] + ")");
}
else
{
for(int i=0; i<num; i++)
{
System.out.println("(" + s[save[i]] + ", " + s[save[i]+1] + ")");
}
}
}
}
파이썬
def length(a, b) :
return abs(a-b)
def GetMinPoint(t) :
min_length = t[-1];
min_point = {t[0], t[-1]}
for n in range(len(t)-1):
if length(t[n], t[n+1]) < min_length :
min_length = length(t[n], t[n+1])
min_point = {t[n], t[n+1]}
return min_point
given = {1, 3, 4, 8, 13, 17, 20}
t = tuple(given)
print(GetMinPoint(t))
음...
s=[1,3,4,8,13,17,20]
r=[]
for i in range (0,len(s)-1):
temp=s[i+1]-s[i]
r.append(temp)
print("(%d,%d)" %(s[r.index(min(r))],s[r.index(min(r))+1]))
zip ,lambda에 익숙치 안다보니 허접하게 짜네요
s = [1, 3, 4, 8, 13, 17, 20]
nearnum = 999
result = []
for i in range(len(s)-1):
if nearnum > s[i+1]-s[i]:
nearnum = s[i+1]-s[i]
result = [s[i],s[i+1]]
print(result)
def func(lis):
list_couples=[]
list_diff=[]
for i in range(len(lis)-1):
for j in range(i+1, len(lis)):
list_diff.append(abs(lis[i]-lis[j]))
list_couples.append((lis[i],lis[j]))
for k in range(len(list_couples)):
if list_diff[k]==min(list_diff):
print (list_couples[k])
min=0
for index, value in enumerate(S):
if index == 0:
pvalue=value
continue
elif index == 1:
min = value - pvalue
minPair =(pvalue,value)
pvalue=value
else:
if min > value - pvalue:
min = value - pvalue
minPair =(pvalue,value)
pvalue=value
JAVA
public class Example {
public static void main(String[] args) {
Integer[] integerArray = new Integer[] { 1, 4, 5, 6, 13, 17, 18 };
minSubtrack(integerArray);
}
private static void minSubtrack(Integer[] integerArray) {
int minValue = 0;
for (int i = 0; i < integerArray.length - 1; i++) {
int diff = integerArray[i + 1] - integerArray[i];
if (i == 0)
minValue = diff;
if (diff < minValue) {
minValue = diff;
}
}
for (int i = 0; i < integerArray.length - 1; i++) {
if ((integerArray[i + 1] - integerArray[i]) == minValue)
System.out.println(integerArray[i] + " , " + integerArray[i + 1]);
}
}
}
```
// 다음 입사 문제 중에서
package main
import "fmt"
func main() {
inp := []int{1, 3, 4, 8, 13, 17, 20}
minIdx := 0
minDst := inp[0]
for i := 0; i < (len(inp) - 1); i++ {
if chk := inp[i+1] - inp[i]; chk < minDst {
minIdx = i
minDst = chk
}
}
fmt.Println(inp[minIdx], inp[minIdx+1])
}
# -*- coding: utf-8 -*-
# python 3.6
inp = [1, 3, 4, 8, 13, 17, 20]
# 거리차의 리스트 작성 및 최소 거리 산정
diff = ([inp[i + 1] - inp[i] for i in range(len(inp) - 1)])
d_min = min(diff)
# 최소 거리와 동일한 거리 쌍의 리스트 모두 출력
rst = [(inp[i], inp[i + 1])
for i in range(len(inp) - 1) if inp[i + 1] - inp[i] == d_min]
print(rst)
# ans: [(3, 4)]
자바입니다.
public void Shortest(int[] a) {
int val1 = a[0];
int val2 = a[1];
int min = a[1]-a[0];
for(int i=1; i<a.length; i++) {
int dist = a[i]-a[i-1];
if(min>dist) {
min = dist;
val1 = a[i-1];
val2 = a[i];
}
}
System.out.println("가장 짧은 거리 : " + min);
System.out.println();
System.out.print("결과 값 : (" + val1 + ", " + val2 +")");
}
def shortest():
print("50이하의 숫자를 6개 입력하세요.")
s=[]
b=[]
c=()
for n in range(6):
s+=[input(str(n+1)+"번째")]
for n in range(5):
b+=[int(s[n+1])-int(s[n])]
for n in range(5):
if b[n]==min(b):
print(min(b))
print(n)
c+=int(s[n]),int(s[n+1])
print(c)
shortest()
public static void main (String[] args) throws java.lang.Exception
{
int[] dot = {1, 5, 7, 9, 10, 12};
int[] difference = new int[dot.length-1]; /* 각 점들의 차이값을 저장시킬 배열 */
for(int k=0; k<dot.length-1; k++){ /* 인접한 2개 점들의 차이를 비교해서 차이값을 저장 */
int a = dot[k+1] - dot[k];
difference[k] = a;
}
int smallest_value = difference[0]; /* 저장된 차이값중에서 가장 작은 값을 찾아내서 저장 */
for(int l=0; l<difference.length; l++){
if(difference[l] < smallest_value && difference[l]!=0){
smallest_value = difference[l];
}
}
for(int o=0; o<dot.length-1; o++){ /* 차이값과 일치하는 가진 쌍을 찾아 출력!!! */
if(dot[o+1] - dot[o] == smallest_value){
System.out.println("결과값 : " + dot[o] + "," + dot[o+1]);
}
}
}
s=[1, 3, 4, 8, 13, 17, 20, 21]
a=[s[i+1]-s[i] for i in range(len(s)-1)]
for i in range(len(s)-1):
if s[i+1]-s[i] ==min(a):
print(s[i] , s[i+1])
'''
3 4
20 21
'''
package codingdojang;
public class ex22 {
public static void main(String[] args) {
// TODO Auto-generated method stub
int[] a = {1, 3, 4, 8, 13, 17, 20};
int min = a[1]-a[0];
for(int i=1; i<a.length; i++) {
if(min > a[i]-a[i-1]) {
min = a[i]-a[i-1];
}
}
System.out.println(min);
}
}
import sys
a = [1,3,4,8,13,17,20]
result = list()
minIndex = 0
minValue = sys.maxsize
for n in range(len(a)-1):
temp = a[n+1] - a[n]
if minValue > temp:
minValue = temp
minIndex = n
result.append([a[minIndex], a[minIndex+1]])
function dots(s) {
var shortestval = s[1]-s[0];
var short_index =[];
for (var i =0; i<s.length;i++){
var sub = s[i+1]-s[i];
if(sub<shortestval){
shortestval = sub;
short_index =[s[i], s[i+1]];
}
}
return short_index;
}
var s = [1, 3, 4, 8, 13, 17, 20];
console.log(dots(s));
S=[1,3,5,8,13,17,20,21]
i=1
dist=S[1]-S[0]
while True:
if i == len(S)-1:
break
if S[i+1]-S[i] < dist:
dist = S[i+1]-S[i]
couple=(S[i],S[i+1])
i+=1
print(couple)
2번째 풀이
python
#코딩도장 - 4
#1차원의 점들이 주어졌을 때, 그 중 가장 거리가 짧은 것의 쌍을 출력하는
#함수를 작성하시오. (단 점들의 배열은 모두 정렬되어있다고 가정한다.)
#예를들어 S={1, 3, 4, 8, 13, 17, 20} 이 주어졌다면, 결과값은 (3, 4)가 될 것이다.
S = []
while True:
point = input('point : ')
print('if you want to stop it, press enter.')
if point == '':
break
else:
S.append(int(point))
S.sort() #점들을 정렬시킨다.
print('S =', S)
i = 0
e = 1
T = []
while True:
length = S[e] - S[i]
T.append(length)
i += 1
e += 1
if e == len(S):
break
R = sorted(T)
f = R[0]
i = 0
while True:
if len(R) == 1:
print('가장 거리가 짧은 쌍 =', S[0], S[1])
break
if T[i] == f:
print('가장 거리가 짧은 쌍 =', S[i], S[i+1])
i += 1
if i+1 == len(S):
break
이제 막 시작한 초보라 배운 것들로만 작성해 보았습니다.
S는 임의로 넣었습니다. 결과는 (3, 4) (4, 5) (13, 14) 로 출력됩니다.
S={1, 3, 4, 5, 8, 13, 14, 17, 20}
S=list(S)
S.sort()
result=[]
gap=S[1]-S[0]
for i in range(1,len(S)-2):
if S[i+1]-S[i]<gap:
gap=S[i+1]-S[i]
result.clear()
result.append((S[i],S[i+1]))
elif S[i+1]-S[i]==gap:
result.append((S[i],S[i+1]))
for i in result:
print(i,end=' ')
import math
def disminizer(points): # points는 리스트로 된 1차원 점들
s = sorted(points) # 어떻게 주어지든 정렬하고 시작
mindis = math.inf # 거리를 무한대로 초기화
for a in s: # 한점을 정한다
for b in s[s.index(a) + 1 : ]: # 슬라이싱; 그 점 다음의 점들로 이루어진 리스트
if b - a < mindis: # 만약 두 점의 차이가 mindis보다 작으면
mindis = b - a # 갱신한다
pair = [a, b] # 그 점들을 리스트로 저장한다.
return pair
print(disminizer([1, 3, 4, 8, 13, 17, 20]))
#파이썬입니다. 정렬 안된 점들을 입력해도 같은 결과가 나오게 했습니다...
public static String rowDistance(int[] arr){ String result =""; int test1 = Integer.MAX_VALUE , test2= 0, test3 =0; for (int i = 0; i < arr.length; i++) { if (i+1 != arr.length && arr[i+1] - arr[i] < test1) { test1 = arr[i+1] -arr[i]; test2 = arr[i]; test3 =arr[i+1]; } } result=test2+","+test3; return result; }
#기본적으로 sorting 된 상태에서는 앞,뒤의 배열의 차이만 고려하면 된다.
def short_dis_pair(input):
dis_out_01 = []
lst = list(input)
lst.sort()
for n in range(len(lst)-1):
dis_out_01.append(lst[n+1]-lst[n])
min_value = min(dis_out_01)
final_inx = dis_out_01.index(min_value)
result = (lst[final_inx],lst[final_inx+1])
print(result)
S1 = (1, 3, 4, 8, 13, 17, 20)
S2 = (3, 5, 1, 7, 14, 20, 33)
# short_dis_pair(S2)
#문제에 대해 관점을 달리 했다.
#결국 최소거리를 가지는 list값을 찾으면 되니깐, 가장작은수와 2번째로 작은수를 찾는다
#이 경우는 sorting여부와 관계없이 찾을 수 있다.
def shortest(input):
lst = list(input)
lst01 = lst.copy()
min_lst = []
for n in range(len(lst)):
min_lst.append(min(lst01))
lst01.remove(min(lst01))
result = (min_lst[0],min_lst[1])
print(result)
shortest(S1)
def Min_Dis(list): list_couple = [] list_dis = [] Min_List = []
for i in range(len(list) - 1):
for j in range(i + 1, len(list)):
list_dis.append(abs(list[i]-list[j]))
list_couple.append((list[i],list[j]))
for k in range(len(list_couple)):
if list_dis[k] == min(list_dis):
Min_List = list_couple[k]
print(Min_List)
Min_Dis([1, 3, 4, 13, 17, 20])
Python code
s = [1, 3, 4, 8, 13, 17, 20]
def fmin_distance(s):
min_distance = max(s) - min(s)
min_ij = (0,0)
for i in range(len(s)):
for j in range(i+1, len(s)):
distance = abs(s[i] - s[j])
if min_distance > distance:
min_ij = (s[i], s[j])
min_distance = distance
return min_ij
min_ij = fmin_distance(s)
print ('(%d, %d)' % (min_ij[0], min_ij[1]))
package promotion; import java.util.Random; public class Sort {
public static void main(String[] args) {
Random random=new Random();
int[] array= new int[7];
int t,temp,j;
for(int i=0;i<array.length;i++) {
array[i]=random.nextInt(100)+1;
}
for(t=array.length/2;t>0;t/=2) {
for(int i=t;i<array.length;i++) {
temp=array[i];
for(j=i;j>=t;j-=t) {
if(temp<array[j-t]) {
array[j]=array[j-t];
}
else break;
}
array[j]=temp;
}
}
System.out.print("배열:(");
for(int i=0;i<array.length;i++) {
System.out.print(array[i]);
if(i==array.length-1) {
continue;
}
System.out.print(",");
}
System.out.println(")");
calculator(array);
}
private static void calculator(int array[]){
int min,temp,left = 0,right = 0;
min=array[1];
for(int i=1;i<array.length;i++) {
temp=array[i]-array[i-1];
if(min>temp) {
min=temp;
left=array[i-1];
right=array[i];
}
}
System.out.println("("+left+","+right+")");
System.out.println("차이값은:"+min);
}
} 1차원 점까지 입력받아서 정렬하고 차이값까지 출력하게 짜봤습니다.
python입니다
import numpy as np
s = sorted([15,32,41,42,143,137,20])
k = [abs(x-y) for x,y in zip(s[:-1],s[1:])]
k_m = np.argmin(k)
print((s[k_m], s[k_m+1]))
최소값이 여러개일때 풀이입니다
import numpy as np
s = sorted([1,2, 4,5, 15,32,41,42,143,137,20])
k = [abs(x-y) for x,y in zip(s[:-1],s[1:])]
min_k = min(k)
k_m=[]
for i,j in enumerate(k):
if min_k == j:
k_m.append(i)
for i in k_m :
print((s[i], s[i+1]))
s=[1,3,4,8,13,17,20]
pairs = list(zip(s[0:], s[1:]))
pairs.sort(key=lambda e:e[1]-e[0])
print(pairs[0])
Common Lisp
(defparameter *a* nil)
(defparameter *b* nil)
(defun get-dist (p1 p2)
(- p2 p1))
(defun min-dist (li)
(unless *a*
(setf *a* (car li))
(setf *b* (cadr li))
(min-dist (cdr li)))
(let ((p1 (car li))
(p2 (cadr li)))
(when (< (get-dist p1 p2) (get-dist *a* *b*))
(setf *a* p1)
(setf *b* p2))
(if (caddr li)
(min-dist (cdr li))
(cons *a* *b*))))
(defun foo (li)
(setf *a* nil)
(setf *b* nil)
(min-dist li))
파이썬 풀이를 보고
(defun foo (li)
(labels ((list->dist (li)
(if (cdr li)
(cons (list (car li) (cadr li)) (list->dist (cdr li))))))
(car (sort (list->dist li) #'< :key #'(lambda (x) (abs (- (car x) (cadr x))))))))
reduce를 써보고 싶어서
(defun foo (li)
(labels ((get-dist (dists)
(abs (- (car dists) (cadr dists))))
(dist-list (li)
(if (cdr li)
(cons (list (car li) (cadr li)) (dist-list (cdr li))))))
(reduce (lambda (a b)
(if (< (get-dist b) (get-dist a))
b
a))
(dist-list li))))
> (foo '(1 3 4 8 13 17 20))
> (3. 4)
S = [1, 3, 4, 8, 13, 17, 20]
s, e = S.pop(0), S.pop(0)
d = abs(s-e)
while True:
if not S: break
n = S.pop(0)
_d = abs(e-n)
if _d < d: s, e = e, n
print s, e
뭔가 더 좋은게 있을것 같은데 .. 풀이 보고나면 내 코드가 맘에 안들까봐 일단 저장 ㅋㅋ
S={1, 3, 4, 8, 13, 17, 20, 21}
Slist=list(S)
num=len(S)
a=[]
for i in range(0,num-1):
distance=Slist[i+1]-Slist[i]
a.append([distance,Slist[i],Slist[i+1]])
a.sort()
for i in range(0,num):
if a[i][0] > a[0][0]: break
else: print a[i][1],a[i][2]
import numpy as np
s = sorted([1,2, 4,5, 15,32,41,42,143,137,20])
k = [abs(x-y) for x,y in zip(s[:-1],s[1:])]
min_k = min(k)
k_m=[]
for i,j in enumerate(k):
if min_k == j:
k_m.append(i)
for i in k_m :
print((s[i], s[i+1]))
S = [1, 2, 4, 5, 8, 15, 19]
value = []
pairs = []
for i in S :
remain = S[:]
remain.remove(i)
result = []
for j in remain :
a = abs(i - j)
result.append(a)
value.append(min(result))
pairs.append((i, remain[result.index(min(result))]))
cnt = 0
for k in value :
if k == min(value) :
print(pairs[cnt])
cnt += 1
public class Point {
public static void main(String[] args) {
int[] intArray = {1,3,4,8,13,17,20};
int res = 100;
int j = 0;
int k = 0;
for(int i = 0; i<intArray.length - 1; i++) {
int sum = intArray[i+1]- intArray[i];
if(res > sum) {
res = sum;
k = intArray[i+1];
j = intArray[i];
}
}
System.out.print("{" + j + ", " + k + "}");
}
}
약간 버그가 있습니다만...
#include <stdio.h>
#include <ctype.h>
#include <stdlib.h>
#include <string.h>
int main(void) {
int min = 0;
int minarr=0;
//int arr[]={1, 3, 4, 8, 13, 17, 20};
int i=0;
int gap=0;
int arrsize=0;
int *arr;
printf("배열의크기를 입력해주십시오\n");
scanf("%d",&arrsize);
if(isdigit(arrsize)!=0||arrsize < 2){
printf("2이상의 숫자만이 입력가능합니다\n");
exit(1);
}
arr = (int *)malloc(sizeof(int)*arrsize);
memset(arr,sizeof(int)*arrsize,0x00);
for(int y=0; y<arrsize;y++){
printf("%d번째의 숫자를 입력해주십시요\n",y+1);
scanf("%d",&arr[y]);
if(isdigit(arr[y])!=0){
printf("숫자만이 입력가능합니다\n");
free (arr);
exit(1);
}
}
for(i=0;i<arrsize-1;i++){
gap=arr[i+1]-arr[i];
if(i==0){
min=gap;
minarr=i;
}else{
if(min > gap){
min=gap;
minarr=i;
}
}
}
printf("min distance arr is (%d,%d)",arr[minarr],arr[minarr+1]);
free (arr);
return 0;
}
from collections import defaultdict
lst = [1, 3, 4, 8, 13, 17, 20,21]
d = defaultdict(list)
for i, j in list(zip(lst, lst[1:])):
d[abs(i-j)].append((i,j))
print(d[min(d)])
include
include
int main()
{
int i,j,n,min;
int number[10];
int MIN_INDEX1=0, MIN_INDEX2=0;
printf("입력하고자 하는 숫자의 개수를 입력하시오: ");
scanf("%d",&n);
printf("숫자를 입력해 주세요: ");
for(i=0;i<n;i++)
{
scanf("%d",&number[i]);
}
// 숫자 입력까지 끝
min = abs(number[1]-number[n]);
for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
{
if(i!=j)
{
if(min>=abs(number[i]-number[j]))
{
min = abs(number[i]-number[j]);
MIN_INDEX1=number[i];
MIN_INDEX2=number[j];
}
}
}
}
printf("%d (%d,%d)",min,MIN_INDEX1,MIN_INDEX2);
return 0;
}
A=[1, 4, 3, 5, 6]
B=[]
A.sort()
for i in range(len(A)-1):
if not B:
B=[A[i+1]-A[i], (A[i], A[i+1])]
elif B and B[0]==A[i+1]-A[i]:
B.append((A[i], A[i+1]))
elif B and B[0]>A[i+1]-A[i]:
B=[A[i+1]-A[i], (A[i], A[i+1])]
length=B[:1]
pairs=B[1:]
print('최소값: {}, 최소값이 나오는 순서쌍: {}'.format(length, pairs))
def getShortDis(src):
arr= []
dist_min = abs(src[0] - src[1])
for idx in range(len(src) - 1):
dist = abs(src[idx] - src[idx + 1])
_2value = [0, 0]
_2value[0] = src[idx]
_2value[1] = src[idx + 1]
if dist < dist_min:
dist_min = dist
arr.clear()
arr.append(_2value)
elif dist == dist_min:
arr.append(_2value)
return arr
sample = [8, 10, 36, 38, 45, 50, 52, 59, 63, 65]
print (getShortDis(sample))
#!/usr/bin/env python
#-*- coding:utf-8 -*-
def sub(a, b):
return b - a
def main():
s=[1, 3, 4, 8, 13, 17, 20]
size=len(s)
result=sub(s[0], s [1])
minSet=s[0], s[1]
for i in range(1, size - 1):
value=sub(s[i], s[i + 1])
if result > value:
minSet = s[i], s[i + 1]
result1=value
print('The smallest result has a value of {0} and {1}.'.format(minSet[0], minSet[1]))
print('The number of cars is {}.'.format(result1))
if __name__ == '__main__':
main()
import java.util.*;
public class ArrayDistance { //JAVA
public ArrayList<Integer> Setting() {
// 배열 초기화 후 ArrayList 타입으로 반환
@SuppressWarnings("resource")
Scanner input = new Scanner(System.in);
ArrayList<Integer> arrayList = new ArrayList<>();
System.out.print("1차원 점들의 개수를 정하시오: ");
int size = input.nextInt();
System.out.print("1차원 점들을 정렬되게 입력하시오: ");
for(int i=0; i<size; i++) {
arrayList.add(input.nextInt());
}
System.out.println(arrayList);
return arrayList;
}
public ArrayList<Integer> ClacDistance(ArrayList<Integer> arrayList) {
// 거리 계산후 ArrayList 타입으로 반환
int min = arrayList.get(1) - arrayList.get(0);
int temp, point1=0, point2=0;
ArrayList<Integer> getArr = new ArrayList();
for(int i=0; i< (arrayList.size() - 1); i++) {
temp = arrayList.get(i+1) - arrayList.get(i);
if(temp <= min) {
min = temp;
point1 = arrayList.get(i);
point2 = arrayList.get(i+1);
}
}
getArr.add(point1);
getArr.add(point2);
return getArr;
}
public static void main(String[] args) {
ArrayDistance dArray = new ArrayDistance();
ArrayList<Integer> setArray = dArray.Setting();
ArrayList<Integer> distance = dArray.ClacDistance(setArray);
System.out.println("최단거리 쌍은 (" + distance.get(0) + ", " + distance.get(1) +")");
}
}
Console
1차원 점들의 개수를 정하시오: 7
1차원 점들을 정렬되게 입력하시오: 1 3 4 8 13 17 20
[1, 3, 4, 8, 13, 17, 20]
최단거리 쌍은 (3, 4)
- 1차원의 점들이 주어졌을 때, 그 중 가장 거리가 짧은 것의 쌍을 출력하는 함수를 작성하시오.
- 1) 입력값은 : 1차원 점(정수를) 요소로 하는 리스트 = s
- 2) 출력값은 : 튜플형의 점의 쌍을 요소로 하는 리스트 = result3
s = [1, 4, 3, 5, 8, 9, 13, 12, 7] # 점 리스트 예시
def dotdistance(s):
ds = [] # 점들간의 거리 리스트 객체
result = []
result2 = []
result3 = []
for a in s:
s.remove(a)
for b in s:
distance = abs(a-b)
ds.append(distance) # 점들간의 거리를 계산하여 ds 객체에 추가
result.append([a,b]) # 각 점의 쌍을 리스트형으로 result 객체에 추가
s.insert(0,a)
m = min(ds)
for i in ds: # 거리 리스트중 최소값을 찾아
if i == m:
n = ds.index(i)
result2.append(result[n]) # result 객체에서 해당 최소값의 인덱스 값과 일치하는 요소를 result2객체에 추가
ds.remove(i) # ds 객체에서 위의 거리 요소값을 삭제
result.remove(result[n]) # result 객체에서 위의 점의 쌍 요소값을 삭제
for i in result2: # result 객체의 각 요소값을 정렬하여 튜플형으로 result3 객체에 추가
i.sort()
s2 = tuple(i)
result3.append(s2)
for i in result3:
if result3.count(i) == 2: # result3 객체에서 중복되는 요소중 처음 요소를 삭제
result3.remove(i)
print( " 가장 가까운 거리: %d " % m,"\n")
print( " 가장 가까운 점의 쌍:", result3 ) # 가장 거리가 가까운 점의 쌍들을 리스트형으로 출력
print(" ■■■ 가장 가까운 점의 쌍 찾기 ■■■","\n")
print(" 점 리스트: ",s,"\n")
dotdistance(s)
package programming;
import java.util.Arrays;
public class daum {
public static void main(String[] args) {
int s[] = {1,3,4,8,13,17,20};
int prev,next;
int min;
int x1=0,x2=1;
min = s[1] - s[0];
for(int i=1;i<s.length-1;i++){
prev = s[i];
next = s[i+1];
if(next-prev<min){
min = next-prev;
x1 = i;
x2 = i+1;
}
}
System.out.printf("(%d,%d)\n",s[x1],s[x2]);
}
}
import java.util.ArrayList;
public class Main {
public static void main(String[] args) {
// 1차원 점들의 배열
int[] s = { 1, 3, 4, 8, 13, 17, 20 };
// 우선 제일 처음값과 그 다음값의 차를 변수의 저장
int sDis = s[1] - s[0];
// loop문 안에서 loop가 진행되면서 값들의 차를 저장할 변수
int sd = 0;
// 결과값을 저장
ArrayList<Integer> result = new ArrayList<Integer>();
for (int i = 1; i < s.length; i++) {
// 배열에 끝에 도달 했는지 확인
if (i + 1 >= s.length)
break;
else
// 처음과 그 다음값 이후부터 배열에 값들에 차를 저장
sd = s[i + 1] - s[i];
// 처음 저장한 값보다 작으면 거리가 짧은것
if (sd < sDis) {
sDis = sd;
// 이 if문안에 들어오면 다른 값보다 제일 짧기 때문에 결과값을 저장할 방을 비워줌
result.clear();
result.add(s[i]);
result.add(s[i + 1]);
// 거리가 짧은 값이 여러개 일 경우
} else if (sd == sDis) {
result.add(s[i]);
result.add(s[i + 1]);
}
}
for (int i = 0; i < result.size(); i++) {
System.out.print(result.get(i) + " ");
}
}
}
아직 자바 초짜 이다 보니 이 정도가 한계네요 ㅎㅎ;;
-
이장흠,
2017/12/21 11:13
public static void getLine(int[] _points)
{
int resultVal = 0;
int checkVal = 0;
int checkVal2 = _points[1] - _points[0];
int checkVal3 =0;
for(int i=1; i<_points.length-1; i++)
{
checkVal3 = _points[i+1] - _points[i];
if(checkVal3 < checkVal2)
{
checkVal = i;
}
}
System.out.println("결과값 = "+_points[checkVal]+", "+_points[checkVal+1]);
}
numbers = [1, 3, 4, 8, 13, 17, 20]
def printShortPair(numList):
numList.sort() # 1. 배열 입력받고 정렬
i = 0
gap = []
min_number = 0
while(i < len(numList) - 2):
if(i == 0): # i가 0일 때 첫 2개 값 비교하여 최소값 지정
gap.insert(i, numList[i + 1] - numList[i])
gap.insert(i + 1, numList[i + 2] - numList[i + 1])
if(gap[i + 1] - gap[i] <= 0):
min_number = gap[i + 1]
else:
min_number = gap[i]
else: # i가 1 이상일 때 이전 최소값과 다음 1개 값 비교하여 최소값 지정
gap.insert(i + 1, numList[i + 2] - numList[i + 1])
if (min_number - gap[i + 1] <= 0):
min_number = min_number
else:
min_number = gap[i + 1]
# print(str(min_number) + " / " + str(i) + "번째")
i += 1
index = gap.index(min_number)
print("(" + str(numList[index]) + "," + str(numList[index + 1]) + ")")
printShortPair(numbers)
S1 = [1, 3, 4, 8, 13, 17, 20]
S2 = S1[1:]
val = (list(map(lambda x,y:y-x , S1,S2)))
val_min = val.index(min(val))
print({S1[val_min],S1[val_min+1]})
import java.util.Scanner;
import java.util.Arrays;
import java.math.*;
public class findFastWay {
public static void main(String[] args) {
Scanner a = new Scanner(System.in);
int size = a.nextInt();
int[] arr = new int[size];
int index=0;
while(a.hasNext()) {
int n = a.nextInt();
arr[index] = n;
System.out.println(index + ", " + arr[index] + " ");
if(index==size-1) {
break;
}
index++;
}
System.out.println(Arrays.toString(arr));
int min;
if(size==1) {
min = 0;
}
if(arr[1]>arr[0]) {
min = arr[1] - arr[0];
}
else {
min = arr[0] - arr[1];
}
for(int i=0; i<size; i++) {
for(int j=0; j<size; j++) {
if(i==j) {
continue;
}
if(Math.abs(arr[j] - arr[i]) < min) {
min = Math.abs(arr[j]-arr[i]);
}
else
continue;
}
}
System.out.println(min);
}
}
맨 처음에 들어갈 수에 대한 size를 먼저 받고
배열안에 차례대로 입력값을 넣은 후 돌아가는 코드입니다
s = (1,2,3,4,9,43,44,57)
x = 0
y = 1
temp = 0
temp1 = 0
temp3 = 1000
ls = []
for _ in s[:-1]:
print(s[x],s[y])
temp = s[x] - s[y]
temp1 = temp**2
print(ls)
if temp3 >= temp1:
temp3 = temp1
ls.append((s[x], s[y]))
x = x + 1
y = y + 1
print(temp3)
print(ls)
S = set([1,4,3,8,13,20,17])
s = list(S)
d = s[1]-s[0]
for i in range(len(s)-1):
if d > s[i+1] - s[i]:
d = s[i+1] - s[i]
d1, d2 = s[i], s[i+1]
print(d1,d2)
s= [1,3,4,8,13,17,20]
def distance(a,b): if a>b : return a-b else: return b-a
for i in s : for j in s: if distance(i,j)==0: pass else: min=distance(0,1) temp=distance(i,j) if temp <min : min=temp
print(min)
S={1, 3, 4, 8, 13, 17, 20}
S = list(S)
s = [S[0],S[1]]
j =0
for i in S[:-1]:
j += 1
if s[1]-s[0] > S[j]-i:
s[0] = S[j-1]
s[1] = S[j]
print(s)
python 3.6
dots = input("Enter the 1 dimension dots separating with commas in ascending order:").split(',')
d = {}
for i in range(len(dots)-1):
d[(float(dots[i]), float(dots[i+1]))] = float(dots[i+1]) - float(dots[i])
for dot, dis in d.items():
if dis == min(d.values()):
print(dot, end=' ')
파이썬 입니다.
def short(): ##초기버전 숫자를 연속적으로 입력했을떄/ 두자리수 이상의 값을 입력할수가 없다./장점은 알아서 순서를 정렬해준다
S=set(input()) ##입력받134는 값에 중복이 없게 집합 자료형으로 만들어준다.
Slist=list(S) ##순서대로 정렬할 수 있게 집합 자료형을 리스트형태로 바꿔준다.
Slist.sort() ##순서대로 정렬
dis=[] ##거리를 저장하기 위한 리스트를 만든다.
result=tuple()## 지역변수가 아닌 글로벌 변수로 선언해준다.
for i in range(len(Slist)-1):
dis.append(int(Slist[i+1])-int(Slist[i]))## dis거리를 비교한 값이 리스트로 저장됨
result=Slist[dis.index(min(dis))],Slist[dis.index(min(dis))+1]
return result
파이썬 입니다.
def hort(*S):##여러개 입력 받아서 튜플형태로 저장
dis=[]
result=tuple()
for i in range(len(S)-1): ##길이를 줄어주어 에러가 나지 않도록 함
dis.append(int(S[i+1])-int(S[i]))
result=S[dis.index(min(dis))],S[dis.index(min(dis))+1]
return result
import java.util.Scanner;
public class level_1_several_points_length {
public static void main(String[] args) {
//배열의 사이즈 정하기.
System.out.println("배열의 크기를 입력하세요.");
Scanner sc = new Scanner(System.in);
int size = sc.nextInt();
int[] array = new int[size];
//배열에 i번째 인덱스에 들어갈 값 정하기.
for (int i = 0; i < size; i++)
{
System.out.println("배열의 " + (i+1) + " 번째 들어갈 인덱스 값을 입력하세요.");
array[i] = sc.nextInt();
}
sc.close();
//배열 오름차순으로 재정렬.
for (int i = 0; i < size; i++)
{
for(int j = i+1; j < size; j++)
{
if(array[i] > array[j])
{
int temp = array[i];
array[i] = array[j];
array[j] = temp;
}
}
}
//재정렬된 배열 출력.
System.out.print("오름차순으로 재정렬된 배열 : ");
for (int i = 0; i < size; i++)
{
System.out.print(array[i] + " ");
}
System.out.println();
//변수 최솟값 정의.
int min = 0;
min = array[1] - array[0];
//인덱스 값 사이의 최솟값 계산, 두 점 사이의 거리가 가장 짧은 것의 쌍 출력.
for (int i = 0; i < size; i++)
{
for(int j = i+1; j < size; j++)
{
if(array[j] - array[i] == 0)
{
System.out.println("(" + array[i] + ", " + array[j] + ")");
min = 0;
break;
}
if(min < array[j] - array[i])
{
continue;
}
else if(min > array[j] - array[i])
{
min = array[j] - array[i];
System.out.print("두 점 사이의 거리가 가장 짧은 것의 쌍 : ");
System.out.println("(" + array[i] + ", " + array[j] + ")");
}
}
}
System.out.println("두 점 사이의 거리의 최솟값 : " + min);
}
}
과정 :
배열 사이즈 설정. 배열 안에 입력할 값 입력. 배열 오름 차순으로 재정렬 및 출력. 두 점 사이의 거리가 가장 짧은 것의 쌍 출력. 두 점 사이의 거리의 최솟값 출력.
다른 분들꺼에 비해서 너무 난잡하다 ㅠ. ㅜ
일차원 점들을 콤마로 구분해서 한 줄로 입력받은 후 결과를 튜플로 출력합니다. 최소거리가 같은 점의 쌍이 두 개 이상인 경우 모두 출력하도록 했습니다.
def Shortest(A):
D = [A[i]-A[i-1] for i in range(1, len(A))]
m = min(D)
i = 0
while i<len(D):
if D[i] == m: print((A[i], A[i+1]))
i+=1
S = list(map(int, input().split(,)))
Shortest(S)
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Random;
public class test1 {
final int ArrLen = 10;
int[] s = new int[ArrLen];
ArrayList<Integer> aList = new ArrayList<>();
ArrayList<Integer> minList = new ArrayList<>();
public void fillArr(int max) {
Random r = new Random();
for (int i = 0; i < s.length; i++) {
int num = r.nextInt(max);
if (!aList.contains(num)) {
aList.add(num);
} else
i--;
}
int size = 0;
for (int aa : aList) {
s[size++] = aa;
}
Arrays.sort(s);
}
public void loopArr() {
int curNum = 0;
int nxtNum = 0;
for (int i = 0; i < s.length; i++) {
if (i < s.length - 1) {
curNum = s[i];
nxtNum = s[i + 1];
minList.add(nxtNum - curNum);
}
}
Integer min = Collections.min(minList);
for (int j = 0; j < minList.size(); j++) {
if (minList.get(j) == min) {
System.out.println("(" + s[j] + " , " + s[j + 1] + ")");
}
}
}
public static void main(String[] args) {
test1 tt = new test1();
tt.fillArr(40);
tt.loopArr();
}
}
배열을 랜덤으로 생성하는 코드까지 넣었습니다...
public static void main(String[] args) {
int[] s = {1,3,4,8,13,17,20};
int[] d = {0,0,0,0,0,0};
int i,j;
int temp=100;
int one = 0,two = 0;
// 1차원이니까 각 점들의 거리만 저장할 배열을 만들면 될듯
// 배열을 탐색 최저값을 저장
// 최저값일 때 양 옆에 있는 점이 무슨점인지 알 수 있음
for(i = 0, j= 1; j<s.length;i++,j++) {
d[i] = s[j] - s[i];
}
for(i = 0 ; i<d.length;i++) {
if(temp>d[i]) {
temp = d[i];
one = i;
two = i+1;
}
}
System.out.println("가장 짧은 거리는 : " + temp);
System.out.println("두 점의 값은 : " + s[one] + ", " + s[two]);
}
s = [1,3,4,8,13,17,20]
def short(s):
min = s[1]-s[0]
result = ()
for i in range(len(s)-1):
if min > abs(s[i+1]-s[i]) :
min = abs(s[i+1]-s[i])
result=(s[i],s[i+1])
return result
function sort_return(input)
tmp1 = unshift!(sort(input), 0)
tmp2 = push!(sort(input), 0)
tmp3 = (tmp2 - tmp1)[2:length(tmp2-tmp1)-1]
tmp4 = tmp3[indmin(tmp3)]
tmp5 = findin(tmp3, tmp4)
for i in tmp5
println(tmp2[i:i+1])
end
end
Julia
s= [1,3,4,8,13,17,20]
a =[]
for i in range(0,len(s)-1):
a.append(s[i+1]-s[i])
for i in range(0,len(s)-1):
if s[i+1]-s[i] == min(a):
result = s[i]
result2 = s[i+1]
print("(%s,%s)" % (result, result2))
a=list(map(int,input().split(',')))
c=[]
k=[]
minss=[]
for i in range(0,len(a)):
for j in range(1,len(a)):
if i < len(a):
k.append([a[i],a[j]])
print(k)
for i in range(0,len(k)):
m=abs(k[i][0]-k[i][1])
if m !=0:
c=[m,[k[i][0],k[i][1]]]
minss.append(c)
print(minss)
minss.sort()
print(minss)
ss=[]
i=0 while i<len(minss):
if minss[i][0] == minss[0][0]:
ss.append(minss[i][1])
i+=1
print(ss)
s<-c(1, 3, 4, 8, 13, 17, 20)
temp<-NULL
pos<-NULL
for(i in 1:NROW(s)-1){
temp<-c(temp,s[i+1]-s[i])
}
print(min(temp))
print(paste(s[which.min(temp)],",",s[which.min(temp)+1]))
r로 풀었습니다.
s<-c(1,3,4,8,13,17,20)
short<-function(...){
v<-(...)
v2<-NULL
r<-NULL
for(i in 2:length(v)){
v2[i]<-v[i]-v[i-1]
}
r<-paste(v[which.min(v2)-1], v[which.min(v2)])
return(r)
}
short(s)
'''
1차원의 점들이 주어졌을 때, 그 중 가장 거리가 짧은 것의 쌍을 출력하는 함수를 작성하시오.
(단 점들의 배열은 모두 정렬되어있다고 가정한다.)
예를들어 S={1, 3, 4, 8, 13, 17, 20} 이 주어졌다면, 결과값은 (3, 4)가 될 것이다.
'''
#S = [1, 3, 4, 8, 13, 17, 20] # 정답: [3,4]
S = [1, 2, 4, 5, 8, 15, 19] # 정답: [1,2], [4,5]
S1 = S[1:]
S2 = S[:-1]
dist = [s1-s2 for s1,s2 in zip(S1,S2)]
print(' ',S1,'\n-',S2)
print('dist: ',dist)
Shortest_D_idx = [i for i,x in enumerate(dist) if x == min(dist)]
print('idx: ', Shortest_D_idx)
print([S[i:i+2] for i in Shortest_D_idx])
import random
point = list()
a = 0
b = 101 # 숫자갯수
d = 10000 #주어진 가장큰 점
while True:
if a < b:
point.append(random.randint(0,d+1))
a += 1
else:
break
point.sort()
point1 = list()
for points in point:
point1.append(points)
#print("수직선위에 점들은", point, "이다")
del point[0] # 오른쪽
del point1[-1] # 왼쪽
#print (point)
#print(point1)
dist = list() #거리
for points in range(0,len(point)):
dist.append(point[points]-point1[points])
#print("각점사이 거리는", dist, "이다")
c = len(dist)
while c > 1:
if dist[0] == 0:
del dist[0]
del point[0]
del point1[0]
c = len(dist)
if dist[0] <= dist[1]:
del dist[1]
del point[1]
del point1[1]
c = len(dist)
#print(c)
else :
del dist[0]
del point[0]
del point1[0]
c = len(dist)
#print(c)
print(point, "와", point1, "의 점 사이의 거리가", dist, "로 가장 가깝다")
"""
1차원의 점들이 주어졌을 때, 그 중 가장 거리가 짧은 것의 쌍을 출력하는 함수를 작성하시오. (단 점들의 배열은 모두 정렬되어있다고 가정한다.)
예를들어 S={1, 3, 4, 8, 13, 17, 20} 이 주어졌다면, 결과값은 (3, 4)가 될 것이다.
"""
s = [1, 3, 4, 8, 13, 17, 20]
s = [1,2,4,5,8,15,19]
def count_close(num_list):
"""Find the closest number between two points in 2D"""
smallest = float('inf')
smallest_list = []
for i in range(len(num_list)-1):
diff = abs(num_list[i] - num_list[i+1])
if diff < smallest:
smallest = diff
smallest_list = []
smallest_list.append((num_list[i], num_list[i+1]))
elif diff == smallest:
smallest_list.append((num_list[i], num_list[i+1]))
return smallest_list
자바입니다
public static void main(String[] args) {
Scanner cin = new Scanner(System.in);
List<Integer> list = new ArrayList<Integer>();
while(true) {
System.out.print("값(종료시 Enter) = ");
String read = cin.nextLine();
if(read.trim().equals("")) {
break;
}else {
list.add(Integer.parseInt(read));
}
}
int[] data = new int[list.size()];
int[] between = new int[data.length-1];
for(int i = 0;i < list.size(); ++i) {
data[i] = list.get(i);
}
for(int i = 0;i < between.length;++i) {
between[i] = Math.abs(data[i] - data[i+1]);
}
int min = Integer.MAX_VALUE;
for(int i = 0;i < between.length;++i) {
if(between[i] < min) {
min = between[i];
}
}
for(int i = 0;i < between.length;++i) {
if(between[i] == min) {
System.out.println("제일 거리가 짧은 점(" + data[i] + ", " + data[i+1] + ")");
}
}
cin.close();
}
꽤 난잡하네요;
-
YEAHx4,
2018/01/24 21:25
def min_distance(S):
temp = 0
min = 1000 # 임의의 큰 수
for i in range(len(S)-1):
if min > S[i+1] - S[i]:
min = S[i+1] - S[i]
temp = i
#print(temp)
print((S[temp], S[temp+1]))
if __name__ == '__main__':
S=[1,3,4,8,13,17,20]
min_distance(S)
Python 3.6
from itertools import combinations
arr = [1, 3, 4, 8, 13, 17, 20]
print(min([[abs(i-j), (i,j)] for i,j in combinations(arr, 2)]))
s<-c(1,3,4,8,13,17,20)
pa<-function(...){ x<-c(...) re<-NULL min<-x[2]-x[1] for(i in 2:length(x)-1){ n<-x[i+1]-x[i] if(min>n){ re<-c(x[i],x[i+1]) min<-n }else if(min==n){ re<-c(re,c(x[i],x[i+1])) } } return(re) } pa(s)
#1차원 점의 좌표 입력.
point=[]
pnum=int(raw_input("점의 개수: "))
for i in range(pnum):
point.append(1)
point[i]= int(raw_input("점의 좌표: "))
#거리가 가장 짧은 두 좌표 판별 후 출력
cor=[]
point.sort()
for i in range(pnum-1):
for j in range(pnum-i-1):
cor.append([point[i], point[i+1:][j]])
dis=[]
for i in range(pnum):
dis.append(cor[i][1]-cor[i][0])
print cor # 점들 사이의 거리를 계산하기 위한 좌표 리스트
print dis # 점들 사이의 거리
print min(dis) # 최단 거리 값
print cor[dis.index(min(dis))] # 최단 거리를 가지는 두 점
def shortest(*s):
s=sorted(list(s)) #정렬되어 있다는 가정이 있다면 생략
spairs=list(zip(s[:-1],s[1:]))
minimum=min(map(lambda x:x[1]-x[0], spairs))
result=[]
for x in spairs:
if x[1]-x[0]==minimum:
result+=[x]
print(result)
shortest(주어진 1차원 점들을 ,를 써서 차례로 씀)
이렇게 하면 임의의 1차원 점들의 집합에 대해서 최단거리인 점들의 순서쌍을 모두 출력할 수 있습니다.
#include <stdio.h>
#include <math.h>
#include <limits.h>
int main(void) {
int nlist[] = { 1, 3, 4, 8, 13, 17, 20 };
int i, sub, sub2; //차이
int correct; //정답
int near1 = 0;
int near2 = 0;
int k = INT_MAX;
for (i = 1; i < 6; i++){
sub = nlist[i + 1] - nlist[i];
if (k > abs(sub)){
k = abs(sub);
near1 = nlist[i + 1];
near2 = nlist[i];
}
}
printf("[%d]와 [%d]\n", near1, near2);
return 0;
}
def two():
result = [1, 2, 3, 4, 8, 13, 17, 20]
min = 100000 # 최소값
one = 0 # 첫번째 값
two = 0 # 두번째 값
for num in result:
if one==0:
one =num
two=num
else:
if two>num:
ch=two-num
else:
ch = num-two
if ch<min:
min=ch
one=two
two=num
print("one : %s, two : %s" % (one, two)) #결과 출력
two()
var s = [1, 3, 4, 8, 13, 17, 20];
var _initial = s[1] - s[0];
for (var i = 0; i < s.length; i++) {
for (var j = i+1; j < s.length; j++) {
var _immi = s[j] - s[i];
if( _immi < _initial) {
_initial = _immi;
};
};
};
var _array = new Array;
for (var i = 0; i < s.length; i++) {
for (var j = i+1; j < s.length; j++) {
var _immi = s[j] - s[i];
if( _immi == _initial) {
_array.push([s[i], s[j]]);
};
};
};
console.log(_initial);
console.log(_array);
만들었는데 생각해보니 이미 소팅이 되어있어서 모든 엘리먼트들끼리 비교 안해도 되겟더라고요... 무슨 멍청한 짓을 한건지....
def min_diff(set):
points = list(set)
points.sort()
small = points[1] - points[0]
for i in range(len(points)-1):
if points[i+1]-points[i] < small:
small = points[i+1]-points[i]
return small
def find_min_diff(set):
points = list(set)
points.sort()
result = []
for i in range(len(points)-1):
if points[i+1]-points[i] == min_diff(set):
result.append((points[i], points[i+1]))
return result
거리가 최단거리인 쌍이 여럿 있으면 모두 출력니다.
메모리를 아끼기 위해 거리를 차례대로 하나씩 측정하고 비교합니다.
# 파이썬
sample = [1, 3, 4, 8, 13, 17, 20, 21]
def find_shortest(list1):
result = []
shortest = []
distance = abs(list1[1]-list1[0])
for m in range(len(list1)-1):
current = abs(list1[m] - list1[m + 1])
if distance == current:
shortest.append((list1[m], list1[m+1]))
elif distance > current:
shortest = [(list1[m], list1[m+1])]
distance = current
return shortest
print(find_shortest(sample))
자바 ArrayList를 써서 입력 정수의 개수와 상관없이 처리하는 프로그램! 입력이 끝나면 정수가 아닌 데이터('end' 등)를 콘솔에 입력하면 됩니다
package CodingDojang;
import java.util.*;
class FindShortestDots {
int[] a;
public FindShortestDots(int[] a) {
this.a = a;
}
public int[] solve() {
int shortestDifference = 0;
int fixed_i = 0;
int[] dots = new int[2];
for(int i = 0; i < a.length - 1; i++) {
if(i == 0 || shortestDifference > (int)Math.abs((double)a[i]-a[i+1])) {
fixed_i = i;
shortestDifference = (int)Math.abs((double)a[i]-a[i+1]);
}
}
dots[0] = a[fixed_i];
dots[1] = a[fixed_i + 1];
return dots;
}
}
public class Daum {
public static void main(String args[]) {
ArrayList<Integer> a = new ArrayList<Integer>();
int[] dots = new int[2];
Scanner scanner = new Scanner(System.in);
while(scanner.hasNextInt()) {
a.add(scanner.nextInt());
}
int[] b = new int[a.size()];
for(int i = 0; i < a.size(); i++) {
b[i] = a.get(i);
}
FindShortestDots d = new FindShortestDots(b);
dots = d.solve();
System.out.printf("(%d, %d)", dots[0], dots[1]);
}
}
import java.util.*;
public class test { public static void main(String[] args) { Scanner scanf=new Scanner(System.in); int[] arr= {1,2,3,5,13,17,20}; int min=arr[1]-arr[0];
for(int i=1; i<arr.length; i++) {
if(min>=arr[i]-arr[i-1]) {
min=arr[i]-arr[i-1];
System.out.println("("+arr[i-1]+","+arr[i]+")");
}
}
}
}
import Data.List
import Data.Function
solution = minimumBy (compare `on` uncurry (-)) . (zip =<< tail)
#include <stdio.h>
#include <stdlib.h>
int main(){
int i=0, j=0;
int num; // 좌표값
int pos1, pos2; // 거리가 짧은 좌표한쌍
int min=10000; // 충분히 큰 수
int arrlen=5; // 동적할당한 배열의 초기길이
int *ptr=(int*)malloc(sizeof(int)*arrlen); // 좌표를 저장할 동적배열
char ch=0; // 개행검사
// 개행 전까지 좌표 입력 받기
while(ch!='\n'){
scanf("%d%c",&num,&ch);
ptr[i++]=num;
// 배열 확장 검사
if(i==arrlen){
arrlen+=5;
ptr=(int*)realloc(ptr,sizeof(int)*arrlen);
}
}
for(j=0; j<i-2; j++){
if(ptr[j+1]-ptr[j]<min){
min=ptr[j+1]-ptr[j];
pos1 = ptr[j];
pos2 = ptr[j+1];
}
}
printf("%d %d",pos1,pos2);
}
D언어 추가해주세요...
import std.stdio;
int sorry(int[] input){
int min = input[1]-input[0]; // 첫번째 비교의 최소값
int cur = 1; // 첫번째 비교의 최소값의 위치
for(int i=2; i<input.length-1; i++){
int x = input[i];
int y = input[i+1];
if( (y-x)<min )
{ min = y-x; cur = x; } // 최소값보다 작으면, 위치(cur)와 최소값(min) 저장
}
return cur;
}
void main(){
int[] input = [1, 3, 4, 8, 13, 17, 20];
int point = sorry(input);
writefln("[%d, %d]", input[point], input[point+1]);
}
출력: [3, 4]
location_list=[]
len_location=int(input("점들의 개수를 입력하세요\n"))
for k in range(len_location):
temp_location=int(input('좌표를 입력하세요\n'))
location_list.append(temp_location)
min_num=9999
min_location_list=[]
for k in range(len_location-1):
temp_difference=(location_list[k+1]-location_list[k])
if min_num==temp_difference:
min_location_list.append((location_list[k],location_list[k+1]))
if min_num>temp_difference:
min_num=temp_difference
del min_location_list[:]
min_location_list.append((location_list[k],location_list[k+1]))
for k in min_location_list:
print(k)
public void MaxDistance() {
int maxdistance = 0;
for(int i = (array.length - 1); i > 0; i--) {
int tempmaxdistance = array[i] - array[i-1];
if(tempmaxdistance > maxdistance) {
x1 = array[i-1];
x2 = array[i];
maxdistance = tempmaxdistance;
}
}
}
package com.codingdojang.level1;
public class DaumDot {
public static void main(String[] args) {
int S[] = {1, 3, 4, 8, 13, 17, 18, 20};
int val1 = S[1] - S[0];
int val2 = 0;
int dot1 = 0;
int dot2 = 0;
for (int i = 1; i < S.length-1; i++) {
val2 = S[i+1] - S[i];
if (val1 > val2) {
val1 = val2;
dot1 = S[i];
dot2 = S[i + 1];
} else if (val1 == val2) {
System.out.println("(" + S[i] + ", " + S[i+1] + ")");
}
}
System.out.println("(" + dot1 + ", " + dot2 + ")");
}
}
최소 거리가 여러 개일 경우를 고려해봄.
Python 3.6 으로 작성하였습니다.
Park Minwoo님 추천 풀이 중에 아래와 같은 방법으로 Pairs 를 설정하여 누락되는 부분을 해결할 수 있습니다.
#S = {1, 3, 4, 8, 13, 17, 20}
S = [1, 2, 4, 5, 8, 15, 19]
pairs = []
for i in S:
for j in S:
if i >= j:
continue
pairs.append((i,j))
[pair for pair in pairs if pair[1]-pair[0] == min([pair[1]-pair[0] for pair in pairs])]
import numpy as np
def short_distance_pair(lst):
diff = np.array(lst[1:])-np.array(lst[:-1])
x = np.argmin(diff)
return (lst[x:x+2])
s = [1, 3, 4, 8, 13, 14, 17, 20];
% 벡터의 차를 계산
diff_s = diff(s);
% 최소값 찾기
min_value = min(diff_s);
% 최소값이 복수일 경우 위치 찾기
x_idx = find(diff_s == min_value);
% 출력을 위해 최소거리쌍 만들기
idx = [x_idx;x_idx+1];
%
s(idx)
using System;
namespace CSharp_Test
{
class Program
{
static void Main(string[] args)
{
int[] arr = { 1, 3, 4, 8, 13, 17, 20 };
int min = 10000; //충분히 큰수로 초기화
int a = 0, b = 0; //두 쌍을 저장할 변수
for(int i = 0; i < arr.Length; i++)
{
for (int j = i+1; j < arr.Length; j++)
{
if (Math.Abs(arr[i] - arr[j]) < min)
{
min = Math.Abs(arr[i] - arr[j]);
a = arr[i]; b = arr[j];
}
}
}
Console.WriteLine("{0}, {1}", a, b);
}
}
}
# 임의의 리스트 생성
a = [0, 2, 3, 6, 6587, 8756, 8757]
nums = len(a)
diff = list()
n = 1
while True:
if n == nums:
break
diff.append(abs(a[n]-a[n-1]))
n = n + 1
minvalue = min(diff)
n = 0
while n < nums-1:
if diff[n] == minvalue:
print([a[n], a[n+1]])
n = n + 1
#include<stdio.h>
int main()
{
int s[] = { 1,3,4,8,13,17,20 };
int min_a = 0, min_b = 0;
int min = s[6]-s[0];
for (int i = 0; i < 7; i++)
{
for (int j = 0; j < 7; j++)
{
if ((s[j] - s[i] > 0) && (s[j] - s[i] < min))
{
min = s[j] - s[i];
min_a = s[i];
min_b = s[j];
}
}
}
printf("(%d,%d)\n", min_a,min_b);
}
def shortestdistance(*numbers):
result = []
count = numbers[-1]*2
args = -1
while args +2 < len(numbers):
args = args + 1
if numbers[args + 1] - numbers[args] < count:
count = numbers[args + 1] - numbers[args]
result = []
result.append((numbers[args], numbers[args + 1]))
elif numbers[args + 1] - numbers[args] == count:
result.append((numbers[args], numbers[args + 1]))
return result
public class ShortDistance {
public static void main(String[] args) {
int[] s = {1, 3, 4, 8, 13, 17, 20};
int gap = s[1]-s[0];
int n1 = s[0], n2=s[1];
int tmp;
for (int i = 1; i < s.length; i++) {
tmp = s[i] - s[i-1];
if (tmp<gap) {
n1=s[i-1];
n2=s[i];
}
}
System.out.println("정답 : "+n1+", "+n2);
}
}
자바입니다. 같을경우도 프린트하라고 해서 해봤습니다. package Q1;
import java.util.Scanner;
/* 1차원의 점들이 주어졌을 때, 그 중 가장 거리가 짧은 것의 쌍을 출력하는 함수를 작성하시오. (단 점들의 배열은 모두 정렬되어있다고 가정한다.)
예를들어 S={1, 3, 4, 8, 13, 17, 20} 이 주어졌다면, 결과값은 (3, 4)가 될 것이다 */ public class Q22 { public static void main(String[] args) { Scanner sc = new Scanner(System.in); int x=0,y=0; int[] arr = {1,3,4,8,10,23,31,44};
for(int i =0; i<arr.length-1;i++) {
if((arr[i+1]-arr[i])>(x-y)) {
x=arr[i+1];
y=arr[i];
}
}
for(int i =0; i<arr.length-1;i++) {
if((arr[i+1]-arr[i])==(x-y)) {
System.out.println("-> "+arr[i]+" "+arr[i+1]);
}
}
}
}
num = input("Enter the numbers : ").split(",")
num = map(int, num)
num.sort()
i = 0
dif = []
result = []
def search(List, Min, out):
min_index = List.index(Min)
out.append([num[min_index], num[min_index + 1]])
return out
while True:
dif.append(num[i+1] - num[i])
i = i + 1
if i == len(num)-1:
i = 0
break
minValue = min(dif)
Count = dif.count(minValue)
if Count == 1:
result = search(dif, minValue, result)
elif Count >= 2 :
for i in range(Count):
result = search(dif, minValue, result)
dif[dif.index(minValue)] = "a"
print(result)
이제 파이썬 시작한지 1달 되는 왕초보네여 ㅜ
나름 머리굴려서 사용자가 입력한 숫자를 이용해서 최소차이발생하는 값을 리스트 짝으로 출력했고 중복이 있을경우도 출력했네요 ㅜ
정렬이 되있다는 가정이 있긴하지만 일부러 소팅하였습니다
입력이 순차적이지 않으면 소팅해서 계산하니 입력값에 주의 하시도록..
Python 2.7 처음 올려봅니다. 너무 지저분하네요.. ㅠㅠ
Set1 = [1, 3, 4, 8, 13, 17, 20]
Set2 = [1, 2, 4, 5, 8, 15, 19]
Set3 = [1,3, 7, 4, 8, 13, 17, 20]
def shortest_path(set):
for i in range(len(set)-1):
for j in range(i, len(set)-1):
diff_criteria = 1
diff = abs(set[i] - set[j+1])
if diff == diff_criteria:
print [set[i], set[j+1]]
else:
diff_criteria += 1
shortest_path(Set1)
shortest_path(Set2)
shortest_path(Set3)
중복값도 다 출력되게 처리했구요 처음 값과 비교하면서 쭉쭉 계산하고 더하는 방식으로 풀었습니다. 대신에 입력을 1,3,6,19,20 이렇게 일일이 입력해줘야 한다는 점.. 보충할꺼나 수정할꺼 말씀해주세요! 코딩해본적도없습니다 ㅠㅜ
a=set([])
a.update(map(int,input().split(',')))
S=list(a)
S.sort()
bingo=abs(S[0]-S[1])
dab=[]
for i in range(0,len(S)-1):
if abs(S[i]-S[i+1])<bingo:
dab.clear()
dab.append([S[i],S[i+1]])
if abs(S[i]-S[i+1]) == bingo:
dab.append([S[i],S[i+1]])
for i in range(len(dab)):
if dab[i]==0:
continue
print(tuple(dab[i]))
코딩공부 3일차
파이썬 첫 도전 해봤습니다.
(random 부분은 따왔습니다.)
import random
S = list(set(list([random.randint(1,100) for i in range(10)])))
sb= []
def f(S):
for x in S:
for y in S:
if x>=y:
continue
else:
sb.append(abs(x-y))
sb.sort()
for a in S:
for b in S:
c = abs(a-b)
if c == sb[0] and a<b:
return (a,b)
print("정수쌍 : ")
print(S)
print('차가 가장 작은 두 수 : ')
print(f(S))
"""
author: Kenny Jeon
date: 03/12/2018
"""
import random
def func(s):
pairs = zip(s[0:], s[1:])
# make list as pairs tuple
min_dist_pairs = list()
# declare list
for pair in pairs:
if len(min_dist_pairs) == 0:
min_dist_pairs.append(pair)
# if list is empty
elif pair[1] - pair[0] == min_dist_pairs[0][1] - min_dist_pairs[0][0]:
min_dist_pairs.append(pair)
# if pair is as same as min dist
elif pair[1] - pair[0] < min_dist_pairs[0][1] - min_dist_pairs[0][0]:
min_dist_pairs.clear()
min_dist_pairs.append(pair)
# if pair is shorter than existing min dist
else:
pass
return min_dist_pairs
if __name__ == "__main__":
points = sorted(list(set([random.randint(1, 100) for i in range(10)])))
print(points)
result = func(points)
print(*result, sep='\n')
def paris(S):
dict = {}
for (x, y) in zip(S[:], S[1:]):
# 해당 거리 값이 처음일 때
if not dict.get(y-x):
dict[y-x] = [(x,y)]
# 해당 거리 값이 존재할 때
else:
dict[y-x] = dict[y-x] + [(x,y)]
# 거리의 리스트 - 최소거리(min)에 대한 해당 값 리턴
return dict[min(dict.keys())]
S = [1, 3, 4, 5, 8, 13, 17, 20]
print(paris(S))
zip 과 딕셔너리를 배울 수 있었습니다.
def couple(lis) :
lis.sort()
res = []
for i in range(len(lis)-1) :
res.append(lis[i+1]-lis[i])
idx = res.index(max(res))
return (lis[idx], lis[idx+1])
print(couple([5,3,7,57,45,8,34,6,23]))
Swift입니다. 정렬이 되어 있고, 최장거리는 하나만 있다고 가정했습니다.
import Foundation
// var input = [1, 3, 4, 8, 13, 17, 20, 21, 29, 30, 49]
var input = [1, 3, 4, 8, 13, 17, 20]
// Zipping input array and input array without first item
// This will generate new array like following
// [(1, 3), (3, 4), (4, 8), (8, 13), (13, 17), (17, 20)]
var zipped = Array(zip(input, input.dropFirst()))
var maxDistance = -1
var maxItem: (Int, Int) = (-1, -1)
// Find maximum distance from zipped array
for item in zipped {
let distance = item.1 - item.0
if distance > maxDistance {
maxDistance = distance
maxItem = item
}
}
print(maxItem.0, maxItem.1)
Javascript로 구현해보았습니다!
const shortNum = (numArr = []) => {
const numberList = numArr.sort((a, b) => a - b);
const tmp = [];
const tmpNum = 111111111111111111;
let i,
numbersLen = numberList.length,
minNum = 0;
for (i = 0; i < numbersLen; i++) {
if (numberList[i + 1]) tmp.push(numberList[i + 1] - numberList[i]);
else tmp.push(tmpNum);
minNum = Math.min.apply(null, tmp);
if (numberList[i + 1] - numberList[i] === minNum) {
return `[${numberList[i]},${numberList[i + 1]}]`;
}
}
}
console.log(shortNum([1, 10, 100, 8, 5]));
public class MinDistance {
public static void main(String[] args) {
// TODO Auto-generated method stub
int[] s = {1, 3, 4, 8, 13, 17, 20};
int distance = s[1] - s[0]; //첫 값
int x = s[0];
int y = s[1];
for(int i = 0; i < s.length; i++){
for(int j=i+1; j <s.length; j++){
if(distance > s[j] - s[i]){
distance = s[j] - s[i];
x=s[i];
y=s[j];
}
}
}
System.out.println("("+x+","+y+")");
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace PracticeWW
{
class Program
{
static void Main(string[] args)
{
int[] data = { 8, 5, 19, 2, 4, 1, 15};
int distance = 0;
var datas = from int d in data
orderby d ascending
select d;
data = datas.ToArray<int>();
for (int i = 0; i < data.Length - 1; i++)
{
if (distance > data[i + 1] - data[i] || i == 0)
distance = data[i + 1] - data[i];
}
for (int i = 0; i < data.Length - 1; i++)
{
if (distance == data[i + 1] - data[i])
Console.WriteLine("({0}, {1})", data[i], data[i + 1]);
}
}
}
}
S = [1, 3, 4, 8, 13, 17, 20]
prevData = None
minimum = S[1] - S[0]
best = (S[1],S[0])
for s in S:
if not prevData:
prevData = s
continue
if minimum > s - prevData:
minimum = s - prevData
best = (prevData,s)
prevData = s
print(best)
/* C언어로 작성 했습니다 */
#include <stdio.h>
#include <stdlib.h>
int main()
{
int n, i, j, k, count=1; //count변수:최소거리가 같은 점들이 있을경우 번호부여
printf("입력할 점의 갯수는? : ");
scanf("%d", &n);
int* arr = (int*)malloc(sizeof(int)*n); // arr배열에 동적메모리 할당
for(j=0;j<n;j++)
{
printf("%d번째 점을 입력하세요 : ", j+1); // 점들은 정렬되었다고 가정해서 입력
scanf("%d", &*(arr+j));
}
int a = arr[0], b = arr[1]; // 서로간의 최단거리인 점의값 변수인 a와b를 초기화
for(i=0;i<n-1;i++) // 최단거리의 점인 a와 b의 값을 구한다
{
if(arr[i+1]-arr[i] < arr[b]-arr[a])
{
a = i;
b = i+1;
}
}
for(k=0;k<n;k++) // a와b의 최단거리값과 똑같은 점들을 찾아 모두 출력한다
{
if(arr[k+1]-arr[k] == arr[b]-arr[a])
{
printf("가장 짧은 점의 쌍(%d)은(%d, %d) 입니다.\n", count, arr[k], arr[k+1]);
count++;
}
}
free(arr); // malloc 함수로 할당된 동적메모리를 free함수로 반환
return 0;
}
s = [1, 3, 5, 8, 13, 17, 20, 24, 28, 29]
tmp = 10
for i in range(len(s)-1):
if tmp > s[i+1] - s[i]:
tmp = s[i+1] - s[i]
s1 = s[i]
s2 = s[i+1]
print(s1, s2)
Q> 다음 입사문제 : 1차원점들 사이에 거리 1차원의 점들이 주어졌을 때, 그 중 가장 거리가 짧은 것의 쌍을 출력하는 함수를 작성하시오.(단 점들의 배열은 모두 정렬되어있다고 가정한다.) 예를들어 S={1, 3, 4, 8, 13, 17, 20} 이 주어졌다면, 결과값은 (3, 4)가 될 것이다.
- 자바 인터프리터가 자바 메모리 Call Stack영역에 main()를 호출하면서 프로그램은 시작된다.
- int형 배열 s를 선언하고, {1, 3, 4, 8, 13, 17, 20}으로 초기화한다.
- 배열s에 값들의 차이를 저장할 크기가 s.length인 int형 배열d를 선언한다.
- s배열의 차이값들을 d배열에 순차적으로 저장한다.
- d배열의 차이값들중 가장 작은 값을 변수 min에 저장
- 변수 min값과 s배열의 차이값과 일치하는 쌍을 찾아내 println메서드로 출력한다.
- main()가 종료되면서 자바 프로그램이 끝난다.
public class dot_distance {
public static void main(String[] args) {
int[] s = {1, 3, 4, 8, 13, 17, 20};
int[] d = new int[s.length-1];
for(int i = 0; i < s.length-1; i++) {
d[i] = s[i+1] - s[i];
}
int min = d[0];
for(int i = 1; i <= d.length-1; i++) {
if(d[i] < min) {
min = d[i];
}
}
for(int i = 0; i < s.length-1; i++) {
if(min == s[i+1] - s[i]) {
System.out.println(s[i] + ", " + s[i+1]);
}
}
}
}
public static String minDist(int[] iArr) {
String oStr = "";
int minDist = Math.abs(iArr[1] - iArr[0]);
for(int i = 1; i < iArr.length - 1; i++) {
if(Math.abs(iArr[i + 1] - iArr[i]) < minDist) {
minDist = Math.abs(iArr[i + 1] - iArr[i]);
oStr = "(" + iArr[i] + ", " + iArr[i + 1] + ")";
}
}
return oStr;
}
from random import randint
arr = []
arrnum = randint(1, 10)
for i in range(arrnum):
i = randint(1,100)
arr.append(i)
arr.sort()
#for i in range(len(arr)):
# print(arr[i])
i = 0
dis = arr[i+1]-arr[i]
min = dis
idx = 0
for i in range(len(arr)-1):
dis = arr[i+1]-arr[i]
if dis < min:
min = dis
idx = i
print(arr[idx], arr[idx+1])
public static int[] paging(int arr[]){
int[] result = new int[2];
int num =0;
int swapNum = 0;
for(int i=0 ; i<arr.length-1 ;i++){
num = arr[i+1]-arr[i];
if(i==0){
swapNum = num;
result[0] = arr[i];
result[1] = arr[i+1];
}else{
if(num<swapNum){
swapNum = num;
result[0] = arr[i];
result[1] = arr[i+1];
}
}
}
return result;
}
S = [1, 3, 4, 8, 13, 17, 20]
min_dist = S[1] - S[0]
for i in range(1, len(S)-1):
if S[i+1]-S[i] < min_dist:
min_dist = S[i+1] - S[i]
for i in range(0, len(S)-1):
if S[i+1]-S[i] == min_dist:
print((S[i],S[i+1]))
복수의 최단거리, 정렬되지 않은 리스트의 경우 포함, 출력되는 코딩입니다.
s = [1, 3, 4, 8, 13, 17, 20,7,24,21] ## 정렬되지 않은 1차원의 점
def mindis(s):
mpairs = []
s.sort() is s ## 1차원의 점 정렬
pairs = list(zip(s[0:],s[1:])) ## 1차원의 점들 양 옆의 값끼리 묶기
sortedpairs = (sorted(pairs, key=lambda x:x[1]-x[0])) ## 거리가 최소인 그룹 순으로 정렬
mpair = min(sortedpairs, key= lambda x:x[1]-x[0]) ## 거리가 최소인 그룹 추출
mpair = list(mpair) ## 그 그룹의 점, 리스트화
for (x,y) in sortedpairs: ## 정렬된 최단 그룹 대입
if y - x == mpair[1]-mpair[0]: ## 대입된 값과 추출된 최단 거리 값 비교
mpairs.append((x,y)) ## 같을 때, mpairs 그룹에 대입
print(mpairs)
import java.util.Scanner;
public class main {
public static void main(String[] args) {
int[] dots;
int n;
Scanner scan = new Scanner(System.in);
System.out.println("갯수 입력 :");
n = scan.nextInt();
dots = new int[n];
for(int i=0; i<n; i++){
System.out.println(i+" 번째 점 위치 입력 : ");
dots[i] = scan.nextInt();
}
int min=999999;
int o_dot1=0;
int o_dot2=0;
for(int i=0; i<n-1; i++){
for(int j=i+1; j<n; j++){
int temp = dots[i]-dots[j];
if(temp < 0)
temp*=(-1);
if(temp < min){
min = temp;
o_dot1 = dots[i];
o_dot2 = dots[j];
}
}
}
System.out.println("("+o_dot1+","+o_dot2+")");
}
}
public void DaumExam() { int[] nAarray = new int[] { 1, 3, 4, 8, 13, 17, 20 };
int nMax = 2147483647;
int nFirst = 0;
int nSecond = 0;
for (int i = 0; i < nAarray.Length - 1; i++)
{
if (nAarray[i+1] - nAarray[i] < nMax)
{
nMax = nAarray[i + 1] - nAarray[i];
nFirst = nAarray[i];
nSecond = nAarray[i + 1];
}
}
Console.WriteLine("{0}, {1}", nFirst, nSecond);
}
Pharo Smalltalk 6.1
solution: anArray
| minIdx minDistance |
minIdx := 1. minDistance := anArray max - anArray min.
1 to:(anArray size - 1) do: [ :idx |
| tmp |
tmp := ((anArray at:idx) - (anArray at:(idx+1))) abs.
(tmp < minDistance) ifTrue: [ minDistance := tmp. minIdx :=idx ]
].
^ {anArray at:minIdx . anArray at:(minIdx+1)}
public class base_short_main {
public static void main(String[] args) {
Calculation cal = new Calculation();
Scanner s = new Scanner(System.in);
Boolean enter = true;
int[] num_array = new int[5];
int check;
int count = 0;
while (enter) {
System.out.println("수를 입력하세요.(최대 5개, 현재 입력받은 배열 수 :" + count + ")");
try {
check = s.nextInt();
System.out.println("숫자가 맞습니다.");
num_array[count] = check;
count++;
if(count == 5){
cal.Cal(num_array);
}
} catch (InputMismatchException e) {
System.out.println("숫자만 입력하세요.");
break;
} catch (Exception e) {
}
}
}
}
public class Calculation {
public void Cal(int[] array){
int min;
int max;
int difference;
int sol = 100;
int min_sol = 0;
int max_sol = 0;
for(int i = 1; i < array.length; i++){
min = array[i-1];
max = array[i];
difference = min - max;
if(difference < 0){
difference = -difference;
}
if(difference<sol){
sol = difference;
min_sol = array[i-1];
max_sol = array[i];
}
}
System.out.println("**결과**");
System.out.println(min_sol+"와 "+max_sol);
System.out.println(sol+"의 차이로 가장 적은 차이가 난다.");
}
}
#리스트 생성
n=1
prilist = []
print("리스트를 입력 하시오 , 단 0이 되면 종료")
#리스트 입력
while(1):
n = int(input("리스트 입력"))
if n > 0:
prilist.append(n)
else:
break
#오름차숨정렬
prilist.sort()
#배열 출력
print(list(prilist))
#배열 검사
p = 0
first = prilist[1]-prilist[0]
ans = first
for i in range(len(prilist)-1):
if prilist[i+1]-prilist[i] < ans:
p = i
ans = prilist[i+1] - prilist[i]
print(ans)
print("(" , prilist[p],",", prilist[p+1], ")")
S={1, 3, 4, 8, 13, 17, 20} l=list(S)
print(l, type(l))
t = [] for i in range(0,len(l),1): #print(int(l[i+1]) - int(l[i])) if i+1 == len(l): break else: t.append( l[i+1] - l[i])
for i in range(0,len(t),1): if min(t) == t[i]: print(l[i],l[i+1])```{.python}
```
#include <iostream>
using namespace std;
int main()
{
int S[] = {1, 3, 4, 8, 13, 17, 20};
int d, min, min_d=S[1] - S[0]; // d : distance
for (int i = 0; i < int(size(S)) - 1; i++)
{
d = S[i + 1] - S[i];
if (d < min_d)
{
min_d = d;
min = i;
}
else;
}
cout << min_d << ", ("<< S[min] <<","<< S[min+1]<< ")"<<endl;
return 0;
}
ECMA 3, IE 6 동작 가능한 Javascript 입니다.
function compareMinDifferent(array) {
if (Object.prototype.toString.call(array) !== "[object Array]") {
throw new TypeError("param is invalid");
}
var minDifferent;
var minDifferentMember = [0, 0];
var register = function(a, b, different) {
minDifferent = different;
minDifferentMember[0] = a;
minDifferentMember[1] = b;
};
array
.sort(function(a, b) {
return a - b;
})
.sort(function(a, b) {
var different = Math.abs(a - b);
if (typeof minDifferent !== "number") {
register(a, b, different);
return a - b;
}
if (minDifferent > different) {
register(a, b, different);
}
return a - b;
});
return minDifferentMember;
}
alert(compareMinDifferent([1, 3, 4, 8, 13, 17, 20]));
C
#include <stdio.h>
#define N 100
int main() {
int i, n, res = 2147483647, S[N] = { 0, };
int a[N] = { 0, }, b[N] = { 0, }, cnt=0;
printf("점들의 갯수 : ");
scanf_s("%d", &n);
for (i = 0; i < n; i++) scanf_s("%d", &S[i]);
for (i = 1; i < n; i++) {
if (S[i] - S[i - 1] <= res) {
if (S[i] - S[i - 1] == res) {
a[cnt] = S[i - 1];
b[cnt++] = S[i];
}
else {
res = S[i] - S[i - 1];
a[cnt] = S[i - 1];
b[cnt++] = S[i];
}
}
}
for (i = 0; i < cnt; i++)
printf("( %d , %d ) \n", a[i], b[i]);
return 0;
}
#include<iostream>
using namespace std;
int main()
{
int array[7] = { 1,3,4,8,13,17,20 };
int min = array[6] - array[0];
int temp, min_index, min_second;
for (int i = 0; i < 6; i++)
{
for (int j = i+1; j < 6; j++)
{
if (array[i] < array[j])
temp = array[j] - array[i];
else
temp = array[i] - array[j];
if (temp < min)
{
min = temp;
min_index = i;
min_second = j;
}
}
}
cout << "가장 거리가 짧은 것은 " << array[min_index] << ' ' << array[min_second] << endl;
}
S = [1, 3, 4, 8, 13, 17, 20] S.sort()
R = list(S[i+1]-S[i] for i in range(len(S)-1)) result = R.index(min(R)) print("(%d, %d)" % (S[result], S[result+1]))
거리를 키로 하고 숫자쌍을 밸류로 하는 딕셔너리를 생성, 최단거리가 동일한 쌍이 2개 이상일 경우에는 모든 쌍을 출력
```{.python}
s = [1,3,4,8,17,20,21]
distance={}
for i in range(len(s)-1): key= s[i+1]-s[i] if key not in distance: distance[key] = ((s[i],s[i+1]),) else: distance[key] = distance[key]+ ((s[i],s[i+1]),)
print distance.get(min(distance.keys())) ```
min_element = []
min_distance = max(S) - min(S)
for element in S:
for element2 in S:
distance = abs(element - element2)
if (distance <= min_distance) & (element != element2):
min_element = sorted([element, element2])
min_distance = distance
여러 코드를 보며 공부하기 좋은 곳이네요.
public void Test2()
{
// 두 수중 차이가 작은 값 찾기, 정렬
Random random = new Random();
List<int> iInputNum1 = new List<int>(20);
int[] iValue = { 1, 10, 40, 12, 34, 5, 4, 7, 9, 11, 50, 32, 13, 31, 22, 16, 8, 22, 18, 37 };
for (int i = 0; i < iInputNum1.Capacity; i++) iInputNum1.Add(random.Next(1, 100));
//for (int i = 0; i < iInputNum1.Capacity; i++) iInputNum1.Add(random.Next(iValue[i]));
iInputNum1.Sort();
int iCompare = 0;
string[] sResult = new string[iInputNum1.Capacity - 1];
int[] iBetween = new int[iInputNum1.Capacity - 1];
for (int i = 0; i < iInputNum1.Count - 1; i++)
{
int iTemp = iInputNum1[i + 1] - iInputNum1[i];
if (iTemp < iCompare)
{
iCompare = iTemp;
iBetween[i] = iInputNum1[i + 1] - iInputNum1[i];
sResult[i] = iInputNum1[i + 1].ToString() + "," + iInputNum1[i].ToString();
}
else
{
iCompare = iTemp;
iBetween[i] = iInputNum1[i + 1] - iInputNum1[i];
sResult[i] = iInputNum1[i + 1].ToString() + "," + iInputNum1[i].ToString();
}
}
Array.Sort(iBetween, sResult);
for (int i = 0; i < iInputNum1.Capacity - 1; i++) Console.WriteLine("Result : {0} / Gap : {1}", sResult[i], iBetween[i].ToString());
}
int temp1 = 0;
int temp2 = 0;
int S[]={1, 3, 4, 8, 13, 17, 20};
for(int i = 0; i < S.length - 1; i++) {
if(S[i] - S[i+1] < temp1) {
temp1 = S[i] - S[i+1];
temp2 = i;
}
}
System.out.println("("+temp2+", "+(temp2+1)+")");
public class Test11 {
public static void main (String[] args) {
Test11 test11 = new Test11();
String result = test11.solve();
System.out.println(" 출력값 "+ result);
}
public static String solve () {
int[] input = {1,3,4,8,13,17,20,66,77,78};
int temp = input[input.length-1];
String tempCha = "";
for (int i = 0 ; i < input.length - 1 ; i++) {
int x1 = input[i];
int x2 = input[i+1];
int cha = x2-x1;
if (cha < temp) {
tempCha = "("+x1+", "+x2+")";
temp = cha;
} else if (cha == temp) {
tempCha += " ("+x1+","+x2+")";
}
}
return tempCha;
}
}
public class MinDistance {
public static void main(String[] args) {
int[] s={1, 3, 4, 8, 13, 17, 20};
System.out.println(findMinDist(s));
}
private static String findMinDist(int[] input) {
int mVal = 0;
String result = null;
for(int i=0;i<input.length-1;i++){
int tempVal = input[i+1] - input[i];
if(result != null){
if(tempVal < mVal){
mVal = tempVal;
result = "(" + input[i] + "," + input[i+1] +")";
}
}else{
mVal = tempVal;
result = "(" + input[i] + "," + input[i+1] +")";
}
}
return result;
}
}
public static void main(String[] args) throws Exception {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String[] str = br.readLine().split(" ");
HashMap<String, Integer> map = new HashMap<>();
int ans = Math.abs(Integer.parseInt(str[0]) - Integer.parseInt(str[1]));
for (int i=1, j=2; i<str.length-1; i++, j++) {
int a = Integer.parseInt(str[i]);
int b = Integer.parseInt(str[j]);
ans = Math.min(ans, Math.abs(a-b));
map.put(a + " : " + b, ans);
}
String[] str2 = map.keySet().toArray(new String[0]);
for(String s : str2) {
if(map.get(s) == ans)
System.out.println(s);
}
}
// 좀 더럽게 푼 듯...
def one_dimention() :
one_dimention_input=list(input("점으로하고싶은숫자들 입력하셈 :").split(" "))
one_dimention=set(one_dimention_input)
one_dimention=sorted(int(x) for x in one_dimention)
min_0=min([abs(min_1-min_2)for min_1,min_2 in zip(one_dimention[0:],one_dimention[1:])])
for min_1,min_2 in zip(one_dimention[0:],one_dimention[1:]) :
if abs(min_1-min_2)==min_0 :
print("(%d,%d)"%(min_1,min_2))
one_dimention()
public class ListDistance {
public static void main(String[] args) {
int[] s= {1,3,4,8,13,17,20};
int min = 0;
int temp;
int[] answer= {0,0};
for(int i=0;i<s.length-1;i++) {
for(int j=i+1;j<s.length;j++) {
if(i==0&&j==1) {
min=Math.abs(s[i]-s[j]);
}
temp=Math.abs(s[i]-s[j]);
if(temp<min) {
min=temp;
answer[0]=s[i];
answer[1]=s[j];
}
}
}
System.out.println("{"+answer[0]+","+answer[1]+"}");
}
}
def shortest(lst): #lst refers to list
dic = {}
lst2 = []
for x in lst:
for k in lst:
if x != k :
res = (k,x)
diff = abs(x-k)
dic[diff] = res
for key in dic.keys():
lst2.append(key)
lst2.sort()
final = lst2[0]
return dic[final]
import static org.junit.Assert.*;
import java.util.ArrayList;
import org.junit.Test;
class Set {
public class Pair {
int first;
int last;
public int distance() {
return last-first;
}
}
ArrayList<Pair> pairs = new ArrayList<Pair>();
public Set(int[] set) {
for(int i=0; i<set.length-1; i++) {
Pair pair = new Pair();
pair.first = set[i];
pair.last = set[i+1];
pairs.add(pair);
}
}
public Pair shortest() {
int min = Integer.MAX_VALUE;
Pair result = null;
for(Pair pair: pairs) {
if (pair.distance() < min) {
result = pair;
min = pair.distance();
}
}
return result;
}
}
public class DaumTest {
@Test
public void test() {
Set set = new Set(new int[]{1,3,4,8,13,17,20});
assertEquals(3, set.shortest().first);
assertEquals(4, set.shortest().last);
}
}
points = [1,3,4,8,13,17,20]
shortest = 9999
for i in range(len(points)-1):
if points[i+1]-points[i] < shortest:
shortest = points[i+1]-points[i]
idx = i
print(points[idx], points[idx+1])
파이썬 3.6.4
def min_dist(cordinate):
cordinate=sorted(cordinate)
pairs = {}
for x,y in zip(cordinate, cordinate[1:]):
if abs(y-x) not in pairs:
pairs[abs(y-x)] = str((x,y))
else:
pairs[abs(y-x)] = str(pairs[abs(y-x)])+' ,'+str((x,y))
return pairs[min(list(pairs.keys()))
----------------------------------------------------------
min_dist([1,3,7,99,-1])
output : '(-1,1), (1,3)'
Python
import itertools
test = [[1, 3, 4, 8, 13, 17, 20], [1, 2, 4, 5, 8, 15, 19]]
for t in test:
min_distance = abs(t[0] - t[-1])
ans = list()
for v in itertools.combinations(t, 2):
if min_distance > abs(v[0]-v[1]):
min_distance = abs(v[0]-v[1])
ans.clear()
ans.append((v[0], v[1]))
elif min_distance == abs(v[0]-v[1]):
ans.append((v[0], v[1]))
print(*ans)
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>regexp</title>
</head>
<body>
<script>
let random = [];
Math.floor(Math.random()*100)
for(let i =0 ; i<8; i++) {
let a = Math.floor(Math.random()*100)
random.push(a);
}
//먼저 random()를 통해서 0~100까지의 임의의 숫자 8가지를 변수 random에 입력받았다.
const sort = random.sort((a,b) => a > b ? -1 : 1)
// 그후 sort()를 이용해서 변수 random에 입력된 8가지 숫자를 오름차순으로 정렬하였다
console.log(sort);
const minArr = [];
for(let i = 0 ; i<random.length-1; i++) {
minArr.push(random[i]-random[i+1]);
}
//예를 들어 [6,3,1] 이란 정렬된 배열에서 각 값사이의 거리가 가장 짧은 값을 구할려면
먼저 6과 3을 비교해보고, 3과 1을 비교해보면 된다. 6과 1인 비교하지 않아도 절대로 그 사이의 거리가
6과3 또는 3과1보다 작지 않다는 것을 알 수 있다. 같은 의미로, 랜덤으로 입력받은 8가지 숫자를 오름차순
으로 정렬하였고 , 각자 바로 옆에 있는 값들만 비교하면 8가지 값중 거리가 가장 짧은 것을 구할 수 있다.
위의 코드에서는 minArr이라는 빈 배열에 내림차순으로 정렬 된 radom값들을 하나하나 대입하였다.
그럼 minArr에는 random 변수 안에 들어 있는 인접한 값들의 차 가 저장된다.
let index = minArr.indexOf(minArr.reduce((pre,cur)=>{
return pre > cur ? cur : pre
}))
//그후 indexOf는 지정한 값에 일치하는 배열의 인덱스를 return 한다. 배열은 minArr이고 indexOf() 함수 안에
minArr.reduce()를 통해소 최솟값을 구하였다. 즉 위으 코드는 minArr의 값들 중에 최솟값의 인덱스를 변수 index스에
저장한 것이다.
console.log(sort[index],sort[index+1])
//sort에는 정렬된 random값이 있고 , index는 최솟값의 인덱스가 있다. 그래서 sort[index]와 sort[index+1]의 차이가
랜덤으로 입력 받은 8가지 난수 중에 사이의 거리가 최소인 값이다.
</script>
</body>
</html>
파이썬으로 작성했습니다.
def minlen(mylist):
minimal = min(mylist[n+1]-mylist[n] for n in range(len(mylist)-1))
resultlist = [ [mylist[n],mylist[n+1]] for n in range(len(mylist)-1) if mylist[n+1]-mylist[n]==minimal ]
print(resultlist)
n=int(input('입력할 1차원 점의 개수 :'))
minlen([ int(input()) for m in range(n) ])
S = [1, 3, 4, 8, 13, 17, 20]
min, result = 1000000, (0, 0)
for i in range(len(S)-1):
if min > S[i+1] - S[i]: min, result = S[i+1] - S[i], (S[i], S[i+1])
print(result)
import sys, random
def getMinDiff( num_list ):
minDiff = -1
for i in range(0,len(num_list)):
if i == 0:
beforeNum = num_list[0]
continue
afterNum = num_list[i]
diff = afterNum - beforeNum
#print("===> (%d-%d) -> %d\n" %(afterNum, beforeNum, diff), end=' ')
if minDiff == -1:
minDiff = diff
else:
if diff < minDiff:
minDiff = diff
beforeNum = afterNum
return minDiff
def printMinDiffPair( num_list, minDiff ):
for i in range(0,len(num_list)):
if i == 0:
beforeNum = num_list[0]
continue
afterNum = num_list[i]
diff = afterNum - beforeNum
if diff == minDiff:
print("(%d,%d)\n" %(beforeNum,afterNum), end='')
beforeNum = afterNum
if __name__ == "__main__":
num_list = list(set([random.randint(1,100) for i in range(10)]))
num_list.sort()
for i in range(1,len(sys.argv)):
num_list.append(int(sys.argv[i]))
minDiff = getMinDiff(num_list)
print("min diff : %d\n" %(minDiff), end='' )
printMinDiffPair(num_list, minDiff)
import java.text.*;
import java.util.*;
public class Main {
public static List<Integer>list=new ArrayList<Integer>();
public static void main(String[] args) {
Random rand=new Random();
Set<Integer>s=new HashSet<Integer>() {};
for(int i=0;i<6;i++) {
s.add(rand.nextInt(50)+1);
}
System.out.println(s);
shortest(s);
}
private static void shortest(Set<Integer>s) {
List<Integer>s_List=new ArrayList<Integer>();
s_List.addAll(s);
Collections.sort(s_List);
int shortest=100;
for(int i=0;i<=4;i++) {
for(int k=i+1;k<=5;k++) {
if((s_List.get(i)-s_List.get(k))<shortest) {
shortest=Math.abs(s_List.get(i)-s_List.get(i));
list.clear();
list.add(s_List.get(i));
list.add(s_List.get(k));
}
}
}
System.out.println(shortest+" "+list);
}
}
list1=[1, 2, 4, 5, 8, 13, 17, 20]
def dic(list1):
temp = -1
result = {}
for i in list1:
if temp == -1:
pass
else:
result[(temp, i)] = i - temp
temp = i
return result
print(dic(list1))
def min_couple(dic1):
min_val = min(dic1.values())
return [k for k, v in dic1.items() if v == min_val]
print(min_couple(dic(list1)))
S=[1, 3, 4, 8, 13, 17, 20]
distance = []
for i in range(len(S)):
for j in range(len(S)):
if i != j :
if abs(S[i] - S[j]) < 10:
distance.append(str(abs(S[i] - S[j]))+"="+str(S[i]) + "," + str(S[j]))
distance.sort()
print(distance[0][2:5])
S = [1,3,5,7,10,11,16,17,24,31,32,35,66]
for i in range(len(S)-1):
l = S[i+1]-S[i]
if 'oldl' not in locals() or l < oldl:
oldl = l
result = [(S[i],S[i+1])]
elif l == oldl:
result.append((S[i],S[i+1]))
print(result)
[(10, 11), (16, 17), (31, 32)]
// 다음 입사문제 중에서
package com.company;
public class Main {
public static void main(String[] args) {
int[] arr = {1, 3, 4, 5, 13, 17, 18};
get(arr);
}
public static void get(int[] arr)
{
int min = arr[1] - arr[0]; // 초기 최소값
int[] x = new int[arr.length - 1];
int[] y = new int[arr.length - 1];
for(int i = 1; i < arr.length; i++)
{
if(arr[i] - arr[i-1] < min)
min = arr[i] - arr[i-1];
}
for(int i = 1; i < arr.length; i++)
{
if(arr[i] - arr[i-1] == min)
{
x[i-1] = arr[i-1];
y[i-1] = arr[i];
System.out.println("(" + x[i-1] + "," + y[i-1] + ")");
}
}
}
}
간단하게 짜봤는데 생각보다 느린것 같네요.
public class main {
public static void main(String[] args) {
int[] S = {1, 3, 4, 8, 13, 17, 20};
Integer temp = null;
for(int i = S.length-2; i > 0; i--){
if(temp == null || temp > (S[i + 1] - S[i])){
temp = (S[i + 1] - S[i]);
}
}
System.out.println(temp);
}
}
n = [1, 3, 6, 8, 9, 17, 20]
temp = abs( n[0] - n[1] )
right = n[0]
left = n[1]
for i in range(len(n)):
for j in range(i+1,len(n)):
if abs( n[i]-n[j] ) < temp:
temp = abs( n[i]-n[j])
right=n[i]
left=n[j]
print(right,',',left)
def finding(x):
n=len(x)
for i in range(1,n-1):
min_val=abs(x[0]-x[1])
if min_val> abs(x[i]-x[i+1]):
min_val= (x[i],x[i+1])
return print(min_val) # 최소 거리
x=[-12,2,7,90,87]
finding(x)
미천한 실력으로 코딩해봤습니다.
import random, sys
n = int(input())
li = random.sample(range(1,50), n)
li.sort()
print(li)
storage_dist = sys.maxsize
storage_pair = []
for i in range(n-1):
if(li[i+1]-li[i]<storage_dist):
storage_dist = li[i+1]-li[i]
storage_pair=[]
storage_pair.append(tuple((li[i], li[i+1])))
elif(li[i+1]-li[i]==storage_dist):
storage_pair.append(tuple((li[i], li[i+1])))
print(storage_pair)
#include<stdio.h>
int main()
{
int arr[] = { 1,3,4,8,13,17,20 };
int i, arrt[2], result;
result = 100;
for (i = 0; i < 6; i++) {
if (arr[i + 1] - arr[i] < result) {
result = arr[i + 1] - arr[i];
arrt[0] = arr[i];
arrt[1] = arr[i + 1];
}
}
printf("%d %d\n", arrt[0], arrt[1]);
getchar();
}
S={1, 3, 4, 8, 13, 17, 20}
minDistance = 1000
def 거리가가장짧은것의쌍(sets):
sets =list(sets)
for i in range(len(sets) - 1):
if abs(sets[i] - sets[i + 1]) < minDistance:
minDistance = abs(sets[i] - sets[i + 1])
num1 = sets[i]
num2 = sets[i+1]
return num1, num2
print(거리가가장짧은것의쌍(S))
짜놓고 보니, dict()를 쓰는게 더 낫겠네요..
def n(S):
a = list(S)
t = list()
j = list()
for i in range(len(a) - 1):
t.append(a[i+1] - a[i])
j.append([a[i], a[i+1]])
return j[(t.index(min(t)))]
#dict()활용시
def n(S):
a = list(S)
t = dict()
for i in range(len(a) - 1):
t[a[i+1] - a[i]] = [a[i], a[i + 1]]
return t[min(t.keys())]
import random
#1차원의 점들이 주어졌을 때,
#그 중 가장 거리가 짧은 것의 쌍을 출력하는 함수를 작성하시오. (점들의 배열은 정렬된상태)
#중복없는 리스트 생성
points = set(random.randint(1,100) for i in range(10))
points = list(points)
points.sort()
distances = [[points[0], points[1], points[1]-points[0]]]
for i in range(1,len(points)-1):
distance = points[i+1]-points[i]
if distances[0][2] > distance:
distances = [[points[i],points[i+1],distance]]
elif distances[0][2] == distance:
distances += [[points[i],points[i+1],distance]]
print("가장 짧은 거리는",distances[0][2],"이며",end=" 쌍은 ")
for i in range(len(distances)):
print("[{}~{}]".format(distances[i][0],distances[i][1]),end="")
print("이다.")
a=input().split()
a_int=list(map(int,a))
min_distance=abs(a_int[0]-a_int[1])
for i in range(len(a_int)):
for j in range(len(a_int)):
if i!=j:
min_distance=min(min_distance,abs(a_int[i]-a_int[j]))
print(min_distance)
Ruby 최소값이 여러개일 때.
mins = []
min = 999
s = [1, 3, 4, 5, 8, 13, 17, 18, 20]
(0...s.length - 1).each do |i|
l = s[i+1] - s[i]
if l < min and not l.zero?
mins.clear
min = l
mins << [s[i], s[i+1]]
elsif l == min and not l.zero?
mins << [s[i], s[i+1]]
end
end
mins.each do |i|
puts "(#{i[0]}, #{i[1]})"
end
C#
using System;
using System.Collections.Generic;
using System.Linq;
namespace CD022
{
class Program
{
static void Main(string[] args)
{
var input = new List<int>() { 1, 3, 4, 8, 13, 17, 20, 21 };
GetShortestPair(input);
}
static void GetShortestPair(List<int> aList)
{
// 최소 거리 계산
int minDistance = aList.Max();
for (int i = 0; i < aList.Count - 1; i++)
{
int tmp = aList[i + 1] - aList[i];
minDistance = minDistance < tmp ? minDistance : tmp;
}
// 최소 거리에 해당하는 쌍 모두 출력
for (int i = 0; i < aList.Count - 1; i++)
{
int tmp = aList[i + 1] - aList[i];
if (minDistance == tmp) { Console.WriteLine($"({aList[i]},{aList[i + 1]})"); }
}
}
}
}
a=input().split()
min=int(a[len(a)-1])-int(a[0])
for i in range(len(a)-1):
if int(a[i+1])-int(a[i])< min:
min=int(a[i+1])-int(a[i])
x,y=a[i], a[i+1]
print((int(x),int(y)))
li = [1,3,4,8,13,17,20]
l2 = [(li[x+1]-li[x],[li[x],li[x+1]]) for x in range(len(li)-1)]
mina = [l2[x][1] for x in range(len(l2)) if l2[x] == min(l2)]
print(mina)
필요한 만큼만 루프를 돌려고 해보았습니다.
#include<iostream>
using namespace std;
int main()
{
int S[] = { 1, 3, 4, 8, 13, 17, 20 };
int min = S[1] - S[0];
int index = 0;
for (int i = 1; i < sizeof(S) / sizeof(int) - 2; i++)
{
if (min > S[i + 1] - S[i])
{
min = S[i + 1] - S[i];
index = i;
}
}
cout << S[index] << " " << S[index + 1];
}
class Test001 {
public static void main(String[] args) {
int[] arr = {1, 3, 4, 8, 13, 17, 20};
int minDistance = 0;
String result = null;
minDistance = 10000;
int anum,bnum;
for (int i=0;i<arr.length;i++) {
for (int j=i+1;j<arr.length;j++) {
int dist = arr[i]-arr[j];
if(dist < 0) {
dist = -dist;
}
if(dist <= minDistance) {
anum = arr[i];
bnum = arr[j];
if(anum>bnum) {
anum = arr[j];
bnum = arr[i];
}
if (dist == minDistance) {
if(result == null) {
result ="["+anum+", "+bnum+"] ";
}else {
result = result +" ["+ anum+", "+bnum+"] ";
}
}
if (dist < minDistance) {
result ="["+anum+", "+bnum+"] ";
}
minDistance = dist;
}
}
}
System.out.println(result);
}
}
import java.util.ArrayList; import java.util.Collections; import java.util.Scanner;
public class shortest {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
ArrayList<Integer> numbers = new ArrayList<>();
int sum = 0;
int a = 0;
while(true) {
int element = scanner.nextInt();
if(element == 0) {
break;
}
numbers.add(element);
}
int big = Collections.max(numbers);
System.out.println(numbers);
for(int i=0; i<numbers.size()-1; i++) {
sum = numbers.get(i+1) - numbers.get(i);
if(sum<big) {
big = sum;
a = i;
}
}
System.out.println("(" + numbers.get(a) + ", " + numbers.get(a+1) + ")");
}
}
import java.util.*;
public class ShortestDistance {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner sc = new Scanner(System.in);
String str = sc.nextLine();
ArrayList<Integer> list = new ArrayList<Integer>(); // 입력값
StringTokenizer st = new StringTokenizer(str);
// 입력받은 값 " "기준으로 분해해서 list에 입력
for(int i=0 ; st.hasMoreTokens() ; i++)
list.add(Integer.parseInt(st.nextToken().toString()));
int min_d = list.get(1) - list.get(0);
// 거리의 최소값 찾기
for(int i=1 ; i<list.size() ; i++)
if(list.get(i) - list.get(i-1) < min_d)
min_d = list.get(i) - list.get(i-1);
// 거리가 최소값인 좌표만 출력
for(int i=1 ; i<list.size() ; i++)
if(list.get(i)-list.get(i-1) == min_d)
System.out.println("(" + list.get(i-1) + ", " + list.get(i) + ")");
}
}
public class KimSanghyeop
{
public static void main(String[] args)
{
int[] arr = {1,5,6,10,12,14,16,17,25,26,28};
int min=arr[1]-arr[0];
int f1, temp;
for(f1=1;f1<arr.length;f1++)
{
temp = arr[f1]-arr[f1-1];
if(temp <min)
{
min=temp;
}
}
for(f1=1;f1<arr.length;f1++)
{
temp = arr[f1]-arr[f1-1];
if(temp ==min)
{
System.out.println("("+arr[f1-1]+" / "+arr[f1]+")");
}
}
}
}
import math
def compare_len(A):
A.sort()
shortest_len=math.inf
result=[]
for i in range (0, len(A)-1):
cur_len = abs(A[i+1]-A[i])
if shortest_len > cur_len :
shortest_len = cur_len
result.clear()
result.append((A[i],A[i+1]))
elif shortest_len == cur_len :
result.append((A[i],A[i+1]))
return result
def input_point():
point_list = []
while(1):
try:
point = input("Input your point : ")
point_list.append(point)
except:
break
return point_list
def calculation(point_list):
length = len(point_list)
result = 9999
shortest_points = []
for i in xrange(0, length):
for j in xrange(0, length):
if point_list[i] == point_list[j]:
break
else:
distance = abs(point_list[i] - point_list[j])
if result > distance:
result = distance
shortest_points = [point_list[i], point_list[j]]
shortest_points.sort()
print "result : {}".format(shortest_points)
point_list = input_point()
calculation(point_list)
def short_distance(S):
distance_list = []
ind=[]
ans=[]
for i in range(0, len(S)):
if i+1 == len(S):
pass
else:
distance= S[i+1]-S[i]
distance_list.append(distance)
print(distance_list)
shortest=int(min(distance_list))
#distance_list.remove(shortest)
while min(distance_list) == shortest:
ind.append(distance_list.index(shortest))
distance_list.remove(shortest)
def make_tuple():
for k in range(0,len(ind)):
ans.append((S[k], S[k + 1]))
make_tuple()
return ans
print(short_distance([1,2,3,4,8,13,17,20]))
s = [1, 3, 4, 5, 13, 17, 20]
candidate = {}
small = abs(s[0] - s[1])
for i in range(len(s)-2):
candidate[str(s[i])+", "+str(s[i+1])] = abs(s[i] - s[i+1])
if abs(s[i] - s[i+1]) < small:
small = abs(s[i] - s[i+1])
for c in candidate:
if small == candidate[c]:
print("(" + c + ")")
//c언어 입니다
include
int main(){ int i, j, mnm=10000; int S[7]={1, 3, 4, 8, 13, 17, 20};
for(i=0;i<6;i++){
if(mnm>S[i+1]-S[i]){
mnm=S[i+1]-S[i];
j=i;
}
}
printf("(%d, %d)\n", S[j], S[j+1]);
return 0;
}
S = [1,3,5,6,13,17,20,120,124]
count = S.__len__()-1
print(S[count-1])
min = S[count-1]-S[count-2]
temp = S[count-1]
flag = count-1
while count >= 1:
temp = S[count]-S[count-1]
print("temp: %d \n" %temp)
if min > temp:
min = temp
flag = count
count = count -1
print("(%d,%d)" %(S[flag],S[flag-1]))
include
int absval(int a,int b); int main() { int* a; int size; int i,j; int temp1, temp2,len,len_temp;
printf("사이즈 입력: ");
scanf("%d", &size);
a = (int*)malloc(sizeof(size*4));
printf("숫자 %d개 입력: ",size);
for (i = 0; i < size; i++)
scanf("%d",&a[i]);
temp1 = a[0];
temp2 = a[1];
len = absval(a[0], a[1]);
for (i = 0; i < size; i++) {
for (j = i + 1; j < size; j++) {
len_temp = absval(a[i], a[j]);
if (len < len_temp) {
temp1 = a[i];
temp2 = a[j];
len = len_temp;
}
}
}
printf("가장 긴 차이: %d 이면 %d와 %d의 차이임\n",len,temp1,temp2);
}
int absval(int a, int b) { if (a > b) return (a - b); else return (b - a); }
# 숫자들을 입력
box = input('').split(' ')
# 입력받은 숫자들사이의 차 중에 가장 작은 값을 구하는 함수
def min_val(box):
num = int()
for i in range(len(box)-1):
if abs(int(box[i])- int(box[i+1])) <= num:
num = abs(int(box[i])- int(box[i+1]))
return num
# 가장 작은 값과 두 숫자의 차이가 같으면 print 해주는 함수
def main():
for i in range(len(box)-1):
if abs(int(box[i])- int(box[i+1])) == min_val(box):
print('({},{})'.format(box[i],box[i+1]))
main()
Java 8
package test;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
public class tut03 {
public static void main(String[] args) {
int[] input= {1,3,4,8,13,17,20};
List<Pair> list = new ArrayList<>();
for (int i = 0; i < input.length-1; i++) {
list.add(new Pair(input[i], input[i+1]));
}
Collections.sort(list);
System.out.println(list.get(0));
}
}
class Pair implements Comparable<Pair> {
int x;
int y;
public Pair(int x, int y) {
this.x = x;
this.y = y;
}
public int diff() {
return y-x;
}
@Override
public String toString() {
return "[x : " + x + ", y : " + y + ", diff : " + diff() + "]";
}
@Override
public int compareTo(Pair a) {
if (this.diff() < a.diff()) {
return -1;
} else if (this.diff() > a.diff()) {
return 1;
}
return 0;
}
}
public class ShortDistance {
public static void main(String[] args) {
// TODO Auto-generated method stub
int[] numList = {1, 3, 4, 8, 13, 17, 20};
int[] idx = new int[2];
int sNum = Integer.MAX_VALUE;
for(int i = 0; i < numList.length-1; i++) {
int temp = numList[i+1] - numList[i];
if(temp < sNum) {
sNum = temp;
idx[0] = i;
idx[1] = i+1;
}
}
System.out.println(numList[idx[0]] + "," + numList[idx[1]]);
}
}
#HiCode
S = [1,3,4,5,13,17,20]
a = [S[i+1]-S[i] for i in range(len(S)-1)]
b = [(S[i],S[i+1]) for i, j in enumerate(a) if j == min(a)]
print(b)
S=[1, 3, 4, 8, 13, 17, 20]
result=[]
for i in range(1,len(S)):
result.append((abs(S[i-1]-S[i]),S[i-1],S[i]))
result.sort()
print(','.join(str(result[0][1])+str(result[0][2])))
def distanceEachNum(int_list):
idx = []
for i in range(len(int_list)-1):
distance = int_list[i+1] - int_list[i]
idx.append(distance)
result = idx.index(min(idx))
return result
def main():
user_input = input("Input sorted number list (divided by comma(,)) : ")
num_li = [int(i) for i in user_input.split(",")]
min_idx = distanceEachNum(num_li)
print("({0},{1})".format(num_li[min_idx], num_li[min_idx+1]))
if __name__ == '__main__':
main()
def closest(givenSet):
ListSet = list(givenSet)
i_close = []
length = 0
for i in range(len(givenSet)-1):
diff = ListSet[i + 1] - ListSet[i]
if i == 0:
length = diff
i_close = [1]
continue
if length > diff:
length = diff
i_close = [i]
elif length == diff:
i_close += [i]
res = set()
for i in i_close:
res.add((ListSet[i], ListSet[i+1]))
return res
print(closest({1, 3, 4, 7, 8, 13, 17, 20}))
답 : {(7, 8), (3, 4)}
#점 입력받고 기본 설정
temp = input("1차원 점들을 입력하세요: ")
point = temp.split()
min = 100000
for i in range(len(point)):
point[i] = int(point[i])
j = 0
while j != len(point)-2:
if min > point[j+1] - point[j]:
min = point[j+1] - point[j]
location = (point[j], point[j+1])
j += 1
print(location, min)
S = [1, 3, 4, 8, 13, 17, 20]
def getClosestDots():
shortestDistance = S[len(S)-1]-S[len(S)-2]
closestDotIdx = 0
for idx in range(len(S)-1):
distance = S[idx+1] - S[idx]
if shortestDistance >= distance:
shortestDistance = distance
closestDotIdx = idx
print(S[closestDotIdx], S[closestDotIdx+1])
getClosestDots()
S = list(map(int,input().split()))
S.sort()
limit = S[len(S)-1] - S[0]
two_points = tuple()
for i in range(len(S)-1):
if S[i+1]-S[i] < limit:
limit = S[i+1]-S[i]
two_points = S[i], S[i+1]
print(two_points)
diffs = []
for i in range(len(s)):
for j in range(i + 1, len(s)):
diffs.append((s[i], s[j]))
print(min(diffs))
#거리가 가장 짧은 쌍
n=int(input('1차원의 점의 개수 입력: '))
ls=[]
for i in range(0,n):
i=int(input('좌표입력: '))
ls.append(i)
ls.sort
a=ls[1]-ls[0]
for j in range(2,n):
for k in range(0,j):
b=ls[j]-ls[k]
if a>b:
a=b
x=k
y=j
print('최단거리: ','(',ls[x],',',ls[y],')')
R로 작성하였습니다
split = function(data){
data = sort(data); print(data)
len = c()
for(i in 1:(length(data) - 1)){
len[i] = abs(data[i] - data[i+1])
}
print(len)
print(paste0("(", data[which.min(len)], ",", data[which.min(len) + 1], ")"))
}
S=set(eval(input()))
def short():
A=[]
for x in range(len(S)):
if (x+1) in range(len(S)):
A.append(list(S)[x]-list(S)[x+1])
M=max(A)
print((list(S)[A.index(M)],list(S)[A.index(M)+1]))
[Python] 각 점들의 거리의 절대값을 리스트화 한 후, 그것의 최소값에 대응하는 쌍을 찾아내는 방식입니다. 수의 정렬 및 최소값을 가진 점들의 갯수에 상관없이 출력되는 코드입니다.
def func(*args):
origin = list(args)
deviation = []
result = []
for i in range(len(origin) - 1):
for j in range((i + 1), len(origin)):
deviation.append(abs(origin[i] - origin[j]))
for i in range(len(origin) - 1):
for j in range((i + 1), len(origin)):
if min(deviation) == abs(origin[i] - origin[j]):
result.append((origin[i], origin[j]))
return result
print(func(13, 3, 9, 17, 4, 1, 19, 8))
[(3, 4), (9, 8)]
상기 코드를 for 문을 내포하는 리스트 형식으로 변경하면 다음과 같습니다.
def func(*args):
origin = list(args)
deviation = [abs(origin[i] - origin[j]) for i in range(len(origin) - 1)
for j in range((i + 1), len(origin))]
result = [(origin[i], origin[j]) for i in range(len(origin) - 1)
for j in range((i + 1), len(origin))
if min(deviation) == abs(origin[i] - origin[j])]
return result
#include<iostream>
using namespace std;
int main(void){
int S[7] = { 1, 3, 30, 8, 13, 17, 20 };//각 좌표
int Sub[50] = {0, };
int num = 0;
int temp = 0;
int resultnum = 0;//최소값 저장값
int num1, num2 = 0;//최소값 좌표
for (int i = 0; i < 6; i++){
for (int k = i+1; k < 7; k++){
Sub[num] = abs(S[i] - S[k]);
num++;
}
}
for (int t = 0; t < num-1; t++){
for (int k = t + 1; k<num; k++){
if (Sub[t] > Sub[k]){
temp = Sub[t];
Sub[t] = Sub[k];
Sub[k] = temp;
}
}
}
if (Sub[0] <= Sub[num - 1]){
cout << Sub[0] << endl;
resultnum = Sub[0];
}
else if(Sub[0] > Sub[num - 1]){
cout << Sub[num-1] << endl;
resultnum = Sub[num-1];
}
for (int i = 0; i < 6; i++){
for (int k = i + 1; k < 7; k++){
Sub[num] = abs(S[i] - S[k]);
if (resultnum == Sub[num]){
num1 = S[i];
num2 = S[k];
}
num++;
}
}
cout << num1 << ", "<< num2 << endl;
return 0;
}
public class Shortcut {
public static void main(String[] args){
shortcut(1,3,4,8,13,17,20);
}
public static void shortcut(int ... num){
int[] min = {num[0],num[1]};
for(int i=1;i<num.length - 1;i++){
if(min[1] - min[0] > num[i+1] - num[i]){
min[0] = num[i];
min[1] = num[i+1];
}
}
System.out.println("("+min[0]+","+min[1]+")");
}
}
def solution(lst):
lst = sorted(lst)
print(lst)
min_c = lst[1]-lst[0]
min_c_i = 1
for i in range(len(lst)-1):
if lst[i+1]-lst[i] < min_c:
min_c = lst[i+1]-lst[i]
min_c_i = i+1
return (lst[min_c_i-1],lst[min_c_i])
var arr = [1, 3, 4, 8, 13, 17, 20];
var minGep = 99;
var obj = {};
for (var i = 0; i < arr.length - 1; i++) {
var temp = arr[i + 1] - arr[i]
obj[temp] = arr[i] + ' ' + arr[i + 1];
minGep = Math.min(minGep, temp);
}
console.log(obj[minGep]);
namespace codingdojang__
{
class Program
{
static void Main(string[] args)
{
List<int> s = new List<int> { 1, 3, 4, 8, 13, 17, 20 };
int min = s[1] - s[0];
int result1 = 0;
int result2 = 0;
for (int i = 0; i < s.Count() - 1; i++)
{
if (s[i + 1] - s[i] <= min)
{
min = s[i + 1] - s[i];
result1 = s[i];
result2 = s[i + 1];
}
}
Console.WriteLine(result1 + ", " + result2);
}
}
}
user_list = input("점을 만들 숫자를 입력하세요.(공백으로 구분) : ").split()
user_list_int = [int(i) for i in user_list]
closest_distance = 1
for order in range(0, len(user_list)-1):
distance = user_list_int[order+1] - user_list_int[order]
if closest_distance >= distance :
closest_distance = distance
closest_two_dot1 = user_list_int[order]
closest_two_dot2 = user_list_int[order+1]
else: pass
print(closest_two_dot1, closest_two_dot2)
s = [1,3,4,7,13,17,20]
distance=[]
min_index = []
for i in range(len(s)-1):
distance.append(s[i+1]-s[i])
for dindex,dvalue in enumerate(distance):
if dvalue==min(distance):
print("(%d,%d)"%(s[dindex],s[dindex+1]))
s = [1, 4, 8, 10, 11, 13, 14, 17, 20, 21]
distMin = 999
for i, p2 in enumerate(s) :
dist = abs(p2 - (s[i - 1]))
if dist < distMin :
distMin = dist
for i, p2 in enumerate(s) :
dist = p2 - (s[i - 1])
if dist == distMin :
print("(%d, %d)"%(s[i - 1], p2), end=' ')
//
// main.c
// practiceProgramming
//
// Created by 최세현 on 07/03/2019.
// Copyright © 2019 최세현. All rights reserved.
//
#include <stdio.h>
int main(int argc, const char * argv[]) {
// insert code here...
int size = 0;
int a = 0;
int b = 0;
int result = 0;
int answer[2] = {0};
printf("점의 갯수는 ? : ");
scanf("%d", &size);
printf("점들을 입력하시오.\n");
for(int i = 0; i < size; i++)
{
a = b;
printf("%d. ",i+1);
scanf("%d", &b);
if(i >= 1)
{
if(i==1)
result = b-a;
if(b-a < result)
{
result = b-a;
answer[0] = a;
answer[1] = b;
}
}
}
printf("정답은 : %d, %d\n", answer[0], answer[1]);
return 0;
}
def minpair(a):
s = set()
min_val= a[1]-a[0]
for i in range(0,len(a)-1):
if a[i+1]-a[i] <min_val:
min_val = a[i+1]-a[i]
for i in range(0,len(a)-1):
if a[i+1]-a[i]==min_val:
s.add((a[i],a[i+1]))
return s
def shortest(*nums):
i = min([nums[x+1]-nums[x],x] for x in range(len(nums)-1))[1]
print(nums[i:i+2])
public class practice {
public static void main(String[] args) {
int[] array = { 1, 3, 4, 8, 13, 17, 20};
System.out.println("결과값 : " + function(array));
}
private static String function(int[] array) {
String str = "";
int min = 10000;
int number =0;
for (int i = 1; i < array.length; i++)
{
if (min > array[i] - array[i-1])
{
min = array[i] - array[i-1];
number = i-1;
}
}
str += array[number] + ", " + array[number + 1];
return str;
}
}
def converter(arg):
import numpy as np
arg = np.array(arg)
arg_distance = (arg[1:] - arg[:len(arg)-1])
arg_distance_idxmin = arg_distance == arg_distance.min()
left = arg[:len(arg)-1][arg_distance_idxmin]
left = int(left)
right = arg[1:][arg_distance_idxmin]
right = int(right)
return left,right
# Python
S = [1, 3, 4, 8, 13, 17, 20]
# S.sort
check = {}
for i, j in zip(S[:-1], S[1:]):
if j - i not in check:
check[j - i] = [[i, j]]
else:
check[j - i] += [[i, j]]
for val in check[min(check.keys())]:
print(val)
public class Daum {
public static void main(String[] args) {
int arr[]= {1, 3, 4, 8, 13, 17, 20};
int sub=9999;
int p = 0;
int i;
for(i=0;i<arr.length-1;i++) {
if(sub>arr[i+1]-arr[i]) {
sub=arr[i+1]-arr[i];
p=i;
}
}
System.out.println(arr[p]+" "+arr[p+1]);
}
}
include
void main(){ int numbers[6] = {1,3,5,8,14,15}; int minDistance = (numbers[1]-numbers[0]); int minDistanceNumber;
for (int i = 0; i < 5; i++){
int distance;
distance = numbers[i+1] - numbers[i];
if (distance < minDistance){
minDistance = distance;
minDistanceNumber = i;
}
}
printf("{%d,%d}\n", numbers[minDistanceNumber], numbers[minDistanceNumber + 1]);
}
private void printShortest(int[] list){
//int (distance , coordinates)
int[][] distanceCord = new int[list.length-1][2];
for ( int i = 0; i <= list.length-2; i++ ){
distanceCord[i][0] = list[i+1] - list[i];
distanceCord[i][1] = i;
}
// sort by distance
for(int i = 0 ; i <= distanceCord.length -1 ; i++){
int[] temp;
for (int j = 0 ; j <= distanceCord.length -1 ; j++){
if(distanceCord[i][0] < distanceCord[j][0]){
temp = distanceCord[i];
distanceCord[i] = distanceCord[j];
distanceCord[j] = temp;
}
}
}
// print min
for(int i = 0 ; i <= distanceCord.length -1 ; i++) {
if(distanceCord[0][0] == distanceCord[i][0]){
System.out.println("(" + list[distanceCord[i][1]] + "," + list[distanceCord[i][1] +1 ] + ")");
}
}
}
#include <iostream>
#include <vector>
using namespace std;
int main(void)
{
vector <int> arr = {1, 2, 4, 5, 8, 13, 17, 20};
int min_diff = arr[1] - arr[0];
int min_idx = 0;
int diff;
for (int i = 1; i < arr.size() - 1; i++) {
diff = arr[i+1] - arr[i];
if(min_diff > diff){
min_diff = diff;
min_idx = i;
}
}
cout << '(' << arr[min_idx] <<',' << arr[min_idx+1] << ')'<<endl;
return 0;
}
q=list(map(int,input().split()));q=set(q);q=sorted(list(q));minn=9999
for i in range(len(q)-1):
minn=min(minn,(q[i+1]-q[i]))
for i in range(len(q)-1):
if q[i+1]-q[i]==minn:
print("({},{})".format(q[i],q[i+1]))
정렬된 배열로 입력해야 한다는 내용을 나중에 읽었다가, 지금 보았군요. 하지만 제가 만든 코드에서 정렬함수를 지우나 안 지우나 8글자 차이밖에 안 나서 그냥 이대로 투고하기로 하였읍니다.
def min_len(L):
pair = [L[0], L[1]]
min_len = L[1] - L[0]
for i in range(len(L) - 1):
_len = L[i+1] - L[i]
if _len < min_len:
min_len = _len
pair = L[i], L[i+1]
print(pair)
파이썬 3.7 사용. 2개 이상의 답이 있으면 모두 출력할 수 있게 써봤습니다. 점 사이의 거리를 하나씩 구해서 모두 리스트로 저장한 다음 최소값을 구하는 것보다 메모리를 적게 쓸 수 있는 방식으로 생각해봤습니다.
S=[1, 3, 4, 8, 13, 17, 20] #입력값
Minimum_d=S[-1]-S[0] #최소거리 판정용. 초기값으로 가장 먼 두점 사이 거리를 넣었다.
for i in range(len(S)-1):
tmp=abs(S[i+1]-S[i]) #인접한 두점사이 거리
if tmp<Minimum_d: #지금까지의 최소값보다 작으면, 이전 결과를 덮어쓰기
result=[[S[i], S[i+1]]]
Minimum_d=tmp
elif tmp==Minimum_d: #지금까지의 최소값과 같으면, 이전 결과에 답을 추가
result.append([S[i], S[i+1]])
for ans in result:
print(ans) #답 모두 출력
function cal(array){
var min, pos;
for (var i=1; i < array.length; i++){
diff = array[i] - array[i-1];
if (i == 1) min = diff;
if (diff < min){
min = diff;
pos = i;
}
}
return [array[pos-1], array[pos]];
}
console.log(cal([1,3,7,8,13,17,20]));
초보자인만큼 어설픈 부분이 아주 많고, 쉬운 함수로 해결하려다보니 깔끔하지는 않은 것 같습니다..
# #22.py
# 점들을 입력 받는다
S=list((input().split(',')))
# 점들을 두개씩 묶어서 변수에 저장한다. 짝을 지을 수 있는 모든 경우의 수를 다 만든다.
S_pair=[]
for i in range(len(S)):
for j in range(i+1,len(S)):
S_pair.append([int(S[i]),int(S[j])])
print(S_pair)
# 두 점들 사이의 길이 계산하여 다른 변수에 리스트로 저장
S_pair_2=[]
for i in range(len(S_pair)):
S_pair_2.append(abs(S_pair[i][0]-S_pair[i][1]))
print('\n',S_pair_2) #확인
# 두 리스트를 하나의 딕셔너리로 묶음, ( 키: 두 점, 값: 두 점 사이의 거리)
S_dict=dict()
for i in range(len(S_pair)):
S_dict[str(S_pair[i])]=(S_pair_2[i])
print(S_dict)
# 최소 거리를 갖는 점을 찾고 출력
print(min(S_dict.values()))
for i,j in S_dict.items():
if j==min(S_dict.values()):
print(i)
n=[1,3,4,8,13,17,20,21]
min=abs(n[0]-n[1])
for i in range(len(n)):
for j in range(len(n)):
if i!=j and abs(n[i]-n[j])<min:
min=abs(n[i]-n[j])
s=int(n[j])
k=int(n[i])
print((k,s))
def distance():
poi = list(map(int, input('좌표를 입력해 주세요. : ').split(' ')))
min_dist = 10000000
min_dist_ind = [0, 0]
for o_rep in range(len(poi)):
for i_rep in range(1, len(poi)):
if poi[i_rep] != poi[o_rep]:
cal_dist = abs(poi[o_rep] - poi[i_rep])
if cal_dist <= min_dist:
min_dist = cal_dist
min_dist_ind[0] = poi[o_rep]
min_dist_ind[1] = poi[i_rep]
print('|{} - {}| = {}'.format(poi[o_rep], poi[i_rep], cal_dist))
else:
pass
return sorted(min_dist_ind)
if __name__ == '__main__':
print(distance())
def solution(mlist):
result = []
m = mlist[-1]
for i in range(len(mlist)-1):
if mlist[i+1] - mlist[i] < m:
result = []
m = mlist[i+1] - mlist[i]
result.append([mlist[i],mlist[i+1]])
elif mlist[i+1] - mlist[i] == m:
result.append([mlist[i],mlist[i+1]])
return result
print(solution([1,3,4,8,13,17,20]))
print(solution([1,3,4,5,8,13,17,20]))
print(solution([1,3,4,8,13,17,20,21]))
파이썬3이고.. 아직 for까지 밖에 공부를 안해서 이렇게 해봤습니다. 숫자는 1~100사이 중복없이 랜덤으로 했습니다.
import random
num=random.randint(1,100)
points = []
distance = []
for i in range(10):
while num in points:
num=random.randint(1,100)
points.append(num)
#이미 들어가있으면 랜덤을 다시 돌려서 points에 넣는 방식으루다가..
print(points) # 생성된 숫자 10개를 일단 출력
points.sort() # 순서대로 정렬
for i in range(len(points)-1):
distance.append([points[i+1] - points[i], points[i], points[i+1]])
#[거리, 첫번째 숫자, 두번째숫자]로 리스트 생성
distance.sort() # 거리 순서대로 정렬
for i in range(len(points)-1):
if distance[i][0] == distance[0][0]:
print(distance[i][1], distance[i][2])
#이건 거리가 같은 것들을 모두 출력해주려고 했습니다.
파이썬이 처음이라 그냥 값 입력 받는것 부터 해서 무식하게 ... java style로 해 봤습니다. 중복 된 것도 출력 되도록..
# 1차원의 점들이 주어졌을 때, 그 중 가장 거리가 짧은 것의 쌍을 출력하는 함수를 작성하시오. (단 점들의 배열은 모두 정렬되어있다고 가정한다.)
# 숫자 입력 받고 sorting 까지 하자. 단 동일한 숫자가 들어오면 그것은 무시
# 예를 들어 8, 1, 4, 6, 6, 8 이라면 6은 하나만 입력 한다. (1, 4, 6, 8)
array = []
while 1:
input_string = input("input the number, if you want to stop, enter any character")
try:
num = int(input_string)
array.append(num)
except ValueError:
break
if len(array) < 2:
print("Invalid input")
exit()
# 입력값 출력
print("Array:", end='')
for i in array:
print('[%d]' %(i), end='')
print("")
# 중복제거
array = list(set(array))
# Sorting
array.sort()
# sorting 된 리스트 출력
print("Sorted List:", end='')
print(array)
if len(array) < 2:
print("Invalid input")
exit()
short_list = []
minimum_path = sys.maxsize
# 탐색
for i in range(0, len(array) - 1): # == for(i=0, i<array.length -1; i++)
temp_path = array[i+1] - array[i]
if temp_path < minimum_path:
short_list.clear()
short_list.append(i)
minimum_path = temp_path
elif temp_path == minimum_path:
short_list.append(i)
# 결과 출력
print("Short list=", end='')
print(short_list)
print('Minimum path length is : %d' %(len(short_list)))
print("Result : ")
for i in short_list:
print('[%d]:[%d]' %(array[short_list[i]], array[short_list[i] + 1]))
python 3.7
nums = list(map(int, input().split(",")))
n = nums[-1] - nums[0]
res = []
for i in range(len(nums)-1):
if n > nums[i+1] - nums[i]:
res = [(nums[i],nums[i+1])]
n = nums[i + 1] - nums[i]
elif n == nums[i+1] - nums[i]:
res.append((nums[i],nums[i+1]))
print(",".join(map(str,res)))
python
p = list(set(map(int, input('임의의 자연수를 n(>=1)개 입력하세요>').split())))
def calc_diff(p):
res = []
diff = []
for i in range(len(p)):
for k in range(len(p)):
if i >= k:
continue
else:
res.append((p[i], p[k]))
diff.append(abs(p[k] - p[i]))
for j in range(len(res)):
if diff[j] == min(diff):
print(res[j], '->', diff[j])
calc_diff(p)
#include <iostream>
#include<array>
using namespace std;
int main()
{
array<int, 7> arr = { 1,3,4,8,13,17,20 };
int length_size = 1000;
int p1, p2;
for (int i = 0; i < arr.size()-1; i++)
{
if (length_size > arr[i + 1] - arr[i])
{
p1 = arr[i]; p2 = arr[i + 1];
length_size = arr[i + 1] - arr[i];
}
}
cout << p1 << " " << p2 << endl;
}
def solution(S):
n=int(len(S))
answer=[]
answer1=[]
for i in range(0,n-1):
answer.append(S[i+1]-S[i])
answer.sort()
for i in range(0,n-1):
if S[i+1]-S[i]==answer[0]:
answer1.append(S[i])
answer1.append(S[i+1])
print(answer1)
def prob():
s = input().split(',')
min_ = 100
minIdx = -1
for i in range(len(s)-1):
temp = int(s[i+1]) - int(s[i])
if temp < min_:
min_ = temp
minIdx = i
print('({0},{1})'.format(s[minIdx],s[minIdx+1]))
print(min_)
n=list(input("1차원 점들 입력").split(' '))
i=0
result=[]
while i<=len(n)-1:
n[i]=int(n[i])
i +=1
n.sort()
length=max(n)-min(n)
for i in n:
for j in n:
if i-j==0:
continue
elif abs(i-j)<=length:
length=abs(i-j)
if result.count([min([i,j]),max([i,j])])==0:
result.append([min([i,j]),max([i,j])])
print(result)
S= [1, 3, 4, 8, 13, 17, 20]
if len(S)==1:
print('error')
else:
ans=abs(S[-1]-S[-2])
ans1= S[-1]
ans2= S[-2]
for i in range(len(S)-1):
for j in range(i+1, len(S)):
dist=abs(S[i]-S[j])
if ans > dist:
ans = dist
ans1= S[i]
ans2= S[j]
print(ans1, ans2)
def find_min(l):
d=dict()
for i in range(len(l)-1):
sub=abs(l[i]-l[i+1])
if sub in d:
d[sub].append((l[i], l[i+1]))
else:
d[sub]=[(l[i], l[i+1])]
for pair in d[min(d)]: print(pair)
l = [1, 3, 4, 8, 13, 17, 20]
find_min(l)
def shortest(l):
dist = [abs(l[i] - l[i+1]) for i in range(len(l)-1)]
mindist = min(dist)
print (l[dist.index(mindist)], l[dist.index(mindist)+1])
import math
_list=[1,3,4,8,13,17,20]
_min=[_list[len(_list)-1]]
_min_num=[0]
for a in range(0,len(_list)):
try:
if _list[a+1]-_list[a] <_min[0]:
_min[0]=_list[a+1]-_list[a]
_min_num[0]=str(_list[a])+","+str(_list[a+1])
except:
None
print(_min_num[0])
S = [1, 2, 8, 10, 15, 20, 30, 31]
list1 = []
for i in range(0, len(S) - 1):
diff = S[i+1] - S[i]
list1.append(diff)
for j in range(0,len(list1)):
if list1[j] == min(list1):
print((S[j],S[j+1]))
arr = [1, 5, 6, 7, 9, 10]
min_n = min([arr[idx + 1] - arr[idx] for idx in range(0, len(arr) - 1)])
result = [(arr[idx], arr[idx + 1]) for idx in range(0, len(arr) - 1) if arr[idx + 1] - arr[idx] == min_n]
print(result)
여러 근거리 점이 있을때를 위한 코드입니다.
void search()
{
int i, j, x, y, min = 100;
int points[7] = { 1, 3, 4, 8, 13, 17, 20 };
for (i = 0; i < 7; i++)
{
for (j = i + 1; j < 7; j++)
{
if (-1 * (points[i] - points[j]) < min)
{
min = -1 * (points[i] - points[j]);
x = points[i];
y = points[j];
}
}
}
printf("x = %d, y = %d, 두 점 사이의 거리 = %d\n", x, y, min);
}
짧게 쓸 수 있는 분들 코드는 볼 때마다 정말 신기합니다 ㅠㅠ
def spair(S):
dict = {}
for (x, y) in zip(S[:-1], S[1:]):
if not dict.get(y-x):
dict[y-x] = [(x,y)]
else:
dict[y-x] = dict[y-x] + [(x,y)]
return dict[min(dict.keys())]
S = [1, 3, 7, 8, 13, 17, 20]
print(spair(S))
PHP
$fn = function($arr) {
sort($arr);
$diff = [];
foreach ($arr as $k => $v) {
if (max($arr) === $v) continue;
$diff[$k] = abs($arr[$k + 1] - $arr[$k]);
}
$min = min($diff);
$result = [];
while (($key = array_search($min, $diff)) !== false) {
$result[] = sprintf("(%s, %s)", $arr[$key], $arr[$key + 1]);
unset($diff[$key]);
}
$result = implode(", ", $result);
return $result;
};
print_r($fn([1, 3, 4, 8, 13, 17, 20])); // (3, 4)
print_r($fn([1, 2, 4, 5, 8, 15, 19])); // (1, 2), (4, 5)
import random
S = []
num = random.randrange(0, 10)
for i in range(20) :
while num in S :
num = random.randrange(0, 100)
S.append(num)
S = sorted(S)
min = 10000000
upper_num = []
lower_num = []
for i in range(len(S)-1):
if S[i+1] - S[i] < min:
min = S[i+1] - S[i]
upper_num.append(S[i+1])
lower_num.append(S[i])
elif S[i+1] - S[i] == min:
upper_num.append(S[i+1])
lower_num.append(S[i])
result = list(zip(lower_num,upper_num))
real_result = []
for i in range(len(result)):
if result[-1][1] - result[-1][0] == result[i][1] - result[i][0]:
real_result.append(result[i])
print(real_result)
public class Ex01 {
public static void main(String[] args) {
int[] arr = {1, 2, 3, 4, 8, 13, 17, 20};
int tmp = arr[1] - arr[0];
int[] num = new int [arr.length];
for (int i = 0; i < arr.length - 1; i++) {
int j = i+1;
if (tmp >= arr[j] - arr[i] && arr[j] - arr[i] > 0) {
tmp = arr[j] - arr[i];
num[i] = arr[i];
num[j] = arr[j];
}
}
for (int i = 0; i < num.length; i ++) {
int j = i+1;
if (num[i] != 0 && num[j] != 0)
System.out.println("(" + num[i] + "," + num[j] + ")");
}
}
}
s = [1,3,5,7,8,9,15,19]
min = s[1]-s[0]
ans = []
for i in range(len(s)):
for j in range(i+1,len(s)):
if s[j]-s[i] <= min:
ans.append([s[i],s[j]])
min = s[j]-s[i]
print(ans)
for i in range(len(ans)-1,-1,-1):
print(i)
if ans[i][1] - ans[i][0] > min:
del ans[i]
print(ans)
s = [1,3,5,7,8,9,15,19] 을 돌리면 같은 최소거리인 애들도 출력되게 했어요.
[[7, 8], [8, 9]]
S=[1, 3, 4, 8, 13, 17, 20]
min_diff = S[-1]
for i in range(len(S)-1):
diff = S[i+1] - S[i]
if diff < min_diff:
min_diff = diff
idx = i
print(idx, S[idx:idx+2])
S=[1,3,4,8,13,17,20]
temp = 0
result = 0
List = []
I_1 = 0
I_2 = 0
for i in range(len(S)-1):
temp = S[i+1]-S[i]
if result < temp :
result = temp
I_1 = i
I_2 = i+1
List.append(I_1)
List.append(I_2)
print(List)
package CodingDojang;
import java.util.Vector;
public class JoinToTheDaumQuiz {
public static void main(String[] args) {
Vector<Integer> result = new Vector<Integer>();
int[] s = {1, 3, 4, 12, 13, 14, 20};
int min = s[s.length - 1];
for(int i = 0; i < s.length - 1; i++) {
if(min >= s[i + 1] - s[i]) {
min = s[i + 1] - s[i];
result.add(s[i]);
result.add(s[i + 1]);
}
}
for(int i = 0 ; i < result.size() - 1; i++) {
int n = result.get(i + 1) - result.get(i);
if(n == min) {
int p = result.get(i);
int p2 = result.get(i+1);
System.out.println(p+","+p2);
}
}
}
}
최소거리가 같은 중복된 쌍이 존재할 경우 출력 해야 한다는 본문 댓글 피드백을 고안하여 코드를 짜보았습니다...
lst=input('input nums:')
lst1=lst.split(',')
result=[]
for i in lst1: #가장 짧은간격 찾기
for n in lst1:
if int(i)-int(n)>0:
result.append(int(i)-int(n))
result.sort()
print(result)
k=result[0]
for i in lst1: #짧은간격에 해당하는 수 찾기
for n in lst1:
if int(i)-int(n)==k:
print(int(i),int(n))
import java.util.*;
public class 다음입사문제중에서 {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
String[] lines = scan.nextLine().split(", ");
ArrayList<String> list = new ArrayList<String>();
int[] nums = Arrays.stream(lines).mapToInt(Integer::parseInt).toArray();
int result = (nums[1]-nums[0]);
for(int j=0; j<lines.length-1; j++) {
if(result>(nums[j+1]-nums[j])) {
result=nums[j+1]-nums[j];
list.clear();
list.add("("+nums[j]+", "+nums[j+1]+")");
}
else if(result==(nums[j+1]-nums[j])) {
list.add("("+nums[j]+", "+nums[j+1]+")");
}
}
String line = String.join(", ", list);
System.out.println(line);
}
파이썬 3.6 입니다
def find_min_distance(number_list):
number_list_1 = number_list[1:]
distance_list = [i[1] - i[0] for i in zip(number_list, number_list_1)]
min_index = distance_list.index(min(distance_list))
return [number_list[min_index], number_list[min_index + 1]]
print(find_min_distance([1, 3, 4, 8, 13, 17, 20]))
sample_S = list({1, 3, 4, 8, 13, 17, 20, 23, 24, 28})
min_dist = int(sample_S[len(sample_S) - 1]) - int(sample_S[len(sample_S) - 2])
ans = []
for i in sample_S[:len(sample_S) - 1]:
j = int(sample_S[sample_S.index(i) + 1])
if j - int(i) <= min_dist:
min_dist = j - int(i)
for i in sample_S[:len(sample_S) - 1]:
j = int(sample_S[sample_S.index(i) + 1])
# print('i : %s j : %s' % (i, j))
if j - int(i) <= int(min_dist):
ans.append([i, j])
print(ans)
Python 3.6
list1=[1,2,6,8,9,11,13,51,56,81]
gap=list() # list1에 임의의 오름차순으로 정렬되어 있는 리스트를, gap에 비어있는 리스트를 지정합니다.
for i in range(len(list1)-1): #gap 리스트에 list1의 이웃한 항목끼리의 차값을 지정합니다.
gap.append(list1[i+1]-list1[i])
x=gap.index(min(gap)) #list의 내장함수인 index를 이용해 차값이 최소인 위치를 반환합니다.
print(list1[x],list1[x+1]) #list의 해당 위치 값들을 출력합니다.
Python 3.9.0
예외처리와 최소값이 여러개인 경우를 포함해서 작성했습니다.
---------------예외처리---------------
# 1차원 좌표점을 입력받아 두 점 사이의 거리가 가장 짧은 두 점을 출력
while True:
d = input("1차원 좌표들을 입력하세요.(ex.입력예시 : 1,2,4,7,9,3 ...) :",)
reinput = True
## 1개 이상 입력했는데, ","로 구분하지 않은 경우 재입력
if len(d) > 1 and ',' not in d:
print("좌표 구분은 반드시 comma (',')를 사용해주세요.")
reinput = True
B = d.split(',')
## 숫자가 아닌 것이 입력되어 있는 경우 재입력
for i in B:
for j in range(0,len(i)):
if i[j] not in '0123456789':
reinput = True
print("숫자가 아닌 것이 있습니다. 숫자만 입력하세요.")
break
else:
reinput = False
if reinput == True:
continue
else:
break
del B
---------------메인 코드---------------
## 입력받은 좌표를 list에 넣고, 오름차순으로 정렬하여 dot에 저장
dot = sorted([int(i) for i in d.split(',')])
## 인접한 두 인덱스 사이의 거리를 비교하여 D에 저장
D = []
for i in range(0,len(dot)-1):
dis = dot[i+1] - dot[i]
D.append(dis)
## 거리가 최소인 값이 출력된 인덱스를 찾아 min_index에 저장
min_index = []
for i in range(0,len(D)):
if D[i] == min(D):
min_index.append(i)
## 거리가 최소인 경우가 한 개인 경우와, 여러 개인 경우를 나누어 출력
if len(min_index) == 1:
a = min_index[0]
b = a+1
print("거리가 최소인 경우는 %d와 %d사이입니다. 거리는 %d 입니다." %(dot[a],dot[b] ,min(D)))
else:
print("거리가 최소인 경우는 %d가지 이며, 거리는 %d 입니다." %(len(min_index),min(D)))
for i in range(0,len(min_index)):
a = min_index[i]
b = a+1
print("%d번째, %d와 %d 사이 입니다." %(i+1,dot[a],dot[b]))
s =[1, 3, 4, 8, 13, 17, 20]
a=s[:-1]
b=s[1:]
Sum={}
for i in range(0,len(a)):
Sum[a[i],b[i]]=abs(a[i]-b[i])
print(min(Sum,key=Sum.get))
(Dictionary)와 절대값(abs)이용해서 짜봣습니다
int arr[7]={1, 3, 4, 8, 13, 17, 20};
int min_dist=10,mini1, mini2;
for(int i=0; i<6; i++)
{
for(int j=i+1; j<7; j++)
{
if(arr[j]-arr[i]<min_dist)
{
min_dist=arr[j]-arr[i];
mini1=arr[i]; mini2=arr[j];
}
}
}
printf("(%d, %d), 거리는 %d \n", mini1, mini2, min_dist);
return 0;
nlst=sorted(list(map(int,input("숫자들을 입력하십시오: ").split(","))))
smallest=nlst[1]-nlst[0] #최솟값이 가장 먼저 나오는 인접한 두 수의 차이라고 가정
elst=[]
for n in range(len(nlst)-1) :
v=nlst[n+1]-nlst[n]
if v<smallest:
smallest=v
elst=[(nlst[n], nlst[n+1])]
elif smallest==v:
elst.append((nlst[n], nlst[n+1]))
print(elst)
파이썬입니다.
# input이 {a, b, c} 형태의 문자열로 입력된다고 가정
S = list(map(int,input().strip('{}').split(',')))
if len(S) <= 1:
print('최소 거리가 정의되지 않음')
min_len = (len(S)>1)*(S[1]-S[0])
# 최소값 찾기
for i in range(len(S)-1):
if S[i+1]-S[i] < min_len: min_len = S[i+1]-S[i]
# 최소 위치 찾기
min_list = []
for i in range(len(S)-1):
if S[i+1]-S[i] == min_len: min_list.append((S[i],S[i+1]))
# 출력
print('최소 거리를 가지는 순서쌍은: ',end='')
for i in min_list: print(i,end=' ')
print('이다')
Javascript(ES6)...
`주어진 s 배열에 제일 앞 요소를 제거한 _s 배열을 생성, s 와 _s 배열의 동일한 index 를 조합하는 zip 함수를 구현, zip 함수가 리턴하는 배열을 두 쌍의 차이가 가장 적은 순서대로 정렬하고 제일 앞 요소 출력`;
// 주어진 두 배열의 동일한 index 요소끼리 묶어주는 함수
function zip(arr1, arr2) {
let l = Math.min(arr1.length, arr2.length);
let result = [];
for(let i = 0; i < l; i++) {
result.push([arr1[i], arr2[i]]);
}
return result;
}
// s 와 _s 생성하고 zip 함수 적용
let s = [1, 3, 4, 8, 13, 17, 20];
let _s = s.slice(1);
let result = zip(s, _s);
// 두 쌍의 차이가 가장 적은 순서대로 정렬
result.sort((a, b) => Math.abs(a[0] - a[1]) - Math.abs(b[0] - b[1]));
console.log(result[0]);
Python 3...
s = [1, 3, 4, 8, 13, 17, 20]
_s = s[1:]
result = list(zip(s, _s))
result.sort(key = lambda x: abs(x[0] - x[1]))
print(result[0])
파이썬을 이용해서 한번 풀어 보았습니다.
array = sorted(set(list(map(int, (input("배열을 입력하세요: ")).split(",")))))
minValue = min(array[i+1] - array[i] for i in range(len(array) - 1))
result = []
for i in range(len(array)-1):
n = array[i+1] - array[i]
if n == minValue:
result.append((array[i], array[i+1]))
print(result)
class 다음_1차원_점들의_최소거리_찾기 { public static void main(String[] args) { int[] s = {1, 3, 4, 8, 13, 17, 20}; int tmp, min, a = 0, b = 0, c = 0, d = 0; int cnt = 0;
min = s[1];
for(int i = 0; i < 6; i++)
{
for(int j = i + 1; j < 6; j++)
{
if(s[i] > s[j])
{
tmp = s[i];
s[i] = s[j];
s[j] = tmp;
}
}
} // 버블정렬
for(int i = 0; i < 6; i++)
{
for(int j = i + 1; j < 6; j++)
{
if(min > s[j] - s[i])
{
min = s[j] - s[i];
a = s[i];
b = s[j];
}
}
}
System.out.printf("1차원 점들의 값은 ");
for(int i = 0; i < 6; i++)
{
System.out.printf("%d ", s[i]);
}
System.out.printf("\n두 점은 %d, %d입니다.", a, b);
}
} JAVA 답은 3, 4 입니다.
import java.util.Scanner;
import java.util.ArrayList;
public class MinFunction {
public static void main(String[] args) {
Scanner Sc = new Scanner(System.in);
ArrayList<Integer> Al = new ArrayList<>();
System.out.print("점들을 입력하시오: "); //정수형으로 입력받음
String str = Sc.nextLine();
String [] array = str.split("[,]"); //문자열로 분할
for(int i = 0; i<array.length; i++) {
Al.add(Integer.parseInt(array[i])); //ArrayList에 값 저장
}
int min =(Al.get(1) - Al.get(0));
for(int j = 0; j< Al.size()-1; j++) {
if(min > (Al.get(j+1) - Al.get(j))) { //최소거리 찾기
min = (Al.get(j+1) - Al.get(j));
}
}
for(int j = 0; j< Al.size()-1; j++) {
if(min == (Al.get(j+1) - Al.get(j))) { //최소거리 일경우 출력
System.out.printf("(%d,%d) ", Al.get(j), Al.get(j+1));
}
}
Sc.close();
}
}
s = list(map(int, input("입력: ").split(",")))
result=[]
for i in range(len(s)-1):
a = s[i+1]-s[i]
result.append(a)
b = s[len(s)-1]-s[len(s)-2]
result.append(b)
print("({} {})".format(s[result.index(min(result))],s[result.index(min(result))+1]))
파이썬 3.8
s=[1, 3, 4, 8, 13, 17, 20]
distance = 1000
min = 0
for i in range(len(s)-1): #정렬되어있으므로 바로옆의 원소와의 차수를 구함
if distance >= s[i+1] - s[i]:
distance, min = s[i+1] - s[i], i # 거리가 더 작은 원소의위치 갱신
print(s[min],s[min+1])
using System;
using System.Collections.Generic;
using System.Linq;
namespace ConsoleApp1
{
class Program
{
static void Distance(int[] a)
{
int mindis = a[1]-a[0];
int[] answer = { 0, 0 };
for (int b=0; b < a.Length-1; b++)
{
if (a[b + 1] - a[b] < mindis)
{
mindis = a[b + 1] - a[b];
answer[0] = a[b]; answer[1] = a[b+1];
}
}
Console.WriteLine($"({answer[0]},{answer[1]})");
}
static void Main(string[] args)
{
int[] S = { 1, 3, 4, 8, 13, 17, 20 };
Distance(S);
}
}
}
s=[1,3,4,8,13,17,20]
v=[]
n=[]
for i in range(len(s)-1):
v.append(abs(s[i]-s[i+1]))
m=min(v)
ml=v.index(m)
n.append(s[m])
n.append(s[m+1])
print(n)
S = {1,3,4,8,13,17,20}
diff = []
for i in S :
for j in S :
if i-j !=0:
diff.append(abs(i-j))
for i in S :
for j in S :
if i-j == min(diff):
print(i,j)
dic={}
def points(l):
for i in l:
for j in l:
if i-j!=0:
dic[abs(i-j)]=(j,i)
return dic.get(min(dic.keys()))
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
/*
1차원의 점들이 주어졌을 때, 그 중 가장 거리가 짧은 것의 쌍을 출력하는 함수를 작성하시오.
(단 점들의 배열은 모두 정렬되어있다고 가정한다.)
예를들어 S={1, 3, 4, 8, 13, 17, 20} 이 주어졌다면, 결과값은 (3, 4)가 될 것이다.
*/
struct A
{
int x1, x2, d;
A(int x1_, int x2_, int d_):x1(x1_),x2(x2_),d(d_){ }
};
bool cmp(A a, A b) {
if (a.d == b.d) {
if (a.x1 == b.x1) {
return a.x2 < b.x2;
}
return a.x1 < b.x1;
}
return a.d < b.d;
}
void Func(int *arr, int size) {
vector<A> v;
for (int i = 0; i < size; i++)
for (int j = i + 1; j < size; j++) { v.push_back(A(arr[i], arr[j], arr[j] - arr[i])); }
sort(v.begin(), v.end(), cmp);
cout << "arr = {";
for (int i = 0; i < size; i++) {
if (i == size - 1) { cout << arr[i] << "}들 중에서 거리가 가장짧은 것의 쌍은"; }
else { cout << arr[i] << " , "; }
}
for (int i = 0; i < v.size(); i++)
if (v[i].d == v[0].d) { cout << " ( " << v[i].x1 << " , " << v[i].x2 << " ) "; }
cout << endl;
for (int i = 0; i < v.size(); i++)
cout << "(\t" << v[i].x1 << "\t,\t" << v[i].x2 << "\t)\t" << "거리 = " << v[i].d << endl;
}
int main() {
int arr[] = { 1, 4, 8, 13, 17, 20 };
Func(arr, sizeof(arr)/sizeof(int));
}
리스트를 가지고 해보았습니다 문제에 대해 적으신걸 보니 임의의 정렬된 리스트에 거리 최소값이 동일한 부분도 출력되어야지 않냐는 것을 보고 그 경우에 해당 값들은 모두 나오게 해보았습니다 다른 분들것을 보니 개인적으로는 dict을 이용하는 부분이 가장 좋아보였습니다
S=[1, 3, 4, 8, 13, 17, 20]
# S=[1, 3, 4, 8, 9, 13, 17, 20]
res_list = [] # 결과값 리스트 (리스트의 형태: 거리, 좌표1, 좌표2)
dis_list = [] # 계산된 거리값을 모아 놓는 리스트 (최소 거리 확인을 위해)
for i in range(len(S)-1):
distance = S[i+1] - S[i]
res_list.append([distance, (S[i], S[i+1])])
dis_list.append(distance)
dis_list.sort()
for i in range(len(res_list)):
if dis_list[0] == res_list[i][0]: # 두 점사이의 최소거리와 동일한 결과값을 갖는 두점의 숫자를 출력
print(res_list[i][1], end=' ')
import java.util.ArrayList;
import java.util.Arrays;
public class BestSmallNumber {
public static void main(String[] args) {
/*
1차원의 점들이 주어졌을 때, 그 중 가장 거리가 짧은 것의 쌍을 출력하는 함수를 작성하시오. (단 점들의 배열은 모두 정렬되어있다고 가정한다.)
예를들어 S={1, 3, 4, 8, 13, 17, 20} 이 주어졌다면, 결과값은 (3, 4)가 될 것이다.
*/
int[] list = {1, 3, 4, 5,8, 13, 17, 20,100,101,2499,2500};
whoIs(list);
}
public static void whoIs(int[] list)
{
class Number
{
int number1;
int number2;
int finalNumber;
public Number(int number1 , int number2)
{
this.number1 = number1;
this.number2 = number2;
this.finalNumber = Math.abs( number2 - number1 ) ;
}
}
ArrayList<Number> numbers = new ArrayList<Number>();
for(int i = 0; i < list.length; i++)
{
for(int j =i ; j < list.length; j++)
{
if( i != j ) {
Number number = new Number( list[j] , list[i]);
numbers.add(number);
}
}
}
int[] finalNumbers = new int[numbers.size()];
for(int i = 0 ; i < numbers.size(); i++)
{
finalNumbers[i] = numbers.get(i).finalNumber ;
}
Arrays.sort(finalNumbers);
for(int i = 0 ; i < numbers.size(); i++)
{
if( finalNumbers[0] == numbers.get(i).finalNumber)
System.out.println( numbers.get(i).number2 +" - "+ numbers.get(i).number1+"의 절대값은"+" "+ numbers.get(i).finalNumber +" "+ "입니다.");
}
}
}
이런식으로 해도되나요? 뉴비라서 잘모르겠네요
#파이썬
from random import *
s,min=[],50
for i in range (0,10): #중복되지 않는 10개의 랜덤 정수값 생성하여
ss=randint(0,50)
while (ss in s):
ss=randint(0,50)
s.append(ss) #s리스트에 입력
s.sort() #s리스트를 오름차순으로 정렬하여
print(s)
for i in range (0,9):
if s[i+1]-s[i]<min: #각 인접한 값의 차를 계산하여 최소값 구함
min=s[i+1]-s[i]
for i in range (0,9): #최소값만큼 인접한 값을 모두 찾아냄
if min==s[i+1]-s[i]:
print (s[i],s[i+1])
<결과>
[0, 2, 3, 11, 21, 26, 32, 41, 42, 48]
2 3
41 42
[2, 6, 7, 10, 15, 16, 20, 24, 27, 43]
6 7
15 16
[10, 13, 20, 26, 27, 32, 33, 37, 42, 47]
26 27
32 33
[6, 18, 25, 32, 35, 40, 41, 42, 45, 46]
40 41
41 42
45 46
[0, 16, 18, 26, 28, 29, 35, 36, 43, 48]
28 29
35 36
-
Buckshot,
2020/04/09 01:20
s=[2, 1, 8, 4, 18, 13, 17, 20]
s.sort()
dist = {}
diff = s[1] - s[0]
dist[diff] = [(s[0], s[1])]
for i in range(2, len(s)):
distance = s[i] - s[i-1]
if distance < diff:
diff = distance
dist[distance] = [(s[i-1], s[i])]
elif distance == diff:
dist[distance] = dist[distance] + [(s[i-1], s[i])]
print(dist[min(dist.keys())])
def array(s):
Lst = list(s)
dic = dict()
for i in range(1, len(s)):
distance = (Lst[i] - Lst[i-1])
key = [(Lst[i-1] , Lst[i])]
if not dic.get(distance):
dic[distance] = key
print(dic)
else:
dic[distance] = dic[distance] + key
print(dic)
print(dic.get(min(dic.keys())))
array({1, 3, 4, 8, 13, 17, 20, 21})
S ={1,3,4,5,6,7,8,13,17,20}
s = list(S)
min_length = s[1]-s[0]
for i in range(1,len(s)):
if s[i] - s[i-1] < min_length :
min_length = s[i] - s[i-1]
print (min_length)
set1=set()
for i in range(1,len(s)):
if s[i] - s[i-1] == min_length :
set1.add( (s[i-1],s[i]) )
print(set1)
ary=input("숫자를 오름차순으로 입력 : ").split(" ")
S=[]
xy=[]
MIN=10000
for i in range(len(ary)-1):
diff=int(ary[i+1])-int(ary[i])
S.append(diff)
xy.append((int(ary[i]),int(ary[i+1])))
if MIN>diff:
MIN=diff
for i in range(len(S)):
if S[i]==MIN:
print("가장 최소 거리 : {}".format(xy[i]))
S = {1, 3, 4, 8, 13, 17, 20}
pairs_S = list(zip(list(S)[0:], list(S)[1:]))
length_S = [j-i for (i, j) in pairs_S]
print(pairs_S[length_S.index(min(length_S))])
S = (1,3,4,8,13,17,20)
c = 1000
reala = 0
realb = 0
for a in S:
for b in S:
if a - b == 0:
trash = tuple()
elif a - b > 0 and a - b < c:
c = a - b
reala = a
realb = b
print('(',realb,',',reala,')',sep="")
s=[1,3,4,8,13,17,20]
dist=[]
for i in range(len(s)-1):
dist.append(s[i+1]-s[i])
print(dist)
m=min(dist)
print(m)
for i in range(len(s)-1):
if s[i+1]-s[i]==m:
print(s[i],s[i+1])
def find_shortest_pairs(l):
distance_dict = dict([(i, l[i + 1] - l[i]) for i in range(len(l) - 1)])
min_distance = min(distance_dict.values())
return [(l[i], l[i + 1]) for (i, distance) in distance_dict.items() if distance == min_distance]
import random
from itertools import combinations
dot = (input().split(","))
dotcom = (list(combinations(dot,2)))
length = []
for i in range(0,len(dotcom)):
length.append(abs(int(dotcom[i][0])-int(dotcom[i][1])))
minlength = min(length)
indices = [i for i, v in enumerate(length) if v == minlength]
for i in indices:
print(dotcom[i])
여러가지를 참조해서 풀었습니다. 이렇게 하니 답이 여러개인 경우도 풀리네요.
import random
length = 10
numbers = list(set([random.randint(1,100) for i in range(length)]))
sorted_numbers = sorted(numbers)
pairs = list(zip(sorted_numbers[:-1],sorted_numbers[1:]))
diffs = [pairs[i][1]-pairs[i][0] for i in range(len(pairs))]
indices = [i for i, value in enumerate(diffs) if value == min(diffs)]
print('numbers are: ', numbers)
print('the pairs of minimum difference are: ',[pairs[i] for i in indices])
print('the minimum difference is: ',min(diffs))
파이썬3입니다.
import random as r
numberList = sorted(set([r.randint(-1000, 1000) for _ in range(10)]))
print(numberList)
distanceList = [int(numberList[x] - numberList[x - 1]) for x in range(len(numberList)) if x - 1 != -1]
d = min(distanceList)
print(f'[{numberList[distanceList.index(d)]}, {numberList[distanceList.index(d) + 1]}]')
s=[1, 3, 4, 8, 13, 17, 20]
a=[[s[0],s[1]]]
his=s[1]-s[0]
for i in range(0, len(s)):
for j in range(i+1, len(s)):
if s[j]-s[i] < his :
a[0] = [s[i], s[j]]
his = s[j]-s[i]
print(a)
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;
public class main {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int[] num = new int[7];
int min=Integer.MAX_VALUE;
int length;
System.out.println("숫자 7개입력하시오, 크기순으로");
int a;
for(int i=0;i<7;i++)
{
a= scan.nextInt();
num[i] = a;
}
Arrays.sort(num); // 크기순으로 정렬
for(int i=0;i<6;i++)
{
length = num[i+1]-num[i];
if(length< min)
{
min = length;
}
}
System.out.println("입력한 숫자들은 ");
for(int i=0; i<7;i++)
{
System.out.print(num[i]+ " " );
}
System.out.println("최소 길이는: " + min);
}
}
단, input에 1, 3, 4, 8, 13, 17, 20 이런 형식으로 집어넣어야 돼요!
S=input("1차원 점들: ").split(',')
index_num=[abs(int(S[i-1])-int(S[i])) for i in range(len(S))].index(min([abs(int(S[i-1])-int(S[i])) for i in range(len(S))]))
print(S[index_num-1], S[index_num])
s = [1, 3, 4, 8, 13, 17, 20, 21]
min_pair = []
min_diff = max(s)
for i in range(len(s)):
if i + 1 == len(s):
break
diff = s[i+1] - s[i]
if min_diff > diff:
min_diff = diff
min_pair = [(s[i], s[i+1])]
elif min_diff == diff:
min_pair.append((s[i], s[i+1]))
print(min_pair)
결과: [(3, 4), (20, 21)]
N = list(map(int,input().split()))
check = N[len(N)-1]+1
for i in range(len(N)-1):
if check > (N[i+1] - N[i]):
check = N[i+1] - N[i]
M = [[N[i],N[i+1]]]
elif check == (N[i+1] - N[i]):
M.append([N[i],N[i+1]])
print(M)
파이썬 입니다
s = [1,3,4,5,13,17,20]
def delta(alpha):
z=[]
a = len(alpha)
for i in range(0,a-1):
b = alpha[i+1]-alpha[i]
z.append(b)
return z
f = sorted(delta(s))
minimum = f[0]
for i in range (0,len(s)-1):
if s[i+1]-s[i] == minimum:
print("가장 거리가 짧은 점들의 좌표는 (%d, %d) 이다." %(s[i],s[i+1]))
else:
pass
package test;
import java.util.*;
public class Test{
public static void main(String[] args) {
int temp, min;
ArrayList<Integer> twin = new ArrayList<>();
Scanner sc = new Scanner(System.in);
String input = sc.nextLine();
String[] arr2 = input.split(", ");
int[] arr = Arrays.stream(arr2).mapToInt(Integer::parseInt).toArray();
Arrays.sort(arr);
min = arr[1] - arr[0];
for(int i=1; i<arr.length-1; i++) {
temp = arr[i+1]-arr[i];
if(min>temp) {
min = temp;
twin.clear();
twin.add(arr[i]); twin.add(arr[i+1]);
}
}
System.out.println(twin);
sc.close();
}
}
def calc_min_distance(S):
""" S is set """
import numpy as np
diff = np.array(list(S))[1:-1] - np.array(list(S))[:-2]
min_ind = np.where(diff == np.min(diff))
return [(min_ind[0][i]+1,min_ind[0][i]+2) for i in range(len(min_ind[0]))]
s=[3,1, 4,5, 8, 13, 17, 20]
s.sort()
sub=[]
for a in range(0,len(s)-1):
sub.append(s[a+1]-s[a])
search=0
for a in range(0,len(sub)-1):
if sub[search] > sub[a]:
search=a
final=[search]
for a in range(0,len(sub)-1):
if sub[search] == sub[a] and search !=a:
final.append(a)
for a in final:
print('(%d,%d)'%(s[a],s[a+1]))
s=[3,1, 4,5, 8, 13, 17, 20]
s.sort()
sub=[]
for a in range(0,len(s)-1):
sub.append(s[a+1]-s[a])
search=0
for a in range(0,len(sub)-1):
if sub[search] > sub[a]:
search=a
final=[search]
for a in range(0,len(sub)-1):
if sub[search] == sub[a] and search !=a:
final.append(a)
for a in final:
print('(%d,%d)'%(s[a],s[a+1]))
s=[3,1, 4,5, 8, 13, 17, 20]
s.sort()
sub=[]
for a in range(0,len(s)-1):
sub.append(s[a+1]-s[a])
search=0
for a in range(0,len(sub)-1):
if sub[search] > sub[a]:
search=a
final=[search]
for a in range(0,len(sub)-1):
if sub[search] == sub[a] and search !=a:
final.append(a)
for a in final:
print('(%d,%d)'%(s[a],s[a+1]))
중복 가능합니다
S=[1, 3, 4, 5, 8, 13, 17, 20]
def short(lista) :
listy = []
answer = lista[1]-lista[0]
for i in range(0, len(lista)-1) :
if answer > lista[i+1] - lista[i] :
listy = [[lista[i], lista[i+1]]]
answer = lista[i+1] - lista[i]
elif answer == lista[i+1] - lista[i] :
listy.append([lista[i+1], lista[i]])
return listy
print(short(S))
#include<stdio.h>
#include<stdlib.h>
#define ars 7
int main()
{
int i,l;
int ary[ars]={1, 3, 4, 8, 13, 17, 20};
for (i=0;i<=ars-2;i++)
{
if(l>abs(ary[i]-ary[i+1]))
l=abs(ary[i]-ary[i+1]) ;
}
printf("%d",l);
return 0;
}
언제나의 C언어 더 줄일 수 있을까?
public static void main(String[] args) {
int[] dot = {1, 3, 4, 8, 13, 17, 20};
int[] result = new int[2];
int min = Integer.MAX_VALUE;
for(int i=0; i<dot.length; i++) {
for(int j=i+1; j<dot.length; j++) {
int number = Math.abs(dot[i] - dot[j]);
if(number<min) {
min = number;
result[0] = dot[i];
result[1] = dot[j];
}
}
}
System.out.println(Arrays.toString(result));
def ShortDis(a) :
a = list(a)
a.sort()
ans = -1
anslist = []
for i in range((len(a)-1)) :
distance = a[i+1] - a[i]
if ans < 0 :
ans = distance
anslist.append(str((a[i], a[i+1])))
elif ans > distance :
ans = distance
anslist = []
anslist.append(str((a[i], a[i+1])))
elif ans == distance :
anslist.append(str((a[i], a[i+1])))
return anslist
S = {1, 3, 4, 8, 13, 17, 20, 21}
print ", ".join(ShortDis(S))
ArrayList<Integer> numList = new ArrayList<Integer>();
for (int i = 0; i < 10; i++) {
numList.add((int) (Math.random() * 100 + 1));
}
numList.sort(null);
ArrayList<Integer> Dif = new ArrayList<Integer>();
System.out.println(numList);
for (int i = 0; i < numList.size()-1; i++) {
Dif.add(numList.get(i+1) -numList.get(i));
}
System.out.println(Dif);
int min = Dif.get(0);
int[] indexFind = new int[10];
for (int i = 0; i < Dif.size()-1; i++) {
if (min > Dif.get(i)) {
min = Dif.get(i);
indexFind[i] = Dif.indexOf(min);
}
}
for (int i = 0; i < indexFind.length; i++) {
System.out.println(indexFind[i]);
}
int max = indexFind[0];
for (int i = 0; i < indexFind.length; i++) {
if (max < indexFind[i]) {
max = indexFind[i];
}
}
System.out.println(numList.get(max)+","+numList.get(max+1));
난수 중복은 감이안오내용
package codeDojang;
import java.util.Scanner;
public class Prac {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int[] ar = new int[7];
for (int i = 0; i < ar.length; i++) {
ar[i] = sc.nextInt();
}
int min = ar[1] - ar[0];
for (int i = 0; i < ar.length-1; i++) {
if(ar[i+1]-ar[i]<min) {
min = ar[i+1]-ar[i];
}
}
for (int i = 0; i < ar.length-1; i++) {
if((ar[i+1]-ar[i])==min) {
System.out.println("("+ar[i]+","+ar[i+1]+")");
}
}
}
}
def distance(list1):
result = []
temp = list1.split(',')
for aa in temp:
temp1 = temp[:]
temp1.remove(aa)
for bb in temp1:
sum_temp = int(aa) - int(bb)
if sum_temp < 0 :
sum_temp = -1*sum_temp
result.append([aa, bb, sum_temp])
for cc in result:
if cc[2] < result[0][2]:
del result[result.index(cc)]
result.insert(0, cc)
return print('shortest distance is {}, between {} and {}'.format(result[0][2], result[0][0], result[0][1]))
distance('1,4,9,8,13,17,20')
def minDistance(s):
result = []
for i in range(0, len(s) - 1):
result.append(s[i + 1] - s[i])
for i in range(len(result)):
if result[i] == min(result):
print("({},{})".format(s[i], s[i + 1]), end=' ')
print()
minDistance([1, 2, 4, 5, 8, 15, 19])
def short_cut(list):
min=max(list)
for i in range(0,len(list)-2,1):
if list[i+1]-list[i]<min:
min=list[i+1]-list[i]
answer=(list[i],list[i+1])
return answer
print(short_cut([1,3,4,8,13,17,20]))
public class pro8 {
public static void main(String[] args) {
// TODO Auto-generated method stub
int[] a = {1,3,4,8,13,17,20};
int temp = 0;
int re = a[a.length-1];
int b1=0, b2=0;
for(int i = 0; i<a.length-1; i++){
temp = a[i+1] - a[i];
if(re>temp){
re=temp;
b1=a[i];
b2=a[i+1];
}
}
System.out.println(b1+", "+b2);
}
}
user_input = {1, 3, 4, 8, 13, 17, 20} # set(int)
mod_input = sorted(list(user_input)) # list(int)
print('input :', mod_input)
distance = []
for i in range(len(mod_input)):
if i < len(mod_input)-1:
value = mod_input[i+1] - mod_input[i]
distance.append(value)
min_dis = min(distance)
min_index = distance.index(min_dis)
print('min_dis_pair :', mod_input[min_index : min_index + 2])
파이썬으로 작성했습니다.
(1) 주어진 집합을 정렬된 리스트로 바꾸고 (2) 리스트 내 이웃한 요소값들의 차로 구성된 리스트를 생성하고 (3) 생성된 리스트내 최소값의 위치를 찾아서 (4) 최소값을 생성하는 값들을 반환합니다.
a=[1,434643,132324,654677,34328,41245,323332,343478] # 임의의 리스트를 작성하였습니다. 왜인지 모르겠는데 줄이 안 띄어지네요;
result=[]
for i in range(len(a)): for j in range(len(a)): result.append(abs(a[i]-a[j]))
b=result.count(0)
for i in range(b): result.remove(0)
result2=[]
for i in range(len(a)): for j in range(len(a)): if abs(a[i]-a[j])==min(result): result2.extend([a[i],a[j])
for i in range(len(result2)//2): # 항상 두 쌍이 생성되어 한 쌍을 버리기 위해 pop을 사용했습니다. result2.pop()
print(result2)
x = [(abs(data[i]-data[j]),data[i],data[j]) for i in range(len(data)) for j in range(i+1,len(data))]
md =min(i[0] for i in x)
for k in [i for i in x if i[0]==md]:
print(k[1:])
arr = list(map(int, input().split()))
MIN = max(arr)
temp = arr.pop(arr.index(min(arr)))
while True:
com = arr.pop(arr.index(min(arr)))
if(com - temp <= MIN):
MIN = com - temp
print("(%d, %d)" %(temp, com))
temp = com
if(arr == []): break
거리의 최소를 찾는거라 배열에서 최소값들만 비교했습니다. 최소1 - 최소2 < 최소1 - 최소아닌값 이라고 생각해서 최소값들끼리만 비교했습니다.
distance = {} #딕셔너리형 활용해보자
count = int(input("1차원 점의 갯수를 입력하시오: "))
s = []
for i in range(count):
s.append(int(input("점들을 입력하시오(오름차순): ")))
for i in range(count):
for j in range(i+1, count):
distance[-(s[i] - s[j])] = s[i], s[j] #dictionary에 두 점 사이 거리를 key로, 두 점을 value로 할당해줌
for i, j in distance.items():
print("Key:", i)
print("Value:", j)
dis_com = []
for i in range(count):
for j in range(i+1, count):
dis_com.append(-(s[i] - s[j]))
print("두 점 사이의 거리들:", dis_com)
count2 = len(dis_com)
for i in range(count2):
smallest = i
for j in range(i+1, count2):
if(dis_com[j]<dis_com[smallest]):
smallest = j
temp = dis_com[i]
dis_com[i] = dis_com[smallest]
dis_com[smallest] = temp
print(f'가장 짧은 거리는 {dis_com[0]}')
print(f'가장 짧은 거리를 가지는 두 점은 {distance[dis_com[0]]}')
a = [1,2,4,7,10,15,19,30,50]
lis = []
for idx in range(len(a)-1):
dif = a[idx+1] -a[idx]
lis.append(dif)
answer = []
for idx, num in enumerate(lis):
if num == min(lis):
answer.append(a[idx])
answer.append(a[idx+1])
print(answer)
#숫자 열 정렬
S=[1, 3, 4, 8, 13, 17, 20]
S.sort()
#차 집합 형성
n=0
subresult = []
while n < len(S)-1:
subresult.append(S[n+1]-S[n])
n+=1
#차집합의 최솟값 구하기
minnum = subresult[0]
for i in subresult :
if i > minnum :
pass
else :
minnum = i
'''print(minnum)''' #중간 점검
#차집합에서 최솟값에 해당하는 순번n 구하기
n=0
count = []
for i in subresult :
if i == minnum :
count.append(n)
n += 1
#원래 숫자열 쌍 구하기
for i in count :
print(S[i],',',S[i+1])
아직 배운지 1주일밖에 되지 않아서 기초적인 내용으로 구성해봤습니다!
S=[1,3,5,8,13,17,20,21,24,25]
L=[]
for i in range(0,len(S)-1):
A=S[i+1]-S[i]
L.append(A)
for n in range(0,len(L)):
if L[n]==min(L):
print((S[n],S[n+1]))
S={1, 3, 4, 8, 13, 17, 20}
s = list(S)
for i in range(0,len(s)-1):
if abs(s[i]-s[i+1]) == 1:
print(s[i],s[i+1])
이게 확실하게 맞는건지 모르겠네요..
def ab(x):
if x<0:
return -x
else:
return x
count=0
list1=list(map(int,input().split(",")))
min=ab(list1[0]-list1[1])
for i in range(len(list1)-1):
for j in range(len(list1)-(i+1)):
if ab(list1[i]-list1[j+i+1]) < min:
min=ab(list1[i]-list1[j+i+1])
n1=list1[i]
n2=list1[j+i+1]
print("("+str(n1)+","+str(n2)+")")
num_list = [1,3,4,8,13,17,20]
dots = {(i, j): abs(i-j) for i in num_list for j in num_list if i < j}
for k, v in dots.items():
if v == min(dots.values()):
print(k)
a = [1, 2, 4, 6, 8, 15, 16, 18, 19]
idx = []
diff = a[1] - a[0]
comp2 = []
for i in range(0, len(a) - 1):
if a[i + 1] - a[i] < diff:
idx = []
idx.append(i)
diff = a[i + 1] - a[i]
elif a[i + 1] - a[i] == diff:
idx.append(i)
for i in idx:
comp = []
comp.append(a[i])
comp.append(a[i + 1])
comp2.append(comp)
print(comp2)
리스트 이용
def distanceMin(*values):
values = list(set(values))
subList = []
valuesList = []
for i in range(len(values)-1,-1,-1):
if i == 0:
break
sub = values[i] - values[i-1]
subList.append(sub)
valuesList.append([values[i],values[i-1]])
min_index = subList.index(min(subList))
return print(valuesList[min_index])
distanceMin(1,3,4,8,13,17,20)
S = [1, 3, 4, 8, 13, 17, 20]
distance = []
n = 0
while n < len(S) - 1:
d = S[n+1] - S[n]
distance.append(d)
n += 1
min_val = min(distance)
ind = distance.index(min_val)
min_distance = [S[ind], S[ind+1]]
print(min_distance)
s = [1, 3, 4, 8, 13, 17, 20]
def find(s):
temp = []
output = []
for i in range(len(s)-1):
temp.append(abs(s[i+1]-s[i]))
j_lst = [i for i, e in enumerate(temp) if e == min(temp)]
for j in j_lst:
output.append([s[j], s[j+1]])
return output
print(find(s))
#include <iostream>
#define ARRSIZE(Arr) sizeof(Arr)/sizeof(Arr[0])
using namespace std;
int main(int argc, char *argv[]) {
int a[] = {1,6,10,15,28};
int x = 0, y = 0;
int min = a[ARRSIZE(a)-1] - a[0];
//printf("Current Min Distance is: %d \n", min);
//printf("Array size is: %lu \n\n", ARRSIZE(a));
for(int i = 0; i < ARRSIZE(a) ; i++){
for(int j = 0; j < ARRSIZE(a) ; j++){
if(a[i] != a[j] & a[i] > a[j]){
int temp = a[i] - a[j];
//printf("%d \n", temp);
if(temp < min){
x = a[j];
y = a[i];
min = temp;
}
}
}
}
printf("Final Min Distance is: %d \n", min);
printf("Two positions are: %d, %d \n", x, y);
}
다른 점의 리스트들로도 작동이 됩니다
def min_dist(*S):
S = list(S)
dict = {}
for (x, y) in zip(S[:-1], S[1:]):
if not dict.get(y-x):
dict[(y-x)] = [(x, y)]
else:
dict[(y-x)] = dict[(y-x)] + [(x, y)]
return dict[min(dict.keys())]
[결과]
min_dist(1, 3, 4, 8, 13, 17, 20)
[(3, 4)]
<파이썬 3>
int iValue = 0;
int jValue = 0;
int[] S = {1, 3, 4, 8, 13, 17, 20};
JSONArray jArray = new JSONArray();
for(int i=0; i<S.length; i++) {
for(int j=i+1; j<S.length; j++) {
JSONObject sObject = new JSONObject();//배열 내에 들어갈 json
sObject.put("j", S[j]);
sObject.put("i", S[i]);
sObject.put("total", S[j]-S[i]);
jArray.add(sObject);
}
}
JSONArray sortedJsonArray = new JSONArray();
List<JSONObject> jsonValues = new ArrayList<JSONObject>();
for (int i = 0; i < jArray.length(); i++) {
jsonValues.add(jArray.getJSONObject(i));
}
Collections.sort( jsonValues, new Comparator<JSONObject>() {
//You can change "Name" with "ID" if you want to sort by ID
@Override
public int compare(JSONObject a, JSONObject b) {
String valA = new String();
String valB = new String();
try {
valA = Integer.toString((int) a.get("total"));
valB = Integer.toString((int) b.get("total"));
}
catch (JSONException e) {
//do something
}
return valA.compareTo(valB);
//if you want to change the sort order, simply use the following:
//return -valA.compareTo(valB);
}
});
for (int i = 0; i < jArray.length(); i++) {
sortedJsonArray.put(jsonValues.get(i));
if(i == 0) {
iValue = jsonValues.get(i).getInt("i");
jValue = jsonValues.get(i).getInt("j");
}
}
System.out.println(iValue + ", " + jValue);
#생각의 흐름대로 적었습니다. abs 를 사용 정렬이 안되 있어도 동작합니다.
S=[1,8,13,17,20,3,5,1000,22,11,90,9,2]
def find_2_min(in_list):
gap = max(in_list)
temp =[0,0]
for i in range(len(in_list)-1):
for j in range(i+1,len(in_list)):
if abs(in_list[i]-in_list[j]) < gap:
gap = abs(in_list[i]-in_list[j])
temp[0] = in_list[i]
temp[1] = in_list[j]
return temp
find_2_min(S)
def minDistance(S):
"""두 점의 거리가 최소인 쌍 구하기"""
subtract = [S[i+1] - S[i] for i in range(len(S)-1)]
print(f'S =', S)
print(f'이웃 값들의 차: ', subtract)
i = subtract.index(min(subtract))
print(f'최소값의 인덱스: ', i)
print(f'최소 거리의 쌍은', (S[i], S[i+1]), '입니다.')
S = []
total = int(input('입력할 수의 총 개수:'))
i = 0
while i < total:
for i in range(total):
num = int(input('수를 입력하세요.: '))
S.append(num)
i += 1
minDistance(S)
초보자티 팍팍...
s = [1,3,4,8,13,17,18,20]
l = []
m = []
n = 0
while len(l) < len(s)-1 :
l.append([s[n],s[n+1]])
n += 1
n = 0
while len(m) < len(l) :
m.append(abs(l[n][0])-abs(l[n][1]))
n += 1
n = 0
while n < 7 :
if m[n] == max(m):
print(l[n])
n += 1
public class Daum {
public static void main(String[] args) {
int[] S = {1, 3, 4, 8, 13, 17, 20};
int count = S[1] - S[0];
int fir = S[0], sec = S[1];
for (int i = 0; i < S.length - 1; i++) {
if(count > S[i+1] - S[i]) {
count = S[i+1] - S[i];
fir = S[i];
sec = S[i+1];
}
}
System.out.println("(" + fir + "," + sec + ")");
}
}
S = sorted(list({1,3,4,8,13,17,20}))
what = lambda x,y : y-x if y > x else x-y
X = list(set([what(a,b) for a in S for b in S]))
k = {}
for a in S:
for b in S:
if a > b:
k[a - b] = (a,b)
elif b > a:
k[b-a] = (a,b)
print(k.get(X[1]))
dict로 풀어보려고 하다가 좀 복잡하게 됐네요 ㅎㅎ 앞에 간단히 푸신 분들 정말 대단합니다 좋은 풀이들 감사드리며 더 열심히 해야겠네요
S = [1, 3, 4, 8, 13, 17, 20] a = [] for i in range(len(S)-1): a.append(abs(S[i] - S[i+1])) S[a.index(min(a))], S[a.index(min(a))+1]
S = [1, 3, 4, 8, 13, 17, 20]
a = []
for i in range(len(S)-1):
a.append(abs(S[i] - S[i+1]))
S[a.index(min(a))], S[a.index(min(a))+1]
s=list(map(int,input('수 입력').split(' ')))
aNum=0
bNum=0
num=sum(s)*sum(s)
for i in range(len(s)-1):
for j in range(i+1,len(s)):
if s[i]-s[j]<0:
if num>(s[i]-s[j])*-1:
num=(s[i]-s[j])*-1
aNum=s[i]
bNum=s[j]
elif num>(s[i]-s[j]):
num=(s[i]-s[j])
aNum=s[i]
bNum=s[j]
print('가장 가까운 쌍 : {},{}'.format(aNum,bNum))
python 3.9.6입니다. 배열 입력이 필요하다는 것과 답이 여러 개이면 모두 출력해야 한다는 것도 구현했습니다. 소스 코드입니다.
array = [int(num) for num in input('수 리스트 입력(공백으로 분리): ').split()]
record = []
result = []
for i in range(len(array)-1):
low = array[i]
high = array[i+1]
size = high - low
record.append((low, high, size))
rec_sort = sorted(record, key=lambda rec: rec[2])
min_size = rec_sort[0][2]
for recs in rec_sort:
if recs[2] != min_size: break
result.append(recs[:-1])
print(result)
실행 결과입니다.
수 리스트 입력(공백으로 분리): 1 3 4 8 13 17 20
[(3, 4)]
수 리스트 입력(공백으로 분리): 1 2 4 5 8 15 19
[(1, 2), (4, 5)]
#codingdojing_daum_least_distance_re
from random import *
S = sorted([randint(1,1000) for i in range(10)]) # 순서대로 정렬되어 있는 조건
#1, 두 점씩 쌍을 맺어서 리스트 -> 차이로 sort
pair_list = [(S[i], S[i+1]) for i in range(len(S)-1)] #
pair_list.sort(key = lambda x : x[1] - x[0]) #두 점의 차이로 sort, [(65, 66), (8, 10), (4, 8), (24, 28), (28, 36), (53, 65), (10, 24), (36, 53), (66, 94)]
result = []
i = 0
while (pair_list[0][1] - pair_list[0][0]) == (pair_list[i][1] - pair_list[i][0]):
result.append(pair_list[i])
i += 1
print(f'distance: {result[0][1]-result[0][0]}, {result}')
#2, dictionary 이용, 풀이참고
pair_dict = {} #key = distance, value = (pairs), key값으로 list 형식으로 pair 저장.
for a, b in zip(S[0:], S[1:]): #(a,b), a < b
pair_dict.setdefault(b-a , [] ) #key 값, list 초기화
pair_dict[b-a] += [(a,b)] #distance 값에 해당하는 pair 리스트 형식으로 추가
print(f"distance: {min(pair_dict.keys())}, {pair_dict[ min(pair_dict.keys()) ]}") #최소 distance에 해당하는 value print
다른 풀이를 참고하여 랜덤으로 점들을 생성한 뒤, sort 후 같은 최소값을 갖는 점들까지 프린트하였습니다. *2가지 방식
return_S=[]
def short(a):
save=a[-1]
for i in range(1,len(a)-1):
if a[i]-a[i-1]<save:
save=a[i]-a[i-1]
return_S.append((a[i-1],a[i]))
print(return_S[-1])
print(short(input()))
파이썬 3.10.8로 작성했습니다. itertools.combination(iter, 2)를 활용해서 해당 샘플 집합의 조합을 구했습니다. 그런 후에 각 조합 요소들의 거리를 구했으며 최소 거리에 해당되는 인덱스를 도출하여 어떤 조합이 최소 거리에 해당되는지 출력했습니다.
from itertools import combinations
S = {1, 3, 4, 8, 13, 17, 20}
combi = list(combinations(list(S), 2))
length = list(map(lambda x: abs(x[0] - x[1]), combi))
min_length_index = length.index(min(length))
print(combi[min_length_index])
S = [1,3,4,8,13,17,20]
A = [S[i+1]-S[i] for i in range(len(S)-1)]
a=min(A)
b=A.index(a)
print(S[b], S[b+1])
package justStudying;
public class test2_20210818 {
public static int[] sol(int[] arr) {
int[] ans = new int[2];
int min = arr.length;
int temp = 0;
for(int i=0; i<arr.length-1; i++) {
temp = arr[i+1] - arr[i];
if(temp < min) {
min = temp;
ans[0] = arr[i];
ans[1] = arr[i+1];
}
}
return ans;
}
public static void main(String[] args) {
// TODO Auto-generated method stub
int[] arr = {1, 3, 4, 8, 13, 17, 20};
int[] ans;
ans = sol(arr);
for(int i=0; i<ans.length; i++) {
System.out.println(ans[i]);
}
}
}
set1 = [1, 3, 4, 8, 13, 17, 20]
dic1 = {}
for i in range(0, len(set1)- 1) :
distance = abs(set1[i+1] - set1[i])
dic1[distance] = (set1[i],set1[i+1])
minval = min(dic1.keys())
print(dic1[minval])
distance = [] S = input("숫자들을 입력하세요 : ").split() S = list(map(int, S)) n = len(S) S.sort()
for i in range(1,n-1): distance.append(S[i] - S[i-1])
d = distance.index(min(distance)) print(S[d],S[d+1])
S={1, 3, 4, 8, 13, 17, 20, 21}
S = list(S)
K = [S[i+1]-S[i] for i in range(len(S)-1)] #인접한 두 수의 차 list
a = min(K) #거리가 가장 짧은 값
R = [n for n in range(len(K)) if K[n] == a] #K값의 몇번째 List인지 구함
F = []
for n in R:
F.append((S[n],S[n+1])) #R에서 구한 값으로 S쌍을 F에 리스트로 append
print(F)
s=[1,3,4,8,13,17,20]
result=[s[1]-s[0],s[0],s[1]]
for i in range(1,len(s)):
if s[i]-s[i-1]< result[0]:
result=[s[i]-s[i-1],s[i-1],s[i]]
print(result[1:])
def solution(dot):
s,ss=dot[1:] ,dot[:-1]
answer = sorted(list(zip(s,ss)), key =lambda i : i[1] -i[0])[0]
return list(answer)
print(solution([1,3,4,8,13,17,20])
list=[1,3,4,8,13,17,20]
distance=''
for i, name in enumerate(list):
for k in list[i+1:]:
new_distance=abs(int(k)-int(name))
if distance=='': distance=new_distance
if new_distance<=distance:
answer=(name,k)
distance=new_distance
print(answer)
S = [1,2,4,5,8,15,19]
list = [S[i+1]-S[i] for i in range(0, len(S)-1)]
for i in range(0, len(list)):
if list[i] == min(list):
print(f"({S[i]}, {S[i+1]})")
else:pass
void main()
{
int pair[2];
int gab = 10000;
int pos[7] = { 1, 3, 4, 8, 13, 17, 20 };
int len = sizeof(pos) / sizeof(pos[0]);
for (int i = 0; i < len-1; i++)
{
int temp = abs(pos[i] - pos[i + 1]);
if (temp < gab)
{
pair[0] = pos[i]; pair[1] = pos[i + 1];
gab = temp;
}
}
cout << pair[0];
cout << pair[1];
}
var pointer = new Array(1, 2, 4, 5, 8, 10 ,18, 22, 26);
var base = parseInt(pointer[1]) - parseInt(pointer[0]);
var result = new Array();
for(var i = 0; i < pointer.length; i++) {
if(i != pointer.length - 1 && base > parseInt(pointer[i + 1]) - parseInt(pointer[i])) {
base = parseInt(pointer[i + 1]) - parseInt(pointer[i]);
result = new Array();
result.push(pointer[i]);
result.push(pointer[i] + 1);
continue;
}
if(i != pointer.length - 1 && base == parseInt(pointer[i + 1]) - parseInt(pointer[i])) {
result.push(pointer[i]);
result.push(pointer[i] + 1);
}
}
var s = [1,3,4,8,13,17,20,23]
var result = 0;
var y = s[0] - s[1]
if(y < 0) y = y * -1
for(i=1; i<s.length-1; i++) {
var x = s[i] - s[i+1]
if(x < 0) x = x * -1
if(y > x) result = i
}
console.log(s[result] + "," + s[result+1])
N = int(input('입력할 점의 갯수는? '))
S = []
T = []
for i in range(0, N):
S.append(int(input('1차원 점의 좌표를 모두 입력하시오 ')))
S.sort()
a = S[1] - S[0]
for i in range(0, N-1):
if a > S[i+1] - S[i]:
a = S[i+1] - S[i]
T = []
T.append('({},{})' .format(S[i], S[i+1]))
elif a == S[i+1] - S[i]:
T.append('({},{})' .format(S[i], S[i+1]))
print()
print("거리가 가장 짧은 것의 쌍은 다음과 같다.")
print(T)
input_list = input(":").split()
length =[]
for i in range(len(input_list)-1):
length.append( (int(input_list[i]) - int(input_list[i+1]))**2 )
min_index = min(length)
for k in range(len(length)):
if length[k] == min_index:
print("({},{}) ".format(input_list[k],input_list[k+1]), end="")
arr = [1,3,4,8,9,17,20]
diff =set()
for i in range(len(arr)-1) :
for j in range(i+1,len(arr)) :
dif = abs(arr[i]-arr[j])
diff.add(dif)
min_dist = min(diff)
for i in range(len(arr)-1) :
for j in range(i+1,len(arr)) :
if abs(arr[i]-arr[j]) == min_dist :
print("결과값은 ",arr[i],',',arr[j])
S = {1, 3, 4, 8, 13, 17, 20}
S = sorted(list(S))
l1 = []
i = 0
while i < len(S) - 1:
i += 1
l1.append((S[i] - S[i-1], (S[i-1],S[i])))
l1.sort()
for x,y in l1:
if x == l1[0][0]:
print(y)
user = list(map(int, input('S : ').split()))
distances = dict()
for i in range(len(user)) :
for j in user[i+1:] :
distances[f'{(user[i], j)}'] = (user[i] - j) ** 2
d2 = sorted(distances.items(), key = lambda x : x[1])
print(*[x[0] for x in d2 if 1 in x], sep = ', ')
import re
p = re.compile("\D")
while True:
sample_input = input("숫자를 입력하세요!! 공백으로 띄워주세요.")
test_string = sample_input.replace(" ", "")
if not p.search(test_string):
break
input_num_list = [int(x) for x in sample_input.split()]
input_num_list.sort()
dist_list = [input_num_list[i+1]-input_num_list[i] for i in range(len(input_num_list)-1)]
result = [(input_num_list[i],input_num_list[i+1]) for i in range(len(dist_list)) if dist_list[i]==min(dist_list)]
print(result)
s1 = [1,2,4,5,13,17,20]
s2 = [abs(s1[i] - s1[i+1]) for i in range(0,len(s1)-1)]
print( [(s1[i],s1[i+1]) for i in range(0,len(s2)) if s2[i] == min(s2)] )
s = list({1, 3, 4, 8, 13, 17, 20})
length = [abs(s[x]-s[x-1]) for x in range(1,len(s))]
ind = length.index(min(a))
print([s[ind],s[ind+1]])
package org.javaturotials.ex;
import java.util.*;
public class test {
public int[] row(int[] a) {
int[] ex = new int[2];
int min=1000;
for(int i=0; i<a.length-1; i++) {
int c = Math.abs(a[i+1]-a[i]);
if(min>c) {
min = c;
ex[0]=a[i];
ex[1]=a[i+1];
}
}
return ex;
}
public static void main(String[] args) {
int[] arr ={1, 3, 4, 8, 13, 17, 20};
int[] st = new int[2];
test a1 = new test();
st = a1.row(arr);
System.out.println(st[0] + " " + st[1]);
}
}
def shortest(array):
distance = []
for i in range(len(array)-1):
distance += [[array[i+1] - array[i],i]]
min_dist = min(distance)
return array[min_dist[1]],array[min_dist[1]+1]
example = [1, 3, 4, 8, 13, 17, 20]
shortest(example)
S={1,3,4,5,7,10}
s=list(S)
def dis(a):
return s[a]-s[a-1]
s_dis=[dis(i) for i in range(1,len(s))]
# s_dis=[]
# for i in range(1,len(s)):
# s_dis.append(dis(i))
for j in range(0,len(s_dis)):
if min(s_dis)==s_dis[j]:
print((s[j],s[j+1]))
else:
pass
되는대로 하다보니 너무 지저분해졌네요 ㅜㅜ
public static void main(String[] args)
{
int[] arr = {1,5,10,20,26,28,31,32};
int[] point = new int[2];
for (int i = 0; i < arr.length-2; i++)
{
int tmp = arr[i+1] - arr[i];
if (tmp > arr[i+2] - arr[i+1])
{
point[0] = arr[i+2];
point[1] = arr[i+1];
}
}
System.out.println(point[0]);
System.out.println(point[1]);
}
최소값이 두개 이상일 때를 가정하고 만들어 봤습니다.
import java.util.Arrays;
public class DaumTest {
public static void main(String[] args) {
int[] arr = { 1, 3, 4, 8, 13, 17, 20, 21, 24, 25 };
int[] min = new int[arr.length - 1]; // sort로 정렬해서 0번째 배열에 최소값이 오게할 배열
int[] result = new int[min.length]; // arr의 뒷 배열에서 앞 배열을 뺀 값을 그대로 저장할 배열
for (int i = 0; i < result.length; i++) {
min[i] = arr[i+1] - arr[i];
result[i] = arr[i+1] - arr[i]; // i+1 에서 i를 뺀 값을 배열 min과 배열 result에 저장
}
Arrays.sort(min); // min을 정렬 시켜서 min[0]에 arr[i+1] - arr[i]의 최소값이 오게 해줌
for (int i = 0; i < result.length; i++) {
if (min[0] == result[i]) { // 최소값과 정렬시키지 않은 result의 값을 비교
System.out.println(arr[i] + "," + arr[i + 1]); // result[i]값은 arr[i]와 위치가 같다는걸 이용
}
}
}
}
def findShortest():
S = list(map(int, input('점들의 값을 입력하시오:').split()))
absDic = {} # 빈 딕셔너리
# 각 점들과의 거리(절대값:abs())를 딕셔너리로 저장
for point1 in S:
for point2 in S:
# 키값이 서로 같지 않고, 뒤집어도 같은 키가 없는 경우 저장
if point1 != point2 and (point2, point1) not in absDic:
absSub = abs(point1 - point2)
absDic[(point1, point2)] = absSub
# 값 중에서 가장 작은 값인 경우 키 출력
for key, value in absDic.items():
if value == min(absDic.values()):
print(key)
findShortest()
S={1, 3, 4, 8, 13 ,5 ,6,17, 20} s=list(S) s.sort() a=s[0] min=1000 result="" for i in s[1::]: if (i-a)<min: min=(i-a) a=i else: a=i for i in s[1::]: if (i-a)==min: result+="("+str(a)+","+str(i)+")" a=i else: a=i print(result,min)
s={1, 3, 4, 8, 13, 17, 20}
s=sorted(list(s))
last=s[-1]
min=1000000
for i in s[-2::-1]:
if last-i<min:
min=last-i
last=i
last=s[-1]
for i in s[-2::-1]:
if last-i==min:
print(i,last)
last=i
s=sorted(list({1, 3, 4, 8, 13, 17, 20,21}))
last=s[-1]
min=s[-1]-s[-2]
for i in s[-2::-1]:
if last-i<min:
min=last-i
last=i
last=s[-1]
for i in s[-2::-1]:
if last-i==min:
print(last,i)
last=i
S = [1, 3, 4, 8, 13, 17, 20]
result = (S[1],S[0])
for i in S :
for j in S :
if i != j :
if abs(i-j) < abs(result[0]-result[1]) :
result = (i, j)
print(result)
s = [ 1, 3, 5, 7, 9, 13, 14, 17, 20 ]
v = [ s[i+1] - s[i] for i in range(len(s)-1) ]
print(s[v.index(min(v))], s[v.index(min(v))+1])
자바로 풀어 봤습니다.
import java.util.Scanner;
import java.util.ArrayList;
import java.util.Comparator;
public class Main {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
ArrayList<Integer> points = new ArrayList<>();
String n;
// x 좌표 값들 입력 받기
while(true) {
System.out.println("x 좌표 값을 입력하시오: (입력을 그만하고 싶으면 !을 입력하시오)");
n = scan.next();
if(n.equals("!")) {
break;
}else {
points.add(Integer.parseInt(n));
}
}
// 오름차순 정리
points.sort(Comparator.naturalOrder());
// 최소 거리 구하기
int minimumDist = points.get(1)-points.get(0), point=0, dist;
for(int i=1; i<points.size()-1; i++) {
dist = points.get(i+1) - points.get(i);
if(dist<minimumDist) {
point = i;
minimumDist = dist;
}
}
// 결과 출력
System.out.printf("(%d, %d) 사이 거리가 %d이며, 제일 짧은 거리를 갖고 있습니다.\n", points.get(point), points.get(point+1), minimumDist);
}
}
def distance(S):
result = []
result_r = []
while S:
a = S.pop()
for i in S:
result.append( (abs(a-i) , (a,i)) )
result.sort()
a = 1
result_r.append(result[0][1])
while result[0][0] == result[a][0]:
result_r.append(result[a][1])
a += 1
return result_r[0:a]
S={1, 3, 4, 8, 13, 17, 20}
distance(S)
[(3, 4)]
A = {1, 2, 4, 5, 8, 15, 19}
distance(A)
[(1, 2), (4, 5)]
import random
S = list(set(list([random.randint(1,100) for i in range(10)])))
S.sort()
length=0
result=[]
for i in range(0, len(S)-1):
if length==0:
length=S[i+1]-S[i]
if length > S[i+1]-S[i]:
result.clear()
length=S[i+1]-S[i]
if length >= S[i+1]-S[i]:
result.append((S[i], S[i+1]))
print("입력된 랜덤값 : {}".format(S))
print("가장 짧은 {}의 거리가 나오는 점의 쌍은 {} 이다.".format(length, result))
랜덤값으로 넣어도 잘 작동되는 분 풀이 보고 랜덤으로 적용했습니다. 랜덤으로 값이 바뀌고 짧은 거리 쌍이 여러개가 나와도 잘 작동합니다.
s = input("숫자를 빈 칸 띄워서 입력 하세요 : ")
s = s.split()
s = set(s)
s = list(map(int, s)) # 정렬 되있다는 것을 가정 했지만 중복되는 숫자, 정렬까지 함
s.sort()
b = [] # 점 사이 거리
c = [] # 가장 짧은 거리의 쌍
for i in range(len(s) - 1):
b.append(s[i + 1] - s[i])
min_num = b.index(min(b)) # 가장 짧은 거리의 index
c.append(s[min_num: min_num + 2]) # 최소값 먼저 하나 출력
while True:
if b.count(min(b)) > 1: # 거리값이 하나 이상일때
if b.count(min(b)) == len(b): # 전부 다 최소값일때
for i in range(len(b)-1):
c.append(s[i+1: i+3])
break
b.insert(min_num, max(b)) # 몇개만 최소값
b.remove(min(b))
min_num = b.index(min(b))
c.append(s[min_num: min_num + 2])
else:
break
print("가장 짧은 거리의 쌍 : ", c)
def distance(*args):
a = []
for i in range(0, len(args)-1):
#args = list(args)
a.append(abs(args[i]-args[i+1]))
for x in range(0,len(a)):
if a[x] == (min(a)):
print(args[x], ',' ,args[x+1])
e.g., distance(1,4,8,11,12,15,18,19,20,26,27) -> 11 , 12 18 , 19 19 , 20 26 , 27
while True:
try:
S = map(int, input("점들의 위치에 대한 숫자들을 입력하세요. (띄어쓰기로 구분)").split())
S = list(set(S))
S.sort()
break
except ValueError:
print("제대로 입력하세요.")
dis = -1
rst = []
for i in range(len(S)-1):
if dis != -1:
if S[i+1]-S[i] > dis:
continue
if S[i+1]-S[i] == dis:
rst.append([S[i],S[i+1]])
continue
dis = S[i+1]-S[i]
rst.clear()
rst.append([S[i], S[i+1]])
print("가장 거리가 짧은 점들은 ({0})이며, 두 사이의 거리는 {1} 입니다.".format(rst, dis))
#include<stdio.h>
#include<stdlib.h>
int main(void)
{
int i, j, s[7] = { 1, 3, 4, 8, 13, 17, 20 }, min = 100, a, b;
for (i = 0; i < 7; i++)
{
for (j = i + 1; j < 7; j++)
{
if (abs(s[j] - s[i]) < min)
{
min = abs(s[j] - s[i]);
a = s[i], b = s[j];
}
}
}
printf("(%d, %d)\n", a, b);
}
c언어입니다.
cmd_list = input("숫자를 입력하세요 :").split(" ")
num_list = []
for n in range(0, len(cmd_list)):
num = int(cmd_list[n])
num_list.append(num)
num_list.sort()
compare_result = float("inf")
number_list = []
for n in range(0, len(cmd_list)):
try:
a = num_list[n]
b = num_list[n+1]
result = abs(a-b)
if compare_result > result:
compare_result = result
number_list[0:2] = [num_list[n], num_list[n+1]]
except (IndexError):
break
print(number_list)
예외처리를 이용해서 해결했습니다
len_list = []
for i in range(len(S)-1):
start = S[i]
end = S[i+1]
len_list.append(end - start)
in_vale = min(len_list)
for i in range(len(len_list)):
if len_list[i] == min_vale:
break
S[i], S[i+1]
a=input("원하는 숫자 입력(띄어쓰기로 구분):")
b=a.split()
b=[int(i) for i in b]
b.sort()
b_zip=list(zip(b,b[1:]))
b_gap=[f-e for e,f in zip(b,b[1:])]
b_gap_min=min(b_gap)
min_multiindex=[k for k in range(len(b_gap)) if b_gap[k]==b_gap_min]
result=[b_zip[i] for i in min_multiindex]
import random as rd
a = []
b = []
for i in range(rd.randint(0,100)):
a.append(rd.randint(0,10000))
a.sort()
print(a)
for j in range(len(a)-1):
b.append(abs(a[j]-a[j+1]))
c = b.index(min(b))
print('({0},{1})'.format(a[c],a[c+1]))
print("리스트 배열을 값을 순차적으로 입력해주세요 예)1 3 4 8 13 17 20")
s=list(map(int, input(':').split()))
min_distance=max(s)
n = []
min_ = []
for i in range(len(s)-1):
distance = s[i+1] - s[i]
n.append({"num1": s[i],
"num2": s[i+1],
"dis": distance})
min_.append(distance)
for j in range(len(n)):
if n[j].get('dis') <= min(min_):
print(f"({n[j].get('num1')},{n[j].get('num2')})")
def min_distance_output(S):
d = []
for i in range(len(S)-1):
d.append(S[i+1] - S[i])
index = list(filter(lambda x:d[x]==min(d), range(len(d))))
for i in index:
print (f"({S[i]}, {S[i+1]})")
S = [1, 3, 4, 8, 13, 17, 20, 21]
min_distance_output(S)
(3, 4) (20, 21)
S = {1,3,4,8,9,13,17,20}
S = list(S)
S1 = []
for i in range(0,len(S)-1):
S1.append(abs((S[i])-S[i+1]))
MinLength = []
for k in range(0,len(S1)):
if S1[k] == min(S1):
MinLength.append([S[k],S[k+1]])
print(MinLength)
S = input("정렬된 배열 입력(공백으로 구분): ")
S = list(S.split(" "))
dic = {}
for i in range(len(S)-1):
dic[(int(S[i]),int(S[i+1]))] = int(S[i+1]) - int(S[i])
result = list(dic.keys())[int(list(dic.values()).index(min(list(dic.values()))))]
print(result)
▲ 최솟값 한 쌍만 구하기
S = input("정렬된 배열 입력(공백으로 구분): ")
S = list(S.split(" "))
dic = {}
for i in range(len(S)-1):
dic[(int(S[i]),int(S[i+1]))] = int(S[i+1]) - int(S[i])
minimum_list = []
for i in range(len(list(dic.values()))-1):
if list(dic.values())[i] == min(list(dic.values())):
minimum_list.append(list(dic.keys())[i])
print(minimum_list)
▲ 최솟값 여러 쌍 구하기
Python. 함수도 함수인데, 최소 거리의 요소 쌍이 복수일 경우 각 쌍을 별도의 리스트로 출력하게 만드는 데 시간이 더 오래 걸린 것 같네요. 생각보다 어려운 과제였습니다.
def shortest_gap(group):
gap = abs(group[1] - group[0]) #첫 요소쌍의 거리를 측정 기준으로 설정
result = [] #결괏값을 나타낼 리스트 생성
for i in range(1, len(group)):
s = abs(group[i] - group[i-1]) #두 요소 사이의 거리를 확인
if gap == s: #거리가 같을 경우 리스트에 해당 요소 쌍을 추가
result.append([group[i-1], group[i]])
elif gap != 0 and s > gap: #요소 간 거리가 기존 설정된 최소 거리보다 클 경우 패스
pass
elif gap != 0 and s < gap: #요소 간 거리가 기존의 최소 거리보다 짧을 경우
gap = s #거리 측정 기준으로 설정
result = [] #기존에 추가되었던 최소 거리 쌍을 모두 제거
result.append([group[i-1], group[i]]) #새로운 최소 거리 쌍을 추가
return result
test = (1,2,4,5,8,15,19)
print(shortest_gap(test))
결과는 [[1, 2], [4, 5]]
S={1, 3, 4, 8, 13, 17, 20}; L1=list(S); L2=[]; S2=set()
for i in range(len(L1)):
for j in range(len(L1)):
L2.append(abs(L1[i]-L1[j]))
for i in range(L2.count(0)):
L2.remove(0)
for i in range(len(L1)):
for j in range(len(L1)):
if abs(L1[i]-L1[j])==min(L2):
S2.add(L1[i]); S2.add(L1[j])
print(tuple(S2))
S={1, 3, 4, 8, 13, 17, 20}
L1=list(S); L2=[]; S2=set(); L3=[]; a=0
for i in range(len(L1)):
L1[i]=int(L1[i])
for i in range(len(L1)):
for j in range(len(L1)):
L2.append(abs(L1[i]-L1[j]))
for i in range(L2.count(0)):
L2.remove(0)
for i in range(len(L1)):
for j in range(len(L1)):
if abs(L1[i]-L1[j])==min(L2):
L3.append(L1[i]); L3.append(L1[j])
for i in range(int(len(L3)/4)):
print(tuple(L3[a:a+2]), end=' ')
a+=4
s = [1, 3, 4, 8, 13, 17, 20]
index = 0
min = float('inf') # float('-inf')
for i in range(1, len(s)):
s[i] - s[i-1] < min:
index = i
print(s[index-1], s[index])
const func = (arr) => {
let min = Infinity
let index = 0
for(let i = 0; i < arr.length - 1; i++){
let compareNum = arr[i + 1] - arr[i]
if(compareNum < min){
min = compareNum
index = i
}
}
return [arr[index], arr[index + 1]]
}
def min_distance(l):
l.sort()
result=[1e10,()]
for i in l:
for j in l:
if i < j:
if j-i <= result[0]:
result[0]=j-i
result[1]=(i,j)
return result[1]
#example
print(min_distance([120,52,24,482,60,2000,502,12324,211,12,1242]))
s[i] - s[i-1]이 기존 min 보다 작다면 result에 넣어줬습니다. 반복문을 s[i] - s[i-1]이 min보다 작다면 result에 push하게 만들었습니다. 따라서 min보다 크다면 result에 들어올 일이 없고, 입력받은 가장 마지막 2자리값이 차가 제일 작은 값이 될 것이기 때문에, sort()를 통해서 원하는 결과를 얻었습니다. 글 쓰면서 생각해보니까 아래와 같이 출력하려면 sort를 할 필요도 없겠네요..
let s = [1,3,4,8,13,17,20];
let min = Infinity;
let result = [];
for(let i = 1; i < s.length; i++){
if(s[i] - s[i-1] < min){
min = s[i] - s[i-1];
result.push(s[i-1], s[i]);
}
}
result.sort((a, b) => b - a);
console.log(result[1], result[0]);
values = [int(v) for v in input().split()]
intA=0
intB=0
intC=values[0]-values[1]#최소 차이의 초기값
for i in range(len(values)-1):
intD=values[i]-values[i+1]#두 원소의 차이값이
if intC<intD:#기존 차이값 보다 작다면
intA=values[i]
intB=values[i+1]
intC=intD#갱신
print(intA,intB)
s=[1, 3, 4, 8, 13, 17, 20]
s.sort()
min = s[1]-s[0]
check = 0
print(min)
for i in range(1,len(s)-1):
if s[i+1]-s[i]<min:
check = i
print(s[check],s[check+1])
JAVA import java.util.Scanner;
public class OneDemensionMinLegnth { public static void main(String[] args) { Scanner scn = new Scanner(System.in);
int n=0, length = 0,lengthTemp, num=0;
System.out.println("숫자의 갯수는? ");
num = scn.nextInt();
int[] oneD = new int[num];
int[] min = new int [2];
System.out.println("숫자를 입력하세요 : ");
for (int i = 0; i < num; i++) {
oneD[i] = scn.nextInt();
}
length = Math.abs(oneD[0]-oneD[1]);
for (int k = 0; k < num; k++) {
for (int j = k; j < num-1; j++) {
lengthTemp = Math.abs(oneD[k]-oneD[j+1]);
if (lengthTemp<=length) {
length=lengthTemp;
min[0] = oneD[k];
min[1] = oneD[j+1];
}
}
}
System.out.println(min[0] + "," + min[1]);
}
}
dot = [1, 3, 4, 8, 13, 17, 20, 21] # 예시, 최소값이 복수 존재함
re = {}
# dot 리스트의 각 숫자들을 이용하여 인접한 숫자 사이의 차이를 딕셔너리에 저장
for i in range(len(dot)-1):
re[dot[i+1], dot[i]] = dot[i+1] - dot[i]
# 딕셔너리에서 차이가 가장 작은 값의 키 도출
min_key = min(re, key=re.get)
# 딕셔너리에서 차이가 가장 작은 값을 가지는 모든 키 출력
result = [k for k in re if re[k] == re[min_key]]
print(result)
import random
S = []
for i in range(random.randrange(1, 50)):
val = random.randrange(1, 100)
if val in S:
continue
S.append(val)
S.sort()
gap = 0
gap_dic = {}
for i in range(len(S)-1):
n_gap = S[i+1] - S[i]
if gap == 0 or gap == n_gap:
gap = n_gap
gap_dic.setdefault(S[i], S[i + 1])
if gap > n_gap:
gap_dic.clear()
gap = n_gap
gap_dic.setdefault(S[i], S[i + 1])
print(S)
print(gap_dic)
def daum(): lst = [1, 3, 4, 8, 13, 17, 20]
mo = []
min_lst = []
for i in range(len(lst)):
for j in range(i + 1, len(lst)):
min_lst.append(lst[j] - lst[i])
tp = (lst[i], lst[j])
mo.append(tp)
a = min_lst.index(min(min_lst))
print(mo[a])
daum()```{.python} def daum(): lst = [1, 3, 4, 8, 13, 17, 20]
mo = []
min_lst = []
for i in range(len(lst)):
for j in range(i + 1, len(lst)):
min_lst.append(lst[j] - lst[i])
tp = (lst[i], lst[j])
mo.append(tp)
a = min_lst.index(min(min_lst))
print(mo[a])
daum() ```
#1차원의 점을 원하는 만큼 입력받고 가장 작은 거리를 가지는 복수의 점들의 쌍을 출력할 수 있도록 만들었습니다.
num = []
pair = []
def same(a, b):
if [min(a, b), max(a, b)] not in pair:
return True
else:
return False
def make_pair(a, b):
if a == b:
return [a, b]
else:
return [min(a, b), max(a, b)]
ending = True
while ending:
wh = (input("1차원의 점을 입력하시오(입력을 원하지 않는다면 x 입력) : "))
if wh == 'x' or wh == 'X':
ending = False
else:
num.append(int(wh))
value = abs(num[0] - num[1])
pair.append(make_pair(num[0], num[1]))
for n in range(0, len(num)):
for k in range(n + 1, len(num)):
vl = abs(num[n] - num[k])
if vl < value:
value = vl
pair = [make_pair(num[n], num[k])]
elif vl == value:
if same(num[n], num[k]):
pair.append(make_pair(num[n], num[k]))
print(pair)
def FindShortestGapInList(targetList):
GapList = list()
for index, item in enumerate(targetList):
if index < len(targetList) -1: GapList.append(targetList[index + 1] - targetList[index])
index = max((v, i) for i, v in enumerate(GapList))[1]
print("(%d, %d)" % (index, (index + 1)))
FindShortestGapInList([1, 3, 4, 8, 13, 17, 20])
S=(1, 3, 4, 8, 13, 17, 20)
import itertools
pairs = list(itertools.combinations(S,2))
distance = []
for i in pairs:
distance.append(abs(i[0]**2-i[1]**2))
f = lambda i: distance[i]
print(pairs[min(range(len(distance)), key=f)])
연속된 두 숫자 간 차이가 가장 작은 숫자 쌍이 두 개 이상 존재하는 경우 모두 찾도록 코드를 작성
s = {1, 3, 4, 8, 13, 17, 18}
sorted_s = sorted(s) # set을 정렬한 리스트로 변환
min_difference = float('inf')
result_pairs = []
for i in range(len(sorted_s) - 1):
tmp = sorted_s[i + 1] - sorted_s[i]
if tmp < min_difference:
min_difference = tmp
result_pairs = [(sorted_s[i], sorted_s[i + 1])]
elif tmp == min_difference:
result_pairs.append((sorted_s[i], sorted_s[i + 1]))
for pair in result_pairs:
print(pair)
출력 결과는 ... (3, 4) (17, 18)
from random import randint
num = int(input("Enter Num:"))
data_set = [];delta_set = []
for i in range(num):
data_set.append(randint(0,100))
data_set.sort()
for j in range(len(data_set)):
if j+1 < len(data_set):
delta_set.append(data_set[j+1]-data_set[j])
else: break
minimum = min(delata_set)
for k in range(len(delta_set)):
if delta_set[k] == minimum:
print('(',data_set[k],data_set[k+1],')')
s = list(map(int, input().split()))
def MinDistance(s):
minPairs = []
lIdx, rIdx = 0, 1
d_min = s[-1]
while rIdx < len(s):
dist = s[rIdx] - s[lIdx]
if dist < d_min:
d_min = dist
minPairs = []
minPairs.append((s[lIdx], s[rIdx]))
elif dist == d_min:
minPairs.append((s[lIdx], s[rIdx]))
lIdx += 1
rIdx += 1
return minPairs
print(MinDistance(s))
from itertools import combinations
import sys
S={1, 3, 4, 8, 13, 17, 20}
pairs = combinations(S, 2)
min = sys.maxsize
result = []
for a, b in pairs:
if min > abs(a-b):
min = abs(a-b)
result = [(a, b)]
elif min == abs(a-b):
min = abs(a-b)
result.append((a,b))
print(result)
lst_dots = input().split(' ')
lst_dots = [int(item) for item in lst_dots]
min_distance = abs(lst_dots[0] - lst_dots[1])
len_lst_dots = len(lst_dots)
ans_pair = (0, 1)
for i in range(len_lst_dots):
for j in range(i + 1,len_lst_dots):
if abs(lst_dots[i] - lst_dots[j]) < min_distance:
min_distance = abs(lst_dots[i] - lst_dots[j])
ans_pair = (lst_dots[i], lst_dots[j])
print(ans_pair)
print(ans_pair)
s = [1, 3, 4, 8, 13, 17, 20]
dis = s[1] - s[0]
dis_less = [s[0], s[1]]
for a, num in enumerate(s):
if a >= 2:
before = s[a-1]
if num - before < dis:
dis = num - before
dis_less = [before, num]
print(tuple(dis_less))
s= [1, 3, 4, 8, 13, 17, 20]
minD = s[-1]-s[0]
minIdx = 0
for i in range(len(s)-1):
if (s[i+1]-s[i])<minD:
minD = s[i+1]-s[i]
minIdx = i
print('({0}, {1})'.format(s[minIdx], s[minIdx+1]))
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
List<Integer> nums = new ArrayList<>();
int min = 999999 ;
int result = 0;
int a = 0;
int b = 0;
int insertNum = 0;
int max = 0;
int count = 0;
System.out.print("넣고 싶은 숫자의 갯수를 입력하세요 : ");
max = sc.nextInt();
do {
System.out.print(" 넣을 숫자를 입력하세요 : ");
insertNum = sc.nextInt();
nums.add(insertNum);
count = count + 1;
}while (count <= max);
for (int i = 0; i < nums.size(); i++) {
for (int k = 0 ; k < i ; k ++) {
if (nums.get(i) < nums.get(k)) {
result = nums.get(k) - nums.get(i);
} else {
result = nums.get(i) - nums.get(k);
}
if (result < min) {
min = result;
a = nums.get(k);
b = nums.get(i);
}
}
}
System.out.println("결과값 ( "+a+", "+b +" )" );
System.out.println("최소 거리 : " +min );
}
}
S = list(map(int, input().split()))
S.sort()
def cal(S):
min_distance = float('inf')
closest_pair = (None, None)
for i in range(len(S) - 1):
distance = S[i+1] - S[i]
if distance < min_distance:
min_distance = distance
closest_pair = (S[i], S[i+1])
print(closest_pair)
cal(S)
JAVA입니다.
package question2.다음_입사문제_중에서;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
public class MinDistance {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner sc = new Scanner(System.in);
String dotsStr = sc.nextLine();
List<Integer> dots = new ArrayList<Integer>();
for (String dotStr : dotsStr.split(", ")) {
dots.add(Integer.parseInt(dotStr));
}
List<List<Integer>> minDistDots = new ArrayList<List<Integer>>();
int minDist = -1;
for (int i = 0; i < dots.size() - 1; i++) {
for (int j = i + 1; j < dots.size(); j++) {
int dist = Math.abs(dots.get(i) - dots.get(j));
if((Integer)minDist == -1 || dist < minDist) {
minDist = dist;
minDistDots = new ArrayList<List<Integer>>();
minDistDots.add(new ArrayList<Integer>());
minDistDots.get(0).add(dots.get(i));
minDistDots.get(0).add(dots.get(j));
}
else {
if(minDist == dist) {
minDistDots.add(new ArrayList<Integer>());
minDistDots.get(minDistDots.size() - 1).add(dots.get(i));
minDistDots.get(minDistDots.size() - 1).add(dots.get(j));
}
}
}
}
for (List<Integer> list : minDistDots) {
System.out.println("(" + list.get(0) + ", " + list.get(1) + ")");
}
sc.close();
}
}
'''
1차원의 점들이 주어졌을 때, 그 중 가장 거리가 짧은 것의 쌍을 출력하는 함수를 작성하시오.
(단 점들의 배열은 모두 정렬되어있다고 가정한다.)
예를들어 S={1, 3, 4, 8, 13, 17, 20} 이 주어졌다면, 결과값은 (3, 4)가 될 것이다.
'''
def compareDistance(S):
min_distance = float('inf')
closest_pair = None
for i in range(len(S)-1):
distance = S[i+1]-S[i]
if(distance < min_distance):
min_distance = distance
closest_pair = (S[i],S[i+1])
print(closest_pair)
S=[1, 3, 4, 8, 13, 17, 20]
compareDistance(S)
# s = {1, 3, 4, 8, 13, 17, 20}은 그냥 예시여서 점들의 값을 받는 함수. 정렬된다고 가정하라고 해서
#숫자만 입력 할 것이라고도 가정
def pointInp():
s = set()
whileChk = True
while whileChk:
a = str(input("점을 입력 하시겠습니까 (Y/N): "))
if a.upper() == "Y":
s.add(int(input("점을 입력하세요: ")))
elif a.upper() == "N":
whileChk = False
else:
print("Y 혹은 N중에 입력을 해주세요")
return s
usr_inp = list(pointInp())
diff = usr_inp[1] - usr_inp[0]
ind = 0
for i in range(1, len(usr_inp)):
if usr_inp[i] - usr_inp[i-1] < diff:
diff = usr_inp[i] - usr_inp[i-1]
ind = i
print(f"({usr_inp[ind-1]}, {usr_inp[ind]})")